--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/generator/typesystem_gui-java.java	Mon May 11 16:01:50 2009 +0000
@@ -0,0 +1,1680 @@
+/****************************************************************************
+**
+** Copyright (C) 1992-2008 Nokia. All rights reserved.
+**
+** This file is part of Qt Jambi.
+**
+** * Commercial Usage
+* Licensees holding valid Qt Commercial licenses may use this file in
+* accordance with the Qt Commercial License Agreement provided with the
+* Software or, alternatively, in accordance with the terms contained in
+* a written agreement between you and Nokia.
+*
+*
+* GNU General Public License Usage
+* Alternatively, this file may be used under the terms of the GNU
+* General Public License versions 2.0 or 3.0 as published by the Free
+* Software Foundation and appearing in the file LICENSE.GPL included in
+* the packaging of this file.  Please review the following information
+* to ensure GNU General Public Licensing requirements will be met:
+* http://www.fsf.org/licensing/licenses/info/GPLv2.html and
+* http://www.gnu.org/copyleft/gpl.html.  In addition, as a special
+* exception, Nokia gives you certain additional rights. These rights
+* are described in the Nokia Qt GPL Exception version 1.2, included in
+* the file GPL_EXCEPTION.txt in this package.
+* 
+* Qt for Windows(R) Licensees
+* As a special exception, Nokia, as the sole copyright holder for Qt
+* Designer, grants users of the Qt/Eclipse Integration plug-in the
+* right for the Qt/Eclipse Integration to link to functionality
+* provided by Qt Designer and its related libraries.
+*
+*
+* If you are unsure which license is appropriate for your use, please
+* contact the sales department at qt-sales@nokia.com.
+
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+****************************************************************************/
+
+package generator;
+
+import qt.QNativePointer;
+import qt.QtBlockedSlot;
+import qt.core.QPoint;
+import qt.core.QPointF;
+import qt.gui.*;
+
+class QIconEngineV2___ extends QIconEngineV2 {
+    public QIconEngineV2 clone() {
+        return null;
+    }
+}// class
+
+class QTransform___ extends QTransform {
+
+    public final QTransform multiply(double d) {
+        operator_multiply_assign(d);
+        return this;
+    }
+
+    public final QTransform multiply(QTransform matrix) {
+        operator_multiply_assign(matrix);
+        return this;
+    }
+
+    public final QTransform add(double d) {
+        operator_add_assign(d);
+        return this;
+    }
+
+    public final QTransform divide(double d) {
+        operator_divide_assign(d);
+        return this;
+    }
+
+    public final QTransform subtract(double d) {
+        operator_subtract_assign(d);
+        return this;
+    }
+
+    /**
+     * Returns an inverted copy of this transformation.
+     *
+     * @return The inverse of the transformation.
+     * @throws IllegalArgumentException
+     *             If this transformation is not invertible.
+     */
+/*    public final QTransform inverted() {
+        QNativePointer ok = new QNativePointer(QNativePointer.Type.Boolean);
+        QTransform returned = inverted(ok);
+        if (!ok.booleanValue())
+            throw new IllegalArgumentException("Transformation is not invertible");
+        return returned;
+    }
+*/
+    /**
+     * Creates a transformation mapping one arbitrary quad into another.
+     *
+     * @return The transformation.
+     * @throws IllegalArgumentException
+     *             If this transformation is not possible.
+     */
+  /*  public static final QTransform quadToQuad(QPolygonF from, QPolygonF to) {
+        QTransform res = new QTransform();
+        QNativePointer resPointer = res.nativePointer();
+        if (quadToQuadPrivate(from, to, resPointer)) {
+            return res;
+        } else
+            throw new IllegalArgumentException("Transformation is not possible");
+    }
+*/
+    /**
+     * Creates a transformation that maps a quad to a unit square.
+     *
+     * @return The transformation.
+     * @throws IllegalArgumentException If this transformation is not possible.
+     */
+/*    public static final QTransform quadToSquare(QPolygonF quad) {
+        QTransform res = new QTransform();
+        QNativePointer resPointer = res.nativePointer();
+        if (quadToSquarePrivate(quad, resPointer)) {
+            return res;
+        } else
+            throw new IllegalArgumentException("Transformation is not possible");
+    }
+*/
+    /**
+     * Creates a transformation that maps a unit square to a the given quad.
+     *
+     * @return The transformation.
+     * @throws IllegalArgumentException
+     *             If this transformation is not possible.
+     */
+/*    public static final QTransform squareToQuad(QPolygonF quad) {
+        QTransform res = new QTransform();
+        QNativePointer resPointer = res.nativePointer();
+        if (squareToQuadPrivate(quad, resPointer)) {
+            return res;
+        } else
+            throw new IllegalArgumentException("Transformation is not possible");
+    }
+*/
+}// class
+
+class QBitmap___ extends QBitmap {
+/*
+    public QBitmap(String fileName, String format) {
+        this(fileName, format == null ? null : qt.QNativePointer.createCharPointer(format));
+    }
+
+    public QBitmap(String fileName) {
+        this(fileName, (String) null);
+    }
+
+    public static QBitmap fromData(qt.core.QSize size, byte bits[], QImage.Format monoFormat) {
+        return fromData(size, qt.internal.QtJambiInternal.byteArrayToNativePointer(bits), monoFormat);
+    }
+
+    public static QBitmap fromData(qt.core.QSize size, byte bits[]) {
+        return fromData(size, bits, QImage.Format.Format_MonoLSB);
+    }
+	*/
+}// class
+
+class QPolygon___ extends QPolygon {
+/*
+    private native void add_private(long nid, int x, int y);
+
+    @QtBlockedSlot
+    public final QPolygon add(int x, int y) {
+        add_private(nativeId(), x, y);
+        return this;
+    }
+
+    @QtBlockedSlot
+    public final QPolygon add(QPoint pt) {
+        add_private(nativeId(), pt.x(), pt.y());
+        return this;
+    }
+
+    @QtBlockedSlot
+    public final QPolygon add(QPolygon p) {
+        int size = p.size();
+        long nid = nativeId();
+        for (int i = 0; i < size; ++i) {
+            QPoint pt = p.at(i);
+            add_private(nid, pt.x(), pt.y());
+        }
+        return this;
+    }
+*/
+}// class
+
+class QPolygonF___ extends QPolygonF {
+  /*
+    private native void add_private(long nid, double x, double y);
+
+    @QtBlockedSlot
+    public final QPolygonF add(double x, double y) {
+        add_private(nativeId(), x, y);
+        return this;
+    }
+
+    @QtBlockedSlot
+    public final QPolygonF add(QPointF pt) {
+        add_private(nativeId(), pt.x(), pt.y());
+        return this;
+    }
+
+    @QtBlockedSlot
+    public final QPolygonF add(QPolygonF p) {
+        int size = p.size();
+        long nid = nativeId();
+        for (int i = 0; i < size; ++i) {
+            QPointF pt = p.at(i);
+            add_private(nid, pt.x(), pt.y());
+        }
+        return this;
+    }
+	*/
+}// class
+
+class QTreeWidgetItemIterator___ extends QTreeWidgetItemIterator {
+    @QtBlockedSlot
+    public final void next(int i) {
+        operator_add_assign(i);
+    }
+
+    @QtBlockedSlot
+    public final void previous(int i) {
+        operator_subtract_assign(i);
+    }
+
+    @QtBlockedSlot
+    public final void next() {
+        operator_increment();
+    }
+
+    @QtBlockedSlot
+    public final void previous() {
+        operator_decrement();
+    }
+
+    @QtBlockedSlot
+    public final QTreeWidgetItem current() {
+        return operator_multiply();
+    }
+}// class
+
+class QTextCursor___ extends QTextCursor {
+/*    public final QTableArea selectedTableCells() {
+        QNativePointer firstRow = new QNativePointer(QNativePointer.Type.Int);
+        QNativePointer numRows = new QNativePointer(QNativePointer.Type.Int);
+        QNativePointer firstColumn = new QNativePointer(QNativePointer.Type.Int);
+        QNativePointer numColumns = new QNativePointer(QNativePointer.Type.Int);
+
+        selectedTableCells(firstRow, numRows, firstColumn, numColumns);
+
+        return new QTableArea(firstRow.intValue(), firstColumn.intValue(), numRows.intValue(), numColumns.intValue());
+    }*/
+}// class
+
+class QComboBox___ extends QComboBox {
+
+}// class
+
+class QMatrix___ extends QMatrix {
+    /**
+     * Returns an inverted copy of this matrix.
+     *
+     * @return The inverse of the matrix.
+     * @throws IllegalArgumentException
+     *             If this matrix is not invertible.
+     */
+/*    public final QMatrix inverted() {
+        QNativePointer ok = new QNativePointer(QNativePointer.Type.Boolean);
+        QMatrix returned = inverted(ok);
+        if (!ok.booleanValue())
+            throw new IllegalArgumentException("Matrix is not invertible");
+        return returned;
+    }
+
+    @QtBlockedSlot
+    public final QMatrix multiply(QMatrix other) {
+        operator_multiply_assign(other);
+        return this;
+    }
+
+    @QtBlockedSlot
+    public final QMatrix multiplied(QMatrix other) {
+        return operator_multiply(other);
+    }
+*/
+}// class
+
+class QImage___ extends QImage {
+    private import qt.qtd.Str;
+
+    public this(in string[] xpm) {
+        this(toStringzArray(xpm));
+    }
+/*
+    public final byte[] copyOfBytes() {
+        QNativePointer bits = bits();
+        byte bytes[] = new byte[numBytes()];
+        for (int i = 0; i < bytes.length; ++i)
+            bytes[i] = bits.byteAt(i);
+        return bytes;
+    }
+*/
+    public this(ubyte[] data, int width, int height, Format format) {
+        this(data.ptr, width, height, format);
+    }
+
+    public this(string fileName, string format = null) {
+        this(fileName, format == null ? null : toStringz(format));
+    }
+}// class
+
+class QPen___ extends QPen {
+  /*
+    public QPen(QColor color, double width, qt.core.Qt.PenStyle s, qt.core.Qt.PenCapStyle c, qt.core.Qt.PenJoinStyle j) {
+        this(new QBrush(color), width, s, c, j);
+    }
+
+    public QPen(QColor color, double width, qt.core.Qt.PenStyle s, qt.core.Qt.PenCapStyle c) {
+        this(new QBrush(color), width, s, c);
+    }
+
+    public QPen(QColor color, double width, qt.core.Qt.PenStyle s) {
+        this(new QBrush(color), width, s);
+    }
+
+    public QPen(QColor color, double width) {
+        this(new QBrush(color), width);
+    }
+
+    public static final QPen NoPen = new QPen(qt.core.Qt.PenStyle.NoPen);
+	*/
+}// class
+
+class QColor___ extends QColor {
+	static this() {
+		White = new QColor(Qt.GlobalColor.white);
+		Black = new QColor(Qt.GlobalColor.black);
+		Red = new QColor(Qt.GlobalColor.red);
+		DarkRed = new QColor(Qt.GlobalColor.darkRed);
+		Green = new QColor(Qt.GlobalColor.green);
+		DarkGreen = new QColor(Qt.GlobalColor.darkGreen);
+		Blue = new QColor(Qt.GlobalColor.blue);
+		DarkBlue = new QColor(Qt.GlobalColor.darkBlue);
+		Cyan = new QColor(Qt.GlobalColor.cyan);
+		DarkCyan = new QColor(Qt.GlobalColor.darkCyan);
+		Magenta = new QColor(Qt.GlobalColor.magenta);
+		DarkMagenta = new QColor(Qt.GlobalColor.darkMagenta);
+		Yellow = new QColor(Qt.GlobalColor.yellow);
+		DarkYellow = new QColor(Qt.GlobalColor.darkYellow);
+		Gray = new QColor(Qt.GlobalColor.gray);
+		DarkGray = new QColor(Qt.GlobalColor.darkGray);
+		LightGray = new QColor(Qt.GlobalColor.lightGray);
+		Transparent = new QColor(Qt.GlobalColor.transparent);
+		Color0 = new QColor(Qt.GlobalColor.color0);
+		Color1 = new QColor(Qt.GlobalColor.color1);    
+	}
+	
+    public static const QColor White;
+    public static const QColor Black;
+    public static const QColor Red;
+    public static const QColor DarkRed;
+    public static const QColor Green;
+    public static const QColor DarkGreen;
+    public static const QColor Blue;
+    public static const QColor DarkBlue;
+    public static const QColor Cyan;
+    public static const QColor DarkCyan;
+    public static const QColor Magenta;
+    public static const QColor DarkMagenta;
+    public static const QColor Yellow;
+    public static const QColor DarkYellow;
+    public static const QColor Gray;
+    public static const QColor DarkGray;
+    public static const QColor LightGray;
+    public static const QColor Transparent;
+    public static const QColor Color0;
+    public static const QColor Color1;
+
+}// class
+
+class QTextLine___ extends QTextLine {
+
+    public final void draw(QPainter painter, QPointF position) {
+        draw(painter, position, null);
+    }
+
+}// class
+
+class QKeySequence___ extends QKeySequence {
+/*
+    @QtBlockedSlot
+    public final int toInt() {
+        return operator_cast_int();
+    }
+
+    @QtBlockedSlot
+    public final int at(int i) {
+        return operator_subscript(i);
+    }
+*/
+}// class
+
+class QPicture___ extends QPicture {
+/*
+    public final boolean load(QIODevice dev) {
+        return load(dev, (QNativePointer) null);
+    }
+
+    public final boolean load(String fileName) {
+        return load(fileName, (qt.QNativePointer) null);
+    }
+
+    public final boolean save(QIODevice dev) {
+        return save(dev, (qt.QNativePointer) null);
+    }
+
+    public final boolean save(String fileName) {
+        return save(fileName, (qt.QNativePointer) null);
+    }
+
+    public final byte[] data() {
+        QNativePointer npData = data_private();
+        if (npData == null)
+            return null;
+        byte returned[] = new byte[size()];
+        for (int i = 0; i < returned.length; ++i)
+            returned[i] = npData.byteAt(i);
+        return returned;
+    }
+*/
+}// class
+
+class QRegion___ extends QRegion {
+/*
+    public void setRects(qt.core.QRect[] rects) {
+        setRects(qt.core.QRect.nativePointerArray(rects), rects.length);
+    }
+*/
+}// class
+
+class QPolygon___ extends QPolygon {
+
+}// class
+
+class QPolygonF___ extends QPolygonF {
+
+}// class
+
+class QTextFrame_iterator___ extends QTextFrame_iterator {
+
+    public final void opPostInc() {
+        operator_increment();
+    }
+
+    public final void opPostDec() {
+        operator_decrement();
+    }
+
+}// class
+
+class QTextBlock_iterator___ extends QTextBlock_iterator {
+
+    public final void opPostInc() {
+        operator_increment();
+    }
+
+    public final void opPostDec() {
+        operator_decrement();
+    }
+
+}// class
+
+class QPixmap___ extends QPixmap {
+
+	private import qt.qtd.Str;
+
+        public this(in string[] xpm) {
+		this(toStringzArray(xpm));
+	}
+	
+    public this(string fileName, string format = null, int flags = Qt.ImageConversionFlag.AutoColor) {
+        this(fileName, toStringz(format), flags);
+    }
+	
+/*
+        public this(string fileName, string format = null, Qt.ImageConversionFlags flags = Qt.ImageConversionFlag.AutoColor) {
+        this(fileName, toStringz(format), flags);
+    }
+*/
+
+        public final bool load(string fileName, string format, int flags = Qt.ImageConversionFlag.AutoColor) {
+        return load(fileName, toStringz(format), flags);
+    }
+/*
+        public final bool load(string fileName, string format = null, Qt.ImageConversionFlags flags = Qt.ImageConversionFlag.AutoColor) {
+        return load(fileName, toStringz(format), flags);
+    }
+*/
+/*
+    public final bool loadFromData(ubyte[] data, string format, int flags = Qt.ImageConversionFlag.AutoColor) {
+        return loadFromData(data.ptr, data.length, toStringz(format), flags);
+    }
+
+    public final bool loadFromData(ubyte[] data, string format = null, Qt.ImageConversionFlags flags = Qt.ImageConversionFlag.AutoColor) {
+        return loadFromData(qdata.ptr, data.length, toStringz(format), flags);
+    }
+*/
+
+    public final bool loadFromData(QByteArray data, string format, int flags = Qt.ImageConversionFlag.AutoColor) {
+        return loadFromData(data, toStringz(format), flags);
+    }
+    
+/*	public final bool loadFromData(QByteArray data, string format = null, Qt.ImageConversionFlags flags = Qt.ImageConversionFlag.AutoColor) {
+        return loadFromData(data, toStringz(format), flags);
+    }
+*/
+
+    public final bool save(string fileName, string format, int quality = -1) {
+        return private_save(fileName, toStringz(format), quality);
+    }
+
+    public final bool save(QIODevice dev, string format, int quality = -1) {
+        return private_save(dev, toStringz(format), quality);
+    }
+}// class
+
+class QItemSelection___ extends QItemSelection {
+
+    public static void split(QItemSelectionRange range, QItemSelectionRange other, QItemSelection result) {
+        qt.QNativePointer np = result.nativePointer();
+        split(range, other, np);
+    }
+
+}// class
+
+class QPainterPath_Element___ extends QPainterPath_Element {
+/*
+    @QtBlockedSlot
+    public final qt.core.QPointF toPoint() {
+        return operator_cast_QPointF();
+    }
+*/
+}// class
+
+class QBrush___ extends QBrush {
+/*
+    public static final QBrush NoBrush = new QBrush(qt.core.Qt.BrushStyle.NoBrush);
+*/
+}// class
+
+class QAbstractItemView___ extends QAbstractItemView {
+
+    private QAbstractItemDelegate[int] __rcDelegatesForColumns;
+    private QAbstractItemDelegate[int] __rcDelegatesForRows;
+
+}// class
+
+class QAccessibleTableInterface___ extends QAccessibleTableInterface {
+
+    public static class CellAtIndex extends QTableArea {
+        public CellAtIndex(int row, int column, int rowSpan, int columnSpan, boolean isSelected) {
+            super(row, column, rowSpan, columnSpan);
+            this.isSelected = isSelected;
+        }
+
+        public boolean isSelected;
+    }
+
+}// class
+
+class QAccessibleInterface___ extends QAccessibleInterface {
+
+    public static class Target {
+        public Target(int childIndex, QAccessibleInterface target) {
+            this.childIndex = childIndex;
+            this.target = target;
+        }
+
+        public QAccessibleInterface target;
+        public int childIndex;
+    }
+
+}// class
+
+class QDesktopServices___ extends QDesktopServices {
+
+    private static java.util.Hashtable<String, InternalUrlHandler> __rcUrlHandlers = new java.util.Hashtable<String, InternalUrlHandler>();
+
+    public static interface UrlHandler {
+        public void handleUrl(qt.core.QUrl url);
+    }
+
+    private static class InternalUrlHandler extends qt.core.QObject {
+
+        private UrlHandler urlHandler;
+
+        private InternalUrlHandler(UrlHandler urlHandler) {
+            this.urlHandler = urlHandler;
+        }
+
+        private void handleUrl(qt.core.QUrl url) {
+            urlHandler.handleUrl(url);
+        }
+
+    }
+
+    public static void setUrlHandler(String scheme, UrlHandler urlHandler) {
+        InternalUrlHandler receiver = urlHandler != null ? new InternalUrlHandler(urlHandler) : null;
+
+        if (receiver == null)
+            __rcUrlHandlers.remove(scheme);
+        else
+            __rcUrlHandlers.put(scheme, receiver);
+        setUrlHandler(scheme, receiver, QNativePointer.createCharPointer("handleUrl"));
+    }
+
+}// class
+
+class QWizardPage___ extends QWizardPage {
+
+    protected final void registerField(String name, QWidget widget) {
+        registerField(name, widget, (qt.QNativePointer) null, (qt.QNativePointer) null);
+    }
+
+    protected final void registerField(String name, QWidget widget, String property) {
+        registerField(name, widget, QNativePointer.createCharPointer(property), null);
+    }
+
+    /**
+     * Creates a field called <code>name</code> associated with the given
+     * property of the given widget. From then on, that property becomes
+     * accessible using <code>field()</code> and <code>setField()</code>.
+     * Fields are global to the entire wizard and make it easy for any single
+     * page to access information stored by another page, without having to put
+     * all the logic in <code>QWizard</code> or having the pages know
+     * explicitly about each other. If name ends with an asterisk (*), the field
+     * is a mandatory field. When a page has mandatory fields, the Next and/or
+     * Finish buttons are enabled only when all mandatory fields are filled.
+     * This requires a <code>changedSignal</code> to be specified, to tell
+     * QWizard to recheck the value stored by the mandatory field.
+     *
+     * QWizard knows the most common Qt widgets. For these (or their
+     * subclasses), you don't need to specify a <code>property</code> or a
+     * <code>changedSignal</code>. The table below lists these widgets:
+     *
+     * <code>QAbstractButton</code> (for which the relevant property is the
+     * <code>checked</code> property), <code>QAbstractSlider</code> (the
+     * <code>value</code> property), <code>QComboBox</code> (<code>currentIndex</code>
+     * property), <code>QDateTimeEdit</code>(<code>dateTime</code>
+     * property), <code>QLineEdit</code>(<code>text</code> property),
+     * <code>QListWidget</code>(<code>currentRow</code> property), or
+     * <code>QSpinBox</code>(<code>value</code> property).
+     *
+     * @param name
+     *            The name which will be used to access the field. Names ending
+     *            with an asterisk signify mandatory fields.
+     * @param widget
+     *            The widget whose property will be accessed using this field.
+     * @param property
+     *            The name of the property associated with the field.
+     * @param changedSignal
+     *            The name of a signal which is emitted when the associated
+     *            property's value changes.
+     *
+     * @see qt.gui.QWizardPage#field
+     * @see qt.gui.QWizardPage#setField
+     */
+    protected final void registerField(String name, QWidget widget, String property, String changedSignal) {
+        String signalSignature = qt.internal.MetaObjectTools.cppSignalSignature(widget, changedSignal);
+        if (signalSignature.length() == 0)
+            throw new QNoSuchSignalException("Signal '" + changedSignal
+                    + "' does not exist or has argument types that cannot be converted to Qt Jambi or java.lang types.");
+        registerField(name, widget, qt.QNativePointer.createCharPointer(property), qt.QNativePointer
+                .createCharPointer(qt.internal.QtJambiInternal.SignalPrefix + signalSignature));
+    }
+
+}// class
+
+class QFontDialog___ extends QFontDialog {
+
+    public static final class Result {
+        public Result(QFont font, boolean ok) {
+            this.font = font;
+            this.ok = ok;
+        }
+
+        public QFont font;
+        public boolean ok;
+    }
+
+}// class
+
+class QMenu___ extends QMenu {
+/*
+    protected final void initStyleOption(qt.gui.QStyleOptionMenuItem option, QAction action) {
+        initStyleOption(option.nativePointer(), action);
+    }
+*/
+    alias QWidget.addAction addAction;
+}// class
+
+class QMenuBar___ extends QMenuBar {
+
+
+}// class
+
+class QToolBar___ extends QToolBar {
+	/*
+	protected final void initStyleOption(qt.gui.QStyleOptionMenuItem option, QAction action) {
+   initStyleOption(option.nativePointer(), action);
+}
+*/
+	alias QWidget.addAction addAction;
+}// class
+
+class QPixmapCache___ extends QPixmapCache {
+
+    public static boolean find(String key, QPixmap pm) {
+        return find(key, pm.nativePointer());
+    }
+
+}// class
+
+class QShortcut___ extends QShortcut {
+
+    public QShortcut(QKeySequence key, QWidget parent) {
+        this(key, parent, null, null, qt.core.Qt.ShortcutContext.WindowShortcut);
+    }
+
+    public QShortcut(QKeySequence key, QWidget parent, qt.core.Qt.ShortcutContext context) {
+        this(key, parent, null, null, context);
+    }
+
+}// class
+
+class QValidator___ extends QValidator {
+
+    public static class QValidationData {
+        public QValidationData(String input, int pos) {
+            string = input;
+            position = pos;
+        }
+
+        public String string;
+        public int position;
+    }
+
+}// class
+
+class QAbstractButton___ extends QAbstractButton {
+
+    /**
+     * Sets the shortcut to the key sequence for the given key string. For
+     * example "Ctrl+O" gives CTRL+'O'. The strings "Ctrl", "Shift", "Alt" and
+     * "Meta" are recognized, as well as their translated equivalents in the
+     * "QShortcut" context (using QObject::tr()). Up to four key codes may be
+     * entered by separating them with commas, e.g. "Alt+X,Ctrl+S,Q".
+     *
+     * @param key
+     *            The description of the key sequence. Typically used with tr()
+     *            so key sequences can be locale aware.
+     */
+    public final void setShortcut(string key) {
+        setShortcut(new QKeySequence(key));
+    }
+
+    /**
+     * Sets the shortcut to the key sequence for the given key. The result will
+     * depend on the currently running platform. The key sequence will be based
+     * on the first element in the list of key bindings for the key.
+     *
+     * @param key
+     *            The key for which to select a key sequence
+     */
+    public final void setShortcut(QKeySequence.StandardKey key) {
+        setShortcut(new QKeySequence(key));
+    }
+
+}// class
+
+class QStyle___ extends QStyle {
+/*
+    @QtBlockedSlot
+    public final int combinedLayoutSpacing(QSizePolicy.ControlTypes controls1, QSizePolicy.ControlTypes controls2,
+            qt.core.Qt.Orientation orientation, QStyleOption option, QWidget widget) {
+        return combinedLayoutSpacing(controls1, controls2, orientation, option == null ? null : option.nativePointer(), widget);
+    }
+
+    @QtBlockedSlot
+    public final int combinedLayoutSpacing(QSizePolicy.ControlTypes controls1, QSizePolicy.ControlTypes controls2,
+            qt.core.Qt.Orientation orientation, QStyleOption option) {
+        return combinedLayoutSpacing(controls1, controls2, orientation, option, null);
+    }
+
+    @QtBlockedSlot
+    public final int combinedLayoutSpacing(QSizePolicy.ControlTypes controls1, QSizePolicy.ControlTypes controls2,
+            qt.core.Qt.Orientation orientation) {
+        return combinedLayoutSpacing(controls1, controls2, orientation, null);
+    }
+
+    @QtBlockedSlot
+    public final int layoutSpacing(QSizePolicy.ControlType control1, QSizePolicy.ControlType control2, qt.core.Qt.Orientation orientation,
+            QStyleOption option, QWidget widget) {
+        return layoutSpacing(control1, control2, orientation, option == null ? null : option.nativePointer(), widget);
+    }
+
+    @QtBlockedSlot
+    public final int layoutSpacing(QSizePolicy.ControlType control1, QSizePolicy.ControlType control2, qt.core.Qt.Orientation orientation,
+            QStyleOption option) {
+        return layoutSpacing(control1, control2, orientation, option, null);
+    }
+
+    @QtBlockedSlot
+    public final int layoutSpacing(QSizePolicy.ControlType control1, QSizePolicy.ControlType control2, qt.core.Qt.Orientation orientation) {
+        return layoutSpacing(control1, control2, orientation, null);
+    }
+*/
+}// class
+
+class QLayout___ extends QLayout {
+/*
+    @QtBlockedSlot
+    public final QContentsMargins getContentsMargins() {
+        QNativePointer left = new QNativePointer(QNativePointer.Type.Int);
+        QNativePointer top = new QNativePointer(QNativePointer.Type.Int);
+        QNativePointer right = new QNativePointer(QNativePointer.Type.Int);
+        QNativePointer bottom = new QNativePointer(QNativePointer.Type.Int);
+
+        getContentsMargins(left, top, right, bottom);
+        return new QContentsMargins(left.intValue(), top.intValue(), right.intValue(), bottom.intValue());
+    }
+
+    @QtBlockedSlot
+    public final void setContentsMargins(QContentsMargins margins) {
+        setContentsMargins(margins.left, margins.top, margins.right, margins.bottom);
+    }
+*/
+}// class
+
+class QGridLayout___ extends QGridLayout {
+/*
+    public final QTableArea getItemPosition(int index) {
+        QNativePointer row = new QNativePointer(QNativePointer.Type.Int);
+        QNativePointer column = new QNativePointer(QNativePointer.Type.Int);
+        QNativePointer rowSpan = new QNativePointer(QNativePointer.Type.Int);
+        QNativePointer columnSpan = new QNativePointer(QNativePointer.Type.Int);
+
+        getItemPosition(index, row, column, rowSpan, columnSpan);
+
+        return new QTableArea(row.intValue(), column.intValue(), rowSpan.intValue(), columnSpan.intValue());
+    }
+*/
+}// class
+
+class QWidget___ extends QWidget {
+/*
+    private native static void __qt_QMessageBox_setWindowTitle(long native_id, String windowTitle);
+
+    private native static void __qt_QMessageBox_setWindowModality(long native_id, int modality);
+
+    @QtBlockedSlot
+    public final QContentsMargins getContentsMargins() {
+        QNativePointer left = new QNativePointer(QNativePointer.Type.Int);
+        QNativePointer top = new QNativePointer(QNativePointer.Type.Int);
+        QNativePointer right = new QNativePointer(QNativePointer.Type.Int);
+        QNativePointer bottom = new QNativePointer(QNativePointer.Type.Int);
+
+        getContentsMargins(left, top, right, bottom);
+        return new QContentsMargins(left.intValue(), top.intValue(), right.intValue(), bottom.intValue());
+    }
+
+    @QtBlockedSlot
+    public final void setContentsMargins(QContentsMargins margins) {
+        setContentsMargins(margins.left, margins.top, margins.right, margins.bottom);
+    }
+*/
+}// class
+
+class QFileDialog___ extends QFileDialog {
+    
+    public static string getOpenFileName(QWidget _parent, string caption = null, string dir = null, string filter = null) {
+        string res;
+        string _selectedFilter = "";
+        qtd_QFileDialog_getOpenFileName_QWidget_string_string_string_nativepointerstring_Options(&res, _parent is null ? null : _parent.nativeId, caption.ptr, caption.length, dir.ptr, dir.length, filter.ptr, filter.length, _selectedFilter.ptr, _selectedFilter.length, 0);
+        return res;
+    }
+    
+    public static string getSaveFileName(QWidget _parent, string caption = null, string dir = null, string filter = null) {
+        string res;
+        string _selectedFilter = "";
+        qtd_QFileDialog_getSaveFileName_QWidget_string_string_string_nativepointerstring_Options(&res, _parent is null ? null : _parent.nativeId, caption.ptr, caption.length, dir.ptr, dir.length, filter.ptr, filter.length, _selectedFilter.ptr, _selectedFilter.length, 0);
+        return res;
+    }
+    
+    public static class Filter {
+        public this(string filter) {
+            this.filter = filter;
+        }
+
+        public string filter;
+        public string selectedFilter = "";
+    }
+
+}// class
+
+class QTabBar___ extends QTabBar {
+
+    public final void initStyleOption(QStyleOptionTab option, int tabIndex) {
+        initStyleOption(option.nativePointer(), tabIndex);
+    }
+
+}// class
+
+class QClipboard___ extends QClipboard {
+/*
+    public static class Text {
+        public String text;
+        public String subtype;
+    }
+
+    public final Text text(String subtype, Mode mode) {
+        QNativePointer np = new QNativePointer(QNativePointer.Type.String);
+        np.setStringValue(subtype != null ? subtype : "");
+
+        Text returned = new Text();
+        returned.text = text(np, mode);
+        returned.subtype = np.stringValue();
+        return returned;
+    }
+
+    public final Text text(String subtype) {
+        return text(subtype, Mode.Clipboard);
+    }
+*/
+}// class
+
+class QAbstractScrollArea___ extends QAbstractScrollArea {
+/*
+    public QPaintEngine paintEngine() {
+        throw new RuntimeException("Cannot open a painter directly on a QAbstractScrollArea, open QPainter on its viewport instead...");
+    }
+*/
+}// class
+
+class QTextDocument___ extends QTextDocument {
+
+    public final void redo(QTextCursor cursor) {
+        redo(cursor.nativePointer());
+    }
+
+    public final void undo(QTextCursor cursor) {
+        undo(cursor.nativePointer());
+    }
+
+}// class
+
+class QSplitter___ extends QSplitter {
+
+    public struct Range {
+		public static Range opCall(int min, int max) {
+            Range rng;
+			rng.minimum = min;
+            rng.maximum = max;
+			return rng;
+        }
+
+        public int minimum;
+        public int maximum;
+    }
+
+    public final Range getRange(int index) {
+        int* min;
+        int* max;
+
+        getRange(index, min, max);
+
+        return Range(*min, *max);
+    }
+
+}// class
+
+class QAction___ extends QAction {
+	
+        public final void setShortcut(string key) {
+		setShortcut(new QKeySequence(key));
+	}
+/*
+    private QActionGroup __rcActionGroup = null;
+*/
+    /**
+     * Sets the shortcut to the key sequence for the given key string. For
+     * example "Ctrl+O" gives CTRL+'O'. The strings "Ctrl", "Shift", "Alt" and
+     * "Meta" are recognized, as well as their translated equivalents in the
+     * "QShortcut" context (using QObject::tr()). Up to four key codes may be
+     * entered by separating them with commas, e.g. "Alt+X,Ctrl+S,Q".
+     *
+     * @param key
+     *            The description of the key sequence. Typically used with tr()
+     *            so key sequences can be locale aware.
+     */
+/*    public final void setShortcut(String key) {
+        setShortcut(new QKeySequence(key));
+    }
+*/
+    /**
+     * Sets the shortcut to the key sequence for the given key. The result will
+     * depend on the currently running platform. The key sequence will be based
+     * on the first element in the list of key bindings for the key.
+     *
+     * @param key
+     *            The key for which to select a key sequence
+     */
+/*    public final void setShortcut(QKeySequence.StandardKey key) {
+        setShortcut(new QKeySequence(key));
+    }
+
+    public final void setIcon(QPixmap pm) {
+        setIcon(new QIcon(pm));
+    }
+*/
+}// class
+
+class QPainter___ extends QPainter {
+
+    public final void setBrush(QColor color) {
+        setBrush(new QBrush(color));
+    }
+
+    public final void setBrush(QGradient gradient) {
+        setBrush(new QBrush(gradient));
+    }
+
+    public final void setBrush(QPixmap pm) {
+        setBrush(new QBrush(pm));
+    }
+    
+    public final void drawConvexPolygon(QPoint[] points) {
+        qtd_QPainter_drawConvexPolygon_nativepointerQPoint_int(nativeId, points.ptr, points.length);
+    }
+    
+    public final void drawConvexPolygon(QPointF[] points) {
+        qtd_QPainter_drawConvexPolygon_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());
+    }
+
+    public QPainter(QWidget widget) {
+        this();
+        begin(widget);
+    }
+
+    public boolean begin(QWidget widget) { // can't be final because of QStylePainter
+        return qt.QtJambiGuiInternal.beginPaint(widget, this);
+    }
+
+    private static java.util.Stack<QPaintDeviceInterface> __rcRedirections = new java.util.Stack<QPaintDeviceInterface>();
+*/
+}// class
+
+class QApplication___ extends QApplication {
+
+        this(in string[] args)
+	{
+//        if (m_instance != null)
+//            throw new RuntimeException("QCoreApplication can only be initialized once");
+            
+		argc = args.length;
+		argv = toStringzArray(args);
+		this(&argc, argv);
+
+//        m_instance.aboutToQuit.connect(m_instance, "disposeOfMyself()");
+	}
+	
+	private int argc;
+	private char **argv;
+
+	/*    public static QApplication instance() {
+        if (type() != Type.Tty)
+            return (QApplication) qt.core.QCoreApplication.instance();
+        return null;
+    }
+
+    public QApplication(String args[]) {
+        this(argc(args), argv(args));
+    }
+
+    public static void setFont(QFont font) {
+        setFont(font, null);
+    }
+
+    public static void setPalette(QPalette palette) {
+        setPalette(palette, null);
+    }
+
+    public static QCursor overrideCursor() {
+        QNativePointer np = overrideCursor_private();
+        return np == null ? null : QCursor.fromNativePointer(np);
+    }
+*/
+}// class
+
+class QFormLayout___ extends QFormLayout {
+
+    /**
+     * Retrieves the row and role (column) of the item at the specified index.
+     * If index is out of bounds, -1 is returned in place of the row.
+     *
+     * @param index The index of the item for which to retrieve the position.
+     * @return A pair of an int (row of item) and an ItemRole (role of the item.)
+     **/
+/*    @QtBlockedSlot
+    public final qt.QPair<Integer, ItemRole> getItemPosition(int index) {
+       qt.QNativePointer row = new qt.QNativePointer(qt.QNativePointer.Type.Int);
+       qt.QNativePointer role = new qt.QNativePointer(qt.QNativePointer.Type.Int);
+
+       getItemPosition(index, row, role);
+
+       return new qt.QPair<Integer, ItemRole>(row.intValue(), ItemRole.resolve(role.intValue()));
+    }
+*/
+    /**
+     * Retrieves the row and role (column) of the specified child layout.
+     * If the layout is not in the form layout, -1 is returned in place of the row.
+     *
+     * @param layout The layout for which to retrieve the position.
+     * @return A pair of an int (row of item) and an ItemRole (role of the item.)
+     */
+/*    @QtBlockedSlot
+    public final qt.QPair<Integer, ItemRole> getLayoutPosition(QLayout layout) {
+        qt.QNativePointer row = new qt.QNativePointer(qt.QNativePointer.Type.Int);
+        qt.QNativePointer role = new qt.QNativePointer(qt.QNativePointer.Type.Int);
+
+        getLayoutPosition(layout, row, role);
+
+        return new qt.QPair<Integer, ItemRole>(row.intValue(), ItemRole.resolve(role.intValue()));
+    }
+*/
+    /**
+     * Retrieves the row and role (column) of the specified widget in the layout.
+     * If the widget is not in the form layout, -1 is returned in place of the row.
+     *
+     * @param widget The widget for which to retrieve the position.
+     * @return A pair of an int (row of item) and an ItemRole (role of the item.)
+     */
+/*    @QtBlockedSlot
+    public final qt.QPair<Integer, ItemRole> getWidgetPosition(QWidget widget) {
+        qt.QNativePointer row = new qt.QNativePointer(qt.QNativePointer.Type.Int);
+        qt.QNativePointer role = new qt.QNativePointer(qt.QNativePointer.Type.Int);
+
+        getWidgetPosition(widget, row, role);
+
+        return new qt.QPair<Integer, ItemRole>(row.intValue(), ItemRole.resolve(role.intValue()));
+    }
+*/
+    /**
+     * Sets the item in the given row for the given role to item, extending the layout with empty rows if necessary.
+     * If the cell is already occupied, the item is not inserted and a IllegalArgumentException is thrown.
+     */
+/*    @QtBlockedSlot
+    public final void setItem(int row, ItemRole role, QLayoutItem item) {
+        if (itemAt(row, role) == null)
+            setItem_private(row, role, item);
+        else
+            throw new IllegalArgumentException("Cell in form layout is already occupied");
+    }
+*/
+}// class
+
+class Subclass_of_QGraphicsLayoutItem___ extends QGraphicsLayoutItem {
+    /*
+    @QtBlockedSlot
+    public final QMarginsF getContentsMargins() {
+        QNativePointer left = new QNativePointer(QNativePointer.Type.Double);
+        QNativePointer top = new QNativePointer(QNativePointer.Type.Double);
+        QNativePointer right = new QNativePointer(QNativePointer.Type.Double);
+        QNativePointer bottom = new QNativePointer(QNativePointer.Type.Double);
+
+        getContentsMargins(left, top, right, bottom);
+        return new QMarginsF(left.doubleValue(), top.doubleValue(), right.doubleValue(), bottom.doubleValue());
+    }*/
+}// class
+
+class QGraphicsWidget___ extends QGraphicsWidget {
+
+    /*
+     * Gets the widget's window frame margins.
+     *
+     * @returns An object containing the margins in left, right, top and bottom coordinates.
+     
+    @QtBlockedSlot
+    public final QMarginsF getWindowFrameMargins() {
+        QNativePointer left = new QNativePointer(QNativePointer.Type.Double);
+        QNativePointer top = new QNativePointer(QNativePointer.Type.Double);
+        QNativePointer right = new QNativePointer(QNativePointer.Type.Double);
+        QNativePointer bottom = new QNativePointer(QNativePointer.Type.Double);
+
+        getWindowFrameMargins(left, top, right, bottom);
+        return new QMarginsF(left.doubleValue(), top.doubleValue(), right.doubleValue(), bottom.doubleValue());
+    }
+    */
+
+}// class
+
+class QPrinter___ extends QPrinter {
+
+    /**
+     * Returns the page margins for this printer.
+     * The unit of the returned margins are specified with the unit parameter.
+     * This function was introduced in Qt 4.4.
+     *
+     * @param unit Specifies the unit of the returned margins.
+     * @return The page margins for this printer.
+     */
+/*    public final QMarginsF getPageMargins(QPrinter.Unit unit) {
+        QNativePointer left = new QNativePointer(QNativePointer.Type.Double);
+        QNativePointer top = new QNativePointer(QNativePointer.Type.Double);
+        QNativePointer right = new QNativePointer(QNativePointer.Type.Double);
+        QNativePointer bottom = new QNativePointer(QNativePointer.Type.Double);
+
+        getPageMargins(left, top, right, bottom, unit);
+        return new QMarginsF(left.doubleValue(), top.doubleValue(), right.doubleValue(), bottom.doubleValue());
+    }*/
+
+}// class
+
+class QListWidget___ extends QListWidget {
+
+    /**
+     * Inserts items with the text labels at the end of the list widget.
+     *
+     * @param labels The collection of labels for the new items.
+     */
+    public final void addItems(string[] labels) {
+        foreach (label; labels)
+            addItem(label);
+    }
+
+    /**
+     * This is an overloaded member function, provided for convenience.
+     * Inserts an item with the text label in the list widget at the position given by row.
+     *
+     * @param row The position in which to insert the new item.
+     * @param label The text of the new item.
+     */
+    public final void insertItem(int row, string label) {
+        insertItem(row, new QListWidgetItem(label, this));
+    }
+
+    /**
+     * Inserts items from the list of labels into the list, starting at the given row.
+     *
+     * @param row The position in which to insert the new items.
+     * @param labels The collection of labels for the new items.
+     */
+    public final void insertItems(int row, string[] labels) {
+		foreach (label; labels)
+            insertItem(row++, label);
+    }
+}// class
+
+
+class QGraphicsScene___ extends QGraphicsScene {
+    /**
+     * Equivalent to addEllipse(rect, null, null)
+     */
+    /*public final QGraphicsEllipseItem addEllipse(qt.core.QRectF rect)
+    {
+        return addEllipse(rect, null);
+    }*/
+
+    /**
+     * Equivalent to addEllipse(rect, pen, null)
+     */
+   /* public final QGraphicsEllipseItem addEllipse(qt.core.QRectF rect, QPen pen)
+    {
+        return addEllipse(rect, pen, null);
+    }*/
+
+
+    /**
+     * Creates and adds an ellipse item to the scene, and returns the item
+     * reference. The geometry of the ellipse is defined by rect, and its pen
+     * and brush are initialized to pen and brush.
+     *
+     * Note that the item's geometry is provided in item coordinates, and its
+     * position is initialized to (0, 0).
+     *
+     * If the item is visible (i.e., QGraphicsItem::isVisible() returns true),
+     * QGraphicsScene will emit changed() once control goes back to the event
+     * loop.
+     *
+     * @param rect The bounding rectangle of the ellipse.
+     * @param pen The pen for the resulting QGraphicsEllipseItem.
+     * @param brush The brush for the resulting QGraphicsEllipseItem.
+     * @return The resulting item.
+     */
+   /* public final QGraphicsEllipseItem addEllipse(qt.core.QRectF rect, QPen pen, QBrush brush)
+    {
+        return addEllipse(rect.x(), rect.y(), rect.width(), rect.height(), pen, brush);
+    }*/
+
+    /**
+     * Equivalent to addEllipse(x, y, w, h, null, null)
+     */
+   /* public final QGraphicsEllipseItem addEllipse(double x, double y, double w, double h) {
+        return addEllipse(x, y, w, h, null);
+    }*/
+
+    /**
+     * Equivalent to addEllipse(x, y, w, h, pen, null)
+     */
+   /* public final QGraphicsEllipseItem addEllipse(double x, double y, double w, double h, QPen pen)
+    {
+        return addEllipse(x, y, w, h, pen, null);
+    }*/
+
+    /**
+     * Creates and adds an ellipse item to the scene, and returns the item
+     * reference. The geometry of the ellipse is defined by x, y, w, h, and its pen
+     * and brush are initialized to pen and brush.
+     *
+     * Note that the item's geometry is provided in item coordinates, and its
+     * position is initialized to (0, 0).
+     *
+     * If the item is visible (i.e., QGraphicsItem.isVisible() returns true),
+     * QGraphicsScene will emit changed once control goes back to the event
+     * loop.
+     *
+     * @param x The left horizontal coordinate of the ellipse's bounding rectangle.
+     * @param y The top vertical coordinate of the ellipse's bounding rectangle.
+     * @param w The width of the ellipse's bounding rectangle.
+     * @param h The height of the ellipse's bounding rectangle.
+     * @param pen The pen for the resulting QGraphicsEllipseItem.
+     * @param brush The brush for the resulting QGraphicsEllipseItem.
+     * @return The resulting item.
+     */
+   /* public final QGraphicsEllipseItem addEllipse(double x, double y, double w, double h, QPen pen, QBrush brush)
+    {
+        QGraphicsEllipseItem item = new QGraphicsEllipseItem(x, y, w, h);
+        item.setPen(pen);
+        item.setBrush(brush);
+
+        addItem(item);
+
+        return item;
+    }*/
+
+    /**
+     * Equivalent to addLine(line, null)
+     */
+   /* public final QGraphicsLineItem addLine(QLineF line) {
+        return addLine(line, null);
+    }*/
+
+    /**
+     * Creates and adds a line item to the scene, and returns the item
+     * reference. The geometry of the line is defined by line, and its pen
+     * is initialized to pen.
+     *
+     * Note that the item's geometry is provided in item coordinates, and its
+     * position is initialized to (0, 0).
+     *
+     * If the item is visible (i.e., QGraphicsItem.isVisible() returns true),
+     * QGraphicsScene will emit changed once control goes back to the event
+     * loop.
+     *
+     * @param line The definition of the line.
+     * @param pen The pen with which to draw the line.
+     * @return The resulting item.
+     */
+   /* public final QGraphicsLineItem addLine(QLineF line, QPen pen)
+    {
+        return addLine(line.x1(), line.y1(), line.x2(), line.y2(), pen);
+    }*/
+
+    /**
+     * Equivalent to addLine(x1, y1, x2, y2, null)
+     */
+  /*  public final QGraphicsLineItem addLine(double x1, double y1, double x2, double y2) {
+        return addLine(x1, y1, x2, y2, null);
+    }*/
+
+    /**
+     * Creates and adds a line item to the scene, and returns the item
+     * reference. The geometry of the line is defined by x1, y1, x2, y2, and its pen
+     * is initialized to pen.
+     *
+     * Note that the item's geometry is provided in item coordinates, and its
+     * position is initialized to (0, 0).
+     *
+     * If the item is visible (i.e., QGraphicsItem.isVisible() returns true),
+     * QGraphicsScene will emit changed once control goes back to the event
+     * loop.
+     *
+     * @param x1 The first horizontal coordinate of the line.
+     * @param y1 The first vertical coordinate of the line.
+     * @param x2 The second horizontal coordinate of the line.
+     * @param y2 The second vertical coordinate of the line.
+     * @param pen The pen with which to draw the line.
+     * @return The resulting item.
+     */
+  /*  public final QGraphicsLineItem addLine(double x1, double y1, double x2, double y2, QPen pen)
+    {
+        QGraphicsLineItem item = new QGraphicsLineItem(x1, y1, x2, y2);
+        item.setPen(pen);
+
+        addItem(item);
+
+        return item;
+    }*/
+
+
+    /**
+     * Equivalent to addPath(path, null, null)
+     */
+    /*public final QGraphicsPathItem addPath(QPainterPath path) {
+        return addPath(path, null);
+    }*/
+
+    /**
+     * Equivalent to addPath(path, pen, null)
+     */
+    /*public final QGraphicsPathItem addPath(QPainterPath path, QPen pen)
+    {
+        return addPath(path, pen, null);
+    }*/
+    /**
+     * Creates and adds a path item to the scene, and returns the item
+     * reference. The geometry of the path is defined by path, and its pen and
+     * brush are initialized to pen and brush.
+     *
+     * Note that the item's geometry is provided in item coordinates, and its
+     * position is initialized to (0, 0).
+     *
+     * If the item is visible (i.e., QGraphicsItem.isVisible() returns true),
+     * QGraphicsScene will emit changed once control goes back to the event
+     * loop.
+     *
+     * @param path The definition of the path.
+     * @param pen The pen for drawing the path.
+     * @param brush The brush for drawing the path.
+     * @return The resulting item.
+     */
+   /* public final QGraphicsPathItem addPath(QPainterPath path, QPen pen, QBrush brush)
+    {
+        QGraphicsPathItem item = new QGraphicsPathItem(path);
+        item.setPen(pen);
+        item.setBrush(brush);
+
+        addItem(item);
+
+        return item;
+    }*/
+
+    /**
+     * Creates and adds a pixmap item to the scene, and returns the item
+     * reference. The pixmap is defined by pixmap.
+     *
+     * Note that the item's geometry is provided in item coordinates, and its
+     * position is initialized to (0, 0).
+     *
+     * If the item is visible (i.e., QGraphicsItem.isVisible() returns true),
+     * QGraphicsScene will emit changed once control goes back to the event
+     * loop.
+     *
+     * @param pixmap The pixmap for which to create a graphics item.
+     * @return The resulting item.
+     */
+   /* public final QGraphicsPixmapItem addPixmap(QPixmap pixmap)
+    {
+        QGraphicsPixmapItem item = new QGraphicsPixmapItem(pixmap);
+
+        addItem(item);
+
+        return item;
+    }*/
+
+    /**
+     * Equivalent to addPolygon(polygon, null, null)
+     */
+  /*  public final QGraphicsPolygonItem addPolygon(QPolygonF polygon) {
+        return addPolygon(polygon, null);
+    }*/
+
+    /**
+     * Equivalent to addPolygon(polygon, pen, null)
+     */
+   /* public final QGraphicsPolygonItem addPolygon(QPolygonF polygon, QPen pen) {
+        return addPolygon(polygon, pen, null);
+    }*/
+
+    /**
+     * Creates and adds a polygon item to the scene, and returns the item
+     * reference. The polygon is defined by polygon, and its pen and
+     * brush are initialized to pen and brush.
+     *
+     * Note that the item's geometry is provided in item coordinates, and its
+     * position is initialized to (0, 0).
+     *
+     * If the item is visible (i.e., QGraphicsItem.isVisible() returns true),
+     * QGraphicsScene will emit changed once control goes back to the event
+     * loop.
+     *
+     * @param polygon The definition of the polygon.
+     * @param pen The pen with which to draw the polygon.
+     * @param brush The brush with which to draw the polygon.
+     * @return The resulting item.
+     */
+  /*  public final QGraphicsPolygonItem addPolygon(QPolygonF polygon, QPen pen, QBrush brush)
+    {
+        QGraphicsPolygonItem item = new QGraphicsPolygonItem(polygon);
+        item.setPen(pen);
+        item.setBrush(brush);
+
+        addItem(item);
+
+        return item;
+    }*/
+
+    /**
+     * Equivalent to addRect(rect, null, null)
+     */
+  /*  public final QGraphicsRectItem addRect(qt.core.QRectF rect) {
+        return addRect(rect, null);
+    }*/
+
+    /**
+     * Equivalent to addRect(rect, pen, null)
+     */
+   /* public final QGraphicsRectItem addRect(qt.core.QRectF rect, QPen pen)
+    {
+        return addRect(rect, pen, null);
+    }*/
+
+    /**
+     * Creates and adds a rectangle item to the scene, and returns the item
+     * reference. The geometry of the rectangle is defined by rect, and its pen
+     * and brush are initialized to pen and brush.
+     *
+     * Note that the item's geometry is provided in item coordinates, and its
+     * position is initialized to (0, 0). For example, if a QRect(50, 50, 100,
+     * 100) is added, its top-left corner will be at (50, 50) relative to the
+     * origin in the item's coordinate system.
+     *
+     * If the item is visible (i.e., QGraphicsItem.isVisible() returns true),
+     * QGraphicsScene will emit changed once control goes back to the event
+     * loop.
+     *
+     * @param rect The definition of the rectangle.
+     * @param pen The pen with which to draw the rectangle.
+     * @param brush The brush with which to draw the rectangle.
+     * @return The resulting item.
+     */
+  /*  public final QGraphicsRectItem addRect(qt.core.QRectF rect, QPen pen, QBrush brush)
+    {
+        return addRect(rect.x(), rect.y(), rect.width(), rect.height(), pen, brush);
+    }*/
+
+    /**
+     * Equivalent to addRect(x, y, w, h, null, null)
+     */
+  /*  public final QGraphicsRectItem addRect(double x, double y, double w, double h) {
+        return addRect(x, y, w, h, null);
+    }*/
+
+    /**
+     * Equivalent to addRect(x, y, w, h, pen, null)
+     */
+   /* public final QGraphicsRectItem addRect(double x, double y, double w, double h, QPen pen) {
+        return addRect(x, y, w, h, pen, null);
+    }*/
+
+    /**
+     * Creates and adds a rectangle item to the scene, and returns the item
+     * reference. The geometry of the rectangle is defined by x, y, w, h, and its pen
+     * and brush are initialized to pen and brush.
+     *
+     * Note that the item's geometry is provided in item coordinates, and its
+     * position is initialized to (0, 0).
+     *
+     * If the item is visible (i.e., QGraphicsItem.isVisible() returns true),
+     * QGraphicsScene will emit changed once control goes back to the event
+     * loop.
+     *
+     * @param x The left horizontal coordinate of the rectangle.
+     * @param y The top vertical coordinate of the rectangle.
+     * @param w The width of the rectangle.
+     * @param h The height of the rectangle.
+     * @param pen The pen with which to draw the rectangle.
+     * @param brush The brush with which to draw the rectangle.
+     * @return The resulting item.
+     */
+   /* public final QGraphicsRectItem addRect(double x, double y, double w, double h, QPen pen, QBrush brush)
+    {
+        QGraphicsRectItem item = new QGraphicsRectItem(x, y, w, h);
+        item.setPen(pen);
+        item.setBrush(brush);
+
+        addItem(item);
+
+        return item;
+    }*/
+
+    /**
+     * Equivalent to addSimpleText(text, null)
+     */
+    /*public final QGraphicsSimpleTextItem addSimpleText(String text) {
+        return addSimpleText(text, null);
+    }*/
+
+    /**
+     * Creates and adds a QGraphicsSimpleTextItem to the scene, and returns the
+     * item reference. The text string is initialized to text, and its font is
+     * initialized to font.
+     *
+     * The item's position is initialized to (0, 0).
+     *
+     * If the item is visible (i.e., QGraphicsItem.isVisible() returns true),
+     * QGraphicsScene will emit changed once control goes back to the event
+     * loop.
+     *
+     * @param text The text to add to the scene.
+     * @param font The font to use for displaying the text.
+     * @return The resulting item.
+     */
+   /* public final QGraphicsSimpleTextItem addSimpleText(String text, QFont font)
+    {
+        QGraphicsSimpleTextItem item = new QGraphicsSimpleTextItem(text);
+        item.setFont(font);
+
+        addItem(item);
+
+        return item;
+    }*/
+
+    /**
+     * Equivalent to addText(text, null)
+     */
+   /* public final QGraphicsTextItem addText(String text) {
+        return addText(text, null);
+    }*/
+
+    /**
+     * Creates and adds a text item to the scene, and returns the item
+     * reference. The text string is initialized to text, and its font
+     * is initialized to font.
+     *
+     * The item's position is initialized to (0, 0).
+     *
+     * If the item is visible (i.e., QGraphicsItem.isVisible() returns true),
+     * QGraphicsScene will emit changed once control goes back to the event
+     * loop.
+     *
+     * @param text The text to add to the scene.
+     * @param font The font to use for displaying the text.
+     * @return The resulting item.
+     */
+   /* public final QGraphicsTextItem addText(String text, QFont font)
+    {
+        QGraphicsTextItem item = new QGraphicsTextItem(text);
+        item.setFont(font);
+
+        addItem(item);
+
+        return item;
+    }*/
+
+}// class