# HG changeset patch
# User eldar
# Date 1247865404 0
# Node ID 99e74c8a22f8193b5c24414d3b51ab51174e02e6
# Parent  0c2a27b232387390312fb181b7a789a8a530c3c4
change ref to in in structs

diff -r 0c2a27b23238 -r 99e74c8a22f8 qt/d1/qt/core/QLine.d
--- a/qt/d1/qt/core/QLine.d	Fri Jul 17 20:32:17 2009 +0000
+++ b/qt/d1/qt/core/QLine.d	Fri Jul 17 21:16:44 2009 +0000
@@ -15,7 +15,7 @@
         return ln;
     }
 
-    public static QLine opCall(ref QPoint pt1_, ref QPoint pt2_) {
+    public static QLine opCall(in QPoint pt1_, in QPoint pt2_) {
         QLine ln;
         ln.pt1 = pt1_;
         ln.pt2 = pt2_;
@@ -74,7 +74,7 @@
         return pt2.y() - pt1.y();
     }
     
-    void translate(ref QPoint point)
+    void translate(in QPoint point)
     {
         pt1 += point;
         pt2 += point;
@@ -85,7 +85,7 @@
         translate(QPoint(adx, ady));
     }
     
-    QLine translated(ref QPoint p) // const
+    QLine translated(in QPoint p) // const
     {
         return QLine(pt1 + p, pt2 + p);
     }
@@ -95,27 +95,27 @@
         return translated(QPoint(adx, ady));
     }
 
-    void p1(ref QPoint aP1)
+    void p1(in QPoint aP1)
     {
         pt1 = aP1;
     }
 
-    void p2(ref QPoint aP2)
+    void p2(in QPoint aP2)
     {
         pt2 = aP2;
     }
 
-    void setP1(ref QPoint aP1) // for convenience
+    void setP1(in QPoint aP1) // for convenience
     {
         pt1 = aP1;
     }
     
-    void setP2(ref QPoint aP2) // for convenience
+    void setP2(in QPoint aP2) // for convenience
     {
         pt2 = aP2;
     }
     
-    void setPoints(ref QPoint aP1, ref QPoint aP2)
+    void setPoints(in QPoint aP1, in QPoint aP2)
     {
         pt1 = aP1;
         pt2 = aP2;
@@ -127,7 +127,7 @@
         pt2 = QPoint(aX2, aY2);
     }
     
-    bool opEquals(ref QLine d) // const
+    bool opEquals(in QLine d) // const
     {
         return pt1 == d.pt1 && pt2 == d.pt2;
     }
@@ -167,7 +167,7 @@
         return ln;
     }
     
-    public static QLineF opCall(ref QPointF apt1, ref QPointF apt2) {
+    public static QLineF opCall(in QPointF apt1, in QPointF apt2) {
         QLineF ln;
         ln.pt1 = apt1;
         ln.pt2 = apt2;
@@ -181,7 +181,7 @@
         return ln;
     }
     
-    public static QLineF opCall(ref QLine line){ 
+    public static QLineF opCall(in QLine line){ 
         QLineF ln;
         ln.pt1 = QPointF(line.p1());
         ln.pt2 = QPointF(line.p2());
@@ -238,7 +238,7 @@
         return QLineF(p1(), p1() + QPointF(dy(), -dx()));
     }
     
-    void translate(ref QPointF point)
+    void translate(in QPointF point)
     {
         pt1 += point;
         pt2 += point;
@@ -249,7 +249,7 @@
         this.translate(QPointF(adx, ady));
     }
     
-    QLineF translated(ref QPointF p) // const
+    QLineF translated(in QPointF p) // const
     {
         return QLineF(pt1 + p, pt2 + p);
     }
@@ -287,27 +287,27 @@
         return QLine(pt1.toPoint(), pt2.toPoint());
     }
     
-    void setP1(ref QPointF aP1)
+    void setP1(in QPointF aP1)
     {
         pt1 = aP1;
     }
     
-    void setP2(ref QPointF aP2)
+    void setP2(in QPointF aP2)
     {
         pt2 = aP2;
     }
     
-    void p1(ref QPointF aP1)
+    void p1(in QPointF aP1)
     {
         pt1 = aP1;
     }
     
-    void p2(ref QPointF aP2)
+    void p2(in QPointF aP2)
     {
         pt2 = aP2;
     }
     
-    void setPoints(ref QPointF aP1, ref QPointF aP2)
+    void setPoints(in QPointF aP1, in QPointF aP2)
     {
         pt1 = aP1;
         pt2 = aP2;
@@ -319,7 +319,7 @@
         pt2 = QPointF(aX2, aY2);
     }
     
-    bool opEquals(ref QLineF d) // const
+    bool opEquals(in QLineF d) // const
     {
         return pt1 == d.pt1 && pt2 == d.pt2;
     }
@@ -328,16 +328,16 @@
         return qtd_QLineF_angle(this);
     }
     
