Mercurial > projects > qtd

changeset 3:323efbe5c2f7

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
native wrap of QLine and QLineF, fixes in opEquals, updated QPainter to the use of native structs
author eldar
date Wed, 13 May 2009 17:34:40 +0000
parents ee8e70aca95e
children 0a29ce1ae854
files cpp/qt_core/QLineF_shell.cpp cpp/qt_core/QLine_shell.cpp cpp/qt_core/QVariant_shell.cpp generator/typesystem_gui-java.java generator/typesystem_gui.xml qt/core/QLine.d qt/core/QLineF.d qt/core/QPoint.d qt/core/QSize.d qt/core/QVariant.d
diffstat 10 files changed, 683 insertions(+), 69 deletions(-) [+]
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cpp/qt_core/QLineF_shell.cpp	Wed May 13 17:34:40 2009 +0000
@@ -0,0 +1,144 @@
+#include <qdatastream.h>
+#include <qline.h>
+
+#include "qtd_core.h"
+
+
+// QLineF::angle() const
+extern "C" DLL_PUBLIC double qtd_QLineF_angle
+(void* __this_nativeId)
+{
+    QLineF *__qt_this = (QLineF *) __this_nativeId;
+    double  __qt_return_value = __qt_this->angle();
+
+    double __d_return_value = __qt_return_value;
+
+    return __d_return_value;
+}
+
+// QLineF::angle(const QLineF & l) const
+extern "C" DLL_PUBLIC double qtd_QLineF_angle_QLineF
+(void* __this_nativeId,
+ void* l0)
+{
+    const QLineF&  __qt_l0 = (const QLineF& ) *(QLineF *)l0;
+    QLineF *__qt_this = (QLineF *) __this_nativeId;
+    double  __qt_return_value = __qt_this->angle((const QLineF& )__qt_l0);
+
+    double __d_return_value = __qt_return_value;
+
+    return __d_return_value;
+}
+
+// QLineF::angleTo(const QLineF & l) const
+extern "C" DLL_PUBLIC double qtd_QLineF_angleTo_QLineF
+(void* __this_nativeId,
+ void* l0)
+{
+    const QLineF&  __qt_l0 = (const QLineF& ) *(QLineF *)l0;
+    QLineF *__qt_this = (QLineF *) __this_nativeId;
+    double  __qt_return_value = __qt_this->angleTo((const QLineF& )__qt_l0);
+
+    double __d_return_value = __qt_return_value;
+
+    return __d_return_value;
+}
+
+// QLineF::intersect(const QLineF & l, QPointF * intersectionPoint) const
+extern "C" DLL_PUBLIC int qtd_QLineF_intersect_QLineF_nativepointerQPointF
+(void* __this_nativeId,
+ void* l0,
+ void* intersectionPoint1)
+{
+    const QLineF&  __qt_l0 = (const QLineF& ) *(QLineF *)l0;
+    QLineF *__qt_this = (QLineF *) __this_nativeId;
+    int  __qt_return_value = __qt_this->intersect((const QLineF& )__qt_l0, (QPointF* )intersectionPoint1);
+
+    int __d_return_value = __qt_return_value;
+
+    return __d_return_value;
+}
+
+// QLineF::isNull() const
+extern "C" DLL_PUBLIC bool qtd_QLineF_isNull
+(void* __this_nativeId)
+{
+    QLineF *__qt_this = (QLineF *) __this_nativeId;
+    bool  __qt_return_value = __qt_this->isNull();
+
+    bool __d_return_value = __qt_return_value;
+
+    return __d_return_value;
+}
+
+// QLineF::length() const
+extern "C" DLL_PUBLIC double qtd_QLineF_length
+(void* __this_nativeId)
+{
+    QLineF *__qt_this = (QLineF *) __this_nativeId;
+    double  __qt_return_value = __qt_this->length();
+
+    double __d_return_value = __qt_return_value;
+
+    return __d_return_value;
+}
+
+// QLineF::operator<<(QDataStream & arg__1)
+extern "C" DLL_PUBLIC void qtd_QLineF_writeTo_QDataStream
+(void* __this_nativeId,
+ void* arg__1)
+{
+    QDataStream&  __qt_arg__1 = (QDataStream& ) * (QDataStream *) arg__1;
+    QLineF *__qt_this = (QLineF *) __this_nativeId;
+    if (__qt_this != 0) ::operator<<((QDataStream& )__qt_arg__1, *__qt_this);
+
+}
+
+// QLineF::operator>>(QDataStream & arg__1)
+extern "C" DLL_PUBLIC void qtd_QLineF_readFrom_QDataStream
+(void* __this_nativeId,
+ void* arg__1)
+{
+    QDataStream&  __qt_arg__1 = (QDataStream& ) * (QDataStream *) arg__1;
+    QLineF *__qt_this = (QLineF *) __this_nativeId;
+    if (__qt_this != 0) ::operator>>((QDataStream& )__qt_arg__1, *__qt_this);
+
+}
+
+// QLineF::p1() const
+extern "C" DLL_PUBLIC QPointF qtd_QLineF_p1
+(void* __this_nativeId)
+{
+    QLineF *__qt_this = (QLineF *) __this_nativeId;
+    QPointF  __qt_return_value = __qt_this->p1();
+
+    QPointF *__d_return_value = (QPointF *) &__qt_return_value;
+
+    return __qt_return_value;
+}
+
+// QLineF::setAngle(double angle)
+extern "C" DLL_PUBLIC void qtd_QLineF_setAngle_double
+(void* __this_nativeId,
+ double angle0)
+{
+    QLineF *__qt_this = (QLineF *) __this_nativeId;
+    __qt_this->setAngle((double )angle0);
+
+}
+
+// QLineF::unitVector() const
+extern "C" DLL_PUBLIC QLineF qtd_QLineF_unitVector
+(void* __this_nativeId)
+{
+    QLineF *__qt_this = (QLineF *) __this_nativeId;
+    return __qt_this->unitVector();
+}
+
+// QLineF::fromPolar(double length, double angle)
+extern "C" DLL_PUBLIC QLineF qtd_QLineF_fromPolar_double_double
+(double length0,
+ double angle1)
+{
+    return QLineF::fromPolar((double )length0, (double )angle1);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cpp/qt_core/QLine_shell.cpp	Wed May 13 17:34:40 2009 +0000
@@ -0,0 +1,26 @@
+#include <qdatastream.h>
+#include <qline.h>
+
+#include "qtd_core.h"
+
+// QLine::operator<<(QDataStream & arg__1)
+extern "C" DLL_PUBLIC void qtd_QLine_writeTo_QDataStream
+(void* __this_nativeId,
+ void* arg__1)
+{
+    QDataStream&  __qt_arg__1 = (QDataStream& ) * (QDataStream *) arg__1;
+    QLine *__qt_this = (QLine *) __this_nativeId;
+    if (__qt_this != 0) ::operator<<((QDataStream& )__qt_arg__1, *__qt_this);
+
+}
+
+// QLine::operator>>(QDataStream & arg__1)
+extern "C" DLL_PUBLIC void qtd_QLine_readFrom_QDataStream
+(void* __this_nativeId,
+ void* arg__1)
+{
+    QDataStream&  __qt_arg__1 = (QDataStream& ) * (QDataStream *) arg__1;
+    QLine *__qt_this = (QLine *) __this_nativeId;
+    if (__qt_this != 0) ::operator>>((QDataStream& )__qt_arg__1, *__qt_this);
+
+}
--- a/cpp/qt_core/QVariant_shell.cpp	Wed May 13 01:20:34 2009 +0000
+++ b/cpp/qt_core/QVariant_shell.cpp	Wed May 13 17:34:40 2009 +0000
@@ -732,27 +732,19 @@
 }
 
 // QVariant::toLine() const
