--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cpp/qt_core/QRectF_shell.cpp	Thu May 14 11:02:22 2009 +0000
@@ -0,0 +1,106 @@
+#include <qdatastream.h>
+#include <qrect.h>
+
+#include "qtd_core.h"
+
+
+// QRectF::contains(const QPointF & p) const
+extern "C" DLL_PUBLIC bool qtd_QRectF_contains_QPointF
+(void* __this_nativeId,
+ void* p0)
+{
+    QRectF *__qt_this = (QRectF *) __this_nativeId;
+    const QPointF&  __qt_p0 = (const QPointF& ) *(QPointF *)p0;
+
+    bool  __qt_return_value = __qt_this->contains((const QPointF& )__qt_p0);
+
+    bool __d_return_value = __qt_return_value;
+
+    return __d_return_value;
+}
+
+// QRectF::contains(const QRectF & r) const
+extern "C" DLL_PUBLIC bool qtd_QRectF_contains_QRectF
+(void* __this_nativeId,
+ void* r0)
+{
+    const QRectF&  __qt_r0 = (const QRectF& ) *(QRectF *)r0;
+    QRectF *__qt_this = (QRectF *) __this_nativeId;
+    bool  __qt_return_value = __qt_this->contains((const QRectF& )__qt_r0);
+
+    bool __d_return_value = __qt_return_value;
+
+    return __d_return_value;
+}
+
+// QRectF::intersects(const QRectF & r) const
+extern "C" DLL_PUBLIC bool qtd_QRectF_intersects_QRectF
+(void* __this_nativeId,
+ void* r0)
+{
+    const QRectF&  __qt_r0 = (const QRectF& ) *(QRectF *)r0;
+    QRectF *__qt_this = (QRectF *) __this_nativeId;
+    bool  __qt_return_value = __qt_this->intersects((const QRectF& )__qt_r0);
+
+    bool __d_return_value = __qt_return_value;
+
+    return __d_return_value;
+}
+
+// QRectF::normalized() const
+extern "C" DLL_PUBLIC QRectF qtd_QRectF_normalized
+(void* __this_nativeId)
+{
+    QRectF *__qt_this = (QRectF *) __this_nativeId;
+    return __qt_this->normalized();
+}
+
+// QRectF::operator&(const QRectF & r) const
+extern "C" DLL_PUBLIC QRectF qtd_QRectF_operator_and_QRectF
+(void* __this_nativeId,
+ void* r0)
+{
+    const QRectF&  __qt_r0 = (const QRectF& ) *(QRectF *)r0;
+    QRectF *__qt_this = (QRectF *) __this_nativeId;
+    return __qt_this->operator&((const QRectF& )__qt_r0);
+}
+
+// QRectF::operator<<(QDataStream & arg__1)
+extern "C" DLL_PUBLIC void qtd_QRectF_writeTo_QDataStream
+(void* __this_nativeId,
+ void* arg__1)
+{
+    QDataStream&  __qt_arg__1 = (QDataStream& ) * (QDataStream *) arg__1;
+    QRectF *__qt_this = (QRectF *) __this_nativeId;
+    if (__qt_this != 0) ::operator<<((QDataStream& )__qt_arg__1, *__qt_this);
+
+}
+
+// QRectF::operator>>(QDataStream & arg__1)
+extern "C" DLL_PUBLIC void qtd_QRectF_readFrom_QDataStream
+(void* __this_nativeId,
+ void* arg__1)
+{
+    QDataStream&  __qt_arg__1 = (QDataStream& ) * (QDataStream *) arg__1;
+    QRectF *__qt_this = (QRectF *) __this_nativeId;
+    if (__qt_this != 0) ::operator>>((QDataStream& )__qt_arg__1, *__qt_this);
+
+}
+
+// QRectF::operator|(const QRectF & r) const
+extern "C" DLL_PUBLIC QRectF qtd_QRectF_operator_or_QRectF
+(void* __this_nativeId,
+ void* r0)
+{
+    const QRectF&  __qt_r0 = (const QRectF& ) *(QRectF *)r0;
+    QRectF *__qt_this = (QRectF *) __this_nativeId;
+    return __qt_this->operator|((const QRectF& )__qt_r0);
+}
+
+// QRectF::toAlignedRect() const
+extern "C" DLL_PUBLIC QRect qtd_QRectF_toAlignedRect
+(void* __this_nativeId)
+{
+    QRectF *__qt_this = (QRectF *) __this_nativeId;
+    return __qt_this->toAlignedRect();
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cpp/qt_core/QRect_shell.cpp	Thu May 14 11:02:22 2009 +0000
@@ -0,0 +1,98 @@
+#include <qdatastream.h>
+#include <qrect.h>
+
+#include "qtd_core.h"
+
+// QRect::contains(const QPoint & p, bool proper) const
+extern "C" DLL_PUBLIC bool qtd_QRect_contains_QPoint_bool
+(void* __this_nativeId,
+ void* p0,
+ bool proper1)
+{
+    QRect *__qt_this = (QRect *) __this_nativeId;
+    const QPoint&  __qt_p0 = (const QPoint& ) *(QPoint *)p0;
+    bool  __qt_return_value = __qt_this->contains((const QPoint& )p0, (bool )proper1);
+
+    bool __d_return_value = __qt_return_value;
+
+    return __d_return_value;
+}
+
+// QRect::contains(const QRect & r, bool proper) const
+extern "C" DLL_PUBLIC bool qtd_QRect_contains_QRect_bool
+(void* __this_nativeId,
+ void* r0,
+ bool proper1)
+{
+    const QRect&  __qt_r0 = (const QRect& ) *(QRect *)r0;
+    QRect *__qt_this = (QRect *) __this_nativeId;
+    bool  __qt_return_value = __qt_this->contains((const QRect& )__qt_r0, (bool )proper1);
+
+    bool __d_return_value = __qt_return_value;
+
+    return __d_return_value;
+}
+
+// QRect::intersects(const QRect & r) const
+extern "C" DLL_PUBLIC bool qtd_QRect_intersects_QRect
+(void* __this_nativeId,
+ void* r0)
+{
+    const QRect&  __qt_r0 = (const QRect& ) *(QRect *)r0;
+    QRect *__qt_this = (QRect *) __this_nativeId;
+    bool  __qt_return_value = __qt_this->intersects((const QRect& )__qt_r0);
+
+    bool __d_return_value = __qt_return_value;
+
+    return __d_return_value;
+}
+
+// QRect::normalized() const
+extern "C" DLL_PUBLIC QRect qtd_QRect_normalized
+(void* __this_nativeId)
+{
+    QRect *__qt_this = (QRect *) __this_nativeId;
+    return __qt_this->normalized();
+}
+
+// QRect::operator&(const QRect & r) const
+extern "C" DLL_PUBLIC QRect qtd_QRect_operator_and_QRect
+(void* __this_nativeId,
+ void* r0)
+{
+    const QRect&  __qt_r0 = (const QRect& ) *(QRect *)r0;
+    QRect *__qt_this = (QRect *) __this_nativeId;
+    return __qt_this->operator&((const QRect& )__qt_r0);
+}
+
+// QRect::operator<<(QDataStream & arg__1)
+extern "C" DLL_PUBLIC void qtd_QRect_writeTo_QDataStream
+(void* __this_nativeId,
+ void* arg__1)
+{
+    QDataStream&  __qt_arg__1 = (QDataStream& ) * (QDataStream *) arg__1;
+    QRect *__qt_this = (QRect *) __this_nativeId;
+    if (__qt_this != 0) ::operator<<((QDataStream& )__qt_arg__1, *__qt_this);
+
+}
+
+// QRect::operator>>(QDataStream & arg__1)
+extern "C" DLL_PUBLIC void qtd_QRect_readFrom_QDataStream
+(void* __this_nativeId,
+ void* arg__1)
+{
+    QDataStream&  __qt_arg__1 = (QDataStream& ) * (QDataStream *) arg__1;
+    QRect *__qt_this = (QRect *) __this_nativeId;
+    if (__qt_this != 0) ::operator>>((QDataStream& )__qt_arg__1, *__qt_this);
+
+}
+
+// QRect::operator|(const QRect & r) const
+extern "C" DLL_PUBLIC QRect qtd_QRect_operator_or_QRect
+(void* __this_nativeId,
+ void* r0)
+{
+    const QRect&  __qt_r0 = (const QRect& ) *(QRect *)r0;
+    QRect *__qt_this = (QRect *) __this_nativeId;
+    return __qt_this->operator|((const QRect& )__qt_r0);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/qt/core/QRect.d	Thu May 14 11:02:22 2009 +0000
@@ -0,0 +1,382 @@
+module qt.core.QRect;
+
+public import qt.QGlobal;
+public import qt.core.Qt;
+
+public import qt.core.QDataStream;
+public import qt.core.QSize;
+public import qt.core.QPoint;
+
+
+public struct QRect
+{
+    public static QRect opCall() {
+        QRect rt;
+        rt.x1 = rt.y1 = 0;
+        rt.x2 = rt.y2 = -1;
+        return rt;
+    }
+
+    public static QRect opCall(int aleft, int atop, int awidth, int aheight)
+    {
+        QRect rt;
+        rt.x1 = aleft;
+        rt.y1 = atop;
+        rt.x2 = (aleft + awidth - 1);
+        rt.y2 = (atop + aheight - 1);
+        return rt;
+    }
+
+    public static QRect opCall(ref QPoint atopLeft, ref QPoint abottomRight)
+    {
+        QRect rt;
+        rt.x1 = atopLeft.x();
+        rt.y1 = atopLeft.y();
+        rt.x2 = abottomRight.x();
+        rt.y2 = abottomRight.y();
+        return rt;
+    }
+
+    public static QRect opCall(ref QPoint atopLeft, ref QSize asize)
+    {
+        QRect rt;
+        rt.x1 = atopLeft.x();
+        rt.y1 = atopLeft.y();
+        rt.x2 = (rt.x1+asize.width() - 1);
+        rt.y2 = (rt.y1+asize.height() - 1);
+        return rt;
+    }
+
+    bool isNull() // const
+    { return x2 == x1 - 1 && y2 == y1 - 1; }
+
+    bool isEmpty() // const
+    { return x1 > x2 || y1 > y2; }
+
+    bool isValid() // const
+    { return x1 <= x2 && y1 <= y2; }
+
+    int left() // const
+    { return x1; }
+
+    int top() // const
+    { return y1; }
+
+    int right() // const
+    { return x2; }
+
+    int bottom() // const
+    { return y2; }
+
+    int x() // const
+    { return x1; }
+
+    int y() // const
+    { return y1; }
+
+    void left(int pos)
+    { x1 = pos; }
+
+    void top(int pos)
+    { y1 = pos; }
+
+    void right(int pos)
+    { x2 = pos; }
+
+    void bottom(int pos)
+    { y2 = pos; }
+
+    void setLeft(int pos)
+    { x1 = pos; }
+
+    void setTop(int pos)
+    { y1 = pos; }
+
+    void setRight(int pos)
+    { x2 = pos; }
+
+    void setBottom(int pos)
+    { y2 = pos; }
+
+    void setTopLeft(ref QPoint p)
+    { x1 = p.x(); y1 = p.y(); }
+
+    void setBottomRight(ref QPoint p)
+    { x2 = p.x(); y2 = p.y(); }
+
+    void setTopRight(ref QPoint p)
+    { x2 = p.x(); y1 = p.y(); }
+
+    void setBottomLeft(ref QPoint p)
+    { x1 = p.x(); y2 = p.y(); }
+
+    void setX(int ax)
+    { x1 = ax; }
+
+    void setY(int ay)
+    { y1 = ay; }
+
+    QPoint topLeft() // const
+    { return QPoint(x1, y1); }
+
+    QPoint bottomRight() // const
+    { return QPoint(x2, y2); }
+
+    QPoint topRight() // const
+    { return QPoint(x2, y1); }
+
+    QPoint bottomLeft() // const
+    { return QPoint(x1, y2); }
+
+    QPoint center() // const
+    { return QPoint((x1+x2)/2, (y1+y2)/2); }
+
+    int width() // const
+    { return  x2 - x1 + 1; }
+
+    int height() // const
+    { return  y2 - y1 + 1; }
+
+    QSize size() // const
+    { return QSize(width(), height()); }
+
+    void translate(int dx, int dy)
+    {
+        x1 += dx;
+        y1 += dy;
+        x2 += dx;
+        y2 += dy;
+    }
+
+    void translate(ref QPoint p)
+    {
+        x1 += p.x();
+        y1 += p.y();
+        x2 += p.x();
+        y2 += p.y();
+    }
+
+    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
+    { return QRect(QPoint(x1 + p.x(), y1 + p.y()), QPoint(x2 + p.x(), y2 + p.y())); }
+
+    void moveTo(int ax, int ay)
+    {
+        x2 += ax - x1;
+        y2 += ay - y1;
+        x1 = ax;
+        y1 = ay;
+    }
+
+    void moveTo(ref QPoint p)
+    {
+        x2 += p.x() - x1;
+        y2 += p.y() - y1;
+        x1 = p.x();
+        y1 = p.y();
+    }
+
+    void moveLeft(int pos)
+    { x2 += (pos - x1); x1 = pos; }
+
+    void moveTop(int pos)
+    { y2 += (pos - y1); y1 = pos; }
+
+    void moveRight(int pos)
+    {
+        x1 += (pos - x2);
+        x2 = pos;
+    }
+
+    void moveBottom(int pos)
+    {
+        y1 += (pos - y2);
+        y2 = pos;
+    }
+
+    void moveTopLeft(ref QPoint p)
+    {
+        moveLeft(p.x());
+        moveTop(p.y());
+    }
+
+    void moveBottomRight(ref QPoint p)
+    {
+        moveRight(p.x());
+        moveBottom(p.y());
+    }
+
+    void moveTopRight(ref QPoint p)
+    {
+        moveRight(p.x());
+        moveTop(p.y());
+    }
+
+    void moveBottomLeft(ref QPoint p)
+    {
+        moveLeft(p.x());
+        moveBottom(p.y());
+    }
+
+    void getRect(int *ax, int *ay, int *aw, int *ah) // const
+    {
+        *ax = x1;
+        *ay = y1;
+        *aw = x2 - x1 + 1;
+        *ah = y2 - y1 + 1;
+    }
+
+    void setRect(int ax, int ay, int aw, int ah)
+    {
+        x1 = ax;
+        y1 = ay;
+        x2 = (ax + aw - 1);
+        y2 = (ay + ah - 1);
+    }
+
+    void getCoords(int *xp1, int *yp1, int *xp2, int *yp2) // const
+    {
+        *xp1 = x1;
+        *yp1 = y1;
+        *xp2 = x2;
+        *yp2 = y2;
+    }
+
+    void setCoords(int xp1, int yp1, int xp2, int yp2)
+    {
+        x1 = xp1;
+        y1 = yp1;
+        x2 = xp2;
+        y2 = yp2;
+    }
+
+    QRect adjusted(int xp1, int yp1, int xp2, int yp2) // const
+    { return QRect(QPoint(x1 + xp1, y1 + yp1), QPoint(x2 + xp2, y2 + yp2)); }
+
+    void adjust(int dx1, int dy1, int dx2, int dy2)
+    {
+        x1 += dx1;
+        y1 += dy1;
+        x2 += dx2;
+        y2 += dy2;
+    }
+
+    void setWidth(int w)
+    { x2 = (x1 + w - 1); }
+
+    void setHeight(int h)
+    { y2 = (y1 + h - 1); }
+
+    void setSize(ref QSize s)
+    {
+        x2 = (s.width()  + x1 - 1);
+        y2 = (s.height() + y1 - 1);
+    }
+
+    bool contains(int ax, int ay, bool aproper) // const
+    {
+        return contains(QPoint(ax, ay), aproper);
+    }
+
+    bool contains(int ax, int ay) // const
+    {
+        return contains(QPoint(ax, ay), false);
+    }
+
+    QRect opOrAssign(ref QRect r)
+    {
+        *this = *this | r;
+        return *this;
+    }
+
+    QRect opAndAssign(ref QRect r)
+    {
+        *this = *this & r;
+        return *this;
+    }
+
+    QRect intersected(ref QRect other) // const
+    {
+        return *this & other;
+    }
+
+    QRect united(ref QRect r) // const
+    {
+        return *this | r;
+    }
+
+    bool opEquals(ref QRect r)
+    {
+        return x1==r.x1 && x2==r.x2 && y1==r.y1 && y2==r.y2;
+    }
+
+    public final void writeTo(QDataStream arg__1) {
+        qtd_QRect_writeTo_QDataStream(this, arg__1 is null ? null : arg__1.nativeId);
+    }
+
+    public final void readFrom(QDataStream arg__1) {
+        qtd_QRect_readFrom_QDataStream(this, arg__1 is null ? null : arg__1.nativeId);
+    }
+
+    public final QRect opAnd(ref QRect r) {
+        return qtd_QRect_operator_and_QRect(this, &r);
+    }
+
+    public final QRect opOr(ref QRect r) {
+        return qtd_QRect_operator_or_QRect(this, &r);
+    }
+
+    public final bool contains(QPoint p, bool proper = false) {
+        return qtd_QRect_contains_QPoint_bool(this, &p, proper);
+    }
+
+    public final bool contains(QRect r, bool proper = false) {
+        return qtd_QRect_contains_QRect_bool(this, &r, proper);
+    }
+    
+    public final bool intersects(QRect r) {
+        return qtd_QRect_intersects_QRect(this, &r);
+    }
+
+    public final QRect normalized() {
+        return qtd_QRect_normalized(this);
+    }
+    
+private:
+    version(OSX)
+    {
+        int y1;
+        int x1;
+        int y2;
+        int x2;
+    }
+    else
+    {
+        int x1;
+        int y1;
+        int x2;
+        int y2;
+    }
+}
+
+
+// C wrappers
+private extern(C) bool  qtd_QRect_contains_QPoint_bool(void* __this_nativeId,
+ void* p0,
+ bool proper1);
+private extern(C) bool  qtd_QRect_contains_QRect_bool(void* __this_nativeId,
+ void* r0,
+ bool proper1);
+private extern(C) bool  qtd_QRect_intersects_QRect(void* __this_nativeId,
+ void* r0);
+private extern(C) QRect  qtd_QRect_normalized(void* __this_nativeId);
+private extern(C) void  qtd_QRect_writeTo_QDataStream(void* __this_nativeId,
+ void* arg__1);
+private extern(C) void  qtd_QRect_readFrom_QDataStream(void* __this_nativeId,
+ void* arg__1);
+private extern(C) QRect  qtd_QRect_operator_and_QRect(void* __this_nativeId,
+ void* r0);
+private extern(C) QRect  qtd_QRect_operator_or_QRect(void* __this_nativeId,
+ void* r0);
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/qt/core/QRectF.d	Thu May 14 11:02:22 2009 +0000
@@ -0,0 +1,338 @@
+module qt.core.QRectF;
+
+public import qt.QGlobal;
+public import qt.core.Qt;
+public import qt.core.QPointF;
+public import qt.core.QRect;
+public import qt.core.QSizeF;
+public import qt.core.QDataStream;
+
+
+public struct QRectF
+{
+
+    public static QRectF opCall()
+    {
+        QRectF rt;
+        rt.xp = rt.yp = 0.;
+        rt.w = rt.h = 0.;
+        return rt;
+    }
+    
+    public static QRectF opCall(qreal aleft, qreal atop, qreal awidth, qreal aheight)
+    {
+        QRectF rt;
+        rt.xp = aleft;
+        rt.yp = atop;
+        rt.w = awidth;
+        rt.h = aheight;
+        return rt;
+    }
+
+    public static QRectF opCall(ref QPointF atopLeft, ref QSizeF asize)
+    {
+        QRectF rt;
+        rt.xp = atopLeft.x();
+        rt.yp = atopLeft.y();
+        rt.w = asize.width();
+        rt.h = asize.height();
+        return rt;
+    }
+
+    public static QRectF opCall(ref QPointF atopLeft, ref QPointF abottomRight)
+    {
+        QRectF rt;
+        rt.xp = atopLeft.x();
+        rt.yp = atopLeft.y();
+        rt.w = abottomRight.x() - rt.xp;
+        rt.h = abottomRight.y() - rt.yp;
+        return rt;
+    }
+
+    public static QRectF opCall(ref QRect r)
+    {
+        QRectF rt;
+        rt.xp = r.x();
+        rt.yp = r.y();
+        rt.w = r.width();
+        rt.h = r.height();
+        return rt;
+    }
+
+    bool isNull() // conts
+    { return qIsNull(w) && qIsNull(h); }
+
+    bool isEmpty() // conts
+    { return w <= 0. || h <= 0.; }
+
+    bool isValid() // conts
+    { return w > 0. && h > 0.; }
+
+    qreal x() // conts
+    { return xp; }
+
+    qreal y() // conts
+    { return yp; }
+
+    qreal left() // const
+    { return xp; }
+    
+    qreal top() // const
+    { return yp; }
+    
+    qreal right() // const
+    { return xp + w; }
+    
+    qreal bottom() // const
+    { return yp + h; }
+    
+    QPointF topLeft() // const
+    { return QPointF(xp, yp); }
+    
+    QPointF bottomRight() // const
+    { return QPointF(xp+w, yp+h); }
+    
+    QPointF topRight() // const
+    { return QPointF(xp+w, yp); }
+    
+    QPointF bottomLeft() // const
+    { return QPointF(xp, yp+h); }
+    
+    void setLeft(qreal pos) { qreal diff = pos - xp; xp += diff; w -= diff; }
+
+    void setRight(qreal pos) { w = pos - xp; }
+
+    void setTop(qreal pos) { qreal diff = pos - yp; yp += diff; h -= diff; }
+
+    void setBottom(qreal pos) { h = pos - yp; }
+
+    void setTopLeft(ref QPointF p) { setLeft(p.x()); setTop(p.y()); }
+
+    void setTopRight(ref QPointF p) { setRight(p.x()); setTop(p.y()); }
+
+    void setBottomLeft(ref QPointF p) { setLeft(p.x()); setBottom(p.y()); }
+
+    void setBottomRight(ref QPointF p) { setRight(p.x()); setBottom(p.y()); }
+
+    QPointF center() // conts
+    { return QPointF(xp + w/2, yp + h/2); }
+
+    void moveLeft(qreal pos) { xp = pos; }
+
+    void moveTop(qreal pos) { yp = pos; }
+
+    void moveRight(qreal pos) { xp = pos - w; }
+
+    void moveBottom(qreal pos) { yp = pos - h; }
+
+    void moveTopLeft(ref QPointF p) { moveLeft(p.x()); moveTop(p.y()); }
+
+    void moveTopRight(ref QPointF p) { moveRight(p.x()); moveTop(p.y()); }
+
+    void moveBottomLeft(ref QPointF p) { moveLeft(p.x()); moveBottom(p.y()); }
+
+    void moveBottomRight(ref QPointF p) { moveRight(p.x()); moveBottom(p.y()); }
+
+    void moveCenter(ref QPointF p) { xp = p.x() - w/2; yp = p.y() - h/2; }
+
+    qreal width() // conts
+    { return w; }
+
+    qreal height() // conts
+    { return h; }
+
+    QSizeF size() // conts
+    { return QSizeF(w, h); }
+
+    void translate(qreal dx, qreal dy)
+    {
+        xp += dx;
+        yp += dy;
+    }
+
+    void translate(ref QPointF p)
+    {
+        xp += p.x();
+        yp += p.y();
+    }
+
+    void moveTo(qreal ax, qreal ay)
+    {
+        xp = ax;
+        yp = ay;
+    }
+
+    void moveTo(ref QPointF p)
+    {
+        xp = p.x();
+        yp = p.y();
+    }
+
+    QRectF translated(qreal dx, qreal dy) // conts
+    { return QRectF(xp + dx, yp + dy, w, h); }
+
+    QRectF translated(ref QPointF p) // conts
+    { return QRectF(xp + p.x(), yp + p.y(), w, h); }
+
+    void getRect(qreal *ax, qreal *ay, qreal *aaw, qreal *aah) // conts
+    {
+        *ax = this.xp;
+        *ay = this.yp;
+        *aaw = this.w;
+        *aah = this.h;
+    }
+
+    void setRect(qreal ax, qreal ay, qreal aaw, qreal aah)
+    {
+        this.xp = ax;
+        this.yp = ay;
+        this.w = aaw;
+        this.h = aah;
+    }
+
+    void getCoords(qreal *xp1, qreal *yp1, qreal *xp2, qreal *yp2) // conts
+    {
+        *xp1 = xp;
+        *yp1 = yp;
+        *xp2 = xp + w;
+        *yp2 = yp + h;
+    }
+
+    void setCoords(qreal xp1, qreal yp1, qreal xp2, qreal yp2)
+    {
+        xp = xp1;
+        yp = yp1;
+        w = xp2 - xp1;
+        h = yp2 - yp1;
+    }
+
+    void adjust(qreal xp1, qreal yp1, qreal xp2, qreal yp2)
+    { xp += xp1; yp += yp1; w += xp2 - xp1; h += yp2 - yp1; }
+
+    QRectF adjusted(qreal xp1, qreal yp1, qreal xp2, qreal yp2) // conts
+    { return QRectF(xp + xp1, yp + yp1, w + xp2 - xp1, h + yp2 - yp1); }
+
+    void setWidth(qreal aw) // for convenience
+    { this.w = aw; }
+
+    void setHeight(qreal ah) // for convenience
+    { this.h = ah; }
+
+    void setSize(ref QSizeF s) // for convenience
+    {
+        w = s.width();
+        h = s.height();
+    }
+
+    void width(qreal aw)
+    { this.w = aw; }
+
+    void height(qreal ah)
+    { this.h = ah; }
+
+    void size(ref QSizeF s)
+    {
+        w = s.width();
+        h = s.height();
+    }
+    
+    bool contains(qreal ax, qreal ay) // conts
+    {
+        return contains(QPointF(ax, ay));
+    }
+
+    QRectF opOrAssign(ref QRectF r)
+    {
+        *this = *this | r;
+        return *this;
+    }
+
+    QRectF opAndAssign(ref QRectF r)
+    {
+        *this = *this & r;
+        return *this;
+    }
+
+    QRectF intersected(ref QRectF r) // conts
+    {
+        return *this & r;
+    }
+
+    QRectF united(ref QRectF r) // conts
+    {
+        return *this | r;
+    }
+
+    bool opEquals(ref QRectF r)
+    {
+        return qFuzzyCompare(xp, r.xp) && qFuzzyCompare(yp, r.yp)
+            && qFuzzyCompare(w, r.w) && qFuzzyCompare(h, r.h);
+    }
+
+    QRect toRect() // conts
+    {
+        return QRect(qRound(xp), qRound(yp), qRound(w), qRound(h));
+    }
+
+    public final bool contains(QPointF p) {
+        return qtd_QRectF_contains_QPointF(this, &p);
+    }
+
+    public final bool contains(QRectF r) {
+        return qtd_QRectF_contains_QRectF(this, &r);
+    }
+
+    public final bool intersects(QRectF r) {
+        return qtd_QRectF_intersects_QRectF(this, &r);
+    }
+
+    public final QRectF normalized() {
+        return qtd_QRectF_normalized(this);
+    }
+
+    public final QRectF opAnd(ref QRectF r) {
+        return qtd_QRectF_operator_and_QRectF(this, &r);
+    }
+
+    public final void writeTo(QDataStream arg__1) {
+        qtd_QRectF_writeTo_QDataStream(this, arg__1 is null ? null : arg__1.nativeId);
+    }
+
+    public final void readFrom(QDataStream arg__1) {
+        qtd_QRectF_readFrom_QDataStream(this, arg__1 is null ? null : arg__1.nativeId);
+    }
+
+    public final QRectF opOr(ref QRectF r) {
+        return qtd_QRectF_operator_or_QRectF(this, &r);
+    }
+
+    public final QRect toAlignedRect() // const
+    {
+        return qtd_QRectF_toAlignedRect(this);
+    }
+
+private:
+    qreal xp;
+    qreal yp;
+    qreal w;
+    qreal h;
+}
+
+
+// C wrappers
+private extern(C) bool  qtd_QRectF_contains_QPointF(void* __this_nativeId,
+ void* p0);
+private extern(C) bool  qtd_QRectF_contains_QRectF(void* __this_nativeId,
+ void* r0);
+private extern(C) bool  qtd_QRectF_intersects_QRectF(void* __this_nativeId,
+ void* r0);
+private extern(C) QRectF  qtd_QRectF_normalized(void* __this_nativeId);
+private extern(C) QRectF  qtd_QRectF_operator_and_QRectF(void* __this_nativeId,
+ void* r0);
+private extern(C) void  qtd_QRectF_writeTo_QDataStream(void* __this_nativeId,
+ void* arg__1);
+private extern(C) void  qtd_QRectF_readFrom_QDataStream(void* __this_nativeId,
+ void* arg__1);
+private extern(C) QRectF  qtd_QRectF_operator_or_QRectF(void* __this_nativeId,
+ void* r0);
+private extern(C) QRect  qtd_QRectF_toAlignedRect(void* __this_nativeId);
\ No newline at end of file