From 90825e2392b2d70e43c7a25b8a3752299a933894 Mon Sep 17 00:00:00 2001 From: toma Date: Wed, 25 Nov 2009 17:56:58 +0000 Subject: Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features. BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdebindings@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- python/pyqt/doc/qtdocs.sip | 1920 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1920 insertions(+) create mode 100644 python/pyqt/doc/qtdocs.sip (limited to 'python/pyqt/doc/qtdocs.sip') diff --git a/python/pyqt/doc/qtdocs.sip b/python/pyqt/doc/qtdocs.sip new file mode 100644 index 00000000..070a4fb4 --- /dev/null +++ b/python/pyqt/doc/qtdocs.sip @@ -0,0 +1,1920 @@ +// This is the SIP file for organising the PyQt documentation. +// +// Copyright (c) 2007 +// Riverbank Computing Limited +// +// This file is part of PyQt. +// +// This copy of PyQt is free software; you can redistribute it and/or modify it +// under the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2, or (at your option) any later +// version. +// +// PyQt is supplied in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +// details. +// +// You should have received a copy of the GNU General Public License along with +// PyQt; see the file LICENSE. If not, write to the Free Software Foundation, +// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + +%Module Dummy + + +%Include qt/versions.sip + + +%Doc + +
+ + Python Bindings for Qt (3.17.2) + + Phil + Thompson + + + + This document describes a set of Python bindings for the Qt widget set. + Contact the author at phil@riverbankcomputing.co.uk. + + + + + +Introduction + +PyQt is a set of Python bindings for the Qt toolkit and available for all +platforms supported by Qt, including Windows, Linux, UNIX, MacOS/X and embedded +systems such as the Sharp Zaurus and the Compaq iPAQ. They have been tested +against Qt versions 1.43 to 3.3.6, Qt Non-commercial, Qtopia 1.5.0, and Python +versions 1.5 to 2.4.2. Qt/Embedded v3 is not supported. Qt v4 is supported +by PyQt v4. + + + +PyQt is available under the GPL license for use with the GPL version of Qt, a +a commercial license for use with the commercial version of Qt, a +non-commercial license for use with the non-commercial version of Qt v2, and an +educational license for use with the educational version of Qt. + + + +There is also an evaluation version of PyQt for Windows. This must be used +with the corresponding evaluation version of Qt. + + + +PyQt 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. + + + +The bindings are implemented as a number of Python modules + + + + + +qt is the main module and contains the core classes and most +user interface widgets. + + + + + +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 +module. + + + + + +qtgl contains the classes implemented in Qt's OpenGL module. + + + + + +qtnetwork contains the classes implemented in Qt's Network +module. + + + + + +qtpe contains the classes implemented in Qtopia (originally +called the Qt Palmtop Environment). It is only supported with Qt/Embedded. + + + + + +qtsql contains the classes implemented in Qt's SQL module. + + + + + +qttable contains the classes implemented in Qt's Table +module. + + + + + +qtui contains the classes implemented in Qt's qui library. +These allow GUIs to be created directly from Qt Designer's +.ui files. + + + + + +qtxml contains the classes implemented in Qt'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 +the Scintilla programmer's editor class. + + + + + +PyQt also includes the pyuic and +pylupdate utilities which correspond to the Qt +uic and lupdate utilities. +pyuic converts the GUI designs created with Qt 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. + + +Changes + +The changes visible to the Python programmer in this release are as follows. + + + + + +This version requires SIP v4.4 (or later). + + + + + +Concatenating Python strings and QStrings is now supported. + + + + + +QString now supports the * and +*= operators that behave as they do for Python strings. + + + + + +QString is more interoperable with Python string and unicode +objects. For example they can be passed as arguments to +open() and to most (but not all) string methods. + + + + + +QPopupMenu (and sub-classes) instances now transfer +ownership of the menu to Python in the call to exec_loop(). +This means the menu's resources are all released when the Python wrapper is +garbage collected without needing to call +QObject.deleteLater(). + + + + + +QObject.sender() now handles Python signals. + + + + + +The missing MacintoshVersion enum has been added. + + + + + +PYQT_BUILD has been removed. + + + + + +The convention for converting between a C/C++ null pointer and Python's +None object has now been universally applied. In previous +versions a null pointer to, for example, a Qt list container would often be +converted to an empty list rather than None. + + + + + + + + +Other PyQt Goodies +Using Qt 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 +uic which generates C++ code from that XML. + + + +PyQt includes pyuic which generates Python code from the +same XML. The Python code is self contained and can be executed immediately. + + + +It is sometimes useful to be able to include some specific Python code in the +output generated by pyuic. For example, if you are using +custom widgets, pyuic has no way of knowing the name of the +Python module containing the widget and so cannot generate the required +import statement. To help get around this, +pyuic will extract any lines entered in the +Comment field of Qt Designer's +Form Settings dialog that begin with +Python: and copies them to the generated output. + + + +Here's a simple example showing the contents of the Comment +field. + + + +This comment will be ignored by pyuic. +Python: +Python:# Import our custom widget. +Python:from foo import bar + + + +Here's the corresponding output from pyuic. + + + +from qt import * + +# Import our custom widget. +from foo import bar + + + +Thanks to Christian Bird, pyuic will extract Python code +entered using Qt Designer to implement slots. In Qt 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. + + + +Make sure that the ui.h file is in the same directory as the +.ui file when using pyuic. The +.ui file implies the name of the .ui.h +file so there is no need to specify it on the command line. + + + +Here's an example of a simple slot. + + + +void DebMainWindowFrm::browsePushButtonClicked() +{ +if self.debugging: + QMessageBox.critical(self, "Event", "browse pushbutton was clicked!") +} + + + +Here is the resulting code when pyuic is run. + + + +class DebMainWindowFrm(QMainWindow): + ...stuff... + def browsePushButtonClicked(self): + if self.debugging: + QMessageBox.critical(self, "Event", "browse pushbutton was clicked!") + + + +Note that indenting is as normal and that self and all other +parameters passed to the slot are available. + + + +If you use this, you will need to turn off all of the fancy options for the C++ +editor in Designer as it tries to force C++ syntax and that's naturally +annoying when trying to code in Python. + + + +Using Qt Linguist + +Qt includes the lupdate program which parses C++ source +files converting calls to the QT_TR_NOOP() and +QT_TRANSLATE_NOOP() macros to .ts +language source files. The lrelease program is then used to +generate .qm binary language files that are distributed with +your application. + + + +Thanks to Detlev Offenbach, PyQt includes the pylupdate +program. This generates the same .ts language source files +from your PyQt source files. + + + + + +Deploying Commercial PyQt Applications + +When deploying commercial PyQt applications it is necessary to discourage users +from accessing the underlying PyQt 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 +VendorID +package. This allows you to build Python extension modules that can only be +imported by a digitally signed custom interpreter. The package enables you to +create such an interpreter with your application embedded within it. The +result is an interpreter that can only run your application, and PyQt modules +that can only be imported by that interpreter. You can use the package to +similarly restrict access to any extension module. + + + +In order to build PyQt with support for the VendorID package, pass the +-i command line flag to configure.py. + + + +<Literal>pyqtconfig</Literal> and Build System Support + +The SIP build system (ie. the sipconfig 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 pyqtconfig module contains the following classes: + + + + +Configuration(sipconfig.Configuration) + + +This class encapsulates additional configuration values, specific to PyQt, that +can be accessed as instance variables. + + + +The following configuration values are provided (in addition to those provided +by the sipconfig.Configuration class): + + + + +pyqt_bin_dir + + +The name of the directory containing the pyuic and +pylupdate executables. + + + + + + +pyqt_config_args + + +The command line passed to configure.py when PyQt was +configured. + + + + + + +pyqt_mod_dir + + +The name of the directory containing the PyQt modules. + + + + + + +pyqt_modules + + +A string containing the names of the PyQt modules that were installed. + + + + + + +pyqt_qt_sip_flags + + +A string of the SIP flags used to generate the code for the +qt module and which should be added to those needed by any +module that imports the qt module. + + + + + + +pyqt_qtaxcontainer_sip_flags + + +A string of the SIP flags used to generate the code for the +qtaxcontainer module and which should be added to those +needed by any module that imports the qtaxcontainer module. + + + + + + +pyqt_qtcanvas_sip_flags + + +A string of the SIP flags used to generate the code for the +qtcanvas module and which should be added to those needed by +any module that imports the qtcanvas module. + + + + + + +pyqt_qtext_sip_flags + + +A string of the SIP flags used to generate the code for the +qtext module and which should be added to those needed by +any module that imports the qtext module. + + + + + + +pyqt_qtgl_sip_flags + + +A string of the SIP flags used to generate the code for the +qtgl module and which should be added to those needed by any +module that imports the qtgl module. + + + + + + +pyqt_qtnetwork_sip_flags + + +A string of the SIP flags used to generate the code for the +qtnetwork module and which should be added to those needed +by any module that imports the qtnetwork module. + + + + + + +pyqt_qtsql_sip_flags + + +A string of the SIP flags used to generate the code for the +qtsql module and which should be added to those needed by +any module that imports the qtsql module. + + + + + + +pyqt_qttable_sip_flags + + +A string of the SIP flags used to generate the code for the +qttable module and which should be added to those needed by +any module that imports the qttable module. + + + + + + +pyqt_qtui_sip_flags + + +A string of the SIP flags used to generate the code for the +qtui module and which should be added to those needed by any +module that imports the qtui module. + + + + + + +pyqt_qtxml_sip_flags + + +A string of the SIP flags used to generate the code for the +qtxml module and which should be added to those needed by +any module that imports the qtxml module. + + + + + + +pyqt_sip_dir + + +The name of the base directory where the .sip files for each +of the PyQt modules is installed. A sub-directory exists with the same name as +the module. + + + + + + +pyqt_version + + +The PyQt version as a 3 part hexadecimal number (eg. v3.10 is represented as +0x030a00). + + + + + + +pyqt_version_str + + +The PyQt version as a string. For development snapshots it will start with +snapshot-. + + + + + + + + + + +QtModuleMakefile(sipconfig.SIPModuleMakefile) + + +The Makefile class for modules that import the qt module. + + + +finalise(self) + + +This is a reimplementation of sipconfig.Makefile.finalise(). + + + + + + + + + +QtAxContainerModuleMakefile(QtModuleMakefile) + + +The Makefile class for modules that import the qtaxcontainer +module. + + + +finalise(self) + + +This is a reimplementation of sipconfig.Makefile.finalise(). + + + + + + + + + +QtCanvasModuleMakefile(QtModuleMakefile) + + +The Makefile class for modules that import the qtcanvas +module. + + + +finalise(self) + + +This is a reimplementation of sipconfig.Makefile.finalise(). + + + + + + + + + +QtExtModuleMakefile(QtModuleMakefile) + + +The Makefile class for modules that import the qtext module. + + + +finalise(self) + + +This is a reimplementation of sipconfig.Makefile.finalise(). + + + + + + + + + +QtGLModuleMakefile(QtModuleMakefile) + + +The Makefile class for modules that import the qtgl module. + + + +finalise(self) + + +This is a reimplementation of sipconfig.Makefile.finalise(). + + + + + + + + + +QtNetworkModuleMakefile(QtModuleMakefile) + + +The Makefile class for modules that import the qtnetwork +module. + + + +finalise(self) + + +This is a reimplementation of sipconfig.Makefile.finalise(). + + + + + + + + + +QtTableModuleMakefile(QtModuleMakefile) + + +The Makefile class for modules that import the qttable +module. + + + +finalise(self) + + +This is a reimplementation of sipconfig.Makefile.finalise(). + + + + + + + + + +QtSQLModuleMakefile(QtTableModuleMakefile) + + +The Makefile class for modules that import the qtsql module. + + + +finalise(self) + + +This is a reimplementation of sipconfig.Makefile.finalise(). + + + + + + + + + +QtUIModuleMakefile(QtModuleMakefile) + + +The Makefile class for modules that import the qtui module. + + + +finalise(self) + + +This is a reimplementation of sipconfig.Makefile.finalise(). + + + + + + + + + +QtXMLModuleMakefile(QtModuleMakefile) + + +The Makefile class for modules that import the qtxml module. + + + +finalise(self) + + +This is a reimplementation of sipconfig.Makefile.finalise(). + + + + + + + + + + +%End + + +%ExportedDoc +Things to be Aware Of +super and Wrapped Classes + +Internally PyQt 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 +that super is currently implemented means that the lazy +lookup is bypassed resulting in AttributeError exceptions +unless the attribute has been previously referenced. + + + +Note that this restriction applies to any class wrapped by SIP and not just +PyQt. + + + + +Python Strings, Qt Strings and Unicode + +Unicode support was added to Qt in v2.0 and to Python in v1.6. In Qt, Unicode +support is implemented using the QString class. It is +important to understand that QStrings, Python string objects +and Python Unicode objects are all different but conversions between them are +automatic in almost all cases and easy to achieve manually when needed. + + + +Whenever PyQt expects a QString 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 +QStrings by using the QString constructor +as demonstrated in the following code fragment. + + + +qs1 = QString('Converted Python string object') +qs2 = QString(u'Converted Python Unicode object') + + + +In order to convert a QString to a Python string object use +the Python str() function. Applying +str() to a null QString and an empty +QString both result in an empty Python string object. + + + +In order to convert a QString to a Python Unicode object use +the Python unicode() function. Applying +unicode() to a null QString and an empty +QString both result in an empty Python Unicode object. + + + +Access to Protected Member Functions + +When an instance of a C++ class is not created from Python it is not possible +to access the protected member functions, or emit the signals, of that +instance. Attempts to do so will raise a Python exception. Also, any Python +methods corresponding to the instance's virtual member functions will never be +called. + + + +<Literal>None</Literal> and <Literal>NULL</Literal> + +Throughout the bindings, the None value can be specified +wherever NULL is acceptable to the underlying C++ code. + + + +Equally, NULL is converted to None +whenever it is returned by the underlying C++ code. + + + + +Support for C++ <Literal>void *</Literal> Data Types + +PyQt represents void * values as objects of type +sip.voidptr. Such values are often used to pass the +addresses of external objects between different Python modules. To make this +easier, a Python integer (or anything that Python can convert to an integer) +can be used whenever a sip.voidptr is expected. + + +A sip.voidptr may be converted to a Python integer by using +the int() builtin function. + + +A sip.voidptr may be converted to a Python string by using +its asstring() method. The asstring() +method takes an integer argument which is the length of the data in bytes. + + + + +Support for Threads + +PyQt implements the full set of Qt'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 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 +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 +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. + + + + +The above comments actually apply to any SIP generated module, not just PyQt. + + + +Garbage Collection + +C++ does not garbage collect unreferenced class instances, whereas Python does. +In the following C++ fragment both colours exist even though the first can no +longer be referenced from within the program: + + + +c = new QColor(); +c = new QColor(); + + + +In the corresponding Python fragment, the first colour is destroyed when +the second is assigned to c: + + + +c = QColor() +c = QColor() + + + +In Python, each colour must be assigned to different names. Typically this +is done within class definitions, so the code fragment would be something like: + + + +self.c1 = QColor() +self.c2 = QColor() + + + +Sometimes a Qt 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 QObject (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 +corresponding child objects. + + + +So, in the following Python fragment, the first QLabel is +not destroyed when the second is assigned to l because the +parent QWidget still has a reference to it. + + + +p = QWidget() +l = QLabel('First label',p) +l = QLabel('Second label',p) + + + +C++ Variables + +Access to C++ variables is supported. They are accessed as Python instance +variables. For example: + + + +tab = QTab() +tab.label = "First Tab" +tab.r = QRect(10,10,75,30) + + + +Global variables and static class variables are effectively read-only. They +can be assigned to, but the underlying C++ variable will not be changed. This +may change in the future. + + + +Access to protected C++ class variables is not supported. This may change in +the future. + + + +Multiple Inheritance + +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 +QTranslator class, and the +QApplication::translate(), QObject::tr() +and QObject::trUtf8() methods. Usually the +tr() method is used to obtain the correct translation of a +message. The translation process uses a message context to allow the same +message to be translated differently. tr() is actually +generated by moc and uses the hardcoded class name as the +context. On the other hand, QApplication::translate() +allows to context to be explicitly stated. + + + +Unfortunately, because of the way Qt implents tr() (and +trUtf8()) it is not possible for PyQt to exactly reproduce +its behavour. The PyQt implementation of tr() (and +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 +words, the context of a translation may change depending on an instance's class +hierarchy. + + + +class A(QObject): + def __init__(self): + QObject.__init__(self) + + def hello(self): + return self.tr("Hello") + +class B(A): + def __init__(self): + A.__init__(self) + +a = A() +a.hello() + +b = B() +b.hello() + + + +In the above the message is translated by a.hello() using a +context of A, and by b.hello() using a +context of B. In the equivalent C++ version the context +would be A in both cases. + + + +The PyQt behaviour is unsatisfactory and may be changed in the future. It is +recommended that QApplication.translate() be used in +preference to tr() (and trUtf8()). This +is guaranteed to work with current and future versions of PyQt and makes it +much easier to share message files between Python and C++ code. Below is the +alternative implementation of A that uses +QApplication.translate(). + + + +class A(QObject): + def __init__(self): + QObject.__init__(self) + + def hello(self): + return qApp.translate("A","Hello") + + + +Note that the code generated by pyuic uses +QApplication.translate(). + + + + + +Signal and Slot Support + +A signal may be either a Qt signal (specified using +SIGNAL()) or a Python signal (specified using +PYSIGNAL()). + + + +A slot can be either a Python callable object, a Qt signal (specified using +SIGNAL()), a Python signal (specified using +PYSIGNAL()), or a Qt slot (specified using +SLOT()). + + + +You connect signals to slots (and other signals) as you would from C++. For +example: + + + +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()")) + + + +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 +connections achieve the same effect. + + + +sbar = QScrollBar() +lcd = QLCDNumber() + +QObject.connect(sbar,SIGNAL("valueChanged(int)"),lcd.display) +QObject.connect(sbar,SIGNAL("valueChanged(int)"),lcd,SLOT("display(int)")) + + + +The difference is that the second connection is made at the C++ level and is +more efficient. + + + +Disconnecting signals works in exactly the same way. + + + +Any instance of a class that is derived from the QObject +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 +tuple which are the arguments to the signal. For example: + + + +a.emit(SIGNAL("clicked()"),()) +a.emit(PYSIGNAL("pySig"),("Hello","World")) + + + +Note that when a slot is a Python callable object its reference count is not +increased. This means that a class instance can be deleted without having to +explicitly disconnect any signals connected to its methods. However, it also +means that using lambda expressions as slots will not work unless you keep a +separate reference to the expression to prevent it from being immediately +garbage collected. + + + +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 +can be used in the same way. + + + + +Static Member Functions + +Static member functions are implemented as Python class functions. +For example the C++ static member function +QObject::connect() is called from Python as +QObject.connect() or self.connect() if +called from a sub-class of QObject. + + + + +Enumerated Types + +Enumerated types are implemented as a set of simple variables corresponding to +the separate enumerated values. + + + +When using an enumerated value the name of the class (or a sub-class) in which +the enumerated type was defined in must be included. For example: + + + +Qt.SolidPattern +QWidget.TabFocus +QFrame.TabFocus + + + + +Module Reference Documentation + +The following sections should be used in conjunction with the normal class +documentation - only the differences specific to the Python bindings are +documented here. + + + +In these sections, Not yet implemented +implies that the feature can be easily implemented if needed. Not +implemented implies that the feature will not be implemented, either +because it cannot be or because it is not appropriate. + + + +If a class is described as being fully implemented then +all non-private member functions and all public class variables have been +implemented. + + + +If an operator has been implemented then it is stated explicitly. + + + +Classes that are not mentioned have not yet been implemented. + + + + +<Literal>qt</Literal> Module Reference +%End + +%Include qt/qglobal.sip +%Include qt/qwindowdefs.sip +%Include qt/qnamespace.sip + +%Include qt/qaccel.sip +%Include qt/qaction.sip +%Include qt/qapplication.sip +%Include qt/qassistantclient.sip +%Include qt/qbitmap.sip +%Include qt/qbrush.sip +%Include qt/qbutton.sip +%Include qt/qbuttongroup.sip +%Include qt/qbytearray.sip +%Include qt/qcdestyle.sip +%Include qt/qcheckbox.sip +%Include qt/qclipboard.sip +%Include qt/qcolor.sip +%Include qt/qcolordialog.sip +%Include qt/qcolorgroup.sip +%Include qt/qcombobox.sip +%Include qt/qcommonstyle.sip +%Include qt/qcstring.sip +%Include qt/qcursor.sip +%Include qt/qdatastream.sip +%Include qt/qdatetime.sip +%Include qt/qdatetimeedit.sip +%Include qt/qdesktopwidget.sip +%Include qt/qdial.sip +%Include qt/qdialog.sip +%Include qt/qdir.sip +%Include qt/qdockarea.sip +%Include qt/qdockwindow.sip +%Include qt/qdragobject.sip +%Include qt/qdrawutil.sip +%Include qt/qdropsite.sip +%Include qt/qerrormessage.sip +%Include qt/qevent.sip +%Include qt/qeventloop.sip +%Include qt/qfile.sip +%Include qt/qfiledialog.sip +%Include qt/qfileinfo.sip +%Include qt/qfont.sip +%Include qt/qfontdatabase.sip +%Include qt/qfontdialog.sip +%Include qt/qfontinfo.sip +%Include qt/qfontmetrics.sip +%Include qt/qframe.sip +%Include qt/qgmanager.sip +%Include qt/qgrid.sip +%Include qt/qgridview.sip +%Include qt/qgroupbox.sip +%Include qt/qhbox.sip +%Include qt/qhbuttongroup.sip +%Include qt/qheader.sip +%Include qt/qhgroupbox.sip +%Include qt/qiconset.sip +%Include qt/qiconview.sip +%Include qt/qimage.sip +%Include qt/qinputdialog.sip +%Include qt/qinterlacestyle.sip +%Include qt/qiodevice.sip +%Include qt/qkeycode.sip +%Include qt/qkeysequence.sip +%Include qt/qlabel.sip +%Include qt/qlayout.sip +%Include qt/qlcdnumber.sip +%Include qt/qlibrary.sip +%Include qt/qlineedit.sip +%Include qt/qlist.sip +%Include qt/qlistbox.sip +%Include qt/qlistview.sip +%Include qt/qlocale.sip +%Include qt/qmainwindow.sip +%Include qt/qmemarray.sip +%Include qt/qmenubar.sip +%Include qt/qmenudata.sip +%Include qt/qmessagebox.sip +%Include qt/qmetaobject.sip +%Include qt/qmime.sip +%Include qt/qmotifplusstyle.sip +%Include qt/qmotifstyle.sip +%Include qt/qmovie.sip +%Include qt/qmultilinedit.sip +%Include qt/qmutex.sip +%Include qt/qnetworkprotocol.sip +%Include qt/qobject.sip +%Include qt/qobjectcleanuphandler.sip +%Include qt/qobjectlist.sip +%Include qt/qpaintdevicemetrics.sip +%Include qt/qpaintdevice.sip +%Include qt/qpainter.sip +%Include qt/qpalette.sip +%Include qt/qpixmap.sip +%Include qt/qpixmapcache.sip +%Include qt/qpair.sip +%Include qt/qpen.sip +%Include qt/qpicture.sip +%Include qt/qplatinumstyle.sip +%Include qt/qpoint.sip +%Include qt/qpointarray.sip +%Include qt/qpopupmenu.sip +%Include qt/qprintdialog.sip +%Include qt/qprinter.sip +%Include qt/qprocess.sip +%Include qt/qprogressbar.sip +%Include qt/qprogressdialog.sip +%Include qt/qptrlist.sip +%Include qt/qpushbutton.sip +%Include qt/qradiobutton.sip +%Include qt/qrangecontrol.sip +%Include qt/qrect.sip +%Include qt/qregexp.sip +%Include qt/qregion.sip +%Include qt/qscrollbar.sip +%Include qt/qscrollview.sip +%Include qt/qsemaphore.sip +%Include qt/qsemimodal.sip +%Include qt/qsessionmanager.sip +%Include qt/qsettings.sip +%Include qt/qsgistyle.sip +%Include qt/qsignalmapper.sip +%Include qt/qsimplerichtext.sip +%Include qt/qsize.sip +%Include qt/qsizegrip.sip +%Include qt/qsizepolicy.sip +%Include qt/qslider.sip +%Include qt/qsocketnotifier.sip +%Include qt/qsound.sip +%Include qt/qspinbox.sip +%Include qt/qsplashscreen.sip +%Include qt/qsplitter.sip +%Include qt/qstatusbar.sip +%Include qt/qstring.sip +%Include qt/qstringlist.sip +%Include qt/qstrlist.sip +%Include qt/qstyle.sip +%Include qt/qstylesheet.sip +%Include qt/qsyntaxhighlighter.sip +%Include qt/qtabbar.sip +%Include qt/qtabdialog.sip +%Include qt/qtableview.sip +%Include qt/qtabwidget.sip +%Include qt/qtextbrowser.sip +%Include qt/qtextcodec.sip +%Include qt/qtextedit.sip +%Include qt/qtextstream.sip +%Include qt/qtextview.sip +%Include qt/qthread.sip +%Include qt/qtimer.sip +%Include qt/qtoolbar.sip +%Include qt/qtoolbox.sip +%Include qt/qtoolbutton.sip +%Include qt/qtooltip.sip +%Include qt/qtranslator.sip +%Include qt/qurl.sip +%Include qt/qurlinfo.sip +%Include qt/qurloperator.sip +%Include qt/quuid.sip +%Include qt/qvalidator.sip +%Include qt/qvaluelist.sip +%Include qt/qvariant.sip +%Include qt/qvbox.sip +%Include qt/qvbuttongroup.sip +%Include qt/qvgroupbox.sip +%Include qt/qwaitcondition.sip +%Include qt/qwhatsthis.sip +%Include qt/qwidget.sip +%Include qt/qwidgetlist.sip +%Include qt/qwidgetstack.sip +%Include qt/qwindow.sip +%Include qt/qwindowsstyle.sip +%Include qt/qwindowsxpstyle.sip +%Include qt/qwizard.sip +%Include qt/qwmatrix.sip +%Include qt/qworkspace.sip + +%ExportedDoc + +%End + + +%ExportedDoc +<Literal>qtaxcontainer</Literal> Module Reference +%End + +%Include qtaxcontainer/qaxbase.sip +%Include qtaxcontainer/qaxobject.sip +%Include qtaxcontainer/qaxwidget.sip + +%ExportedDoc + +%End + + +%ExportedDoc +<Literal>qtcanvas</Literal> Module Reference +%End + +%Include qtcanvas/qcanvas.sip + +%ExportedDoc + +%End + + +%ExportedDoc +<Literal>qtext</Literal> Module Reference + +QextScintilla + + void getCursorPosition + int *line + int *index + + +This takes no parameters and returns a tuple of the values returned by the +line and index pointers. + + + + void getSelection + int *lineFrom + int *indexFrom + int *lineTo + int *indexTo + + +This takes no parameters and returns a tuple of the values returned by the +lineFrom, indexFrom, +lineTo and indexTo pointers. + + + +QextScintillaAPIs + +QextScintillaAPIs is fully implemented. + + + +QextScintillaBase + +QextScintillaBase is fully implemented. + + + +QextScintillaCommand + +QextScintillaCommand is fully implemented. + + + +QextScintillaCommandSet + +QextScintillaCommandSet is fully implemented. + + + +QextScintillaDocument + +QextScintillaDocument is fully implemented. + + + +QextScintillaLexer + +QextScintillaLexer is fully implemented. + + + +QextScintillaLexerBash (QScintilla v1.4+) + +QextScintillaLexerBash is fully implemented. + + + +QextScintillaLexerBatch (QScintilla v1.6+) + +QextScintillaLexerBatch is fully implemented. + + + +QextScintillaLexerCPP + +QextScintillaLexerCPP is fully implemented. + + + +QextScintillaLexerCSharp + +QextScintillaLexerCSharp is fully implemented. + + + +QextScintillaLexerCSS (QScintilla v1.6+) + +QextScintillaLexerCSS is fully implemented. + + + +QextScintillaLexerDiff (QScintilla v1.6+) + +QextScintillaLexerDiff is fully implemented. + + + +QextScintillaLexerHTML (QScintilla v1.1+) + +QextScintillaLexerHTML is fully implemented. + + + +QextScintillaLexerIDL + +QextScintillaLexerIDL is fully implemented. + + + +QextScintillaLexerJava + +QextScintillaLexerJava is fully implemented. + + + +QextScintillaLexerJavaScript + +QextScintillaLexerJavaScript is fully implemented. + + + +QextScintillaLexerLua (QScintilla v1.5+) + +QextScintillaLexerLua is fully implemented. + + + +QextScintillaLexerMakefile (QScintilla v1.6+) + +QextScintillaLexerMakefile is fully implemented. + + + +QextScintillaLexerPerl + +QextScintillaLexerPerl is fully implemented. + + + +QextScintillaLexerPOV (QScintilla v1.6+) + +QextScintillaLexerPOV is fully implemented. + + + +QextScintillaLexerProperties (QScintilla v1.6+) + +QextScintillaLexerProperties is fully implemented. + + + +QextScintillaLexerPython + +QextScintillaLexerPython is fully implemented. + + + +QextScintillaLexerRuby (QScintilla v1.5+) + +QextScintillaLexerRuby is fully implemented. + + + +QextScintillaLexerSQL (QScintilla v1.1+) + +QextScintillaLexerSQL is fully implemented. + + + +QextScintillaLexerTeX (QScintilla v1.6+) + +QextScintillaLexerTeX is fully implemented. + + + +QextScintillaMacro + +QextScintillaMacro is fully implemented. + + + +QextScintillaPrinter + +QextScintillaPrinter is fully implemented. + + +%End + + +%ExportedDoc + +%End + + +%ExportedDoc +<Literal>qtgl</Literal> Module Reference +%End + +%Include qtgl/qgl.sip +%Include qtgl/qglcolormap.sip + +%ExportedDoc + +%End + + +%ExportedDoc +<Literal>qtnetwork</Literal> Module Reference +%End + +%Include qtnetwork/qdns.sip +%Include qtnetwork/qftp.sip +%Include qtnetwork/qhostaddress.sip +%Include qtnetwork/qhttp.sip +%Include qtnetwork/qlocalfs.sip +%Include qtnetwork/qnetwork.sip +%Include qtnetwork/qserversocket.sip +%Include qtnetwork/qsocket.sip +%Include qtnetwork/qsocketdevice.sip + +%ExportedDoc + +%End + + +%ExportedDoc +<Literal>qtpe</Literal> Module Reference + +QPEApplication + + QApplication + 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. + + + + int exec + + + +This has been renamed to exec_loop in Python. + + + +AppLnk + + virtual QString exec const + + + +This has been renamed to exec_property in Python. + + + +AppLnkSet + +AppLnkSet is fully implemented. + + + +Config + +Config is fully implemented. + + + +DateFormat + +DateFormat is fully implemented. + + + +DocLnk + + QString exec const + + + +This has been renamed to exec_property in Python. + + + +DocLnkSet + +DocLnkSet is fully implemented. + + + +FileManager + +FileManager is fully implemented. + + + +FileSelector + +FileSelector is fully implemented. + + + +FileSelectorItem + +FileSelectorItem is fully implemented. + + + +FontDatabase + +FontDatabase is fully implemented. + + + +Global + + static void setBuiltinCommands + Command * + + +Not implemented. + + + +MenuButton + +MenuButton is fully implemented. + + + +QCopEnvelope + +QCopEnvelope is fully implemented. + + + +QDawg + +QDawg is fully implemented. + + + +QPEMenuBar + +QPEMenuBar is fully implemented. + + + +QPEToolBar + +QPEToolBar is fully implemented. + + + +Resource + +Resource is fully implemented. + + + + +%End + + +%ExportedDoc +<Literal>qtsql</Literal> Module Reference +%End + +%Include qtsql/qdatabrowser.sip +%Include qtsql/qdatatable.sip +%Include qtsql/qdataview.sip +%Include qtsql/qeditorfactory.sip +%Include qtsql/qsql.sip +%Include qtsql/qsqlcursor.sip +%Include qtsql/qsqldatabase.sip +%Include qtsql/qsqldriver.sip +%Include qtsql/qsqleditorfactory.sip +%Include qtsql/qsqlerror.sip +%Include qtsql/qsqlfield.sip +%Include qtsql/qsqlform.sip +%Include qtsql/qsqlindex.sip +%Include qtsql/qsqlpropertymap.sip +%Include qtsql/qsqlquery.sip +%Include qtsql/qsqlrecord.sip +%Include qtsql/qsqlresult.sip +%Include qtsql/qsqlselectcursor.sip + +%ExportedDoc + +%End + + +%ExportedDoc +<Literal>qttable</Literal> Module Reference +%End + +%Include qttable/qtable.sip + +%ExportedDoc + +%End + + +%ExportedDoc +<Literal>qtui</Literal> Module Reference +%End + +%Include qtui/qwidgetfactory.sip + +%ExportedDoc + +%End + + +%ExportedDoc +<Literal>qtxml</Literal> Module Reference +%End + +%Include qtxml/qdom.sip + +%ExportedDoc + +%End + + +%Doc +
+%End -- cgit v1.2.3