From 8a055d66f43592c257cece2eb8cc021808062917 Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Tue, 29 Nov 2011 01:11:08 -0600 Subject: Initial TQt conversion --- doc/PyQt.html | 2116 ++++++++++++++++++++++++++++----------------------------- 1 file changed, 1058 insertions(+), 1058 deletions(-) (limited to 'doc/PyQt.html') diff --git a/doc/PyQt.html b/doc/PyQt.html index a7fb2ab..71e167d 100644 --- a/doc/PyQt.html +++ b/doc/PyQt.html @@ -2,7 +2,7 @@ Python Bindings for Qt (3.18.1)Python Bindings for TQt (3.18.1)Python Bindings for Qt (3.18.1)Python Bindings for TQt (3.18.1)

This document describes a set of Python bindings for the Qt widget set. +> This document describes a set of Python bindings for the TQt widget set. Contact the author at

PyTQt is available under the GPL license for use with the GPL version of TQt, a +a commercial license for use with the commercial version of TQt, a +non-commercial license for use with the non-commercial version of TQt v2, and an +educational license for use with the educational version of TQt.

PyQt is built using SIP (a tool for generating Python extension modules for +>PyTQt is built using SIP (a tool for generating Python extension modules for C++ class libraries). SIP v4.6 or later must be installed in order to build -and run this version of PyQt.

PyQt for MacOS/X requires Qt v3.1.0 or later and Python v2.3 or later.

PyTQt for MacOS/X retquires TQt v3.1.0 or later and Python v2.3 or later.

The bindings are implemented as a number of Python modules

qtaxcontainer contains a sub-set of the classes implemented -in Qt's QAxContainer module, part of Qt's ActiveQt framework.

  • qtcanvas contains the classes implemented in Qt's Canvas +> contains the classes implemented in TQt's Canvas module.

  • qtgl contains the classes implemented in Qt's OpenGL module.

    contains the classes implemented in TQt's OpenGL module.

  • qtnetwork contains the classes implemented in Qt's Network +> contains the classes implemented in TQt's Network module.

  • qtpe contains the classes implemented in Qtopia (originally -called the Qt Palmtop Environment). It is only supported with Qt/Embedded.

    contains the classes implemented in TQtopia (originally +called the TQt Palmtop Environment). It is only supported with TQt/Embedded.

  • qtsql contains the classes implemented in Qt's SQL module.

    contains the classes implemented in TQt's SQL module.

  • qttable contains the classes implemented in Qt's Table +> contains the classes implemented in TQt's Table module.

  • qtui contains the classes implemented in Qt's qui library. -These allow GUIs to be created directly from Qt Designer's +> contains the classes implemented in TQt's tqui library. +These allow GUIs to be created directly from TQt Designer's .uiqtxml contains the classes implemented in Qt's XML module.

    contains the classes implemented in TQt's XML module.

  • qtext contains useful third-party classes that are not part -of Qt. At the moment it contains bindings for QScintilla, the port to Qt of +of TQt. At the moment it contains bindings for TQScintilla, the port to TQt of the Scintilla programmer's editor class.

    • PyQt also includes the PyTQt also includes the pyuic and pylupdate utilities which correspond to the Qt +> utilities which correspond to the TQt uicpyuic converts the GUI designs created with Qt Designer to +> converts the GUI designs created with TQt Designer to executable Python code. pylupdate scans Python code, extracts all strings that are candidates for internationalisation, and creates -an XML file for use by Qt Linguist.

    Other PyQt GoodiesOther PyTQt Goodies
    Using Qt DesignerUsing TQt Designer

    Qt Designer is a GPL'ed GUI design editor provided by Trolltech as part of Qt. -It generates an XML description of a GUI design. Qt includes +>TQt Designer is a GPL'ed GUI design editor provided by Trolltech as part of TQt. +It generates an XML description of a GUI design. TQt includes uic which generates C++ code from that XML.

    PyQt includes PyTQt includes pyuic which generates Python code from the @@ -236,7 +236,7 @@ custom widgets, pyuic has no way of knowing the name of the -Python module containing the widget and so cannot generate the required +Python module containing the widget and so cannot generate the retquired importComment field of Qt Designer's +> field of TQt Designer's Form Settingspyuic will extract Python code -entered using Qt Designer to implement slots. In Qt Designer, when you need to +entered using TQt Designer to implement slots. In TQt Designer, when you need to edit a slot and the source editor appears, enter Python code between the curly braces. Don't worry about the correct starting indent level, each line is prepended with a correct indentation.

    void DebMainWindowFrm::browsePushButtonClicked() { if self.debugging: - QMessageBox.critical(self, "Event", "browse pushbutton was clicked!") + TQMessageBox.critical(self, "Event", "browse pushbutton was clicked!") }
    class DebMainWindowFrm(QMainWindow):
+>class DebMainWindowFrm(TQMainWindow):
     ...stuff...
     def browsePushButtonClicked(self):
         if self.debugging:
-            QMessageBox.critical(self, "Event", "browse pushbutton was clicked!")
    Using Qt LinguistUsing TQt Linguist

    Qt includes the TQt includes the lupdate program which parses C++ source @@ -411,7 +411,7 @@ CLASS="LITERAL" > binary language files that are distributed with your application.

    Thanks to Detlev Offenbach, PyQt includes the Thanks to Detlev Offenbach, PyTQt includes the pylupdate @@ -419,7 +419,7 @@ program. This generates the same .ts language source files -from your PyQt source files.

    Deploying Commercial PyQt ApplicationsDeploying Commercial PyTQt Applications

    When deploying commercial PyQt applications it is necessary to discourage users -from accessing the underlying PyQt modules for themselves. A user that used +>When deploying commercial PyTQt applications it is necessary to discourage users +from accessing the underlying PyTQt modules for themselves. A user that used the modules shipped with your application to develop new applications would -themselves be considered a developer and would need their own commercial Qt and -PyQt licenses.

    One solution to this problem is the

    In order to build PyQt with support for the VendorID package, pass the +>In order to build PyTQt with support for the VendorID package, pass the -isipconfig module) is described -in the SIP documentation. PyQt includes the pyqtconfig module that can be used by configuration scripts of other bindings that are -built on top of PyQt.

    The

    This class encapsulates additional configuration values, specific to PyQt, that +>This class encapsulates additional configuration values, specific to PyTQt, that can be accessed as instance variables.

    The following configuration values are provided (in addition to those provided @@ -538,7 +538,7 @@ CLASS="LITERAL" >

    The name of the directory containing the PyQt modules.

    The name of the directory containing the PyTQt modules.

    A string containing the names of the PyQt modules that were installed.

    A string containing the names of the PyTQt modules that were installed.

    .sip files for each -of the PyQt modules is installed. A sub-directory exists with the same name as +of the PyTQt modules is installed. A sub-directory exists with the same name as the module.

    The PyQt version as a 3 part hexadecimal number (eg. v3.10 is represented as +>The PyTQt version as a 3 part hexadecimal number (eg. v3.10 is represented as 0x030a00

    The PyQt version as a string. For development snapshots it will start with +>The PyTQt version as a string. For development snapshots it will start with snapshot-

    QtModuleMakefile(sipconfig.SIPModuleMakefile)TQtModuleMakefile(sipconfig.SIPModuleMakefile)

    QtAxContainerModuleMakefile(QtModuleMakefile)TQtAxContainerModuleMakefile(TQtModuleMakefile)

    QtCanvasModuleMakefile(QtModuleMakefile)TQtCanvasModuleMakefile(TQtModuleMakefile)

    QtExtModuleMakefile(QtModuleMakefile)TQtExtModuleMakefile(TQtModuleMakefile)

    QtGLModuleMakefile(QtModuleMakefile)TQtGLModuleMakefile(TQtModuleMakefile)

    QtNetworkModuleMakefile(QtModuleMakefile)TQtNetworkModuleMakefile(TQtModuleMakefile)

    QtTableModuleMakefile(QtModuleMakefile)TQtTableModuleMakefile(TQtModuleMakefile)

    QtSQLModuleMakefile(QtTableModuleMakefile)TQtSQLModuleMakefile(TQtTableModuleMakefile)

    QtUIModuleMakefile(QtModuleMakefile)TQtUIModuleMakefile(TQtModuleMakefile)

    QtXMLModuleMakefile(QtModuleMakefile)TQtXMLModuleMakefile(TQtModuleMakefile)

    super and Wrapped Classes

    Internally PyQt implements a lazy technique for attribute lookup where +>Internally PyTQt implements a lazy technique for attribute lookup where attributes are only placed in type and instance dictionaries when they are first referenced. This technique is needed to reduce the time taken to import -large modules such as PyQt.

    In most circumstances this technique is transparent to an application. The exception is when super is used with a PyQt class. The way +> is used with a PyTQt class. The way that super

    Note that this restriction applies to any class wrapped by SIP and not just -PyQt.

    Python Strings, Qt Strings and UnicodePython Strings, TQt Strings and Unicode

    Unicode support was added to Qt in v2.0 and to Python in v1.6. In Qt, Unicode +>Unicode support was added to TQt in v2.0 and to Python in v1.6. In TQt, Unicode support is implemented using the QStringTQString class. It is important to understand that QStringTQStrings, Python string objects and Python Unicode objects are all different but conversions between them are automatic in many cases and easy to achieve manually when needed.

    Whenever PyQt expects a Whenever PyTQt expects a QStringTQString as a function argument, a Python string object or a Python Unicode object can be provided instead, and -PyQt will do the necessary conversion automatically.

    You may also manually convert Python string and Unicode objects to QStringTQStrings by using the QStringTQString constructor as demonstrated in the following code fragment.

    qs1 = QString('Converted Python string object')
-qs2 = QString(u'Converted Python Unicode object')
    qs1 = TQString('Converted Python string object') +qs2 = TQString(u'Converted Python Unicode object')

    In order to convert a QStringTQString to a Python string object use the Python str() to a null QStringTQString and an empty QStringTQString both result in an empty Python string object.

    In order to convert a QStringTQString to a Python Unicode object use the Python unicode() to a null QStringTQString and an empty QStringTQString both result in an empty Python Unicode object.

    Data Types

    PyQt represents PyTQt represents void * values as objects of type @@ -1416,11 +1416,11 @@ NAME="AEN517" >Support for Threads

    PyQt implements the full set of Qt's thread classes. Python, of course, also +>PyTQt implements the full set of TQt's thread classes. Python, of course, also has its own thread extension modules. If you are using SIP v4 (or later) and -Python v2.3.5 (or later) then PyQt does not impose any additional restrictions. -(Read the relevant part of the Qt documentation to understand the restrictions -imposed by the Qt API.)

    If you are using earlier versions of either SIP or Python then it is possible to use either of the APIs so long as you follow some simple rules.

    • If you use the Qt API then the very first If you use the TQt API then the very first import of one of -the PyQt modules must be done from the main thread.

    • If you use the Python API then all calls to PyQt (including any +>If you use the Python API then all calls to PyTQt (including any imports) must be done from one thread only. Therefore, if -you want to make calls to PyQt from several threads then you must use the Qt +you want to make calls to PyTQt from several threads then you must use the TQt API.

    • If you want to use both APIs in the same application then all calls to PyQt -must be done from threads created using the Qt API.

      If you want to use both APIs in the same application then all calls to PyTQt +must be done from threads created using the TQt API.

    The above comments actually apply to any SIP generated module, not just PyQt.

    The above comments actually apply to any SIP generated module, not just PyTQt.

    c = new QColor();
-c = new QColor();
    c = new TQColor(); +c = new TQColor();
    c = QColor()
-c = QColor()
    c = TQColor() +c = TQColor()
    self.c1 = QColor()
-self.c2 = QColor()
    self.c1 = TQColor() +self.c2 = TQColor()

    Sometimes a Qt class instance will maintain a pointer to another instance and +>Sometimes a TQt class instance will maintain a pointer to another instance and will eventually call the destructor of that second instance. The most common example is that a QObjectTQObject (and any of its sub-classes) keeps pointers to its children and will automatically call their destructors. In these cases, the corresponding Python object will also keep a reference to the @@ -1527,7 +1527,7 @@ corresponding child objects.

    So, in the following Python fragment, the first QLabelTQLabel is not destroyed when the second is assigned to because the parent QWidgetTQWidget still has a reference to it.

    p = QWidget()
-l = QLabel('First label',p)
-l = QLabel('Second label',p)
    p = TQWidget() +l = TQLabel('First label',p) +l = TQLabel('Second label',p)
    tab = QTab()
+>tab = TQTab()
 tab.label = "First Tab"
-tab.r = QRect(10,10,75,30)

    It is not possible to define a new Python class that sub-classes from more than -one Qt class.

    i18n Support

    Qt implements i18n support through the Qt Linguist application, the +>TQt implements i18n support through the TQt Linguist application, the QTranslatorTQTranslator class, and the QApplication::translate()TQApplication::translate(), QObject::tr()TQObject::tr() and QObject::trUtf8()TQObject::trUtf8() methods. Usually the and uses the hardcoded class name as the context. On the other hand, QApplication::translate()TQApplication::translate() allows to context to be explicitly stated.

    Unfortunately, because of the way Qt implents Unfortunately, because of the way TQt implents tr() (and trUtf8()) it is not possible for PyQt to exactly reproduce -its behavour. The PyQt implementation of ) it is not possible for PyTQt to exactly reproduce +its behavour. The PyTQt implementation of tr() (and @@ -1658,7 +1658,7 @@ CLASS="LITERAL" >trUtf8()) uses the class name of the instance as the context. The key difference, and the source of potential problems, is that the -context is determined dynamically in PyQt, but is hardcoded in Qt. In other +context is determined dynamically in PyTQt, but is hardcoded in TQt. In other words, the context of a translation may change depending on an instance's class hierarchy.

    class A(QObject):
+>class A(TQObject):
     def __init__(self):
-        QObject.__init__(self)
+        TQObject.__init__(self)
 
     def hello(self):
         return self.tr("Hello")
@@ -1709,10 +1709,10 @@ CLASS="LITERAL"
 >A in both cases.
    The PyQt behaviour is unsatisfactory and may be changed in the future.  It is
+>The PyTQt behaviour is unsatisfactory and may be changed in the future.  It is
 recommended that QApplication.translate()TQApplication.translate() be used in
 preference to trUtf8()).  This
-is guaranteed to work with current and future versions of PyQt and makes it
+is guaranteed to work with current and future versions of PyTQt and makes it
 much easier to share message files between Python and C++ code.  Below is the
 alternative implementation of  that uses
 QApplication.translate()TQApplication.translate().
    class A(QObject):
+>class A(TQObject):
     def __init__(self):
-        QObject.__init__(self)
+        TQObject.__init__(self)
 
     def hello(self):
         return qApp.translate("A","Hello")
     uses
 QApplication.translate()TQApplication.translate().
    Signal and Slot Support
    A signal may be either a Qt signal (specified using
+>A signal may be either a TQt signal (specified using
 SIGNAL()PYSIGNAL()).
    A slot can be either a Python callable object, a Qt signal (specified using
+>A slot can be either a Python callable object, a TQt signal (specified using
 SIGNAL()PYSIGNAL()), or a Qt slot (specified using
+>), or a TQt slot (specified using
 SLOT()
    QObject.connect(a,SIGNAL("QtSig()"),pyFunction)
-QObject.connect(a,SIGNAL("QtSig()"),pyClass.pyMethod)
-QObject.connect(a,SIGNAL("QtSig()"),PYSIGNAL("PySig"))
-QObject.connect(a,SIGNAL("QtSig()"),SLOT("QtSlot()"))
-QObject.connect(a,PYSIGNAL("PySig"),pyFunction)
-QObject.connect(a,PYSIGNAL("PySig"),pyClass.pyMethod)
-QObject.connect(a,PYSIGNAL("PySig"),SIGNAL("QtSig()"))
-QObject.connect(a,PYSIGNAL("PySig"),SLOT("QtSlot()"))
    TQObject.connect(a,SIGNAL("TQtSig()"),pyFunction)
+TQObject.connect(a,SIGNAL("TQtSig()"),pyClass.pyMethod)
+TQObject.connect(a,SIGNAL("TQtSig()"),PYSIGNAL("PySig"))
+TQObject.connect(a,SIGNAL("TQtSig()"),SLOT("TQtSlot()"))
+TQObject.connect(a,PYSIGNAL("PySig"),pyFunction)
+TQObject.connect(a,PYSIGNAL("PySig"),pyClass.pyMethod)
+TQObject.connect(a,PYSIGNAL("PySig"),SIGNAL("TQtSig()"))
+TQObject.connect(a,PYSIGNAL("PySig"),SLOT("TQtSlot()"))
    When a slot is a Python method that corresponds to a Qt slot then a signal can
-be connected to either the Python method or the Qt slot.  The following
+>When a slot is a Python method that corresponds to a TQt slot then a signal can
+be connected to either the Python method or the TQt slot.  The following
 connections achieve the same effect.
    sbar = QScrollBar()
-lcd = QLCDNumber()
+>sbar = TQScrollBar()
+lcd = TQLCDNumber()
 
-QObject.connect(sbar,SIGNAL("valueChanged(int)"),lcd.display)
-QObject.connect(sbar,SIGNAL("valueChanged(int)"),lcd,SLOT("display(int)"))
    Any instance of a class that is derived from the QObjectTQObject
 class can emit a signal using the emit method.  This takes
-two arguments.  The first is the Python or Qt signal, the second is a Python
+two arguments.  The first is the Python or TQt signal, the second is a Python
 tuple which are the arguments to the signal.  For example:
    Qt allows a signal to be connected to a slot that requires fewer arguments than
-the signal passes.  The extra arguments are quietly discarded.  Python slots
+>TQt allows a signal to be connected to a slot that retquires fewer arguments than
+the signal passes.  The extra arguments are tquietly discarded.  Python slots
 can be used in the same way. 
    QObject::connect()TQObject::connect() is called from Python as
 QObject.connect()TQObject.connect() or self.connect() if
 called from a sub-class of QObjectTQObject.
    Qt.SolidPattern
-QWidget.TabFocus
-QFrame.TabFocus
    TQt.SolidPattern
+TQWidget.TabFocus
+TQFrame.TabFocus
    Qt ConstantsTQt Constants
    All constant values defined by Qt have equivalent constants defined to Python.
    All constant values defined by TQt have equivalent constants defined to Python.
    Qt (Qt v2+)TQt (TQt v2+)
    QtTQt is fully implemented.
    QAccelTQAccel
    QAccelTQAccel is fully implemented.
    QAction (Qt v2.2+)TQAction (TQt v2.2+)
    QActionTQAction is fully implemented.
    QActionGroup (Qt v2.2+)TQActionGroup (TQt v2.2+)
    QActionGroupTQActionGroup is fully implemented.
    QApplicationTQApplication
    QApplicationTQApplication(int &argc, char **argv);
    This takes one parameter which is a list of argument strings.  Arguments
-used by Qt are removed from the list.
    QApplicationTQApplication(int &argc, char **argv, bool GUIenabled);
    This takes two parameters, the first of which is a list of argument strings.
-Arguments used by Qt are removed from the list.
    QApplicationTQApplication(int &argc, char **argv, Type type);
    This takes two parameters, the first of which is a list of argument strings.
-Arguments used by Qt are removed from the list. (Qt v2.2+)
    QAssistantClient (Qt v3.1+)TQAssistantClient (TQt v3.1+)
    QAssistantClientTQAssistantClient is fully implemented.
    QBitmapTQBitmap
    QBitmapTQBitmap is fully implemented.
    QBrushTQBrush
    QBrushTQBrush is fully implemented, including the Python
 QButtonTQButton
    QButtonTQButton is fully implemented.
    QButtonGroupTQButtonGroup
    QButtonGroupTQButtonGroup is fully implemented.
    QByteArrayTQByteArray
    A Python string can be used whenever a QByteArrayTQByteArray can be
 used.  A QByteArrayTQByteArray can be converted to a Python string
 using the Python QByteArray &assignTQByteArray &assign(const char *data, uint size);
    QByteArray &setRawDataTQByteArray &setRawData(const char *data, uintsize);
    QCDEStyle (Qt v2+)TQCDEStyle (TQt v2+)
    QCDEStyleTQCDEStyle is fully implemented.
    QCheckBoxTQCheckBox
    QCheckBoxTQCheckBox is fully implemented.
    QClipboardTQClipboard
    Not yet implemented (Qt v1.x).
    Not yet implemented (TQt v1.x).
    Not yet implemented (Qt v1.x).
    Not yet implemented (TQt v1.x).
    QColorTQColor
    The Python QColorDialog (Qt v2+)TQColorDialog (TQt v2+)
    static QRgb getRgba(QRgb initial, bool *ok, QWidget *parent = 0, const char *name = 0);
    static TQRgb getRgba(TQRgb initial, bool *ok, TQWidget *parent = 0, const char *name = 0);
     parameters and returns a tuple containing the
 QRgbTQRgb result and the okQColorGroupTQColorGroup
    QColorGroupTQColorGroup is fully implemented.
    QComboBoxTQComboBox
    QComboBoxTQComboBox is fully implemented.
    QCommonStyle (Qt v2+)TQCommonStyle (TQt v2+)
    y values.  (Qt v2)
     values.  (TQt v2)
    virtual void tabbarMetrics(const QTabBar *t, int &hframe, int &vframe, int &overlap);
    (const TQTabBar *t, int &hframe, int &vframe, int &overlap);
    overlap values.  (Qt v2)
     values.  (TQt v2)
    QCString (Qt v2+)TQCString (TQt v2+)
    A Python string can be used whenever a QCStringTQCString can be used.
 A QCStringTQCString can be converted to a Python string using the
 Python QCString &sprintfTQCString &sprintf(const char *format, ...);
    QCursorTQCursor
    QCursorTQCursor is fully implemented.
    QDataStreamTQDataStream
    QDataStream &readBytesTQDataStream &readBytes(const char *&s, uint &l);
    This takes no parameters.  The QDataStreamTQDataStream result and the
 data read are returned as a tuple.
    QDataStream &readRawBytesTQDataStream &readRawBytes(const char *s, uint l);
     parameter.  The
 QDataStreamTQDataStream result and the data read are returned as a
 tuple.
    QDataStream &writeBytesTQDataStream &writeBytes(const char *s, uint len);
    QDataStream &writeRawBytesTQDataStream &writeRawBytes(const char *s, uint len);
    QDateTQDate
    The Python
@@ -3018,7 +3018,7 @@ CLASS="FUNCDEF"
 >
    This takes no parameters and returns the week number and the year number as a
-tuple. (Qt v3.1+)
    QDateTimeTQDateTime
    QDateTimeTQDateTime is fully implemented, including the Python
 QTimeTQTime
    QTimeTQTime is fully implemented, including the Python
 QDateEdit (Qt v3+)TQDateEdit (TQt v3+)
    QDateEditTQDateEdit is fully implemented.
    QTimeEdit (Qt v3+)TQTimeEdit (TQt v3+)
    QTimeEditTQTimeEdit is fully implemented.
    QDateTimeEdit (Qt v3+)TQDateTimeEdit (TQt v3+)
    QDateTimeEditTQDateTimeEdit is fully implemented.
    QDesktopWidget (Qt v3+)TQDesktopWidget (TQt v3+)
    QDesktopWidgetTQDesktopWidget is fully implemented.
    QDial (Qt v2.2+)TQDial (TQt v2.2+)
    QDialTQDial is fully implemented.
    QDialogTQDialog
    QObject.deleteLater()TQObject.deleteLater() or other techniques.
    QDirTQDir
    QDirTQDir is fully implemented, including the Python
 QFileInfoListTQFileInfoList
    This class isn't implemented.  Whenever a QFileInfoListTQFileInfoList is
 the return type of a function or the type of an argument, a Python list of
 QFileInfoTQFileInfo instances is used instead.
    QDockArea (Qt v3+)TQDockArea (TQt v3+)
    bool hasDockWindow const(QDockWindow *w, int *index = 0);
    (TQDockWindow *w, int *index = 0);
    w parameter and returns the index of the
-QDockWIndow or -1 if the QDockArea does not contain the QDockWindow.
    QDockWindow (Qt v3+)TQDockWindow (TQt v3+)
    QDockWindowTQDockWindow is fully implemented.
    QColorDrag (Qt v2.1+)TQColorDrag (TQt v2.1+)
    QColorDragTQColorDrag is fully implemented.
    QDragObjectTQDragObject
    QDragObjectTQDragObject is fully implemented.
    QImageDragTQImageDrag
    QImageDragTQImageDrag is fully implemented.
    QStoredDragTQStoredDrag
    QStoredDragTQStoredDrag is fully implemented.
    QTextDragTQTextDrag
    QTextDragTQTextDrag is fully implemented.
    QUriDrag (Qt v2+)TQUriDrag (TQt v2+)
    QUriDragTQUriDrag is fully implemented.
    QUrlDrag (Qt v1.x)TQUrlDrag (TQt v1.x)
    QUrlDragTQUrlDrag is fully implemented.
    QDropSiteTQDropSite
    QDropSiteTQDropSite is fully implemented.
    QErrorMessage (Qt v3+)TQErrorMessage (TQt v3+)
    QErrorMessageTQErrorMessage is fully implemented.
    QEventTQEvent
    QEventTQEvent is fully implemented.
    Instances of QEventTQEvents are automatically converted to the
 correct sub-class.
    QChildEventTQChildEvent
    QChildEventTQChildEvent is fully implemented.
    QCloseEventTQCloseEvent
    QCloseEventTQCloseEvent is fully implemented.
    QIconDragEvent (Qt v3.3+)TQIconDragEvent (TQt v3.3+)
    QIconDragEventTQIconDragEvent is fully implemented.
    QContextMenuEvent (Qt v3+)TQContextMenuEvent (TQt v3+)
    QContextMenuEventTQContextMenuEvent is fully implemented.
    QCustomEventTQCustomEvent
    QCustomEventTQCustomEvent is fully implemented.  Any Python object can be
 passed as the event data and its reference count is increased.
    QDragEnterEventTQDragEnterEvent
    QDragEnterEventTQDragEnterEvent is fully implemented.
    QDragLeaveEventTQDragLeaveEvent
    QDragLeaveEventTQDragLeaveEvent is fully implemented.
    QDragMoveEventTQDragMoveEvent
    QDragMoveEventTQDragMoveEvent is fully implemented.
    QDropEventTQDropEvent
    QDropEventTQDropEvent is fully implemented.
    QFocusEventTQFocusEvent
    QFocusEventTQFocusEvent is fully implemented.
    QHideEventTQHideEvent
    QHideEventTQHideEvent is fully implemented.
    QIMComposeEvent (Qt v3.1+)TQIMComposeEvent (TQt v3.1+)
    QIMComposeEventTQIMComposeEvent is fully implemented.
    QIMEvent (Qt v3+)TQIMEvent (TQt v3+)
    QIMEventTQIMEvent is fully implemented.
    QKeyEventTQKeyEvent
    QKeyEventTQKeyEvent is fully implemented.
    QMouseEventTQMouseEvent
    QMouseEventTQMouseEvent is fully implemented.
    QMoveEventTQMoveEvent
    QMoveEventTQMoveEvent is fully implemented.
    QPaintEventTQPaintEvent
    QPaintEventTQPaintEvent is fully implemented.
    QResizeEventTQResizeEvent
    QResizeEventTQResizeEvent is fully implemented.
    QShowEventTQShowEvent
    QShowEventTQShowEvent is fully implemented.
    QTabletEvent (Qt v3+)TQTabletEvent (TQt v3+)
    QTabletEventTQTabletEvent is fully implemented.
    QTimerEventTQTimerEvent
    QTimerEventTQTimerEvent is fully implemented.
    QWheelEvent (Qt v2+)TQWheelEvent (TQt v2+)
    QWheelEventTQWheelEvent is fully implemented.
    QEventLoop (Qt v3.1+)TQEventLoop (TQt v3.1+)
    QFileTQFile
    Not yet implemented. (Qt v2+)
    Not yet implemented. (TQt v2+)
    Not yet implemented. (Qt v2+)
    Not yet implemented. (TQt v2+)
    QFileDialogTQFileDialog
    QFileDialogTQFileDialog is fully implemented.
    QFileIconProviderTQFileIconProvider
    QFileIconProviderTQFileIconProvider is fully implemented.
    QFilePreviewTQFilePreview
    QFilePreviewTQFilePreview is fully implemented.  However it cannot be
-used from Python in the same way as it is used from C++ because PyQt does not
+used from Python in the same way as it is used from C++ because PyTQt does not
 support multiple inheritance involving more than one wrapped class.  A trick
 that seems to work is to use composition rather than inheritance as in the
 following code fragment.
    class FilePreview(QFilePreview):
+>class FilePreview(TQFilePreview):
     pass
 
-class Preview(QLabel):
+class Preview(TQLabel):
     def __init__(self, parent=None):
-        QLabel.__init__(self, parent)
+        TQLabel.__init__(self, parent)
         self.preview = FilePreview()
         self.preview.previewUrl = self.previewUrl

    Note that QFilePreview cannot be instantiated directly because it is abstract. +>Note that TQFilePreview cannot be instantiated directly because it is abstract. Thanks to Hans-Peter Jansen for this trick.

    QFileInfoTQFileInfo

    QFileInfoTQFileInfo is fully implemented.

    QFontTQFont

    QFontTQFont is fully implemented, including the Python QFontDatabase (Qt v2.1+)TQFontDatabase (TQt v2.1+)

    QFontDatabaseTQFontDatabase is fully implemented.

    (bool *ok, const TQFont &def, TQWidget *parent = 0, const char *name = 0);

    parameters and returns a tuple containing the QFontTQFont result and the okstatic QFont getFont(bool *ok, QWidget *parent = 0, const char *name = 0);

    static TQFont getFont(bool *ok, TQWidget *parent = 0, const char *name = 0);

    parameters and returns a tuple containing the QFontTQFont result and the QFontInfoTQFontInfo

    QFontInfoTQFontInfo is fully implemented.

    QFontMetricsTQFontMetrics
    QRect boundingRect(int x, int y, int w, int h, int flags, const QString &str, int len = -1, int tabstops = 0, int *tabarray = 0);

    TQRect boundingRect(int x, int y, int w, int h, int flags, const TQString &str, int len = -1, int tabstops = 0, int *tabarray = 0);

    QSize size(int flags, const QString &str, int len = -1, int tabstops = 0, int *tabarray = 0);

    TQSize size(int flags, const TQString &str, int len = -1, int tabstops = 0, int *tabarray = 0);

    QFrameTQFrame

    QFrameTQFrame is fully implemented.

    QGManager (Qt v1.x)TQGManager (TQt v1.x)

    QGManagerTQGManager is fully implemented.

    QChain (Qt v1.x)TQChain (TQt v1.x)

    QChainTQChain is implemented as an opaque class.

    QGrid (Qt v2+)TQGrid (TQt v2+)

    QGridTQGrid is fully implemented.

    QGridView (Qt v3+)TQGridView (TQt v3+)

    QGridViewTQGridView is fully implemented.

    QGroupBoxTQGroupBox

    QGroupBoxTQGroupBox is fully implemented.

    QHBox (Qt v2+)TQHBox (TQt v2+)

    QHBoxTQHBox is fully implemented.

    QHButtonGroup (Qt v2+)TQHButtonGroup (TQt v2+)

    QHButtonGroupTQHButtonGroup is fully implemented.

    QHeaderTQHeader

    QHeaderTQHeader is fully implemented.

    QHGroupBox (Qt v2+)TQHGroupBox (TQt v2+)

    QHGroupBoxTQHGroupBox is fully implemented.

    QIconSetTQIconSet

    QIconSetTQIconSet is fully implemented.

    QIconFactory (Qt v3.1+)TQIconFactory (TQt v3.1+)

    QIconFactoryTQIconFactory is fully implemented.

    QIconView (Qt v2.1+)TQIconView (TQt v2.1+)
    QIconViewItem *makeRowLayout(QIconViewItem *begin, int &y);

    TQIconViewItem *makeRowLayout(TQIconViewItem *begin, int &y);

    QIconViewItem (Qt v2.1+)TQIconViewItem (TQt v2.1+)

    QIconViewItemTQIconViewItem is fully implemented.

    QIconDrag (Qt v2.1+)TQIconDrag (TQt v2.1+)

    QIconDragTQIconDrag is fully implemented.

    QIconDragItem (Qt v2.1+)TQIconDragItem (TQt v2.1+)

    QIconDragItemTQIconDragItem is fully implemented.

    QImageTQImage

    The Python QImageTQImage(const char *xpm[]);

    QImage(uchar *data, int w, int h, int depth, QRgb *colorTable, int numColors, Endian bitOrder);

    TQImage(uchar *data, int w, int h, int depth, TQRgb *colorTable, int numColors, Endian bitOrder);

    The colorTable parameter is a list of QRgb instances or -None. (Qt v2.1+)

    parameter is a list of TQRgb instances or +None. (TQt v2.1+)

    QRgb *colorTableTQRgb *colorTable();

    QImage convertDepthWithPalette(int, QRgb *p, int pc, int cf = 0);

    TQImage convertDepthWithPalette(int, TQRgb *p, int pc, int cf = 0);

    QImageIOTQImageIO

    QImageTextKeyLangTQImageTextKeyLang

    QImageTextKeyLangTQImageTextKeyLang is fully implemented.

    QInputDialog (Qt v2.1+)TQInputDialog (TQt v2.1+)
    static QString getText(const QString &caption, const QString &label, const QString &text = QString::null, bool *ok = 0, QWidget *parent = 0, const char *name = 0);

    static TQString getText(const TQString &caption, const TQString &label, const TQString &text = TQString::null, bool *ok = 0, TQWidget *parent = 0, const char *name = 0);

    is not passed and the returned value is a tuple of the QStringTQString result and the ok flag. -(Qt v2.1 - v2.3.1)

    static QString getText(const QString &caption, const QString &label, QLineEdit::EchoModeecho, const QString &text = QString::null, bool *ok = 0, QWidget *parent = 0, const char *name = 0);

    static TQString getText(const TQString &caption, const TQString &label, TQLineEdit::EchoModeecho, const TQString &text = TQString::null, bool *ok = 0, TQWidget *parent = 0, const char *name = 0);

    is not passed and the returned value is a tuple of the QStringTQString result and the ok flag. -(Qt v2.2 - v2.3.1)

    static QString getText(const QString &caption, const QString &label, QLineEdit::EchoModeecho = QLineEdit::Normal, const QString &text = QString::null, bool *ok = 0, QWidget *parent = 0, const char *name = 0);

    static TQString getText(const TQString &caption, const TQString &label, TQLineEdit::EchoModeecho = TQLineEdit::Normal, const TQString &text = TQString::null, bool *ok = 0, TQWidget *parent = 0, const char *name = 0);

    is not passed and the returned value is a tuple of the QStringTQString result and the ok flag. -(Qt v3+)

    static int getInteger(const QString &caption, const QString &label, int num = 0, int from = -2147483647, int to = 2147483647, int step = 1, bool *ok = 0, QWidget *parent = 0, const char *name = 0);

    (const TQString &caption, const TQString &label, int num = 0, int from = -2147483647, int to = 2147483647, int step = 1, bool *ok = 0, TQWidget *parent = 0, const char *name = 0);

    static double getDouble(const QString &caption, const QString &label, double num = 0, double from = -2147483647, double to = 2147483647, int step = 1, bool *ok = 0, QWidget *parent = 0, const char *name = 0);

    (const TQString &caption, const TQString &label, double num = 0, double from = -2147483647, double to = 2147483647, int step = 1, bool *ok = 0, TQWidget *parent = 0, const char *name = 0);

    static QString getItem(const QString &caption, const QString &label, const QStringList &list, int current = 0, bool editable = TRUE, bool *ok = 0, QWidget *parent = 0, const char *name = 0);

    static TQString getItem(const TQString &caption, const TQString &label, const TQStringList &list, int current = 0, bool editable = TRUE, bool *ok = 0, TQWidget *parent = 0, const char *name = 0);

    is not passed and the returned value is a tuple of the QStringTQString result and the okQInterlaceStyle (Qt v2.3.1+)TQInterlaceStyle (TQt v2.3.1+)

    void scrollBarMetrics(const QTabBar *sb, int &sliderMin, int &sliderMax, int &sliderLength, int &buttonDim);

    (const TQTabBar *sb, int &sliderMin, int &sliderMax, int &sliderLength, int &buttonDim);

    QIODeviceTQIODevice

    QIODeviceTQIODevice is fully implemented.

    QKeySequence (Qt v3+)TQKeySequence (TQt v3+)

    QKeySequenceTQKeySequence is fully implemented including the operators !=, QString()TQString() and int(). A QStringTQString instance or a Python integer may be used whenever a QKeySequenceTQKeySequence can be used.

    QLabelTQLabel

    QLabelTQLabel is fully implemented.

    QLayoutTQLayout

    QLayoutTQLayout is fully implemented.

    QBoxLayoutTQBoxLayout

    QBoxLayoutTQBoxLayout is fully implemented.

    QGLayoutIterator (Qt v2+)TQGLayoutIterator (TQt v2+)

    QGLayoutIteratorTQGLayoutIterator is fully implemented.

    QGridLayoutTQGridLayout
    bool findWidget(QWidget *w, int *row, int *col);

    (TQWidget *w, int *row, int *col);

    col. (Qt v2+)

    . (TQt v2+)

    QHBoxLayoutTQHBoxLayout

    QHBoxLayoutTQHBoxLayout is fully implemented.

    QLayoutItem (Qt v2+)TQLayoutItem (TQt v2+)

    QLayoutItemTQLayoutItem is fully implemented.

    QLayoutIterator (Qt v2+)TQLayoutIterator (TQt v2+)
    QLayoutItem *nextTQLayoutItem *next();

    This is a wrapper around the QLayoutIteratorTQLayoutIterator QSpacerItem (Qt v2+)TQSpacerItem (TQt v2+)

    QSpacerItemTQSpacerItem is fully implemented.

    QVBoxLayoutTQVBoxLayout

    QVBoxLayoutTQVBoxLayout is fully implemented.

    QWidgetItem (Qt v2+)TQWidgetItem (TQt v2+)

    QWidgetItemTQWidgetItem is fully implemented.

    QLCDNumberTQLCDNumber

    QLCDNumberTQLCDNumber is fully implemented.

    QLibrary (Qt v3+)TQLibrary (TQt v3+)

    QLibraryTQLibrary is fully implemented.

    QLineEditTQLineEdit
    int characterAt(int xpos, QChar *chr);

    (int xpos, TQChar *chr);

    chr value as a tuple. (Qt v3+)

    value as a tuple. (TQt v3+)

    This has been renamed delChar in Python. (Qt v2+)

    in Python. (TQt v2+)

    end values as a tuple. -(Qt v3+)

    QList<type> (Qt v2)TQList<type> (TQt v2)

    Types based on the QListTQList template are automatically converted to and from Python lists of the type.

    QListBoxTQListBox
    yPos. -(Qt v1.x)

    QListBoxItemTQListBoxItem

    QListBoxItemTQListBoxItem is fully implemented.

    QListBoxPixmapTQListBoxPixmap

    QListBoxPixmapTQListBoxPixmap is fully implemented.

    QListBoxTextTQListBoxText

    QListBoxTextTQListBoxText is fully implemented.

    QListViewTQListView

    QListViewTQListView is fully implemented.

    Note that to remove a child QListViewItemTQListViewItem you must first call QListViewItemTQListViewItem

    QListViewItemTQListViewItem is fully implemented.

    Note that to remove a child QListViewItemTQListViewItem you must first call QCheckListItemTQCheckListItem

    QCheckListItemTQCheckListItem is fully implemented.

    QListViewItemIterator (Qt v2+)TQListViewItemIterator (TQt v2+)

    QListViewItemIteratorTQListViewItemIterator is fully implemented.

    QLocale (Qt v3.3+)TQLocale (TQt v3.3+)
    QMainWindowTQMainWindow
    QTextStream &operator<<(QTextStream &, const QMainWindow &);

    TQTextStream &operator<<(TQTextStream &, const TQMainWindow &);

    This operator is fully implemented. (Qt v3+)

    This operator is fully implemented. (TQt v3+)

    QTextStream &operator>>(QTextStream &, QMainWindow &);

    TQTextStream &operator>>(TQTextStream &, TQMainWindow &);

    This operator is fully implemented. (Qt v3+)

    This operator is fully implemented. (TQt v3+)

    bool getLocation(QToolBar *tb, ToolBarDock &dock, int &index, bool &nl, int &extraOffset);

    (TQToolBar *tb, ToolBarDock &dock, int &index, bool &nl, int &extraOffset);

    and extraOffset values. (Qt v2.1.0+)

    values. (TQt v2.1.0+)

    QList<QToolBar> toolBarsTQList<TQToolBar> toolBars(ToolBarDock dock);

    This returns a list of QToolBar instances. (Qt v2.1.0+)

    TQToolBar instances. (TQt v2.1.0+)

    QMemArray<type> (Qt v3+)TQMemArray<type> (TQt v3+)

    Types based on the QMemArrayTQMemArray template are automatically converted to and from Python lists of the type.

    QMenuBarTQMenuBar

    QMenuBarTQMenuBar is fully implemented.

    QMenuDataTQMenuData
    QMenuItem *findItem(int id, QMenuData **parent);

    TQMenuItem *findItem(int id, TQMenuData **parent);

    QCustomMenuItem (Qt v2.1+)TQCustomMenuItem (TQt v2.1+)

    QCustomMenuItemTQCustomMenuItem is fully implemented.

    QMenuItemTQMenuItem

    QMenuItem is an internal Qt class.

    TQMenuItem is an internal TQt class.

    QMessageBoxTQMessageBox

    QMessageBoxTQMessageBox is fully implemented.

    QMetaObjectTQMetaObject
    const QClassInfo *classInfo constconst TQClassInfo *classInfo const(bool super = FALSE);

    QMetaPropertyTQMetaProperty

    QMetaPropertyTQMetaProperty is fully implemented.

    QMimeSource (Qt v2+)TQMimeSource (TQt v2+)

    QMimeSourceTQMimeSource is fully implemented.

    QMimeSourceFactory (Qt v2+)TQMimeSourceFactory (TQt v2+)

    QMimeSourceFactoryTQMimeSourceFactory is fully implemented.

    QWindowsMime (Qt v3+)TQWindowsMime (TQt v3+)

    QWindowsMimeTQWindowsMime is fully implemented.

    QMotifPlusStyle (Qt v2.2+)TQMotifPlusStyle (TQt v2.2+)
    y values. (Qt v2)

    values. (TQt v2)

    void scrollBarMetrics(const QScrollBar *sb, int &sliderMin, int &sliderMax, int &sliderLength, int &buttonDim);

    (const TQScrollBar *sb, int &sliderMin, int &sliderMax, int &sliderLength, int &buttonDim);

    buttonDim values. -(Qt v2)

    QMotifStyle (Qt v2+)TQMotifStyle (TQt v2+)
    void scrollBarMetrics(const QTabBar *sb, int &sliderMin, int &sliderMax, int &sliderLength, int &buttonDim);

    (const TQTabBar *sb, int &sliderMin, int &sliderMax, int &sliderLength, int &buttonDim);

    buttonDim values. -(Qt v2)

    void tabbarMetrics(const QTabBar *t, int &hframe, int &vframe, int &overlap);

    (const TQTabBar *t, int &hframe, int &vframe, int &overlap);

    overlap values. (Qt v2)

    values. (TQt v2)

    QMovieTQMovie
    QMovie(QDataSource *src, int bufsize = 1024);

    TQMovie(TQDataSource *src, int bufsize = 1024);

    data and not -passed as a parameter. (Qt v2.2.0+)

    QMultiLineEditTQMultiLineEdit
    col values. (Qt v1.x, Qt v2.x)

    values. (TQt v1.x, TQt v2.x)

    This has been renamed delChar in Python. (Qt v1.x, Qt v2.x)

    in Python. (TQt v1.x, TQt v2.x)

    col values. (Qt v1.x, Qt v2.x)

    values. (TQt v1.x, TQt v2.x)

    QMutex (Qt v2.2+)TQMutex (TQt v2.2+)

    QMutexTQMutex is fully implemented.

    QMutexLocker (Qt v3.1+)TQMutexLocker (TQt v3.1+)

    QMutexLockerTQMutexLocker is fully implemented.

    QNetworkOperation (Qt v2.1+)TQNetworkOperation (TQt v2.1+)

    QNetworkOperationTQNetworkOperation is fully implemented.

    QNetworkProtocol (Qt v2.1+)TQNetworkProtocol (TQt v2.1+)

    QNetworkProtocolTQNetworkProtocol is fully implemented.

    QNetworkProtocolFactoryBase (Qt v2.1+)TQNetworkProtocolFactoryBase (TQt v2.1+)

    QNetworkProtocolFactoryBaseTQNetworkProtocolFactoryBase is fully implemented.

    QObjectTQObject
    bool disconnect(const QObject *receiver, const char *member = 0);

    (const TQObject *receiver, const char *member = 0);

    bool disconnect(const char *signal = 0, const QObject *receiver = 0, const char *member = 0);

    (const char *signal = 0, const TQObject *receiver = 0, const char *member = 0);

    static bool disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *member);

    (const TQObject *sender, const char *signal, const TQObject *receiver, const char *member);

    At the moment PyQt does not support the full behaviour of the corresponding Qt +>At the moment PyTQt does not support the full behaviour of the corresponding TQt method. In particular, specifying None (ie. 0 in C++) for the QObjectCleanupHandler (Qt v3+)TQObjectCleanupHandler (TQt v3+)

    QObjectCleanupHandlerTQObjectCleanupHandler is fully implemented.

    QObjectListTQObjectList

    This class isn't implemented. Whenever a QObjectListTQObjectList is the return type of a function or the type of an argument, a Python list of QObjectTQObject instances is used instead.

    QPaintDeviceMetricsTQPaintDeviceMetrics

    QPaintDeviceMetricsTQPaintDeviceMetrics is fully implemented.

    QPaintDeviceTQPaintDevice
    virtual bool cmd(int, QPainter *, QPDevCmdParam *);

    (int, TQPainter *, TQPDevCmdParam *);

    QPainterTQPainter

    QRect boundingRectTQRect boundingRect(int x, int y, int w, int h, int flags, const char *str, int len = -1, char **intern = 0);

    QRect boundingRect(const QRect&, int flags, const char *str, int len = -1, char **intern = 0);

    TQRect boundingRect(const TQRect&, int flags, const char *str, int len = -1, char **intern = 0);

    void drawText(int x, int y, int w, int h, int flags, const char *str, int len = -1, QRect *br = 0, char **intern = 0);

    (int x, int y, int w, int h, int flags, const char *str, int len = -1, TQRect *br = 0, char **intern = 0);

    void drawText(const QRect&, int flags, const char *str, int len = -1, QRect *br = 0, char **intern = 0);

    (const TQRect&, int flags, const char *str, int len = -1, TQRect *br = 0, char **intern = 0);

    QPaletteTQPalette

    QPaletteTQPalette is fully implemented, including the Python QPixmapTQPixmap

    QPixmapTQPixmap(const char *xpm[]);

    QPixmapCache (Qt v3+)TQPixmapCache (TQt v3+)

    QPixmapCacheTQPixmapCache is fully implemented.

    QPair<type,type> (Qt v3+)TQPair<type,type> (TQt v3+)

    Types based on the QPairTQPair template are automatically converted to and from Python tuples of two elements.

    QPenTQPen

    QPenTQPen is fully implemented, including the Python QPictureTQPicture

    QPlatinumStyle (Qt v2+)TQPlatinumStyle (TQt v2+)
    void scrollBarMetrics(const QTabBar *sb, int &sliderMin, int &sliderMax, int &sliderLength, int &buttonDim);

    (const TQTabBar *sb, int &sliderMin, int &sliderMax, int &sliderLength, int &buttonDim);

    buttonDim values. -(Qt v2)

    QPointTQPoint

    The Python @@ -6652,7 +6652,7 @@ NAME="AEN2485" >QCOORD &rxTQCOORD &rx();

    QCOORD &ryTQCOORD &ry();

    QPointArrayTQPointArray
    QPointArray(int nPoints, const QCOORD *points);

    TQPointArray(int nPoints, const TQCOORD *points);

    bool putPoints(int index, int nPoints, const QCOORD *points);

    (int index, int nPoints, const TQCOORD *points);

    bool setPoints(int nPoints, const QCOORD *points);

    (int nPoints, const TQCOORD *points);

    QPopupMenuTQPopupMenu

    int exec(const QPoint &pos, int indexAtPoint = 0);

    (const TQPoint &pos, int indexAtPoint = 0);

    QPrintDialog (X11)TQPrintDialog (X11)

    QPrintDialogTQPrintDialog is fully implemented.

    QPrinterTQPrinter

    QPrinterTQPrinter is fully implemented.

    QProcess (Qt v3+)TQProcess (TQt v3+)

    QProcessTQProcess is fully implemented.

    QProgressBarTQProgressBar

    QProgressBarTQProgressBar is fully implemented.

    QProgressDialogTQProgressDialog

    QProgressDialogTQProgressDialog is fully implemented. value.

    QPtrList<type> (Qt v3+)TQPtrList<type> (TQt v3+)

    Types based on the QPtrListTQPtrList template are automatically converted to and from Python lists of the type.

    QPushButtonTQPushButton

    QPushButtonTQPushButton is fully implemented.

    QRadioButtonTQRadioButton

    QRadioButtonTQRadioButton is fully implemented.

    QRangeControlTQRangeControl

    QRangeControlTQRangeControl is fully implemented.

    QRectTQRect

    The Python @@ -7036,12 +7036,12 @@ NAME="AEN2649" >QCOORD &rBottomTQCOORD &rBottom();

    Not implemented. (Qt v2+)

    Not implemented. (TQt v2+)

    QCOORD &rLeftTQCOORD &rLeft();

    Not implemented. (Qt v2+)

    Not implemented. (TQt v2+)

    QCOORD &rRightTQCOORD &rRight();

    Not implemented. (Qt v2+)

    Not implemented. (TQt v2+)

    QCOORD &rTopTQCOORD &rTop();

    Not implemented. (Qt v2+)

    Not implemented. (TQt v2+)

    QRegExpTQRegExp

    The Python len value. (Qt v1.x)

    value. (TQt v1.x)

    int match(const QString &str, int index = 0, int *len = 0);

    (const TQString &str, int index = 0, int *len = 0);

    len value. (Qt v2+)

    value. (TQt v2+)

    QRegionTQRegion

    The Python @@ -7232,7 +7232,7 @@ NAME="AEN2719" >QArray<QRect> rectsTQArray<TQRect> rects();

    void setRects(QRect *rects, int num);

    (TQRect *rects, int num);

    Not yet implemented. (Qt v2.2+)

    Not yet implemented. (TQt v2.2+)

    QScrollBarTQScrollBar

    QScrollBarTQScrollBar is fully implemented.

    QScrollViewTQScrollView
    vy -values. (Qt v2+)

    y -values. (Qt v2+)

    QSemaphore (Qt v2.2+)TQSemaphore (TQt v2.2+)

    QSemaphoreTQSemaphore is fully implemented. The +=-= operators have also been implemented, but require +> operators have also been implemented, but retquire Python v2.0 or later.

    QSemiModal (Qt v1, v2)TQSemiModal (TQt v1, v2)

    QSemiModalTQSemiModal is fully implemented.

    QSessionManager (Qt v2+)TQSessionManager (TQt v2+)

    QSessionManagerTQSessionManager is fully implemented.

    QSettings (Qt v3+)TQSettings (TQt v3+)
    bool readBoolEntry(const QString &key, bool def = 0, bool *ok = 0);

    (const TQString &key, bool def = 0, bool *ok = 0);

    double readDoubleEntry(const QString &key, double def = 0, bool *ok = 0);

    (const TQString &key, double def = 0, bool *ok = 0);

    QString readEntry(const QString &key, const QString &def = QString::null, bool *ok = 0);

    TQString readEntry(const TQString &key, const TQString &def = TQString::null, bool *ok = 0);

    is not passed and the returned value is a tuple of the QStringTQString result and the okQStringList readListEntry(const QString &key, bool *ok = 0);

    TQStringList readListEntry(const TQString &key, bool *ok = 0);

    is not passed and the returned value is a tuple of the QStringListTQStringList result and the okQStringList readListEntry(const QString &key, const QChar &separator, bool *ok = 0);

    TQStringList readListEntry(const TQString &key, const TQChar &separator, bool *ok = 0);

    is not passed and the returned value is a tuple of the QStringListTQStringList result and the okint readNumEntry(const QString &key, int def = 0, bool *ok = 0);

    (const TQString &key, int def = 0, bool *ok = 0);

    bool writeEntry(const QString &key, bool value);

    (const TQString &key, bool value);

    QSGIStyle (Qt v2.2+)TQSGIStyle (TQt v2.2+)

    void scrollBarMetrics(const QScrollBar *sb, int &sliderMin, int &sliderMax, int &sliderLength, int &buttonDim);

    (const TQScrollBar *sb, int &sliderMin, int &sliderMax, int &sliderLength, int &buttonDim);

    buttonDim values. -(Qt v2)

    QSignalMapperTQSignalMapper

    QSignalMapperTQSignalMapper is fully implemented.

    QSimpleRichText (Qt v2+)TQSimpleRichText (TQt v2+)

    QSimpleRichTextTQSimpleRichText is fully implemented.

    QSizeTQSize

    The Python @@ -7687,7 +7687,7 @@ NAME="AEN2913" >QCOORD &rheightTQCOORD &rheight();

    QCOORD &rwidthTQCOORD &rwidth();

    QSizeGrip (Qt v2+)TQSizeGrip (TQt v2+)

    QSizeGripTQSizeGrip is fully implemented.

    QSizePolicy (Qt v2+)TQSizePolicy (TQt v2+)

    QSizePolicyTQSizePolicy is fully implemented.

    QSliderTQSlider

    QSliderTQSlider is fully implemented.

    QSocketNotifierTQSocketNotifier

    QSocketNotifierTQSocketNotifier is fully implemented.

    QSound (Qt v2.2+)TQSound (TQt v2.2+)

    QSoundTQSound is fully implemented.

    QSpinBoxTQSpinBox
    QSplashScreen (Qt v3.2.0+)TQSplashScreen (TQt v3.2.0+)

    QSplashScreenTQSplashScreen is fully implemented.

    QSplitterTQSplitter
    and max values as a tuple. (Qt v2+)

    values as a tuple. (TQt v2+)

    QStatusBarTQStatusBar

    QStatusBarTQStatusBar is fully implemented.

    QChar (Qt v2+)TQChar (TQt v2+)
    QStringTQString

    A Python string object (or Unicode object) can be used whenever a QStringTQString can be used. A QStringTQString can be converted to a Python string object using the Python QCharRef atTQCharRef at(uint i);

    Not yet implemented. (Qt v2+)

    Not yet implemented. (TQt v2+)

    QChar constref constTQChar constref const(uint i);

    Not yet implemented. (Qt v2+)

    Not yet implemented. (TQt v2+)

    QChar &refTQChar &ref(uint i);

    Not yet implemented. (Qt v2+)

    Not yet implemented. (TQt v2+)

    QString &setUnicodeCodesTQString &setUnicodeCodes(const ushort *unicode_as_shorts, uint len);

    Not yet implemented. (Qt v2.1+)

    Not yet implemented. (TQt v2.1+)

    QString &sprintfTQString &sprintf(const char *format, ...);

    QStringList (Qt v2+)TQStringList (TQt v2+)

    The Python Iterator append(const QString &x);

    (const TQString &x);

    Iterator prepend(const QString &x);

    (const TQString &x);

    QStrListTQStrList

    This class isn't implemented. Whenever a QStrListTQStrList is the return type of a function or the type of an argument, a Python list of strings is used instead.

    QStyle (Qt v2+)TQStyle (TQt v2+)
    y values. (Qt v2)

    values. (TQt v2)

    virtual void scrollBarMetrics(const QScrollBar *b, int &sliderMin, int &sliderMax, int &sliderLength, int &buttonDim);

    (const TQScrollBar *b, int &sliderMin, int &sliderMax, int &sliderLength, int &buttonDim);

    buttonDim values. -(Qt v2)

    virtual void tabbarMetrics(const QTabBar *t, int &hframe, int &vframe, int &overlap);

    (const TQTabBar *t, int &hframe, int &vframe, int &overlap);

    overlap values. (Qt v2)

    values. (TQt v2)

    QStyleOption (Qt v3+)TQStyleOption (TQt v3+)

    QStyleOptionTQStyleOption is fully implemented.

    QStyleSheet (Qt v2+)TQStyleSheet (TQt v2+)

    QStyleSheetTQStyleSheet is fully implemented.

    QStyleSheetItem (Qt v2+)TQStyleSheetItem (TQt v2+)

    QStyleSheetItemTQStyleSheetItem is fully implemented.

    QSyntaxHighlighter (Qt v3.1+)TQSyntaxHighlighter (TQt v3.1+)

    QSyntaxHighlighterTQSyntaxHighlighter is fully implemented.

    QTabTQTab

    QTabTQTab is fully implemented.

    QTabBarTQTabBar
    QList<QTab> tabListTQList<TQTab> tabList();

    This returns a list of QTabTQTab instances.

    QTabDialogTQTabDialog

    QTabDialogTQTabDialog is fully implemented.

    QTableView (Qt 1.x, Qt 2.x)TQTableView (TQt 1.x, TQt 2.x)
    QTabWidget (Qt v2+)TQTabWidget (TQt v2+)

    QTabWidgetTQTabWidget is fully implemented.

    QTextBrowser (Qt v2+)TQTextBrowser (TQt v2+)

    QTextBrowserTQTextBrowser is fully implemented.

    QTextCodec (Qt v2+)TQTextCodec (TQt v2+)
    virtual QCString fromUnicode(const QString &uc, int &lenInOut);

    virtual TQCString fromUnicode(const TQString &uc, int &lenInOut);

    The returned value is a tuple of the QCStringTQCString result and the updated QTextDecoder (Qt v2+)TQTextDecoder (TQt v2+)

    QTextDecoderTQTextDecoder is fully implemented.

    QTextEncoder (Qt v2+)TQTextEncoder (TQt v2+)
    virtual QCString fromUnicode = 0(const QString &uc, int &lenInOut);

    virtual TQCString fromUnicode = 0(const TQString &uc, int &lenInOut);

    The returned value is a tuple of the QCStringTQCString result and the updated QTextEdit (Qt v3+)TQTextEdit (TQt v3+)

    int charAt(const QPoint &pos, int *para = 0);

    (const TQPoint &pos, int *para = 0);

    virtual bool find(const QString &expr, bool cs, bool wo, bool forward = TRUE, int *para = 0, int *index = 0);

    (const TQString &expr, bool cs, bool wo, bool forward = TRUE, int *para = 0, int *index = 0);

    QTextStreamTQTextStream

    QTextStreamTQTextStream(FILE *fp, int mode);

    QTextStream &readRawBytesTQTextStream &readRawBytes(char *buf, uint len);

    QTextStream &writeRawBytesTQTextStream &writeRawBytes(const char *buf, uint len);

    QTextIStream (Qt v2+)TQTextIStream (TQt v2+)
    QTextIStreamTQTextIStream(FILE *fp, int mode);

    QTextOStream (Qt v2+)TQTextOStream (TQt v2+)
    QTextOStreamTQTextOStream(FILE *fp, int mode);

    QTextView (Qt v2+)TQTextView (TQt v2+)

    QTextViewTQTextView is fully implemented.

    QThread (Qt v2.2+)TQThread (TQt v2.2+)

    QThreadTQThread is fully implemented.

    QTimerTQTimer

    QTimerTQTimer is fully implemented.

    QToolBarTQToolBar

    QToolBarTQToolBar is fully implemented.

    QToolBox (Qt v3.2.0+)TQToolBox (TQt v3.2.0+)

    QToolBoxTQToolBox is fully implemented.

    QToolButtonTQToolButton

    QToolButtonTQToolButton is fully implemented.

    QToolTipTQToolTip

    QToolTipTQToolTip is fully implemented.

    QToolTipGroupTQToolTipGroup

    QToolTipGroupTQToolTipGroup is fully implemented.

    QTranslator (Qt v2+)TQTranslator (TQt v2+)

    QTranslatorTQTranslator is fully implemented.

    QTranslatorMessage (Qt v2.2+)TQTranslatorMessage (TQt v2.2+)

    QTranslatorMessageTQTranslatorMessage is fully implemented.

    QUrl (Qt v2.1+)TQUrl (TQt v2.1+)

    QUrlTQUrl is fully implemented, including the QString()TQString(), ==QUrlInfo (Qt v2.1+)TQUrlInfo (TQt v2.1+)

    QUrlInfoTQUrlInfo is fully implemented.

    QUrlOperator (Qt v2.1+)TQUrlOperator (TQt v2.1+)
    QUuid (Qt v3.0+)TQUuid (TQt v3.0+)

    QUuidTQUuid is fully implemented.

    QValidatorTQValidator
    virtual State validate(QString& input, int& pos);

    (TQString& input, int& pos);

    QDoubleValidatorTQDoubleValidator

    State validate(QString& input, int& pos);

    (TQString& input, int& pos);

    QIntValidatorTQIntValidator

    State validate(QString& input, int& pos);

    (TQString& input, int& pos);

    QRegExpValidator (Qt v3+)TQRegExpValidator (TQt v3+)

    virtual State validate(QString& input, int& pos);

    (TQString& input, int& pos);

    QValueList<type> (Qt v2+)TQValueList<type> (TQt v2+)

    Types based on the QValueListTQValueList template are automatically converted to and from Python lists of the type.

    QVariant (Qt v2.1+)TQVariant (TQt v2.1+)
    QVariantTQVariant(const char *val);

    QVariant(const QBitArray &val);

    TQVariant(const TQBitArray &val);

    Not yet implemented. (Qt v3+)

    Not yet implemented. (TQt v3+)

    QVariant(const QValueList<QVariant> &val);

    TQVariant(const TQValueList<TQVariant> &val);

    QVariant(const QMap<QString,QVariant> &val);

    TQVariant(const TQMap<TQString,TQVariant> &val);

    QBitArray &asBitArrayTQBitArray &asBitArray();

    Not yet implemented. (Qt v3+)

    Not yet implemented. (TQt v3+)

    QValueList<QVariant> &asListTQValueList<TQVariant> &asList();

    QMap<QString,QVariant> &asMapTQMap<TQString,TQVariant> &asMap();

    QValueListConstIterator<QVariant>listBegin constTQValueListConstIterator<TQVariant>listBegin const();

    QValueListConstIterator<QVariant>listEnd constTQValueListConstIterator<TQVariant>listEnd const();

    QMapConstIterator<QString,QVariant>mapBegin constTQMapConstIterator<TQString,TQVariant>mapBegin const();

    QMapConstIterator<QString,QVariant>mapEnd constTQMapConstIterator<TQString,TQVariant>mapEnd const();

    QMapConstIterator<QString,QVariant>mapFind const(const QString &key);

    TQMapConstIterator<TQString,TQVariant>mapFind const(const TQString &key);

    QValueListConstIterator<QString>stringListBegin constTQValueListConstIterator<TQString>stringListBegin const();

    QValueListConstIterator<QString>stringListEnd constTQValueListConstIterator<TQString>stringListEnd const();

    const QBitArray toBitArray constconst TQBitArray toBitArray const();

    Not yet implemented. (Qt v3+)

    Not yet implemented. (TQt v3+)

    const QValueList<QVariant>toList constconst TQValueList<TQVariant>toList const();

    const QMap<QString,QVariant>toMap constconst TQMap<TQString,TQVariant>toMap const();

    QVBox (Qt v2+)TQVBox (TQt v2+)

    QVBoxTQVBox is fully implemented.

    QVButtonGroup (Qt v2+)TQVButtonGroup (TQt v2+)

    QVButtonGroupTQVButtonGroup is fully implemented.

    QVGroupBox (Qt v2+)TQVGroupBox (TQt v2+)

    QVGroupBoxTQVGroupBox is fully implemented.

    QWaitCondition (Qt v2.2+)TQWaitCondition (TQt v2.2+)

    QWaitConditionTQWaitCondition is fully implemented.

    QWhatsThisTQWhatsThis

    QWhatsThisTQWhatsThis is fully implemented.

    QWidgetTQWidget
    QWExtra *extraDataTQWExtra *extraData();

    QFocusData *focusDataTQFocusData *focusData();

    QWidgetListTQWidgetList

    This class isn't implemented. Whenever a QWidgetListTQWidgetList is the return type of a function or the type of an argument, a Python list of instances is used instead.

    QWidgetStackTQWidgetStack

    QWidgetStackTQWidgetStack is fully implemented.

    QWindowTQWindow

    QWindow is fully implemented (Qt v1.x).

    TQWindow is fully implemented (TQt v1.x).

    QWindowsStyle (Qt v2+)TQWindowsStyle (TQt v2+)
    y values. (Qt v2)

    values. (TQt v2)

    void scrollBarMetrics(const QTabBar *sb, int &sliderMin, int &sliderMax, int &sliderLength, int &buttonDim);

    (const TQTabBar *sb, int &sliderMin, int &sliderMax, int &sliderLength, int &buttonDim);

    buttonDim values. -(Qt v2)

    void tabbarMetrics(const QTabBar *t, int &hframe, int &vframe, int &overlap);

    (const TQTabBar *t, int &hframe, int &vframe, int &overlap);

    overlap values. (Qt v2)

    values. (TQt v2)

    QWindowsXPStyle (Qt v3.0.1+, Windows)TQWindowsXPStyle (TQt v3.0.1+, Windows)

    QWindowsXPStyleTQWindowsXPStyle is fully implemented.

    QWizard (Qt v2+)TQWizard (TQt v2+)

    QWizardTQWizard is fully implemented.

    QWMatrixTQWMatrix

    The Python QWMatrix invert constTQWMatrix invert const(bool *invertible = 0);

    This takes no parameters and returns a tuple of the QWMatrixTQWMatrix result and the ty -values. (Qt v1.x)

    ty -values. (Qt v2+)

    QWorkspace (Qt v2.1+)TQWorkspace (TQt v2.1+)

    QWorkspaceTQWorkspace is fully implemented.

    QAxBase (Windows, Qt v3+)TQAxBase (Windows, TQt v3+)
    QAxObjectTQAxObject(IUnknown *iface = 0);

    long queryInterface(const QUuid &uuid, void **iface);

    (const TQUuid &uuid, void **iface);

    unsigned long registerWeakActiveObject(const QString &guid);

    (const TQString &guid);

    This is a utility method provided by PyQt to make it easier to use +>This is a utility method provided by PyTQt to make it easier to use Mark Hammond's win32com COM function is called to register the QAxBaseTQAxBase instance as a weak object with the QAxObject (Windows, Qt v3+)TQAxObject (Windows, TQt v3+)

    QAxObject(IUnknown *iface, QObject *parent = 0, const char *name = 0);

    TQAxObject(IUnknown *iface, TQObject *parent = 0, const char *name = 0);

    QAxWidget (Windows, Qt v3+)TQAxWidget (Windows, TQt v3+)

    QAxWidget(IUnknown *iface, QWidget *parent = 0, const char *name = 0);

    TQAxWidget(IUnknown *iface, TQWidget *parent = 0, const char *name = 0);

    QCanvas (Qt v2.2+)TQCanvas (TQt v2.2+)

    QCanvasTQCanvas is fully implemented.

    QCanvasEllipse (Qt v2.2+)TQCanvasEllipse (TQt v2.2+)

    QCanvasEllipseTQCanvasEllipse is fully implemented.

    QCanvasItem (Qt v2.2+)TQCanvasItem (TQt v2.2+)

    QCanvasItemTQCanvasItem is fully implemented.

    QCanvasItemList (Qt v2.2+)TQCanvasItemList (TQt v2.2+)

    This class isn't implemented. Whenever a QCanvasItemListTQCanvasItemList is the return type of a function or the type of an argument, a Python list of QCanvasItemTQCanvasItem instances is used instead.

    QCanvasLine (Qt v2.2+)TQCanvasLine (TQt v2.2+)

    QCanvasLineTQCanvasLine is fully implemented.

    QCanvasPixmap (Qt v2.2+)TQCanvasPixmap (TQt v2.2+)

    QCanvasPixmapTQCanvasPixmap is fully implemented.

    QCanvasPixmapArray (Qt v2.2+)TQCanvasPixmapArray (TQt v2.2+)
    QPixmapArray(QList<QPixmap> pixmaps, QList<QPoint> hotspots);

    TQPixmapArray(TQList<TQPixmap> pixmaps, TQList<TQPoint> hotspots);

    The pixmaps argument is a Python list of QPixmap instances, +> argument is a Python list of TQPixmap instances, and the hotspots argument is a Python list of QPoint -instances. (Qt v2.2.0 - Qt v2.3.1)

    argument is a Python list of TQPoint +instances. (TQt v2.2.0 - TQt v2.3.1)

    QPixmapArray(QValueList<QPixmap> pixmaps, QPointArray hotspots = QPointArray());

    TQPixmapArray(TQValueList<TQPixmap> pixmaps, TQPointArray hotspots = TQPointArray());

    The pixmaps argument is a Python list of QPixmap instances. -(Qt v3+)

    argument is a Python list of TQPixmap instances. +(TQt v3+)

    QCanvasPolygon (Qt v2.2+)TQCanvasPolygon (TQt v2.2+)

    QCanvasPolygonTQCanvasPolygon is fully implemented.

    QCanvasPolygonalItem (Qt v2.2+)TQCanvasPolygonalItem (TQt v2.2+)

    QCanvasPolygonalItemTQCanvasPolygonalItem is fully implemented.

    QCanvasRectangle (Qt v2.2+)TQCanvasRectangle (TQt v2.2+)

    QCanvasRectangleTQCanvasRectangle is fully implemented.

    QCanvasSpline (Qt v3.0+)TQCanvasSpline (TQt v3.0+)

    QCanvasSplineTQCanvasSpline is fully implemented.

    QCanvasSprite (Qt v2.2+)TQCanvasSprite (TQt v2.2+)

    QCanvasSpriteTQCanvasSprite is fully implemented.

    QCanvasText (Qt v2.2+)TQCanvasText (TQt v2.2+)

    QCanvasTextTQCanvasText is fully implemented.

    QCanvasView (Qt v2.2+)TQCanvasView (TQt v2.2+)

    QCanvasViewTQCanvasView is fully implemented.

    QextScintillaLexerBash (QScintilla v1.4+)QextScintillaLexerBash (TQScintilla v1.4+)

    QextScintillaLexerBatch (QScintilla v1.6+)QextScintillaLexerBatch (TQScintilla v1.6+)

    QextScintillaLexerCSS (QScintilla v1.6+)QextScintillaLexerCSS (TQScintilla v1.6+)

    QextScintillaLexerDiff (QScintilla v1.6+)QextScintillaLexerDiff (TQScintilla v1.6+)

    QextScintillaLexerHTML (QScintilla v1.1+)QextScintillaLexerHTML (TQScintilla v1.1+)

    QextScintillaLexerLua (QScintilla v1.5+)QextScintillaLexerLua (TQScintilla v1.5+)

    QextScintillaLexerMakefile (QScintilla v1.6+)QextScintillaLexerMakefile (TQScintilla v1.6+)

    QextScintillaLexerPOV (QScintilla v1.6+)QextScintillaLexerPOV (TQScintilla v1.6+)

    QextScintillaLexerProperties (QScintilla v1.6+)QextScintillaLexerProperties (TQScintilla v1.6+)

    QextScintillaLexerRuby (QScintilla v1.5+)QextScintillaLexerRuby (TQScintilla v1.5+)

    QextScintillaLexerSQL (QScintilla v1.1+)QextScintillaLexerSQL (TQScintilla v1.1+)

    QextScintillaLexerTeX (QScintilla v1.6+)QextScintillaLexerTeX (TQScintilla v1.6+)

    QGLTQGL

    QGLTQGL is fully implemented.

    QGLContextTQGLContext

    QGLContextTQGLContext is fully implemented.

    QGLFormatTQGLFormat

    QGLFormatTQGLFormat is fully implemented.

    QGLWidgetTQGLWidget

    QGLWidgetTQGLWidget is fully implemented.

    QGLColormap (Qt v3.0+)TQGLColormap (TQt v3.0+)
    void setEntries(int count, const QRgb *colors, int base = 0);

    (int count, const TQRgb *colors, int base = 0);

    QDns (Qt v2.2+)TQDns (TQt v2.2+)

    QDnsTQDns is fully implemented.

    QFtp (Qt v2.2+)TQFtp (TQt v2.2+)
    QHostAddress (Qt v2.2+)TQHostAddress (TQt v2.2+)
    QHostAddressTQHostAddress(Q_UINT8 *ip6Addr);

    QHostAddressTQHostAddress(const Q_IPV6ADDR &ip6Addr);

    QHttp (Qt v3+)TQHttp (TQt v3+)
    QHttpHeader (Qt v3.1+)TQHttpHeader (TQt v3.1+)

    QHttpHeaderTQHttpHeader is fully implemented.

    QHttpRequestHeader (Qt v3.1+)TQHttpRequestHeader (TQt v3.1+)

    QHttpRequestHeaderTQHttpRequestHeader is fully implemented.

    QHttpResponseHeader (Qt v3.1+)TQHttpResponseHeader (TQt v3.1+)

    QHttpResponseHeaderTQHttpResponseHeader is fully implemented.

    QLocalFs (Qt v2.1+)TQLocalFs (TQt v2.1+)

    QLocalFsTQLocalFs is fully implemented.

    QServerSocket (Qt v2.2+)TQServerSocket (TQt v2.2+)

    QServerSocketTQServerSocket is fully implemented.

    QSocket (Qt v2.2+)TQSocket (TQt v2.2+)
    QSocketDevice (Qt v2.2+)TQSocketDevice (TQt v2.2+)
    QPEApplicationTQPEApplication
    QApplicationTQApplication(int& argc, char **argv, Type type);

    This takes two parameters, the first of which is a list of argument strings. -Arguments used by Qt are removed from the list.

    virtual QString exec constvirtual TQString exec const();

    QString exec constTQString exec const();

    QCopEnvelopeTQCopEnvelope

    QCopEnvelopeTQCopEnvelope is fully implemented.

    QDawgTQDawg

    QDawgTQDawg is fully implemented.

    QPEMenuBarTQPEMenuBar

    QPEMenuBarTQPEMenuBar is fully implemented.

    QPEToolBarTQPEToolBar

    QPEToolBarTQPEToolBar is fully implemented.

    QDataBrowser (Qt v3+)TQDataBrowser (TQt v3+)
    QDataTable (Qt v3+)TQDataTable (TQt v3+)

    QDataTableTQDataTable is fully implemented.

    QDataView (Qt v3+)TQDataView (TQt v3+)

    QDataViewTQDataView is fully implemented.

    QEditorFactory (Qt v3+)TQEditorFactory (TQt v3+)

    QEditorFactoryTQEditorFactory is fully implemented.

    QSql (Qt v3+)TQSql (TQt v3+)

    QSqlTQSql is fully implemented.

    QSqlCursor (Qt v3+)TQSqlCursor (TQt v3+)
    virtual int del(const QString &filter, bool invalidate = TRUE);

    (const TQString &filter, bool invalidate = TRUE);

    bool exec(const QString &query);

    (const TQString &query);

    QSqlDatabase (Qt v3+)TQSqlDatabase (TQt v3+)

    QSqlQuery exec(const QString &query = QString::null);

    TQSqlQuery exec(const TQString &query = TQString::null);

    QSqlDriver (Qt v3+)TQSqlDriver (TQt v3+)

    QSqlDriverTQSqlDriver is fully implemented.

    QSqlEditorFactory (Qt v3+)TQSqlEditorFactory (TQt v3+)

    QSqlEditorFactoryTQSqlEditorFactory is fully implemented.

    QSqlError (Qt v3+)TQSqlError (TQt v3+)

    QSqlErrorTQSqlError is fully implemented.

    QSqlField (Qt v3+)TQSqlField (TQt v3+)

    QSqlFieldTQSqlField is fully implemented.

    QSqlFieldInfo (Qt v3+)TQSqlFieldInfo (TQt v3+)

    QSqlFieldInfoTQSqlFieldInfo is fully implemented.

    QSqlForm (Qt v3+)TQSqlForm (TQt v3+)

    QSqlFormTQSqlForm is fully implemented.

    QSqlIndex (Qt v3+)TQSqlIndex (TQt v3+)

    QSqlIndexTQSqlIndex is fully implemented.

    QSqlPropertyMap (Qt v3+)TQSqlPropertyMap (TQt v3+)

    QSqlPropertyMap is fully implemented. However, because PyQt +>TQSqlPropertyMap is fully implemented. However, because PyTQt does not allow new properties to be defined, it is not possible to implement custom editor widgets in Python and add them to a property map. This will simple be ignored.

    This problem may be addressed in a future release of PyQt.

    This problem may be addressed in a future release of PyTQt.

    QSqlQuery (Qt v3+)TQSqlQuery (TQt v3+)
    QMap<QString,QVariant> boundValues constTQMap<TQString,TQVariant> boundValues const();

    Not yet implemented. (Qt v3.2.0+)

    Not yet implemented. (TQt v3.2.0+)

    virtual bool exec(const QString &query);

    (const TQString &query);

    This has been renamed execQuery in Python. (Qt v3.1+)

    in Python. (TQt v3.1+)

    QSqlRecord (Qt v3+)TQSqlRecord (TQt v3+)

    QSqlRecordTQSqlRecord is fully implemented.

    QSqlRecordInfo (Qt v3+)TQSqlRecordInfo (TQt v3+)

    QSqlRecordInfoTQSqlRecordInfo is implemented as a Python list of QSqlFieldInfoTQSqlFieldInfo instances.

    QSqlResult (Qt v3+)TQSqlResult (TQt v3+)

    QSqlResultTQSqlResult is fully implemented.

    QSqlSelectCursor (Qt v3.2.0+)TQSqlSelectCursor (TQt v3.2.0+)
    bool exec(const QString &query);

    (const TQString &query);

    QTable (Qt v2.2+)TQTable (TQt v2.2+)

    QTableTQTable is fully implemented.

    QTableItem (Qt v2.2+)TQTableItem (TQt v2.2+)

    QTableItemTQTableItem is fully implemented.

    QCheckTableItem (Qt v3+)TQCheckTableItem (TQt v3+)

    QCheckTableItemTQCheckTableItem is fully implemented.

    QComboTableItem (Qt v3+)TQComboTableItem (TQt v3+)

    QComboTableItemTQComboTableItem is fully implemented.

    QTableSelection (Qt v2.2+)TQTableSelection (TQt v2.2+)

    QTableSelectionTQTableSelection is fully implemented.

    QWidgetFactory (Qt v3+)TQWidgetFactory (TQt v3+)

    QWidgetFactoryTQWidgetFactory is fully implemented.

    QDomImplementation (Qt v2.2+)TQDomImplementation (TQt v2.2+)

    QDomImplementationTQDomImplementation is fully implemented.

    QDomNode (Qt v2.2+)TQDomNode (TQt v2.2+)

    QDomNodeTQDomNode is fully implemented, including the Python QDomNodeList (Qt v2.2+)TQDomNodeList (TQt v2.2+)

    QDomNodeListTQDomNodeList is fully implemented.

    QDomDocument (Qt v2.2+)TQDomDocument (TQt v2.2+)
    bool setContent(const QCString &buffer, bool namespaceProcessing, QString *errorMsg = 0, int *errorLine = 0, int *errorColumn = 0);

    (const TQCString &buffer, bool namespaceProcessing, TQString *errorMsg = 0, int *errorLine = 0, int *errorColumn = 0);

    errorColumn values. (Qt v3+)

    values. (TQt v3+)

    bool setContent(const QByteArray &buffer, bool namespaceProcessing, QString *errorMsg = 0, int *errorLine = 0, int *errorColumn = 0);

    (const TQByteArray &buffer, bool namespaceProcessing, TQString *errorMsg = 0, int *errorLine = 0, int *errorColumn = 0);

    errorColumn values. (Qt v3+)

    values. (TQt v3+)

    bool setContent(const QString &text, bool namespaceProcessing, QString *errorMsg = 0, int *errorLine = 0, int *errorColumn = 0);

    (const TQString &text, bool namespaceProcessing, TQString *errorMsg = 0, int *errorLine = 0, int *errorColumn = 0);

    errorColumn values. (Qt v3+)

    values. (TQt v3+)

    bool setContent(const QIODevice *dev, bool namespaceProcessing, QString *errorMsg = 0, int *errorLine = 0, int *errorColumn = 0);

    (const TQIODevice *dev, bool namespaceProcessing, TQString *errorMsg = 0, int *errorLine = 0, int *errorColumn = 0);

    errorColumn values. (Qt v3+)

    values. (TQt v3+)

    bool setContent(const QCString &buffer, QString *errorMsg = 0, int *errorLine = 0, int *errorColumn = 0);

    (const TQCString &buffer, TQString *errorMsg = 0, int *errorLine = 0, int *errorColumn = 0);

    errorColumn values. (Qt v3+)

    values. (TQt v3+)

    bool setContent(const QByteArray &buffer, QString *errorMsg = 0, int *errorLine = 0, int *errorColumn = 0);

    (const TQByteArray &buffer, TQString *errorMsg = 0, int *errorLine = 0, int *errorColumn = 0);

    errorColumn values. (Qt v3+)

    values. (TQt v3+)

    bool setContent(const QString &text, QString *errorMsg = 0, int *errorLine = 0, int *errorColumn = 0);

    (const TQString &text, TQString *errorMsg = 0, int *errorLine = 0, int *errorColumn = 0);

    errorColumn values. (Qt v3+)

    values. (TQt v3+)

    bool setContent(const QIODevice *dev, QString *errorMsg = 0, int *errorLine = 0, int *errorColumn = 0);

    (const TQIODevice *dev, TQString *errorMsg = 0, int *errorLine = 0, int *errorColumn = 0);

    errorColumn values. (Qt v3+)

    values. (TQt v3+)

    bool setContent(QXmlInputSource *source, QXmlReader *reader, QString *errorMsg = 0, int *errorLine = 0, int *errorColumn = 0);

    (TQXmlInputSource *source, TQXmlReader *reader, TQString *errorMsg = 0, int *errorLine = 0, int *errorColumn = 0);

    Not yet implemented. (Qt v3.2.0+)

    Not yet implemented. (TQt v3.2.0+)

    QDomDocumentFragment (Qt v2.2+)TQDomDocumentFragment (TQt v2.2+)

    QDomDocumentFragmentTQDomDocumentFragment is fully implemented.

    QDomDocumentType (Qt v2.2+)TQDomDocumentType (TQt v2.2+)

    QDomDocumentTypeTQDomDocumentType is fully implemented.

    QDomNamedNodeMap (Qt v2.2+)TQDomNamedNodeMap (TQt v2.2+)

    QDomNamedNodeMapTQDomNamedNodeMap is fully implemented.

    QDomCharacterData (Qt v2.2+)TQDomCharacterData (TQt v2.2+)

    QDomCharacterDataTQDomCharacterData is fully implemented.

    QDomAttr (Qt v2.2+)TQDomAttr (TQt v2.2+)

    QDomAttrTQDomAttr is fully implemented.

    QDomElement (Qt v2.2+)TQDomElement (TQt v2.2+)

    QDomElementTQDomElement is fully implemented.

    QDomText (Qt v2.2+)TQDomText (TQt v2.2+)

    QDomTextTQDomText is fully implemented.

    QDomComment (Qt v2.2+)TQDomComment (TQt v2.2+)

    QDomCommentTQDomComment is fully implemented.

    QDomCDATASection (Qt v2.2+)TQDomCDATASection (TQt v2.2+)

    QDomCDATASectionTQDomCDATASection is fully implemented.

    QDomNotation (Qt v2.2+)TQDomNotation (TQt v2.2+)

    QDomNotationTQDomNotation is fully implemented.

    QDomEntity (Qt v2.2+)TQDomEntity (TQt v2.2+)

    QDomEntityTQDomEntity is fully implemented.

    QDomEntityReference (Qt v2.2+)TQDomEntityReference (TQt v2.2+)

    QDomEntityReferenceTQDomEntityReference is fully implemented.

    QDomProcessingInstruction (Qt v2.2+)TQDomProcessingInstruction (TQt v2.2+)

    QDomProcessingInstructionTQDomProcessingInstruction is fully implemented.