-extern "C" DLL_PUBLIC void* qtd_QVariant_toLine
+extern "C" DLL_PUBLIC QLine qtd_QVariant_toLine
 (void* __this_nativeId)
 {
     QVariant_QtDShell *__qt_this = (QVariant_QtDShell *) __this_nativeId;
-    QLine  __qt_return_value = __qt_this->toLine();
-
-    void* __java_return_value = (void*) new QLine(__qt_return_value);
-
-    return __java_return_value;
+    return __qt_this->toLine();
 }
 
 // QVariant::toLineF() const
-extern "C" DLL_PUBLIC void* qtd_QVariant_toLineF
+extern "C" DLL_PUBLIC QLineF qtd_QVariant_toLineF
 (void* __this_nativeId)
 {
     QVariant_QtDShell *__qt_this = (QVariant_QtDShell *) __this_nativeId;
-    QLineF  __qt_return_value = __qt_this->toLineF();
-
-    void* __java_return_value = (void*) new QLineF(__qt_return_value);
-
-    return __java_return_value;
+    return __qt_this->toLineF();
 }
 
 // QVariant::toList() const
--- a/generator/typesystem_gui-java.java	Wed May 13 01:20:34 2009 +0000
+++ b/generator/typesystem_gui-java.java	Wed May 13 17:34:40 2009 +0000
@@ -1051,6 +1051,39 @@
     public final void drawConvexPolygon(QPointF[] points) {
         qtd_QPainter_drawConvexPolygon_nativepointerQPointF_int(nativeId, points.ptr, points.length);
     }