-    public final double angle(ref QLineF l) {
+    public final double angle(in QLineF l) {
         return qtd_QLineF_angle_QLineF(this, &l);
     }
     
-    public final double angleTo(ref QLineF l) {
+    public final double angleTo(in QLineF l) {
         return qtd_QLineF_angleTo_QLineF(this, &l);
     }
     
     // ### Qt 5: rename intersects() or intersection() and rename IntersectType IntersectionType
-    private final QLineF_IntersectType intersect(ref QLineF l, QPointF* intersectionPoint) {
+    private final QLineF_IntersectType intersect(in QLineF l, QPointF* intersectionPoint) {
         return cast(QLineF_IntersectType) qtd_QLineF_intersect_QLineF_nativepointerQPointF(this, &l, intersectionPoint);
     }
     
diff -r 0c2a27b23238 -r 99e74c8a22f8 qt/d1/qt/core/QPoint.d
--- a/qt/d1/qt/core/QPoint.d	Fri Jul 17 20:32:17 2009 +0000
+++ b/qt/d1/qt/core/QPoint.d	Fri Jul 17 21:16:44 2009 +0000
@@ -53,22 +53,22 @@
 { return yp; }
 */
 
-    QPoint opAddAssign(ref QPoint p)
+    QPoint opAddAssign(in QPoint p)
     { xp+=p.xp; yp+=p.yp; return *this; }
 
-    QPoint opSubAssign(ref QPoint p)
+    QPoint opSubAssign(in QPoint p)
     { xp-=p.xp; yp-=p.yp; return *this; }
 
     QPoint opMulAssign(qreal c)
     { xp = qRound(xp*c); yp = qRound(yp*c); return *this; }
     
-    bool opEquals(ref QPoint p)
+    bool opEquals(in QPoint p)
     { return xp == p.xp && yp == p.yp; }
 
-    QPoint opAdd(ref QPoint p)
+    QPoint opAdd(in QPoint p)
     { return QPoint(this.xp+p.xp, this.yp+p.yp); }
 
-    QPoint opSub(ref QPoint p)
+    QPoint opSub(in QPoint p)
     { return QPoint(this.xp-p.xp, this.yp-p.yp); }
     
     QPoint opMul(qreal c)
@@ -124,7 +124,7 @@
         return pt;
     }
     
-    public static QPointF opCall(ref QPoint p) {
+    public static QPointF opCall(in QPoint p) {
         QPointF pt;
         pt.xp = p.x();
         pt.yp = p.y();
@@ -167,22 +167,22 @@
 }
 */
     
-    QPointF opAddAssign(ref QPointF p)
+    QPointF opAddAssign(in QPointF p)
     { xp+=p.xp; yp+=p.yp; return *this; }
     
-    QPointF opSubAssign(ref QPointF p)
+    QPointF opSubAssign(in QPointF p)
     { xp-=p.xp; yp-=p.yp; return *this; }
     
     QPointF opMulAssign(qreal c)
     { xp*=c; yp*=c; return *this; }
     
-    bool opEquals(ref QPointF p)
+    bool opEquals(in QPointF p)
     { return qFuzzyCompare(xp, p.xp) && qFuzzyCompare(yp, p.yp); }
     
-    QPointF opAdd(ref QPointF p)
+    QPointF opAdd(in QPointF p)
     { return QPointF(this.xp+p.xp, this.yp+p.yp); }
     
-    QPointF opSub(ref QPointF p)
+    QPointF opSub(in QPointF p)
     { return QPointF(this.xp-p.xp, this.yp-p.yp); }
     
     QPointF opMul(qreal c)
diff -r 0c2a27b23238 -r 99e74c8a22f8 qt/d1/qt/core/QRect.d
--- a/qt/d1/qt/core/QRect.d	Fri Jul 17 20:32:17 2009 +0000
+++ b/qt/d1/qt/core/QRect.d	Fri Jul 17 21:16:44 2009 +0000
@@ -27,7 +27,7 @@
         return rt;
     }
 
-    public static QRect opCall(ref QPoint atopLeft, ref QPoint abottomRight)
+    public static QRect opCall(in QPoint atopLeft, in QPoint abottomRight)
     {
         QRect rt;
         rt.x1 = atopLeft.x();
@@ -37,7 +37,7 @@
         return rt;
     }
 
-    public static QRect opCall(ref QPoint atopLeft, ref QSize asize)
+    public static QRect opCall(in QPoint atopLeft, in QSize asize)
     {
         QRect rt;
         rt.x1 = atopLeft.x();
@@ -98,16 +98,16 @@
     void setBottom(int pos)
     { y2 = pos; }
 
-    void setTopLeft(ref QPoint p)
+    void setTopLeft(in QPoint p)
     { x1 = p.x(); y1 = p.y(); }
 
-    void setBottomRight(ref QPoint p)
+    void setBottomRight(in QPoint p)
     { x2 = p.x(); y2 = p.y(); }
 
-    void setTopRight(ref QPoint p)
+    void setTopRight(in QPoint p)
     { x2 = p.x(); y1 = p.y(); }
 
-    void setBottomLeft(ref QPoint p)
+    void setBottomLeft(in QPoint p)
     { x1 = p.x(); y2 = p.y(); }
 
     void setX(int ax)
@@ -148,7 +148,7 @@
         y2 += dy;
     }
 
-    void translate(ref QPoint p)
+    void translate(in QPoint p)
     {
         x1 += p.x();
         y1 += p.y();
@@ -159,7 +159,7 @@
     QRect translated(int dx, int dy) // const
     { return QRect(QPoint(x1 + dx, y1 + dy), QPoint(x2 + dx, y2 + dy)); }
 
-    QRect translated(ref QPoint p) // const
+    QRect translated(in QPoint p) // const
     { return QRect(QPoint(x1 + p.x(), y1 + p.y()), QPoint(x2 + p.x(), y2 + p.y())); }
 
     void moveTo(int ax, int ay)
@@ -170,7 +170,7 @@
         y1 = ay;
     }
 
-    void moveTo(ref QPoint p)
+    void moveTo(in QPoint p)
     {
         x2 += p.x() - x1;
         y2 += p.y() - y1;
@@ -196,25 +196,25 @@
         y2 = pos;
     }
 
-    void moveTopLeft(ref QPoint p)
+    void moveTopLeft(in QPoint p)
     {
         moveLeft(p.x());
         moveTop(p.y());
     }
 
-    void moveBottomRight(ref QPoint p)
+    void moveBottomRight(in QPoint p)
     {
         moveRight(p.x());
         moveBottom(p.y());
     }
 
-    void moveTopRight(ref QPoint p)
+    void moveTopRight(in QPoint p)
     {
         moveRight(p.x());
         moveTop(p.y());
     }
 
-    void moveBottomLeft(ref QPoint p)
+    void moveBottomLeft(in QPoint p)
     {
         moveLeft(p.x());
         moveBottom(p.y());
@@ -269,7 +269,7 @@
     void setHeight(int h)
     { y2 = (y1 + h - 1); }
 
-    void setSize(ref QSize s)
+    void setSize(in QSize s)
     {
         x2 = (s.width()  + x1 - 1);
         y2 = (s.height() + y1 - 1);
@@ -285,29 +285,29 @@
         return contains(QPoint(ax, ay), false);
     }
 
-    QRect opOrAssign(ref QRect r)
+    QRect opOrAssign(in QRect r)
     {
         *this = *this | r;
         return *this;
     }
 
-    QRect opAndAssign(ref QRect r)
+    QRect opAndAssign(in QRect r)
     {
         *this = *this & r;
         return *this;
     }
 
-    QRect intersected(ref QRect other) // const
+    QRect intersected(in QRect other) // const
     {
         return *this & other;
     }
 
-    QRect united(ref QRect r) // const
+    QRect united(in QRect r) // const
     {
         return *this | r;
     }
 
-    bool opEquals(ref QRect r)
+    bool opEquals(in QRect r)
     {
         return x1==r.x1 && x2==r.x2 && y1==r.y1 && y2==r.y2;
     }
@@ -320,11 +320,11 @@
         qtd_QRect_readFrom_QDataStream(this, arg__1 is null ? null : arg__1.nativeId);
     }
 
-    public final QRect opAnd(ref QRect r) {
+    public final QRect opAnd(in QRect r) {
         return qtd_QRect_operator_and_QRect(this, &r);
     }
 
-    public final QRect opOr(ref QRect r) {
+    public final QRect opOr(in QRect r) {
         return qtd_QRect_operator_or_QRect(this, &r);
     }
 
diff -r 0c2a27b23238 -r 99e74c8a22f8 qt/d1/qt/core/QRectF.d
--- a/qt/d1/qt/core/QRectF.d	Fri Jul 17 20:32:17 2009 +0000
+++ b/qt/d1/qt/core/QRectF.d	Fri Jul 17 21:16:44 2009 +0000
@@ -29,7 +29,7 @@
         return rt;
     }
 
-    public static QRectF opCall(ref QPointF atopLeft, ref QSizeF asize)
+    public static QRectF opCall(in QPointF atopLeft, in QSizeF asize)
     {
         QRectF rt;
         rt.xp = atopLeft.x();
@@ -39,7 +39,7 @@
         return rt;
     }
 
-    public static QRectF opCall(ref QPointF atopLeft, ref QPointF abottomRight)
+    public static QRectF opCall(in QPointF atopLeft, in QPointF abottomRight)
     {
         QRectF rt;
         rt.xp = atopLeft.x();
@@ -49,7 +49,7 @@
         return rt;
     }
 
-    public static QRectF opCall(ref QRect r)
+    public static QRectF opCall(in QRect r)
     {
         QRectF rt;
         rt.xp = r.x();
@@ -106,13 +106,13 @@
 
     void setBottom(qreal pos) { h = pos - yp; }
 
-    void setTopLeft(ref QPointF p) { setLeft(p.x()); setTop(p.y()); }
+    void setTopLeft(in QPointF p) { setLeft(p.x()); setTop(p.y()); }
 
-    void setTopRight(ref QPointF p) { setRight(p.x()); setTop(p.y()); }
+    void setTopRight(in QPointF p) { setRight(p.x()); setTop(p.y()); }
 
-    void setBottomLeft(ref QPointF p) { setLeft(p.x()); setBottom(p.y()); }
+    void setBottomLeft(in QPointF p) { setLeft(p.x()); setBottom(p.y()); }
 
-    void setBottomRight(ref QPointF p) { setRight(p.x()); setBottom(p.y()); }
+    void setBottomRight(in QPointF p) { setRight(p.x()); setBottom(p.y()); }
 
     QPointF center() // conts
     { return QPointF(xp + w/2, yp + h/2); }
@@ -125,15 +125,15 @@
 
     void moveBottom(qreal pos) { yp = pos - h; }
 
-    void moveTopLeft(ref QPointF p) { moveLeft(p.x()); moveTop(p.y()); }
+    void moveTopLeft(in QPointF p) { moveLeft(p.x()); moveTop(p.y()); }
 
-    void moveTopRight(ref QPointF p) { moveRight(p.x()); moveTop(p.y()); }
+    void moveTopRight(in QPointF p) { moveRight(p.x()); moveTop(p.y()); }
 
-    void moveBottomLeft(ref QPointF p) { moveLeft(p.x()); moveBottom(p.y()); }
+    void moveBottomLeft(in QPointF p) { moveLeft(p.x()); moveBottom(p.y()); }
 
-    void moveBottomRight(ref QPointF p) { moveRight(p.x()); moveBottom(p.y()); }
+    void moveBottomRight(in QPointF p) { moveRight(p.x()); moveBottom(p.y()); }
 
-    void moveCenter(ref QPointF p) { xp = p.x() - w/2; yp = p.y() - h/2; }
+    void moveCenter(in QPointF p) { xp = p.x() - w/2; yp = p.y() - h/2; }
 
     qreal width() // conts
     { return w; }
@@ -150,7 +150,7 @@
         yp += dy;
     }
 
-    void translate(ref QPointF p)
+    void translate(in QPointF p)
     {
         xp += p.x();
         yp += p.y();
@@ -162,7 +162,7 @@
         yp = ay;
     }
 
-    void moveTo(ref QPointF p)
+    void moveTo(in QPointF p)
     {
         xp = p.x();
         yp = p.y();
@@ -171,7 +171,7 @@
     QRectF translated(qreal dx, qreal dy) // conts
     { return QRectF(xp + dx, yp + dy, w, h); }
 
-    QRectF translated(ref QPointF p) // conts
+    QRectF translated(in QPointF p) // conts
     { return QRectF(xp + p.x(), yp + p.y(), w, h); }
 
     void getRect(qreal *ax, qreal *ay, qreal *aaw, qreal *aah) // conts
@@ -218,7 +218,7 @@
     void setHeight(qreal ah) // for convenience
     { this.h = ah; }
 
-    void setSize(ref QSizeF s) // for convenience
+    void setSize(in QSizeF s) // for convenience
     {
         w = s.width();
         h = s.height();
@@ -230,7 +230,7 @@
     void height(qreal ah)
     { this.h = ah; }
 
-    void size(ref QSizeF s)
+    void size(in QSizeF s)
     {
         w = s.width();
         h = s.height();
@@ -241,29 +241,29 @@
         return contains(QPointF(ax, ay));
     }
 
-    QRectF opOrAssign(ref QRectF r)
+    QRectF opOrAssign(in QRectF r)
     {
         *this = *this | r;
         return *this;
     }
 
-    QRectF opAndAssign(ref QRectF r)
+    QRectF opAndAssign(in QRectF r)
     {
         *this = *this & r;
         return *this;
     }
 
-    QRectF intersected(ref QRectF r) // conts
+    QRectF intersected(in QRectF r) // conts
     {
         return *this & r;
     }
 
-    QRectF united(ref QRectF r) // conts
+    QRectF united(in QRectF r) // conts
     {
         return *this | r;
     }
 
-    bool opEquals(ref QRectF r)
+    bool opEquals(in QRectF r)
     {
         return qFuzzyCompare(xp, r.xp) && qFuzzyCompare(yp, r.yp)
             && qFuzzyCompare(w, r.w) && qFuzzyCompare(h, r.h);
@@ -290,7 +290,7 @@
         return qtd_QRectF_normalized(this);
     }
 
-    public final QRectF opAnd(ref QRectF r) {
+    public final QRectF opAnd(in QRectF r) {
         return qtd_QRectF_operator_and_QRectF(this, &r);
     }
 
@@ -302,7 +302,7 @@
         qtd_QRectF_readFrom_QDataStream(this, arg__1 is null ? null : arg__1.nativeId);
     }
 
-    public final QRectF opOr(ref QRectF r) {
+    public final QRectF opOr(in QRectF r) {
         return qtd_QRectF_operator_or_QRectF(this, &r);
     }
 
diff -r 0c2a27b23238 -r 99e74c8a22f8 qt/d1/qt/core/QSize.d
--- a/qt/d1/qt/core/QSize.d	Fri Jul 17 20:32:17 2009 +0000
+++ b/qt/d1/qt/core/QSize.d	Fri Jul 17 21:16:44 2009 +0000
@@ -15,16 +15,16 @@
 */
 
     public static QSize opCall() {
-    	QSize sz;
-    	sz.wd = sz.ht = -1;
-    	return sz;
+        QSize sz;
+        sz.wd = sz.ht = -1;
+        return sz;
     }
 
     public static QSize opCall(int w, int h) {
-    	QSize sz;
-    	sz.wd = w;
-    	sz.ht = h;
-    	return sz;
+        QSize sz;
+        sz.wd = w;
+        sz.ht = h;
+        return sz;
     }
 
     final bool isNull()
@@ -55,26 +55,26 @@
     { ht = h; }
     
     void transpose() {
-		int tmp = wd;
-		wd = ht;
-		ht = tmp;
-	}
+        int tmp = wd;
+        wd = ht;
+        ht = tmp;
+    }
 
     void scale(int w, int h, Qt.AspectRatioMode mode) {
-    	scale(QSize(w, h), mode);
+        scale(QSize(w, h), mode);
     }
     
-    void scale(ref QSize s, Qt.AspectRatioMode mode) {
-    	__qtd_QSize_scale_QSize_AspectRatioMode(this, &s, mode);
+    void scale(in QSize s, Qt.AspectRatioMode mode) {
+        __qtd_QSize_scale_QSize_AspectRatioMode(this, &s, mode);
     }
 
-    QSize expandedTo(ref QSize otherSize) {
+    QSize expandedTo(in QSize otherSize) {
         return QSize(qMax(wd,otherSize.wd), qMax(ht,otherSize.ht));
-	}
+    }
 
-    QSize boundedTo(ref QSize otherSize) {
-    	return QSize(qMin(wd,otherSize.wd), qMin(ht,otherSize.ht));
-	}
+    QSize boundedTo(in QSize otherSize) {
+        return QSize(qMin(wd,otherSize.wd), qMin(ht,otherSize.ht));
+    }
 /*
     public final void writeTo(QDataStream arg__1)    {
         __qtd_QSize_writeTo_QDataStream(this, arg__1 is null ? null : arg__1.nativeId);
@@ -84,37 +84,37 @@
         __qtd_QSize_readFrom_QDataStream(this, arg__1 is null ? null : arg__1.nativeId);
     }
 */
-	QSize opAddAssign(ref QSize s)
-	{ wd+=s.wd; ht+=s.ht; return *this; }
+    QSize opAddAssign(in QSize s)
+    { wd+=s.wd; ht+=s.ht; return *this; }
 
-	QSize opSubAssign(ref QSize s)
-	{ wd-=s.wd; ht-=s.ht; return *this; }
+    QSize opSubAssign(in QSize s)
+    { wd-=s.wd; ht-=s.ht; return *this; }
 
-	QSize opMulAssign(qreal c)
-	{ wd = qRound(wd*c); ht = qRound(ht*c); return *this; }
+    QSize opMulAssign(qreal c)
+    { wd = qRound(wd*c); ht = qRound(ht*c); return *this; }
 
-	bool opEquals(ref QSize s)
-	{ return wd == s.wd && ht == s.ht; }
+    bool opEquals(in QSize s)
+    { return wd == s.wd && ht == s.ht; }
 
-	QSize opAdd(ref QSize s)
-	{ return QSize(this.wd+s.wd, this.ht+s.ht); }
+    QSize opAdd(in QSize s)
+    { return QSize(this.wd+s.wd, this.ht+s.ht); }
 
-	QSize opSub(ref QSize s)
-	{ return QSize(this.wd-s.wd, this.ht-s.ht); }
+    QSize opSub(in QSize s)
+    { return QSize(this.wd-s.wd, this.ht-s.ht); }
 
-	QSize opMul(qreal c)
-	{ return QSize(qRound(this.wd*c), qRound(this.ht*c)); }
+    QSize opMul(qreal c)
+    { return QSize(qRound(this.wd*c), qRound(this.ht*c)); }
 
-	QSize opDivAssign(qreal c) {
-    	assert(!qFuzzyCompare(c + 1, 1.));
-    	wd = qRound(wd/c); ht = qRound(ht/c);
-    	return *this;
-	}
+    QSize opDivAssign(qreal c) {
+        assert(!qFuzzyCompare(c + 1, 1.));
+        wd = qRound(wd/c); ht = qRound(ht/c);
+        return *this;
+    }
 
-	QSize opDiv(qreal c) {
-    	assert(!qFuzzyCompare(c + 1, 1.));
-    	return QSize(qRound(this.wd/c), qRound(this.ht/c));
-	}
+    QSize opDiv(qreal c) {
+        assert(!qFuzzyCompare(c + 1, 1.));
+        return QSize(qRound(this.wd/c), qRound(this.ht/c));
+    }
 
 private:
     int wd;
@@ -125,80 +125,80 @@
 public struct QSizeF
 {
 /* ctors, reserved for D2
-	this()
-	{ wd = ht = -1.; }
+    this()
+    { wd = ht = -1.; }
 
-	this(ref QSize sz)
-	{ wd = sz.width(); ht = sz.height(); }
+    this(ref QSize sz)
+    { wd = sz.width(); ht = sz.height(); }
 
-	this(qreal w, qreal h)
-	{ wd = w; ht = h; }
+    this(qreal w, qreal h)
+    { wd = w; ht = h; }
 */
-	public static QSizeF opCall() {
-    	QSizeF sz;
-		sz.wd = sz.ht = -1.;
-		return sz;
-	}
+    public static QSizeF opCall() {
+        QSizeF sz;
+        sz.wd = sz.ht = -1.;
+        return sz;
+    }
 
-	public static QSizeF opCall(ref QSizeF s) {
-		QSizeF sz;
-		sz.wd = s.width(); sz.ht = s.height();
-		return sz;
-	}
+    public static QSizeF opCall(in QSizeF s) {
+        QSizeF sz;
+        sz.wd = s.width(); sz.ht = s.height();
+        return sz;
+    }
 
-	public static QSizeF opCall(qreal w, qreal h) {
-		QSizeF sz;
-		sz.wd = w; sz.ht = h;
-		return sz;
-	}
+    public static QSizeF opCall(qreal w, qreal h) {
+        QSizeF sz;
+        sz.wd = w; sz.ht = h;
+        return sz;
+    }
 
-	bool isNull()
-	{ return qIsNull(wd) && qIsNull(ht); }
+    bool isNull()
+    { return qIsNull(wd) && qIsNull(ht); }
 
-	bool isEmpty()
-	{ return wd <= 0. || ht <= 0.; }
+    bool isEmpty()
+    { return wd <= 0. || ht <= 0.; }
 
-	bool isValid()
-	{ return wd >= 0. && ht >= 0.; }
+    bool isValid()
+    { return wd >= 0. && ht >= 0.; }
 
-	qreal width()
-	{ return wd; }
+    qreal width()
+    { return wd; }
 
-	qreal height()
-	{ return ht; }
+    qreal height()
+    { return ht; }
 
-	void width(qreal w)
-	{ wd = w; }
+    void width(qreal w)
+    { wd = w; }
 
-	void height(qreal h)
-	{ ht = h; }
+    void height(qreal h)
+    { ht = h; }
 
-	void setWidth(qreal w)
-	{ wd = w; }
+    void setWidth(qreal w)
+    { wd = w; }
 
-	void setHeight(qreal h)
-	{ ht = h; }
+    void setHeight(qreal h)
+    { ht = h; }
 
-	void scale(qreal w, qreal h, Qt.AspectRatioMode mode)
-	{ scale(QSizeF(w, h), mode); }
+    void scale(qreal w, qreal h, Qt.AspectRatioMode mode)
+    { scale(QSizeF(w, h), mode); }
 
     public final void scale(QSizeF s, Qt.AspectRatioMode mode)
     { __qtd_QSizeF_scale_QSizeF_AspectRatioMode(this, &s, mode); }
 
-	void transpose() {
-    	qreal tmp = wd;
-    	wd = ht;
-    	ht = tmp;
-	}
+    void transpose() {
+        qreal tmp = wd;
+        wd = ht;
+        ht = tmp;
+    }
 
-	QSizeF expandedTo(ref QSizeF otherSize)
-	{ return QSizeF(qMax(wd,otherSize.wd), qMax(ht,otherSize.ht)); }
+    QSizeF expandedTo(in QSizeF otherSize)
+    { return QSizeF(qMax(wd,otherSize.wd), qMax(ht,otherSize.ht)); }
 
-	QSizeF boundedTo(ref QSizeF otherSize)
-	{ return QSizeF(qMin(wd,otherSize.wd), qMin(ht,otherSize.ht)); }
+    QSizeF boundedTo(in QSizeF otherSize)
+    { return QSizeF(qMin(wd,otherSize.wd), qMin(ht,otherSize.ht)); }
 
-	QSize toSize()
-	{ return QSize(qRound(wd), qRound(ht));	}
+    QSize toSize()
+    { return QSize(qRound(wd), qRound(ht));    }
 /*
     public final void writeTo(QDataStream arg__1) {
         __qtd_QSizeF_writeTo_QDataStream(this, arg__1 is null ? null : arg__1.nativeId);
@@ -207,39 +207,39 @@
     public final void readFrom(QDataStream arg__1) {
         __qtd_QSizeF_readFrom_QDataStream(this, arg__1 is null ? null : arg__1.nativeId);
 */
-	QSizeF opAddAssign(ref QSizeF s)
-	{ wd += s.wd; ht += s.ht; return *this; }
+    QSizeF opAddAssign(in QSizeF s)
+    { wd += s.wd; ht += s.ht; return *this; }
 
-	QSizeF opSubAssign(ref QSizeF s)
-	{ wd -= s.wd; ht -= s.ht; return *this; }
+    QSizeF opSubAssign(in QSizeF s)
+    { wd -= s.wd; ht -= s.ht; return *this; }
 
-	QSizeF opMulAssign(qreal c)
-	{ wd *= c; ht *= c; return *this; }
+    QSizeF opMulAssign(qreal c)
+    { wd *= c; ht *= c; return *this; }
 
-	bool opEquals(ref QSizeF s)
-	{ return qFuzzyCompare(wd, s.wd) && qFuzzyCompare(ht, s.ht); }
+    bool opEquals(in QSizeF s)
+    { return qFuzzyCompare(wd, s.wd) && qFuzzyCompare(ht, s.ht); }
 
-	QSizeF opAdd(ref QSizeF s)
-	{ return QSizeF(this.wd+s.wd, this.ht+s.ht); }
+    QSizeF opAdd(in QSizeF s)
+    { return QSizeF(this.wd+s.wd, this.ht+s.ht); }
 
-	QSizeF opSub(ref QSizeF s)
-	{ return QSizeF(this.wd-s.wd, this.ht-s.ht); }
+    QSizeF opSub(in QSizeF s)
+    { return QSizeF(this.wd-s.wd, this.ht-s.ht); }
 
-	QSizeF opMul(qreal c)
-	{ return QSizeF(this.wd*c, this.ht*c); }
+    QSizeF opMul(qreal c)
+    { return QSizeF(this.wd*c, this.ht*c); }
 
-	QSizeF opDivAssign(qreal c)
-	{
-	    assert(!qFuzzyCompare(c + 1, 1.));
-	    wd = wd/c; ht = ht/c;
-	    return *this;
-	}
+    QSizeF opDivAssign(qreal c)
+    {
+        assert(!qFuzzyCompare(c + 1, 1.));
+        wd = wd/c; ht = ht/c;
+        return *this;
+    }
 
-	QSizeF opDiv(qreal c)
-	{
-	    assert(!qFuzzyCompare(c + 1, 1.));
-	    return QSizeF(this.wd/c, this.ht/c);
-	}
+    QSizeF opDiv(qreal c)
+    {
+        assert(!qFuzzyCompare(c + 1, 1.));
+        return QSizeF(this.wd/c, this.ht/c);
+    }
 
 private:
     qreal wd;