# HG changeset patch # User eldar # Date 1242236080 0 # Node ID 323efbe5c2f7da6a23a6c36ab87d757372997c91 # Parent ee8e70aca95e92b0b5af55506e76cfad597eebb1 native wrap of QLine and QLineF, fixes in opEquals, updated QPainter to the use of native structs diff -r ee8e70aca95e -r 323efbe5c2f7 cpp/qt_core/QLineF_shell.cpp --- /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 +#include + +#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); +} diff -r ee8e70aca95e -r 323efbe5c2f7 cpp/qt_core/QLine_shell.cpp --- /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 +#include + +#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); + +} diff -r ee8e70aca95e -r 323efbe5c2f7 cpp/qt_core/QVariant_shell.cpp --- 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 diff -r ee8e70aca95e -r 323efbe5c2f7 generator/typesystem_gui-java.java --- 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()); diff -r ee8e70aca95e -r 323efbe5c2f7 generator/typesystem_gui.xml --- 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 @@ - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + diff -r ee8e70aca95e -r 323efbe5c2f7 qt/core/QLine.d --- /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); diff -r ee8e70aca95e -r 323efbe5c2f7 qt/core/QLineF.d --- /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 diff -r ee8e70aca95e -r 323efbe5c2f7 qt/core/QPoint.d --- 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); } diff -r ee8e70aca95e -r 323efbe5c2f7 qt/core/QSize.d --- 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); } diff -r ee8e70aca95e -r 323efbe5c2f7 qt/core/QVariant.d --- 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);