+    
+    public final void drawLines(QLine[] lines) {
+        qtd_QPainter_drawLines_nativepointerQLine_int(nativeId, lines.ptr, lines.length);
+    }
+
+    public final void drawLines(QLineF[] lines) {
+        qtd_QPainter_drawLines_nativepointerQLineF_int(nativeId, lines.ptr, lines.length);
+    }
+    
+    public final void drawPolygon(QPoint[] points, Qt_FillRule fillRule = Qt_FillRule.OddEvenFill) {
+        qtd_QPainter_drawPolygon_nativepointerQPoint_int_FillRule(nativeId, points.ptr, points.length, fillRule);
+    }
+
+    public final void drawPolygon(QPointF[] points, Qt_FillRule fillRule = Qt_FillRule.OddEvenFill) {
+        qtd_QPainter_drawPolygon_nativepointerQPointF_int_FillRule(nativeId, points.ptr, points.length, fillRule);
+    }
+
+    public final void drawPolyline(QPoint[] points) {
+        qtd_QPainter_drawPolyline_nativepointerQPoint_int(nativeId, points.ptr, points.length);
+    }
+
+    public final void drawPolyline(QPointF[] points) {
+        qtd_QPainter_drawPolyline_nativepointerQPointF_int(nativeId, points.ptr, points.length);
+    }
+    
+    public final void drawPoints(QPoint[] points) {
+        qtd_QPainter_drawPoints_nativepointerQPoint_int(nativeId, points.ptr, points.length);
+    }
+
+    public final void drawPoints(QPointF[] points) {
+        qtd_QPainter_drawPoints_nativepointerQPointF_int(nativeId, points.ptr, points.length);
+    }
+    
 /*
     public static QPaintDeviceInterface redirected(QPaintDeviceInterface device, qt.core.QPoint offset) {
         return redirected(device, offset == null ? null : offset.nativePointer());
--- a/generator/typesystem_gui.xml	Wed May 13 01:20:34 2009 +0000
+++ b/generator/typesystem_gui.xml	Wed May 13 17:34:40 2009 +0000
@@ -7249,53 +7249,64 @@
       <access modifier="private"/>
     </modify-function>
     <modify-function signature="drawLines(const QLine *, int)">
-        <remove/>
+        <access modifier="private"/>
     </modify-function>
     <modify-function signature="drawLines(const QLineF *, int)">
+        <access modifier="private"/>
+    </modify-function>
+
+    <modify-function signature="drawPoints(const QPoint *, int)">
+        <access modifier="private"/>
+    </modify-function>
+    <modify-function signature="drawPoints(const QPointF *, int)">
+        <access modifier="private"/>
+    </modify-function>
+    
+    <modify-function signature="drawPolygon(const QPoint *, int, Qt::FillRule)">
+        <access modifier="private"/>
+    </modify-function>
+    <modify-function signature="drawPolygon(const QPointF *, int, Qt::FillRule)">
+        <access modifier="private"/>
+    </modify-function>
+
+    <modify-function signature="drawPolyline(const QPoint *, int)">
+        <access modifier="private"/>
+    </modify-function>
+    <modify-function signature="drawPolyline(const QPointF *, int)">
+        <access modifier="private"/>
+    </modify-function>
+    
+    <modify-function signature="drawRects(const QRect *, int)">
         <remove/>
     </modify-function>
+    <modify-function signature="drawRects(const QRectF *, int)">
+        <remove/>
+    </modify-function>
+    <modify-function signature="drawRects(const QVector&lt;QRectF&gt; &amp;)">
+        <rename to="drawRectsF"/>
+    </modify-function>
+
+    <modify-function signature="drawLines(const QVector&lt;QLine&gt; &amp;)">
+        <remove/>
+    </modify-function>
+    <modify-function signature="drawLines(const QVector&lt;QLineF&gt; &amp;)">
+        <remove/>
+    </modify-function>
+
+    <modify-function signature="drawLines(const QVector&lt;QPoint&gt; &amp;)">
+        <remove/>
+    </modify-function>
+    <modify-function signature="drawLines(const QVector&lt;QPointF&gt; &amp;)">
+        <remove/>
+    </modify-function>
+
     <modify-function signature="drawLines(const QPoint *, int)">
         <remove/>
     </modify-function>
     <modify-function signature="drawLines(const QPointF *, int)">
         <remove/>
     </modify-function>
-    <modify-function signature="drawPoints(const QPoint *, int)">
-        <remove/>
-    </modify-function>
-    <modify-function signature="drawPoints(const QPointF *, int)">
-        <remove/>
-    </modify-function>
-    <modify-function signature="drawPolygon(const QPoint *, int, Qt::FillRule)">
-        <remove/>
-    </modify-function>
-    <modify-function signature="drawPolygon(const QPointF *, int, Qt::FillRule)">
-        <remove/>
-    </modify-function>
-    <modify-function signature="drawPolyline(const QPoint *, int)">
-        <remove/>
-    </modify-function>
-    <modify-function signature="drawPolyline(const QPointF *, int)">
-        <remove/>
-    </modify-function>
-    <modify-function signature="drawRects(const QRect *, int)">
-        <remove/>
-    </modify-function>
-    <modify-function signature="drawRects(const QRectF *, int)">
-        <remove/>
-    </modify-function>
-    <modify-function signature="drawLines(const QVector&lt;QPoint&gt; &amp;)">
-        <rename to="drawLinesFromPoints"/>
-    </modify-function>
-    <modify-function signature="drawLines(const QVector&lt;QPointF&gt; &amp;)">
-        <rename to="drawLinesFromPointsF"/>
-    </modify-function>
-    <modify-function signature="drawLines(const QVector&lt;QLineF&gt; &amp;)">
-        <rename to="drawLinesF"/>
-    </modify-function>
-    <modify-function signature="drawRects(const QVector&lt;QRectF&gt; &amp;)">
-        <rename to="drawRectsF"/>
-    </modify-function>
+
 
     <modify-function signature="QPainter(QPaintDevice *)">
         <modify-argument index="1">
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/qt/core/QLine.d	Wed May 13 17:34:40 2009 +0000
@@ -0,0 +1,400 @@
+module qt.core.QLine;
+
+public import qt.QGlobal;
+public import qt.core.Qt;
+public import qt.core.QPoint;
+public import qt.core.QDataStream;
+
+
+public struct QLine
+{
+    public static QLine opCall() {
+        QLine ln;
+        ln.pt1 = QPoint();
+        ln.pt2 = QPoint();
+        return ln;
+    }
+
+    public static QLine opCall(ref QPoint pt1_, ref QPoint pt2_) {
+        QLine ln;
+        ln.pt1 = pt1_;
+        ln.pt2 = pt2_;
+        return ln;
+    }
+
+    public static QLine opCall(int x1pos, int y1pos, int x2pos, int y2pos) {
+        QLine ln;
+        ln.pt1 = QPoint(x1pos, y1pos);
+        ln.pt2 = QPoint(x2pos, y2pos);
+        return ln;
+    }
+    
+    bool isNull() // const
+    {
+        return pt1 == pt2;
+    }
+    
+    int x1() // const
+    {
+        return pt1.x();
+    }
+    
+    int y1() // const
+    {
+        return pt1.y();
+    }
+    
+    int x2() // const
+    {
+        return pt2.x();
+    }
+    
+    int y2() // const
+    {
+        return pt2.y();
+    }
+    
+    QPoint p1() // const
+    {
+        return pt1;
+    }
+    
+    QPoint p2() // const
+    {
+        return pt2;
+    }
+    
+    int dx() // const
+    {
+        return pt2.x() - pt1.x();
+    }
+    
+    int dy() // const
+    {
+        return pt2.y() - pt1.y();
+    }
+    
+    void translate(ref QPoint point)
+    {
+        pt1 += point;
+        pt2 += point;
+    }
+    
+    void translate(int adx, int ady)
+    {
+        translate(QPoint(adx, ady));
+    }
+    
+    QLine translated(ref QPoint p) // const
+    {
+        return QLine(pt1 + p, pt2 + p);
+    }
+    
+    QLine translated(int adx, int ady) // const
+    {
+        return translated(QPoint(adx, ady));
+    }
+
+    void p1(ref QPoint aP1)
+    {
+        pt1 = aP1;
+    }
+
+    void p2(ref QPoint aP2)
+    {
+        pt2 = aP2;
+    }
+
+    void setP1(ref QPoint aP1) // for convenience
+    {
+        pt1 = aP1;
+    }
+    
+    void setP2(ref QPoint aP2) // for convenience
+    {
+        pt2 = aP2;
+    }
+    
+    void setPoints(ref QPoint aP1, ref QPoint aP2)
+    {
+        pt1 = aP1;
+        pt2 = aP2;
+    }
+    
+    void setLine(int aX1, int aY1, int aX2, int aY2)
+    {
+        pt1 = QPoint(aX1, aY1);
+        pt2 = QPoint(aX2, aY2);
+    }
+    
+    bool opEquals(ref QLine d) // const
+    {
+        return pt1 == d.pt1 && pt2 == d.pt2;
+    }
+
+    public final void writeTo(QDataStream arg__1) {
+        qtd_QLine_writeTo_QDataStream(this, arg__1 is null ? null : arg__1.nativeId);
+    }
+
+    public final void readFrom(QDataStream arg__1) {
+        qtd_QLine_readFrom_QDataStream(this, arg__1 is null ? null : arg__1.nativeId);
+    }
+
+private:
+    QPoint pt1, pt2;
+}
+
+
+public enum QLineF_IntersectType {
+    NoIntersection = 0,
+    BoundedIntersection = 1,
+    UnboundedIntersection = 2
+}
+
+public struct QLineF
+{
+    
+    alias QLineF_IntersectType IntersectType;
+    
+    alias QLineF_IntersectType.NoIntersection NoIntersection;
+    alias QLineF_IntersectType.BoundedIntersection BoundedIntersection;
+    alias QLineF_IntersectType.UnboundedIntersection UnboundedIntersection;
+    
+    public static QLineF opCall() {
+        QLineF ln;
+        ln.pt1 = QPointF();
+        ln.pt2 = QPointF();
+        return ln;
+    }
+    
+    public static QLineF opCall(ref QPointF apt1, ref QPointF apt2) {
+        QLineF ln;
+        ln.pt1 = apt1;
+        ln.pt2 = apt2;
+        return ln;
+    }
+    
+    public static QLineF opCall(qreal x1pos, qreal y1pos, qreal x2pos, qreal y2pos) {
+        QLineF ln;
+        ln.pt1 = QPointF(x1pos, y1pos);
+        ln.pt2 = QPointF(x2pos, y2pos);
+        return ln;
+    }
+    
+    public static QLineF opCall(ref QLine line){ 
+        QLineF ln;
+        ln.pt1 = QPointF(line.p1());
+        ln.pt2 = QPointF(line.p2());
+        return ln;
+    }
+    
+    public final bool isNull() // const
+    {
+        return qtd_QLineF_isNull(this);
+    }
+    
+    qreal x1() // const
+    {
+        return pt1.x();
+    }
+    
+    qreal y1() // const
+    {
+        return pt1.y();
+    }
+    
+    qreal x2() // const
+    {
+        return pt2.x();
+    }
+    
+    qreal y2() // const
+    {
+        return pt2.y();
+    }
+    
+    QPointF p1() // const
+    {
+        return pt1;
+    }
+    
+    QPointF p2() // const
+    {
+        return pt2;
+    }
+    
+    qreal dx() // const
+    {
+        return pt2.x() - pt1.x();
+    }
+    
+    qreal dy() // const
+    {
+        return pt2.y() - pt1.y();
+    }
+    
+    QLineF normalVector() // const
+    {
+        return QLineF(p1(), p1() + QPointF(dy(), -dx()));
+    }
+    
+    void translate(ref QPointF point)
+    {
+        pt1 += point;
+        pt2 += point;
+    }
+    
+    void translate(qreal adx, qreal ady)
+    {
+        this.translate(QPointF(adx, ady));
+    }
+    
+    QLineF translated(ref QPointF p) // const
+    {
+        return QLineF(pt1 + p, pt2 + p);
+    }
+    
+    QLineF translated(qreal adx, qreal ady) // const
+    {
+        return translated(QPointF(adx, ady));
+    }
+    
+    void setLength(qreal len)
+    {
+        if (isNull())
+            return;
+        QLineF v = unitVector();
+        pt2 = QPointF(pt1.x() + v.dx() * len, pt1.y() + v.dy() * len);
+    }
+    
+    void length(qreal len)
+    {
+        if (isNull())
+            return;
+        QLineF v = unitVector();
+        pt2 = QPointF(pt1.x() + v.dx() * len, pt1.y() + v.dy() * len);
+    }
+    
+    QPointF pointAt(qreal t) // const
+    {
+        qreal vx = pt2.x() - pt1.x();
+        qreal vy = pt2.y() - pt1.y();
+        return QPointF(pt1.x() + vx * t, pt1.y() + vy * t);
+    }
+    
+    QLine toLine() // const
+    {
+        return QLine(pt1.toPoint(), pt2.toPoint());
+    }
+    
+    void setP1(ref QPointF aP1)
+    {
+        pt1 = aP1;
+    }
+    
+    void setP2(ref QPointF aP2)
+    {
+        pt2 = aP2;
+    }
+    
+    void p1(ref QPointF aP1)
+    {
+        pt1 = aP1;
+    }
+    
+    void p2(ref QPointF aP2)
+    {
+        pt2 = aP2;
+    }
+    
+    void setPoints(ref QPointF aP1, ref QPointF aP2)
+    {
+        pt1 = aP1;
+        pt2 = aP2;
+    }
+    
+    void setLine(qreal aX1, qreal aY1, qreal aX2, qreal aY2)
+    {
+        pt1 = QPointF(aX1, aY1);
+        pt2 = QPointF(aX2, aY2);
+    }
+    
+    bool opEquals(ref QLineF d) // const
+    {
+        return pt1 == d.pt1 && pt2 == d.pt2;
+    }
+    
+    public final double angle() {
+        return qtd_QLineF_angle(this);
+    }
+    
+    public final double angle(ref QLineF l) {
+        return qtd_QLineF_angle_QLineF(this, &l);
+    }
+    
+    public final double angleTo(ref 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) {
+        return cast(QLineF_IntersectType) qtd_QLineF_intersect_QLineF_nativepointerQPointF(this, &l, intersectionPoint);
+    }
+    
+    public final double length() {
+        return qtd_QLineF_length(this);
+    }
+    
+    public final void writeTo(QDataStream arg__1) {
+        qtd_QLineF_writeTo_QDataStream(this, arg__1 is null ? null : arg__1.nativeId);
+    }
+    
+    public final void readFrom(QDataStream arg__1) {
+        qtd_QLineF_readFrom_QDataStream(this, arg__1 is null ? null : arg__1.nativeId);
+    }
+    
+    public final void setAngle(double angle) {
+        qtd_QLineF_setAngle_double(this, angle);
+    }
+    
+    public final QLineF unitVector() {
+        return qtd_QLineF_unitVector(this);
+    }
+    
+    public static QLineF fromPolar(double length, double angle) {
+        return qtd_QLineF_fromPolar_double_double(length, angle);
+    }
+    
+    private:
+        QPointF pt1, pt2;
+}
+
+
+// C wrappers
+// QLine
+private extern(C) void  qtd_QLine_writeTo_QDataStream(void* __this_nativeId,
+ void* arg__1);
+private extern(C) void  qtd_QLine_readFrom_QDataStream(void* __this_nativeId,
+ void* arg__1);
+
+// QLineF
+private extern(C) bool  qtd_QLineF_isNull(void* __this_nativeId);
+private extern(C) double  qtd_QLineF_angle(void* __this_nativeId);
+private extern(C) double  qtd_QLineF_angle_QLineF(void* __this_nativeId,
+ void* l0);
+private extern(C) double  qtd_QLineF_angleTo_QLineF(void* __this_nativeId,
+ void* l0);
+private extern(C) int  qtd_QLineF_intersect_QLineF_nativepointerQPointF(void* __this_nativeId,
+ void* l0,
+ void* intersectionPoint1);
+private extern(C) double  qtd_QLineF_length(void* __this_nativeId);
+private extern(C) void  qtd_QLineF_writeTo_QDataStream(void* __this_nativeId,
+ void* arg__1);
+private extern(C) void  qtd_QLineF_readFrom_QDataStream(void* __this_nativeId,
+ void* arg__1);
+private extern(C) void  qtd_QLineF_setAngle_double(void* __this_nativeId,
+ double angle0);
+
+private extern(C) QLineF  qtd_QLineF_unitVector(void* __this_nativeId);
+private extern(C) QLineF  qtd_QLineF_fromPolar_double_double(double length0,
+ double angle1);
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/qt/core/QLineF.d	Wed May 13 17:34:40 2009 +0000
@@ -0,0 +1,4 @@
+module qt.core.QLineF;
+/* dummy */
+
+public import qt.core.QLine;
\ No newline at end of file
--- a/qt/core/QPoint.d	Wed May 13 01:20:34 2009 +0000
+++ b/qt/core/QPoint.d	Wed May 13 17:34:40 2009 +0000
@@ -35,7 +35,13 @@
 
     void y(int ypos)
     { yp = ypos; }
-    
+
+    void setX(int xpos) // for convenience
+        { xp = xpos; }
+
+    void setY(int ypos) // for convenience
+        { yp = ypos; }
+
     public final int manhattanLength() {
         return qtd_QPoint_manhattanLength(this);
     }
@@ -56,8 +62,8 @@
     QPoint opMulAssign(qreal c)
     { xp = qRound(xp*c); yp = qRound(yp*c); return *this; }
     
-    bool opEquals(ref QPoint p1, ref QPoint p2)
-    { return p1.xp == p2.xp && p1.yp == p2.yp; }
+    bool opEquals(ref QPoint p)
+    { return xp == p.xp && yp == p.yp; }
 
     QPoint opAdd(ref QPoint p)
     { return QPoint(this.xp+p.xp, this.yp+p.yp); }
@@ -170,8 +176,8 @@
     QPointF opMulAssign(qreal c)
     { xp*=c; yp*=c; return *this; }
     
-    bool opEquals(ref QPointF p1, ref QPointF p2)
-    { return qFuzzyCompare(p1.xp, p2.xp) && qFuzzyCompare(p1.yp, p2.yp); }
+    bool opEquals(ref QPointF p)
+    { return qFuzzyCompare(xp, p.xp) && qFuzzyCompare(yp, p.yp); }
     
     QPointF opAdd(ref QPointF p)
     { return QPointF(this.xp+p.xp, this.yp+p.yp); }
--- a/qt/core/QSize.d	Wed May 13 01:20:34 2009 +0000
+++ b/qt/core/QSize.d	Wed May 13 17:34:40 2009 +0000
@@ -47,11 +47,11 @@
     
     final void height(int h)
     { ht = h; }
-
-    final void setWidth(int w)
+    
+    final void setWidth(int w) // for convenience
     { wd = w; }
     
-    void setHeight(int h)
+    final void setHeight(int h) // for convenience
     { ht = h; }
     
     void transpose() {
@@ -93,8 +93,8 @@
 	QSize opMulAssign(qreal c)
 	{ wd = qRound(wd*c); ht = qRound(ht*c); return *this; }
 
-	bool opEquals(ref QSize s1, ref QSize s2)
-	{ return s1.wd == s2.wd && s1.ht == s2.ht; }
+	bool opEquals(ref QSize s)
+	{ return wd == s.wd && ht == s.ht; }
 
 	QSize opAdd(ref QSize s)
 	{ return QSize(this.wd+s.wd, this.ht+s.ht); }
@@ -216,8 +216,8 @@
 	QSizeF opMulAssign(qreal c)
 	{ wd *= c; ht *= c; return *this; }
 
-	bool opEquals(ref QSizeF s1, ref QSizeF s2)
-	{ return qFuzzyCompare(s1.wd, s2.wd) && qFuzzyCompare(s1.ht, s2.ht); }
+	bool opEquals(ref 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); }
--- a/qt/core/QVariant.d	Wed May 13 01:20:34 2009 +0000
+++ b/qt/core/QVariant.d	Wed May 13 17:34:40 2009 +0000
@@ -149,13 +149,13 @@
 
 
     public this(QLine line) {
-        void* __qt_return_value = qtd_QVariant_QVariant_QLine(line is null ? null : line.nativeId);
+        void* __qt_return_value = qtd_QVariant_QVariant_QLine(&line);
         super(__qt_return_value);
     }
 
 
     public this(QLineF line) {
-        void* __qt_return_value = qtd_QVariant_QVariant_QLineF(line is null ? null : line.nativeId);
+        void* __qt_return_value = qtd_QVariant_QVariant_QLineF(&line);
         super(__qt_return_value);
     }
 
@@ -350,13 +350,11 @@
     }
 
     public final QLine toLine() {
-        void* __qt_return_value = qtd_QVariant_toLine(nativeId);
-        return new QLine(__qt_return_value, false);
+        return qtd_QVariant_toLine(nativeId);
     }
 
     public final QLineF toLineF() {
-        void* __qt_return_value = qtd_QVariant_toLineF(nativeId);
-        return new QLineF(__qt_return_value, false);
+        return qtd_QVariant_toLineF(nativeId);
     }
 
     public final QLocale toLocale() {
@@ -512,8 +510,8 @@
  bool* ok0);
 private extern(C) int  qtd_QVariant_toInt_nativepointerbool(void* __this_nativeId,
  bool* ok0);
-private extern(C) void*  qtd_QVariant_toLine(void* __this_nativeId);
-private extern(C) void*  qtd_QVariant_toLineF(void* __this_nativeId);
+private extern(C) QLine  qtd_QVariant_toLine(void* __this_nativeId);
+private extern(C) QLineF  qtd_QVariant_toLineF(void* __this_nativeId);
 private extern(C) void*  qtd_QVariant_toLocale(void* __this_nativeId);
 private extern(C) long  qtd_QVariant_toLongLong_nativepointerbool(void* __this_nativeId,
  bool* ok0);