From: Thiago Macieira Date: Sun, 4 Jun 2006 15:52:05 +0000 (+0000) Subject: * qt/: Update to Subversion r548032. X-Git-Tag: dbus-0.62~19 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=edbf2bfc109ce94b2604ea20328fda25542e4383;p=platform%2Fupstream%2Fdbus.git * qt/: Update to Subversion r548032. This includes a big reorganisation of the files inside the subdir. We really need a version control system that supports moving of files. I'm not bothering with history anyways anymore, since the bindings will be moved out to git. The history should be restored from Subversion when that happens. --- diff --git a/ChangeLog b/ChangeLog index 4c72e18..7b6857a 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,9 @@ +2006-06-04 Thiago Macieira + + * qt/: Update to Subversion r548032. + This includes a big reorganisation of the files inside the + subdir. + 2006-05-30 Sjoerd Simons * dbus/dbus-sysdeps.c: Make tcp socket connection error somewhat more diff --git a/qt/Doxyfile b/qt/Doxyfile index c9e2547..a57ca5c 100644 --- a/qt/Doxyfile +++ b/qt/Doxyfile @@ -23,14 +23,14 @@ PROJECT_NAME = QtDBus # This could be handy for archiving the generated documentation or # if some version control system is used. -PROJECT_NUMBER = 0.60 +PROJECT_NUMBER = 0.62 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) # base path where the generated documentation will be put. # If a relative path is entered, it will be relative to the location # where doxygen was started. If left blank the current directory will be used. -OUTPUT_DIRECTORY = ../doc/api +OUTPUT_DIRECTORY = doc/api # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create # 4096 sub-directories (in 2 levels) under the output directory of each output @@ -287,7 +287,7 @@ HIDE_IN_BODY_DOCS = NO # to NO (the default) then the documentation will be excluded. # Set it to YES to include the internal documentation. -INTERNAL_DOCS = NO +INTERNAL_DOCS = YES # If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate # file names in lower-case letters. If set to YES upper-case letters are also @@ -459,7 +459,7 @@ WARN_LOGFILE = # directories like "/usr/src/myproject". Separate the files or directories # with spaces. -INPUT = . +INPUT = src # If the value of the INPUT tag contains directories, you can use the # FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp @@ -512,14 +512,13 @@ EXCLUDE_PATTERNS = Makefile.* \ magic \ NOTES \ TODO \ - THANKS \ - *_p.h + THANKS # The EXAMPLE_PATH tag can be used to specify one or more files or # directories that contain example code fragments that are included (see # the \include command). -EXAMPLE_PATH = +EXAMPLE_PATH = examples # If the value of the EXAMPLE_PATH tag contains directories, you can use the # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp @@ -1029,7 +1028,8 @@ PREDEFINED = DBUS_BEGIN_DECLS= \ DOXYGEN_SHOULD_SKIP_THIS \ _DBUS_DEFINE_GLOBAL_LOCK(name)= \ _DBUS_GNUC_PRINTF(from,to)= \ - Q_DECLARE_FLAGS(flags,theenum)= + Q_DECLARE_FLAGS(flags,theenum)= \ + Q_QDOC # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then # this tag can be used to specify a list of macro names that should be expanded. @@ -1065,7 +1065,7 @@ SKIP_FUNCTION_MACROS = YES # If a tag file is not located in the directory in which doxygen # is run, you must also specify the path to the tagfile here. -TAGFILES = /home/tjmaciei/troll/qt-4.1/doc/qt.tag=http://doc.trolltech.com/4.1 +TAGFILES = ./qt.tag=http://doc.trolltech.com/4.1 # When a file name is specified after GENERATE_TAGFILE, doxygen will create # a tag file that is based on the input files it reads. diff --git a/qt/Makefile.am b/qt/Makefile.am index c91c342..e09fd1e 100644 --- a/qt/Makefile.am +++ b/qt/Makefile.am @@ -1,80 +1,7 @@ -SUBDIRS = . examples +DIST_SUBDIRS = src tools examples if HAVE_QT -INCLUDES=-I$(top_srcdir) $(DBUS_CLIENT_CFLAGS) $(DBUS_QT_CFLAGS) -DDBUS_COMPILATION - -lib_LTLIBRARIES=libdbus-qt4-1.la - -dbusincludedir=$(includedir)/dbus-1.0/dbus -dbusinclude_HEADERS= \ - qdbusbus.h \ - qdbusmacros.h \ - qdbuserror.h \ - qdbusmessage.h \ - qdbusserver.h \ - qdbusconnection.h \ - qdbusabstractinterface.h \ - qdbusinterface.h \ - qdbusutil.h \ - qdbusabstractadaptor.h \ - qdbusreply.h \ - qdbustypehelper_p.h - -noinst_HEADERS= \ - qdbusabstractadaptor_p.h \ - qdbusabstractinterface_p.h \ - qdbusconnection_p.h \ - qdbusinterface_p.h \ - qdbusintrospection_p.h \ - qdbusmarshall_p.h \ - qdbusmessage_p.h \ - qdbusmetaobject_p.h \ - qdbustype_p.h \ - qdbusxmlparser_p.h - -libdbus_qt4_1_la_SOURCES = \ - qdbusbus.cpp \ - qdbusconnection.cpp \ - qdbuserror.cpp \ - qdbusintegrator.cpp \ - qdbusmarshall.cpp \ - qdbusmessage.cpp \ - qdbusserver.cpp \ - qdbustype.cpp \ - qdbusabstractinterface.cpp \ - qdbusinterface.cpp \ - qdbusxmlparser.cpp \ - qdbusutil.cpp \ - qdbusintrospection.cpp \ - qdbusabstractadaptor.cpp \ - qdbusthread.cpp \ - qdbusinternalfilters.cpp \ - qdbusmetaobject.cpp \ - qdbusmisc.cpp \ - qdbusxmlgenerator.cpp - -bin_PROGRAMS = dbusidl2cpp dbuscpp2xml -dbusidl2cpp_SOURCES = dbusidl2cpp.cpp -dbusidl2cpp_LDFLAGS = -no-undefined -dbusidl2cpp_LDADD = $(DBUS_QT_LIBS) libdbus-qt4-1.la -dbuscpp2xml_SOURCES = dbuscpp2xml.cpp -dbuscpp2xml_LDFLAGS = -no-undefined -dbuscpp2xml_LDADD = $(DBUS_QT_LIBS) libdbus-qt4-1.la - -qdbusabstractadaptor.lo: qdbusabstractadaptor.moc qdbusabstractadaptor_p.moc -qdbusabstractinterface.lo: qdbusabstractinterface.moc -qdbusbus.lo: qdbusbus.moc -qdbusserver.lo: qdbusserver.moc -qdbusintegrator.lo: qdbusconnection_p.moc - -CLEANFILES=qdbusabstractadaptor.moc qdbusserver.moc qdbusconnection_p.moc qdbusconnection_p.moc qdbusabstractadaptor_p.moc qdbusbus.moc qdbusabstractinterface.moc - -libdbus_qt4_1_la_LIBADD= $(DBUS_QT_LIBS) $(top_builddir)/dbus/libdbus-1.la -libdbus_qt4_1_la_LDFLAGS= -version-info 1:0 -no-undefined -libdbus_qt4_1_la_CPPFLAGS= -DQDBUS_MAKEDLL - -EXTRA_DIST = qt-dbus.qdocconf - -%.moc: %.h - $(QT_MOC) $< > $@ +QT_SUBDIRS = src tools examples endif + +SUBDIRS = $(QT_SUBDIRS) diff --git a/qt/examples/Makefile.am b/qt/examples/Makefile.am index 7906f28..5d1e054 100644 --- a/qt/examples/Makefile.am +++ b/qt/examples/Makefile.am @@ -1,6 +1,5 @@ -if HAVE_QT -INCLUDES=-I$(top_srcdir) $(DBUS_CLIENT_CFLAGS) $(DBUS_QT_CFLAGS) -DDBUS_COMPILATION -LDADD = ../libdbus-qt4-1.la +INCLUDES=-I$(top_srcdir)/qt $(DBUS_CLIENT_CFLAGS) $(DBUS_QT_CFLAGS) -DDBUS_COMPILATION +LDADD = ../src/libdbus-qt4-1.la if HAVE_QT_GUI chat_LDADD = $(LDADD) $(DBUS_QT_GUI_LIBS) @@ -10,7 +9,7 @@ chat.o: chatmainwindow.h chatsetnickname.h chatinterface.h chatadaptor.h chat.mo chatmainwindow.h: chatmainwindow.ui chatsetnickname.h: chatsetnickname.ui chatinterface.cpp chatinterface.h: com.trolltech.ChatInterface.xml - ../dbusidl2cpp -m -p chatinterface $? + ../tools/dbusidl2cpp -m -p chatinterface $? $(QT_MOC) -o chatinterface.moc chatinterface.h CHAT=chat @@ -41,5 +40,4 @@ CLEANFILES = chat.moc chatadaptor.moc complexping.moc complexpong.moc pong.moc \ $(QT_MOC) $< > $@ %.h: %.ui $(QT_UIC) -o $@ $? -endif diff --git a/qt/examples/complexpong.h b/qt/examples/complexpong.h index eaf5065..c6ad2db 100644 --- a/qt/examples/complexpong.h +++ b/qt/examples/complexpong.h @@ -28,7 +28,7 @@ class Pong: public QDBusAbstractAdaptor { Q_OBJECT Q_CLASSINFO("D-Bus Interface", "com.trolltech.QtDBus.ComplexPong.Pong") - Q_PROPERTY(QString value READ value WRITE setValue); + Q_PROPERTY(QString value READ value WRITE setValue) public: QString m_value; QString value() const; diff --git a/qt/qt.tag b/qt/qt.tag new file mode 100644 index 0000000..494fb38 --- /dev/null +++ b/qt/qt.tag @@ -0,0 +1,66720 @@ + + + Q3Accel + q3accel.html + + Q3Accel + Q3Accel + ( QWidget * parent, const char * name = 0 ) + + + Q3Accel + Q3Accel-2 + ( QWidget * watch, QObject * parent, const char * name = 0 ) + + + activated + activated + ( int id ) + + + activatedAmbiguously + activatedAmbiguously + ( int id ) + + + clear + clear + () + + + connectItem + connectItem + ( int id, const QObject * receiver, const char * member ) + + + count + count + () + + + disconnectItem + disconnectItem + ( int id, const QObject * receiver, const char * member ) + + + findKey + findKey + ( const QKeySequence & key ) + + + insertItem + insertItem + ( const QKeySequence & key, int id = -1 ) + + + isEnabled + isEnabled + () + + + isItemEnabled + isItemEnabled + ( int id ) + + + key + key + ( int id ) + + + removeItem + removeItem + ( int id ) + + + setEnabled + setEnabled + ( bool enable ) + + + setItemEnabled + setItemEnabled + ( int id, bool enable ) + + + setWhatsThis + setWhatsThis + ( int id, const QString & text ) + + + shortcutKey + shortcutKey + ( const QString & str ) + + + whatsThis + whatsThis + ( int id ) + + + keyToString + keyToString + ( QKeySequence k ) + + + stringToKey + stringToKey + ( const QString & s ) + + + + Q3ActionGroup + q3actiongroup.html + + Q3ActionGroup + Q3ActionGroup + ( QObject * parent, const char * name = 0 ) + + + Q3ActionGroup + Q3ActionGroup-2 + ( QObject * parent, const char * name, bool exclusive ) + + + activated + activated + ( Q3Action * action ) + + + add + add + ( Q3Action * action ) + + + addSeparator + addSeparator + () + + + addTo + addTo + ( QWidget * w ) + + + addedTo + addedTo + ( QWidget * actionWidget, QWidget * container, Q3Action * a ) + + + addedTo + addedTo-2 + ( int index, Q3PopupMenu * menu, Q3Action * a ) + + + insert + insert + ( Q3Action * action ) + + + selected + selected + ( Q3Action * action ) + + + + Q3Action + q3action.html + + Q3Action + Q3Action + ( QObject * parent, const char * name = 0 ) + + + Q3Action + Q3Action-2 + ( const QString & menuText, QKeySequence accel, QObject * parent, const char * name = 0 ) + + + Q3Action + Q3Action-3 + ( const QIcon & icon, const QString & menuText, QKeySequence accel, QObject * parent, const char * name = 0 ) + + + Q3Action + Q3Action-4 + ( const QString & text, const QIcon & icon, const QString & menuText, QKeySequence accel, QObject * parent, const char * name = 0, bool toggle = false ) + + + Q3Action + Q3Action-5 + ( const QString & text, const QString & menuText, QKeySequence accel, QObject * parent, const char * name = 0, bool toggle = false ) + + + Q3Action + Q3Action-6 + ( QObject * parent, const char * name, bool toggle ) + + + activate + activate + () + + + activated + activated + () + + + addTo + addTo + ( QWidget * w ) + + + addedTo + addedTo + ( QWidget * actionWidget, QWidget * container ) + + + addedTo + addedTo-2 + ( int index, Q3PopupMenu * menu ) + + + removeFrom + removeFrom + ( QWidget * w ) + + + setDisabled + setDisabled + ( bool disable ) + + + toggle + toggle + () + + + toggled + toggled + ( bool on ) + + + + Q3AsciiCache + q3asciicache.html + + Q3AsciiCache + Q3AsciiCache-2 + ( int maxCost = 100, int size = 17, bool caseSensitive = true, bool copyKeys = true ) + + + clear + clear + () + + + count + count + () + + + find + find + ( const char * k, bool ref = true ) + + + insert + insert + ( const char * k, const type * d, int c = 1, int p = 0 ) + + + isEmpty + isEmpty + () + + + maxCost + maxCost + () + + + remove + remove + ( const char * k ) + + + setMaxCost + setMaxCost + ( int m ) + + + size + size + () + + + statistics + statistics + () + + + take + take + ( const char * k ) + + + totalCost + totalCost + () + + + operator[] + operator-5b-5d + ( const char * k ) + + + + Q3AsciiCacheIterator + q3asciicacheiterator.html + + Q3AsciiCacheIterator + Q3AsciiCacheIterator + ( const Q3AsciiCache<type> & cache ) + + + Q3AsciiCacheIterator + Q3AsciiCacheIterator-2 + ( const Q3AsciiCacheIterator<type> & ci ) + + + atFirst + atFirst + () + + + atLast + atLast + () + + + count + count + () + + + current + current + () + + + currentKey + currentKey + () + + + isEmpty + isEmpty + () + + + toFirst + toFirst + () + + + toLast + toLast + () + + + operator + operator-type--2a + type *() + + + operator() + operator-28-29 + () + + + operator++ + operator-2b-2b + () + + + operator+= + operator-2b-eq + ( uint jump ) + + + operator-- + operator-- + () + + + operator-= + operator--eq + ( uint jump ) + + + operator= + operator-eq + ( const Q3AsciiCacheIterator<type> & ci ) + + + + Q3AsciiDict + q3asciidict.html + + Q3AsciiDict + Q3AsciiDict + ( int size = 17, bool caseSensitive = true, bool copyKeys = true ) + + + Q3AsciiDict + Q3AsciiDict-2 + ( const Q3AsciiDict<type> & dict ) + + + clear + clear + () + + + count + count + () + + + find + find + ( const char * key ) + + + insert + insert + ( const char * key, const type * item ) + + + isEmpty + isEmpty + () + + + read + read + ( QDataStream & s, Q3PtrCollection::Item & item ) + + + remove + remove + ( const char * key ) + + + replace + replace + ( const char * key, const type * item ) + + + resize + resize + ( uint newsize ) + + + size + size + () + + + statistics + statistics + () + + + take + take + ( const char * key ) + + + write + write + ( QDataStream & s, Q3PtrCollection::Item item ) + + + operator= + operator-eq + ( const Q3AsciiDict<type> & dict ) + + + operator[] + operator-5b-5d + ( const char * key ) + + + + Q3AsciiDictIterator + q3asciidictiterator.html + + Q3AsciiDictIterator + Q3AsciiDictIterator + ( const Q3AsciiDict<type> & dict ) + + + count + count + () + + + current + current + () + + + currentKey + currentKey + () + + + isEmpty + isEmpty + () + + + toFirst + toFirst + () + + + operator + operator-type--2a + type *() + + + operator() + operator-28-29 + () + + + operator++ + operator-2b-2b + () + + + operator+= + operator-2b-eq + ( uint jump ) + + + + Q3ButtonGroup + q3buttongroup.html + + Q3ButtonGroup + Q3ButtonGroup + ( QWidget * parent = 0, const char * name = 0 ) + + + Q3ButtonGroup + Q3ButtonGroup-2 + ( const QString & title, QWidget * parent = 0, const char * name = 0 ) + + + Q3ButtonGroup + Q3ButtonGroup-3 + ( int strips, Qt::Orientation orientation, QWidget * parent = 0, const char * name = 0 ) + + + Q3ButtonGroup + Q3ButtonGroup-4 + ( int strips, Qt::Orientation orientation, const QString & title, QWidget * parent = 0, const char * name = 0 ) + + + clicked + clicked + ( int id ) + + + count + count + () + + + find + find + ( int id ) + + + id + id + ( QAbstractButton * button ) + + + insert + insert + ( QAbstractButton * button, int id = -1 ) + + + pressed + pressed + ( int id ) + + + released + released + ( int id ) + + + remove + remove + ( QAbstractButton * button ) + + + selected + selected + () + + + + Q3Button + q3button.html + + Q3Button + Q3Button + ( QWidget * parent = 0, const char * name = 0, Qt::WFlags f = 0 ) + + + drawButton + drawButton + ( QPainter * painter ) + + + drawButtonLabel + drawButtonLabel + ( QPainter * painter ) + + + paintEvent + paintEvent + ( QPaintEvent * event ) + + + + Q3Cache + q3cache.html + + Q3Cache + Q3Cache-2 + ( int maxCost = 100, int size = 17, bool caseSensitive = true ) + + + clear + clear + () + + + count + count + () + + + find + find + ( const QString & k, bool ref = true ) + + + insert + insert + ( const QString & k, const type * d, int c = 1, int p = 0 ) + + + isEmpty + isEmpty + () + + + maxCost + maxCost + () + + + remove + remove + ( const QString & k ) + + + setMaxCost + setMaxCost + ( int m ) + + + size + size + () + + + statistics + statistics + () + + + take + take + ( const QString & k ) + + + totalCost + totalCost + () + + + operator[] + operator-5b-5d + ( const QString & k ) + + + + Q3CacheIterator + q3cacheiterator.html + + Q3CacheIterator + Q3CacheIterator + ( const Q3Cache<type> & cache ) + + + Q3CacheIterator + Q3CacheIterator-2 + ( const Q3CacheIterator<type> & ci ) + + + atFirst + atFirst + () + + + atLast + atLast + () + + + count + count + () + + + current + current + () + + + currentKey + currentKey + () + + + isEmpty + isEmpty + () + + + toFirst + toFirst + () + + + toLast + toLast + () + + + operator + operator-type--2a + type *() + + + operator() + operator-28-29 + () + + + operator++ + operator-2b-2b + () + + + operator+= + operator-2b-eq + ( uint jump ) + + + operator-- + operator-- + () + + + operator-= + operator--eq + ( uint jump ) + + + operator= + operator-eq + ( const Q3CacheIterator<type> & ci ) + + + + Q3CanvasEllipse + q3canvasellipse.html + + Q3CanvasEllipse + Q3CanvasEllipse + ( Q3Canvas * canvas ) + + + Q3CanvasEllipse + Q3CanvasEllipse-2 + ( int width, int height, Q3Canvas * canvas ) + + + Q3CanvasEllipse + Q3CanvasEllipse-3 + ( int width, int height, int startangle, int angle, Q3Canvas * canvas ) + + + angleLength + angleLength + () + + + angleStart + angleStart + () + + + drawShape + drawShape + ( QPainter & p ) + + + height + height + () + + + rtti + rtti + () + + + setAngles + setAngles + ( int start, int length ) + + + setSize + setSize + ( int width, int height ) + + + width + width + () + + + + Q3Canvas + q3canvas.html + + Q3Canvas + Q3Canvas + ( QObject * parent = 0, const char * name = 0 ) + + + Q3Canvas + Q3Canvas-2 + ( int w, int h ) + + + Q3Canvas + Q3Canvas-3 + ( QPixmap p, int h, int v, int tilewidth, int tileheight ) + + + advance + advance + () + + + allItems + allItems + () + + + backgroundColor + backgroundColor + () + + + backgroundPixmap + backgroundPixmap + () + + + chunkSize + chunkSize + () + + + collisions + collisions + ( const QPoint & p ) + + + collisions + collisions-2 + ( const QRect & r ) + + + collisions + collisions-3 + ( const Q3PointArray & chunklist, const Q3CanvasItem * item, bool exact ) + + + drawArea + drawArea + ( const QRect & clip, QPainter * painter, bool dbuf = false ) + + + drawBackground + drawBackground + ( QPainter & painter, const QRect & clip ) + + + drawForeground + drawForeground + ( QPainter & painter, const QRect & clip ) + + + height + height + () + + + onCanvas + onCanvas + ( int x, int y ) + + + onCanvas + onCanvas-2 + ( const QPoint & p ) + + + rect + rect + () + + + resize + resize + ( int w, int h ) + + + resized + resized + () + + + retune + retune + ( int chunksze, int mxclusters = 100 ) + + + setAdvancePeriod + setAdvancePeriod + ( int ms ) + + + setAllChanged + setAllChanged + () + + + setBackgroundColor + setBackgroundColor + ( const QColor & c ) + + + setBackgroundPixmap + setBackgroundPixmap + ( const QPixmap & p ) + + + setChanged + setChanged + ( const QRect & area ) + + + setDoubleBuffering + setDoubleBuffering + ( bool y ) + + + setTile + setTile + ( int x, int y, int tilenum ) + + + setTiles + setTiles + ( QPixmap p, int h, int v, int tilewidth, int tileheight ) + + + setUnchanged + setUnchanged + ( const QRect & area ) + + + setUpdatePeriod + setUpdatePeriod + ( int ms ) + + + size + size + () + + + tile + tile + ( int x, int y ) + + + tileHeight + tileHeight + () + + + tileWidth + tileWidth + () + + + tilesHorizontally + tilesHorizontally + () + + + tilesVertically + tilesVertically + () + + + update + update + () + + + validChunk + validChunk + ( int x, int y ) + + + validChunk + validChunk-2 + ( const QPoint & p ) + + + width + width + () + + + + Q3CanvasItem + q3canvasitem.html + + RttiValues + RttiValues-enum + + + + Q3CanvasItem + Q3CanvasItem + ( Q3Canvas * canvas ) + + + advance + advance + ( int phase ) + + + animated + animated + () + + + boundingRect + boundingRect + () + + + boundingRectAdvanced + boundingRectAdvanced + () + + + canvas + canvas + () + + + collidesWith + collidesWith + ( const Q3CanvasItem * other ) + + + collisions + collisions + ( bool exact ) + + + draw + draw + ( QPainter & painter ) + + + hide + hide + () + + + isActive + isActive + () + + + isEnabled + isEnabled + () + + + isSelected + isSelected + () + + + isVisible + isVisible + () + + + move + move + ( double x, double y ) + + + moveBy + moveBy + ( double dx, double dy ) + + + rtti + rtti + () + + + setActive + setActive + ( bool yes ) + + + setAnimated + setAnimated + ( bool y ) + + + setCanvas + setCanvas + ( Q3Canvas * c ) + + + setEnabled + setEnabled + ( bool yes ) + + + setSelected + setSelected + ( bool yes ) + + + setVelocity + setVelocity + ( double vx, double vy ) + + + setVisible + setVisible + ( bool yes ) + + + setX + setX + ( double x ) + + + setXVelocity + setXVelocity + ( double vx ) + + + setY + setY + ( double y ) + + + setYVelocity + setYVelocity + ( double vy ) + + + setZ + setZ + ( double z ) + + + show + show + () + + + update + update + () + + + x + x + () + + + xVelocity + xVelocity + () + + + y + y + () + + + yVelocity + yVelocity + () + + + z + z + () + + + + Q3CanvasItemList + q3canvasitemlist.html + + operator+ + operator-2b + ( const Q3CanvasItemList & l ) + + + active + active + () + + + enabled + enabled + () + + + selected + selected + () + + + visible + visible + () + + + + Q3CanvasLine + q3canvasline.html + + Q3CanvasLine + Q3CanvasLine + ( Q3Canvas * canvas ) + + + endPoint + endPoint + () + + + rtti + rtti + () + + + setPoints + setPoints + ( int xa, int ya, int xb, int yb ) + + + startPoint + startPoint + () + + + + Q3CanvasPixmapArray + q3canvaspixmaparray.html + + Q3CanvasPixmapArray + Q3CanvasPixmapArray + () + + + Q3CanvasPixmapArray + Q3CanvasPixmapArray-2 + ( const QString & datafilenamepattern, int fc = 0 ) + + + Q3CanvasPixmapArray + Q3CanvasPixmapArray-4 + ( Q3ValueList<QPixmap> list, Q3PointArray hotspots = Q3PointArray() + + + count + count + () + + + image + image + ( int i ) + + + isValid + isValid + () + + + readCollisionMasks + readCollisionMasks + ( const QString & filename ) + + + readPixmaps + readPixmaps + ( const QString & filenamepattern, int fc = 0 ) + + + setImage + setImage + ( int i, Q3CanvasPixmap * p ) + + + Q3CanvasPixmapArray + Q3CanvasPixmapArray-3 + ( Q3PtrList<QPixmap> list, Q3PtrList<QPoint> hotspots ) + + + operator! + operator-not + () + + + + Q3CanvasPixmap + q3canvaspixmap.html + + Q3CanvasPixmap + Q3CanvasPixmap + ( const QString & datafilename ) + + + Q3CanvasPixmap + Q3CanvasPixmap-2 + ( const QImage & image ) + + + Q3CanvasPixmap + Q3CanvasPixmap-3 + ( const QPixmap & pm, const QPoint & offset ) + + + offsetX + offsetX + () + + + offsetY + offsetY + () + + + setOffset + setOffset + ( int x, int y ) + + + + Q3CanvasPolygonalItem + q3canvaspolygonalitem.html + + Q3CanvasPolygonalItem + Q3CanvasPolygonalItem + ( Q3Canvas * canvas ) + + + areaPoints + areaPoints + () + + + areaPointsAdvanced + areaPointsAdvanced + () + + + boundingRect + boundingRect + () + + + brush + brush + () + + + draw + draw + ( QPainter & p ) + + + drawShape + drawShape + ( QPainter & p ) + + + invalidate + invalidate + () + + + isValid + isValid + () + + + pen + pen + () + + + rtti + rtti + () + + + setBrush + setBrush + ( QBrush b ) + + + setPen + setPen + ( QPen p ) + + + setWinding + setWinding + ( bool enable ) + + + winding + winding + () + + + + Q3CanvasPolygon + q3canvaspolygon.html + + Q3CanvasPolygon + Q3CanvasPolygon + ( Q3Canvas * canvas ) + + + areaPoints + areaPoints + () + + + drawShape + drawShape + ( QPainter & p ) + + + points + points + () + + + rtti + rtti + () + + + setPoints + setPoints + ( Q3PointArray pa ) + + + + Q3CanvasRectangle + q3canvasrectangle.html + + Q3CanvasRectangle + Q3CanvasRectangle + ( Q3Canvas * canvas ) + + + Q3CanvasRectangle + Q3CanvasRectangle-2 + ( const QRect & r, Q3Canvas * canvas ) + + + Q3CanvasRectangle + Q3CanvasRectangle-3 + ( int x, int y, int width, int height, Q3Canvas * canvas ) + + + chunks + chunks + () + + + drawShape + drawShape + ( QPainter & p ) + + + height + height + () + + + rect + rect + () + + + rtti + rtti + () + + + setSize + setSize + ( int width, int height ) + + + size + size + () + + + width + width + () + + + + Q3CanvasSpline + q3canvasspline.html + + Q3CanvasSpline + Q3CanvasSpline + ( Q3Canvas * canvas ) + + + closed + closed + () + + + controlPoints + controlPoints + () + + + rtti + rtti + () + + + setControlPoints + setControlPoints + ( Q3PointArray ctrl, bool close = true ) + + + + Q3CanvasSprite + q3canvassprite.html + + FrameAnimationType + FrameAnimationType-enum + + + + Q3CanvasSprite + Q3CanvasSprite + ( Q3CanvasPixmapArray * a, Q3Canvas * canvas ) + + + advance + advance + ( int phase ) + + + bottomEdge + bottomEdge + () + + + bottomEdge + bottomEdge-2 + ( int ny ) + + + boundingRect + boundingRect + () + + + draw + draw + ( QPainter & painter ) + + + frame + frame + () + + + frameCount + frameCount + () + + + height + height + () + + + image + image + () + + + image + image-2 + ( int f ) + + + imageAdvanced + imageAdvanced + () + + + leftEdge + leftEdge + () + + + leftEdge + leftEdge-2 + ( int nx ) + + + move + move + ( double x, double y ) + + + move + move-2 + ( double nx, double ny, int nf ) + + + rightEdge + rightEdge + () + + + rightEdge + rightEdge-2 + ( int nx ) + + + rtti + rtti + () + + + setFrame + setFrame + ( int f ) + + + setFrameAnimation + setFrameAnimation + ( FrameAnimationType type = Cycle, int step = 1, int state = 0 ) + + + setSequence + setSequence + ( Q3CanvasPixmapArray * a ) + + + topEdge + topEdge + () + + + topEdge + topEdge-2 + ( int ny ) + + + width + width + () + + + + Q3CanvasText + q3canvastext.html + + Q3CanvasText + Q3CanvasText + ( Q3Canvas * canvas ) + + + Q3CanvasText + Q3CanvasText-2 + ( const QString & t, Q3Canvas * canvas ) + + + Q3CanvasText + Q3CanvasText-3 + ( const QString & t, QFont f, Q3Canvas * canvas ) + + + boundingRect + boundingRect + () + + + color + color + () + + + draw + draw + ( QPainter & painter ) + + + font + font + () + + + rtti + rtti + () + + + setColor + setColor + ( const QColor & c ) + + + setFont + setFont + ( const QFont & f ) + + + setText + setText + ( const QString & t ) + + + setTextFlags + setTextFlags + ( int f ) + + + text + text + () + + + textFlags + textFlags + () + + + + Q3CanvasView + q3canvasview.html + + Q3CanvasView + Q3CanvasView + ( QWidget * parent = 0, const char * name = 0, Qt::WFlags f = 0 ) + + + Q3CanvasView + Q3CanvasView-2 + ( Q3Canvas * canvas, QWidget * parent = 0, const char * name = 0, Qt::WFlags f = 0 ) + + + canvas + canvas + () + + + drawContents + drawContents + ( QPainter * p, int cx, int cy, int cw, int ch ) + + + inverseWorldMatrix + inverseWorldMatrix + () + + + setCanvas + setCanvas + ( Q3Canvas * canvas ) + + + setWorldMatrix + setWorldMatrix + ( const QMatrix & wm ) + + + sizeHint + sizeHint + () + + + worldMatrix + worldMatrix + () + + + + Q3CheckListItem + q3checklistitem.html + + ToggleState + ToggleState-enum + + + + Type + Type-enum + + + + Q3CheckListItem + Q3CheckListItem + ( Q3CheckListItem * parent, const QString & text, Type tt = RadioButtonController ) + + + Q3CheckListItem + Q3CheckListItem-2 + ( Q3CheckListItem * parent, Q3ListViewItem * after, const QString & text, Type tt = RadioButtonController ) + + + Q3CheckListItem + Q3CheckListItem-3 + ( Q3ListViewItem * parent, const QString & text, Type tt = RadioButtonController ) + + + Q3CheckListItem + Q3CheckListItem-4 + ( Q3ListViewItem * parent, Q3ListViewItem * after, const QString & text, Type tt = RadioButtonController ) + + + Q3CheckListItem + Q3CheckListItem-5 + ( Q3ListView * parent, const QString & text, Type tt = RadioButtonController ) + + + Q3CheckListItem + Q3CheckListItem-6 + ( Q3ListView * parent, Q3ListViewItem * after, const QString & text, Type tt = RadioButtonController ) + + + Q3CheckListItem + Q3CheckListItem-7 + ( Q3ListViewItem * parent, const QString & text, const QPixmap & p ) + + + Q3CheckListItem + Q3CheckListItem-8 + ( Q3ListView * parent, const QString & text, const QPixmap & p ) + + + activate + activate + () + + + isOn + isOn + () + + + isTristate + isTristate + () + + + paintCell + paintCell + ( QPainter * p, const QColorGroup & cg, int column, int width, int align ) + + + paintFocus + paintFocus + ( QPainter * p, const QColorGroup & cg, const QRect & r ) + + + rtti + rtti + () + + + setOn + setOn + ( bool b ) + + + setState + setState + ( ToggleState s ) + + + setTristate + setTristate + ( bool b ) + + + state + state + () + + + stateChange + stateChange + ( bool b ) + + + text + text + () + + + turnOffChild + turnOffChild + () + + + type + type + () + + + + Q3CheckTableItem + q3checktableitem.html + + Q3CheckTableItem + Q3CheckTableItem + ( Q3Table * table, const QString & txt ) + + + isChecked + isChecked + () + + + rtti + rtti + () + + + setChecked + setChecked + ( bool b ) + + + + Q3ColorDrag + q3colordrag.html + + Q3ColorDrag + Q3ColorDrag + ( const QColor & col, QWidget * dragsource = 0, const char * name = 0 ) + + + Q3ColorDrag + Q3ColorDrag-2 + ( QWidget * dragsource = 0, const char * name = 0 ) + + + canDecode + canDecode + ( QMimeSource * source ) + + + decode + decode + ( QMimeSource * source, QColor & color ) + + + setColor + setColor + ( const QColor & color ) + + + + Q3ComboBox + q3combobox.html + + Policy + Policy-enum + + + + Q3ComboBox + Q3ComboBox + ( QWidget * parent = 0, const char * name = 0 ) + + + Q3ComboBox + Q3ComboBox-2 + ( bool rw, QWidget * parent = 0, const char * name = 0 ) + + + activated + activated + ( int index ) + + + activated + activated-2 + ( const QString & string ) + + + autoResize + autoResize + () + + + changeItem + changeItem + ( const QString & t, int index ) + + + changeItem + changeItem-2 + ( const QPixmap & im, int index ) + + + changeItem + changeItem-3 + ( const QPixmap & im, const QString & t, int index ) + + + clear + clear + () + + + clearEdit + clearEdit + () + + + clearValidator + clearValidator + () + + + hide + hide + () + + + highlighted + highlighted + ( int index ) + + + highlighted + highlighted-2 + ( const QString & string ) + + + insertItem + insertItem + ( const QString & t, int index = -1 ) + + + insertItem + insertItem-2 + ( const QPixmap & pixmap, int index = -1 ) + + + insertItem + insertItem-3 + ( const QPixmap & pixmap, const QString & text, int index = -1 ) + + + insertStrList + insertStrList + ( const char ** strings, int numStrings = -1, int index = -1 ) + + + insertStrList + insertStrList-2 + ( const Q3StrList & list, int index = -1 ) + + + insertStrList + insertStrList-3 + ( const Q3StrList * list, int index = -1 ) + + + insertStringList + insertStringList + ( const QStringList & list, int index = -1 ) + + + lineEdit + lineEdit + () + + + listBox + listBox + () + + + pixmap + pixmap + ( int index ) + + + popup + popup + () + + + removeItem + removeItem + ( int index ) + + + setAutoResize + setAutoResize + ( bool ) + + + setEditText + setEditText + ( const QString & newText ) + + + setEnabled + setEnabled + ( bool enable ) + + + setFont + setFont + ( const QFont & font ) + + + setLineEdit + setLineEdit + ( QLineEdit * edit ) + + + setListBox + setListBox + ( Q3ListBox * newListBox ) + + + setPalette + setPalette + ( const QPalette & palette ) + + + setValidator + setValidator + ( const QValidator * v ) + + + text + text + ( int index ) + + + textChanged + textChanged + ( const QString & string ) + + + updateMask + updateMask + () + + + validator + validator + () + + + + Q3ComboTableItem + q3combotableitem.html + + Q3ComboTableItem + Q3ComboTableItem + ( Q3Table * table, const QStringList & list, bool editable = false ) + + + count + count + () + + + currentItem + currentItem + () + + + currentText + currentText + () + + + isEditable + isEditable + () + + + rtti + rtti + () + + + setCurrentItem + setCurrentItem + ( int i ) + + + setCurrentItem + setCurrentItem-2 + ( const QString & s ) + + + setEditable + setEditable + ( bool b ) + + + setStringList + setStringList + ( const QStringList & l ) + + + text + text + ( int i ) + + + + Q3CString + q3cstring.html + + Q3CString + Q3CString + () + + + Q3CString + Q3CString-2 + ( int size ) + + + Q3CString + Q3CString-3 + ( const Q3CString & s ) + + + Q3CString + Q3CString-4 + ( const QByteArray & ba ) + + + Q3CString + Q3CString-5 + ( const char * str ) + + + Q3CString + Q3CString-6 + ( const char * str, uint maxsize ) + + + append + append + ( const char * str ) + + + copy + copy + () + + + leftJustify + leftJustify + ( uint width, char fill = ' ', bool truncate = false ) + + + lower + lower + () + + + rightJustify + rightJustify + ( uint width, char fill = ' ', bool truncate = false ) + + + setExpand + setExpand + ( uint index, char c ) + + + setNum + setNum + ( double n, char f = 'g', int prec = 6 ) + + + setNum + setNum-2 + ( long n ) + + + setNum + setNum-3 + ( ulong n ) + + + setNum + setNum-4 + ( int n ) + + + setNum + setNum-5 + ( uint n ) + + + setNum + setNum-6 + ( short n ) + + + setNum + setNum-7 + ( ushort n ) + + + setNum + setNum-8 + ( float n, char f = 'g', int prec = 6 ) + + + setStr + setStr + ( const char * str ) + + + simplifyWhiteSpace + simplifyWhiteSpace + () + + + sprintf + sprintf + ( const char * format, ... ) + + + stripWhiteSpace + stripWhiteSpace + () + + + toDouble + toDouble + ( bool * ok = 0 ) + + + toFloat + toFloat + ( bool * ok = 0 ) + + + toInt + toInt + ( bool * ok = 0 ) + + + toLong + toLong + ( bool * ok = 0 ) + + + toShort + toShort + ( bool * ok = 0 ) + + + toUInt + toUInt + ( bool * ok = 0 ) + + + toULong + toULong + ( bool * ok = 0 ) + + + toUShort + toUShort + ( bool * ok = 0 ) + + + upper + upper + () + + + operator= + operator-eq + ( const Q3CString & s ) + + + operator= + operator-eq-2 + ( const QByteArray & ba ) + + + operator= + operator-eq-3 + ( const char * str ) + + + + Q3DataBrowser + q3databrowser.html + + Boundary + Boundary-enum + + + + Q3DataBrowser + Q3DataBrowser + ( QWidget * parent = 0, const char * name = 0, Qt::WFlags fl = 0 ) + + + beforeDelete + beforeDelete + ( QSqlRecord * buf ) + + + beforeInsert + beforeInsert + ( QSqlRecord * buf ) + + + beforeUpdate + beforeUpdate + ( QSqlRecord * buf ) + + + boundary + boundary + () + + + clearValues + clearValues + () + + + Confirm + confirmCancel + Q3DataBrowser::confirmCancel( QSql::Op m ) + + + Confirm + confirmEdit + Q3DataBrowser::confirmEdit( QSql::Op m ) + + + currentChanged + currentChanged + ( const QSqlRecord * record ) + + + currentEdited + currentEdited + () + + + cursorChanged + cursorChanged + ( Q3SqlCursor::Mode mode ) + + + del + del + () + + + deleteCurrent + deleteCurrent + () + + + first + first + () + + + firstRecordAvailable + firstRecordAvailable + ( bool available ) + + + form + form + () + + + handleError + handleError + ( const QSqlError & error ) + + + insert + insert + () + + + insertCurrent + insertCurrent + () + + + last + last + () + + + lastRecordAvailable + lastRecordAvailable + ( bool available ) + + + next + next + () + + + nextRecordAvailable + nextRecordAvailable + ( bool available ) + + + prev + prev + () + + + prevRecordAvailable + prevRecordAvailable + ( bool available ) + + + primeDelete + primeDelete + ( QSqlRecord * buf ) + + + primeInsert + primeInsert + ( QSqlRecord * buf ) + + + primeUpdate + primeUpdate + ( QSqlRecord * buf ) + + + readFields + readFields + () + + + refresh + refresh + () + + + seek + seek + ( int i, bool relative = false ) + + + setForm + setForm + ( Q3SqlForm * form ) + + + setSqlCursor + setSqlCursor + ( Q3SqlCursor * cursor, bool autoDelete = false ) + + + sqlCursor + sqlCursor + () + + + update + update + () + + + updateBoundary + updateBoundary + () + + + updateCurrent + updateCurrent + () + + + writeFields + writeFields + () + + + + Q3DataTable + q3datatable.html + + Refresh + Refresh-enum + + + + DateFormat + dateFormat-prop + + + + Q3DataTable + Q3DataTable + ( QWidget * parent = 0, const char * name = 0 ) + + + Q3DataTable + Q3DataTable-2 + ( Q3SqlCursor * cursor, bool autoPopulate = false, QWidget * parent = 0, const char * name = 0 ) + + + addColumn + addColumn + ( const QString & fieldName, const QString & label = QString() + + + adjustColumn + adjustColumn + ( int col ) + + + autoDelete + autoDelete + () + + + beforeDelete + beforeDelete + ( QSqlRecord * buf ) + + + beforeInsert + beforeInsert + ( QSqlRecord * buf ) + + + beforeUpdate + beforeUpdate + ( QSqlRecord * buf ) + + + beginInsert + beginInsert + () + + + beginUpdate + beginUpdate + ( int row, int col, bool replace ) + + + Confirm + confirmCancel + Q3DataTable::confirmCancel( QSql::Op m ) + + + Confirm + confirmEdit + Q3DataTable::confirmEdit( QSql::Op m ) + + + currentChanged + currentChanged + ( QSqlRecord * record ) + + + currentRecord + currentRecord + () + + + cursorChanged + cursorChanged + ( QSql::Op mode ) + + + deleteCurrent + deleteCurrent + () + + + fieldAlignment + fieldAlignment + ( const QSqlField * field ) + + + find + find + ( const QString & str, bool caseSensitive, bool backwards ) + + + handleError + handleError + ( const QSqlError & e ) + + + indexOf + indexOf + ( uint i ) + + + insertCurrent + insertCurrent + () + + + installEditorFactory + installEditorFactory + ( Q3SqlEditorFactory * f ) + + + installPropertyMap + installPropertyMap + ( Q3SqlPropertyMap * m ) + + + paintField + paintField + ( QPainter * p, const QSqlField * field, const QRect & cr, bool selected ) + + + primeDelete + primeDelete + ( QSqlRecord * buf ) + + + primeInsert + primeInsert + ( QSqlRecord * buf ) + + + primeUpdate + primeUpdate + ( QSqlRecord * buf ) + + + refresh + refresh + ( Refresh mode ) + + + refresh + refresh-2 + () + + + removeColumn + removeColumn + ( int col ) + + + repaintCell + repaintCell + ( int row, int col ) + + + reset + reset + () + + + setAutoDelete + setAutoDelete + ( bool enable ) + + + setColumn + setColumn + ( uint col, const QString & fieldName, const QString & label = QString() + + + setColumnWidth + setColumnWidth + ( int col, int w ) + + + setSize + setSize + ( Q3SqlCursor * sql ) + + + setSqlCursor + setSqlCursor + ( Q3SqlCursor * cursor = 0, bool autoPopulate = false, bool autoDelete = false ) + + + sortAscending + sortAscending + ( int col ) + + + sortColumn + sortColumn + ( int col, bool ascending = true, bool wholeRows = false ) + + + sortDescending + sortDescending + ( int col ) + + + sqlCursor + sqlCursor + () + + + text + text + ( int row, int col ) + + + updateCurrent + updateCurrent + () + + + value + value + ( int row, int col ) + + + + Q3DataView + q3dataview.html + + Q3DataView + Q3DataView + ( QWidget * parent = 0, const char * name = 0, Qt::WFlags fl = 0 ) + + + clearValues + clearValues + () + + + form + form + () + + + readFields + readFields + () + + + record + record + () + + + refresh + refresh + ( QSqlRecord * buf ) + + + setForm + setForm + ( Q3SqlForm * form ) + + + setRecord + setRecord + ( QSqlRecord * record ) + + + writeFields + writeFields + () + + + + Q3DateEdit + q3dateedit.html + + Order + Order-enum + + + + Q3DateEdit + Q3DateEdit + ( QWidget * parent = 0, const char * name = 0 ) + + + Q3DateEdit + Q3DateEdit-2 + ( const QDate & date, QWidget * parent = 0, const char * name = 0 ) + + + fix + fix + () + + + sectionFormattedText + sectionFormattedText + ( int sec ) + + + separator + separator + () + + + setDay + setDay + ( int day ) + + + setMonth + setMonth + ( int month ) + + + setRange + setRange + ( const QDate & min, const QDate & max ) + + + setSeparator + setSeparator + ( const QString & s ) + + + setYear + setYear + ( int year ) + + + updateButtons + updateButtons + () + + + valueChanged + valueChanged + ( const QDate & date ) + + + + Q3DateTimeEditBase + q3datetimeeditbase.html + + + Q3DateTimeEdit + q3datetimeedit.html + + Q3DateTimeEdit + Q3DateTimeEdit + ( QWidget * parent = 0, const char * name = 0 ) + + + Q3DateTimeEdit + Q3DateTimeEdit-2 + ( const QDateTime & datetime, QWidget * parent = 0, const char * name = 0 ) + + + autoAdvance + autoAdvance + () + + + dateEdit + dateEdit + () + + + setAutoAdvance + setAutoAdvance + ( bool advance ) + + + timeEdit + timeEdit + () + + + valueChanged + valueChanged + ( const QDateTime & datetime ) + + + + Q3DeepCopy + q3deepcopy.html + + Q3DeepCopy + Q3DeepCopy + () + + + Q3DeepCopy + Q3DeepCopy-2 + ( const T & t ) + + + operator + operator-T + T() + + + operator= + operator-eq + ( const T & t ) + + + + Q3Dict + q3dict.html + + Q3Dict + Q3Dict + ( int size = 17, bool caseSensitive = true ) + + + Q3Dict + Q3Dict-2 + ( const Q3Dict<type> & dict ) + + + clear + clear + () + + + count + count + () + + + find + find + ( const QString & key ) + + + insert + insert + ( const QString & key, const type * item ) + + + isEmpty + isEmpty + () + + + read + read + ( QDataStream & s, Q3PtrCollection::Item & item ) + + + remove + remove + ( const QString & key ) + + + replace + replace + ( const QString & key, const type * item ) + + + resize + resize + ( uint newsize ) + + + size + size + () + + + statistics + statistics + () + + + take + take + ( const QString & key ) + + + write + write + ( QDataStream & s, Q3PtrCollection::Item item ) + + + operator= + operator-eq + ( const Q3Dict<type> & dict ) + + + operator[] + operator-5b-5d + ( const QString & key ) + + + + Q3DictIterator + q3dictiterator.html + + Q3DictIterator + Q3DictIterator + ( const Q3Dict<type> & dict ) + + + count + count + () + + + current + current + () + + + currentKey + currentKey + () + + + isEmpty + isEmpty + () + + + toFirst + toFirst + () + + + operator + operator-type--2a + type *() + + + operator() + operator-28-29 + () + + + operator++ + operator-2b-2b + () + + + + Q3Dns + q3dns.html + + RecordType + RecordType-enum + + + + Q3Dns + Q3Dns + () + + + Q3Dns + Q3Dns-2 + ( const QString & label, RecordType rr = A ) + + + Q3Dns + Q3Dns-3 + ( const QHostAddress & address, RecordType rr = Ptr ) + + + addresses + addresses + () + + + canonicalName + canonicalName + () + + + hostNames + hostNames + () + + + isWorking + isWorking + () + + + label + label + () + + + mailServers + mailServers + () + + + qualifiedNames + qualifiedNames + () + + + recordType + recordType + () + + + resultsReady + resultsReady + () + + + servers + servers + () + + + setLabel + setLabel + ( const QString & label ) + + + setLabel + setLabel-2 + ( const QHostAddress & address ) + + + setRecordType + setRecordType + ( RecordType rr = A ) + + + texts + texts + () + + + + Q3DockArea + q3dockarea.html + + HandlePosition + HandlePosition-enum + + + + Orientation + orientation-prop + + + + Q3DockArea + Q3DockArea + ( Qt::Orientation o, HandlePosition h = Normal, QWidget * parent = 0, const char * name = 0 ) + + + dockWindowList + dockWindowList + () + + + hasDockWindow + hasDockWindow + ( Q3DockWindow * w, int * index = 0 ) + + + isDockWindowAccepted + isDockWindowAccepted + ( Q3DockWindow * dw ) + + + lineUp + lineUp + ( bool keepNewLines ) + + + moveDockWindow + moveDockWindow + ( Q3DockWindow * w, int index = -1 ) + + + moveDockWindow + moveDockWindow-2 + ( Q3DockWindow * w, const QPoint & p, const QRect & r, bool swap ) + + + removeDockWindow + removeDockWindow + ( Q3DockWindow * w, bool makeFloating, bool swap, bool fixNewLines = true ) + + + setAcceptDockWindow + setAcceptDockWindow + ( Q3DockWindow * dw, bool accept ) + + + + Q3DockWindow + q3dockwindow.html + + CloseMode + CloseMode-enum + + + + Place + Place-enum + + + + Q3DockWindow + Q3DockWindow + ( Place p = InDock, QWidget * parent = 0, const char * name = 0, Qt::WFlags f = 0 ) + + + Q3DockWindow + Q3DockWindow-2 + ( QWidget * parent, const char * name = 0, Qt::WFlags f = 0 ) + + + area + area + () + + + boxLayout + boxLayout + () + + + dock + dock + () + + + fixedExtent + fixedExtent + () + + + isCloseEnabled + isCloseEnabled + () + + + isHorizontalStretchable + isHorizontalStretchable + () + + + isVerticalStretchable + isVerticalStretchable + () + + + Orientation + orientation + Q3DockWindow::orientation() + + + orientationChanged + orientationChanged + ( Qt::Orientation o ) + + + placeChanged + placeChanged + ( Q3DockWindow::Place p ) + + + setFixedExtentHeight + setFixedExtentHeight + ( int h ) + + + setFixedExtentWidth + setFixedExtentWidth + ( int w ) + + + setHorizontalStretchable + setHorizontalStretchable + ( bool b ) + + + setOrientation + setOrientation + ( Qt::Orientation o ) + + + setVerticalStretchable + setVerticalStretchable + ( bool b ) + + + setWidget + setWidget + ( QWidget * w ) + + + undock + undock + ( QWidget * widget ) + + + undock + undock-2 + () + + + visibilityChanged + visibilityChanged + ( bool visible ) + + + widget + widget + () + + + windowTitle + windowTitle + () + + + + Q3DragObject + q3dragobject.html + + DragMode + DragMode-enum + + + + Q3DragObject + Q3DragObject + ( QWidget * dragSource = 0, const char * name = 0 ) + + + drag + drag + () + + + drag + drag-2 + ( DragMode mode ) + + + dragCopy + dragCopy + () + + + dragLink + dragLink + () + + + dragMove + dragMove + () + + + pixmap + pixmap + () + + + pixmapHotSpot + pixmapHotSpot + () + + + setPixmap + setPixmap + ( QPixmap pm, const QPoint & hotspot ) + + + setPixmap + setPixmap-2 + ( QPixmap pm ) + + + source + source + () + + + target + target + () + + + + Q3DropSite + q3dropsite.html + + Q3DropSite + Q3DropSite + ( QWidget * self ) + + + + Q3EditorFactory + q3editorfactory.html + + Q3EditorFactory + Q3EditorFactory + ( QObject * parent = 0 ) + + + createEditor + createEditor + ( QWidget * parent, const QVariant & v ) + + + defaultFactory + defaultFactory + () + + + installDefaultFactory + installDefaultFactory + ( Q3EditorFactory * factory ) + + + + Q3FileDialog + q3filedialog.html + + Mode + Mode-enum + + + + PreviewMode + PreviewMode-enum + + + + ViewMode + ViewMode-enum + + + + Q3FileDialog + Q3FileDialog + ( const QString & dirName, const QString & filter = QString() + + + Q3FileDialog + Q3FileDialog-2 + ( QWidget * parent = 0, const char * name = 0, bool modal = false ) + + + addFilter + addFilter + ( const QString & filter ) + + + addLeftWidget + addLeftWidget + ( QWidget * w ) + + + addRightWidget + addRightWidget + ( QWidget * w ) + + + addToolButton + addToolButton + ( QAbstractButton * b, bool separator = false ) + + + addWidgets + addWidgets + ( QLabel * l, QWidget * w, QPushButton * b ) + + + dir + dir + () + + + dirEntered + dirEntered + ( const QString & directory ) + + + fileHighlighted + fileHighlighted + ( const QString & file ) + + + fileSelected + fileSelected + ( const QString & file ) + + + filesSelected + filesSelected + ( const QStringList & files ) + + + filterSelected + filterSelected + ( const QString & filter ) + + + getExistingDirectory + getExistingDirectory + ( const QString & dir = QString() + + + getOpenFileName + getOpenFileName + ( const QString & startWith = QString() + + + getOpenFileNames + getOpenFileNames + ( const QString & filter = QString() + + + getSaveFileName + getSaveFileName + ( const QString & startWith = QString() + + + iconProvider + iconProvider + () + + + rereadDir + rereadDir + () + + + resortDir + resortDir + () + + + selectAll + selectAll + ( bool b ) + + + setContentsPreview + setContentsPreview + ( QWidget * w, Q3FilePreview * preview ) + + + setDir + setDir + ( const QDir & dir ) + + + setDir + setDir-2 + ( const QString & pathstr ) + + + setFilter + setFilter + ( const QString & newFilter ) + + + setFilters + setFilters + ( const QString & filters ) + + + setFilters + setFilters-2 + ( const char ** types ) + + + setFilters + setFilters-3 + ( const QStringList & types ) + + + setIconProvider + setIconProvider + ( Q3FileIconProvider * provider ) + + + setInfoPreview + setInfoPreview + ( QWidget * w, Q3FilePreview * preview ) + + + setSelectedFilter + setSelectedFilter + ( const QString & mask ) + + + setSelectedFilter + setSelectedFilter-2 + ( int n ) + + + setSelection + setSelection + ( const QString & filename ) + + + setUrl + setUrl + ( const Q3UrlOperator & url ) + + + url + url + () + + + + Q3FileIconProvider + q3fileiconprovider.html + + Q3FileIconProvider + Q3FileIconProvider + ( QObject * parent = 0, const char * name = 0 ) + + + pixmap + pixmap + ( const QFileInfo & info ) + + + + Q3FilePreview + q3filepreview.html + + Q3FilePreview + Q3FilePreview + () + + + previewUrl + previewUrl + ( const Q3Url & url ) + + + + Q3Frame + q3frame.html + + Q3Frame + Q3Frame + ( QWidget * parent, const char * name = 0, Qt::WFlags f = 0 ) + + + drawContents + drawContents + ( QPainter * painter ) + + + drawFrame + drawFrame + ( QPainter * p ) + + + frameChanged + frameChanged + () + + + frameWidth + frameWidth + () + + + paintEvent + paintEvent + ( QPaintEvent * event ) + + + resizeEvent + resizeEvent + ( QResizeEvent * event ) + + + + Q3Ftp + q3ftp.html + + Command + Command-enum + + + + Error + Error-enum + + + + State + State-enum + + + + Q3Ftp + Q3Ftp + () + + + Q3Ftp + Q3Ftp-2 + ( QObject * parent, const char * name = 0 ) + + + abort + abort + () + + + bytesAvailable + bytesAvailable + () + + + cd + cd + ( const QString & dir ) + + + clearPendingCommands + clearPendingCommands + () + + + close + close + () + + + commandFinished + commandFinished + ( int id, bool error ) + + + commandStarted + commandStarted + ( int id ) + + + connectToHost + connectToHost + ( const QString & host, Q_UINT16 port = 21 ) + + + currentCommand + currentCommand + () + + + currentDevice + currentDevice + () + + + currentId + currentId + () + + + dataTransferProgress + dataTransferProgress + ( int done, int total ) + + + done + done + ( bool error ) + + + error + error + () + + + errorString + errorString + () + + + get + get + ( const QString & file, QIODevice * dev = 0 ) + + + hasPendingCommands + hasPendingCommands + () + + + list + list + ( const QString & dir = QString() + + + listInfo + listInfo + ( const QUrlInfo & i ) + + + login + login + ( const QString & user = QString() + + + mkdir + mkdir + ( const QString & dir ) + + + put + put + ( QIODevice * dev, const QString & file ) + + + put + put-2 + ( const QByteArray & data, const QString & file ) + + + rawCommand + rawCommand + ( const QString & command ) + + + rawCommandReply + rawCommandReply + ( int replyCode, const QString & detail ) + + + readAll + readAll + () + + + readBlock + readBlock + ( char * data, Q_ULONG maxlen ) + + + readyRead + readyRead + () + + + remove + remove + ( const QString & file ) + + + rename + rename + ( const QString & oldname, const QString & newname ) + + + rmdir + rmdir + ( const QString & dir ) + + + state + state + () + + + stateChanged + stateChanged + ( int state ) + + + + Q3Grid + q3grid.html + + Q3Grid + Q3Grid + ( int n, QWidget * parent = 0, const char * name = 0, Qt::WFlags f = 0 ) + + + Q3Grid + Q3Grid-2 + ( int n, Qt::Orientation orient, QWidget * parent = 0, const char * name = 0, Qt::WFlags f = 0 ) + + + setSpacing + setSpacing + ( int space ) + + + + Q3GridView + q3gridview.html + + Q3GridView + Q3GridView + ( QWidget * parent = 0, const char * name = 0, Qt::WFlags f = 0 ) + + + cellGeometry + cellGeometry + ( int row, int column ) + + + cellRect + cellRect + () + + + columnAt + columnAt + ( int x ) + + + dimensionChange + dimensionChange + ( int oldNumRows, int oldNumCols ) + + + ensureCellVisible + ensureCellVisible + ( int row, int column ) + + + gridSize + gridSize + () + + + paintCell + paintCell + ( QPainter * p, int row, int col ) + + + paintEmptyArea + paintEmptyArea + ( QPainter * p, int cx, int cy, int cw, int ch ) + + + repaintCell + repaintCell + ( int row, int column, bool erase = true ) + + + rowAt + rowAt + ( int y ) + + + updateCell + updateCell + ( int row, int column ) + + + + Q3GroupBox + q3groupbox.html + + Orientation + orientation-prop + + + + Q3GroupBox + Q3GroupBox + ( QWidget * parent = 0, const char * name = 0 ) + + + Q3GroupBox + Q3GroupBox-2 + ( const QString & title, QWidget * parent = 0, const char * name = 0 ) + + + Q3GroupBox + Q3GroupBox-3 + ( int strips, Qt::Orientation orientation, QWidget * parent = 0, const char * name = 0 ) + + + Q3GroupBox + Q3GroupBox-4 + ( int strips, Qt::Orientation orientation, const QString & title, QWidget * parent = 0, const char * name = 0 ) + + + addSpace + addSpace + ( int size ) + + + insideMargin + insideMargin + () + + + insideSpacing + insideSpacing + () + + + setColumnLayout + setColumnLayout + ( int strips, Qt::Orientation direction ) + + + setInsideMargin + setInsideMargin + ( int m ) + + + setInsideSpacing + setInsideSpacing + ( int s ) + + + + Q3HBox + q3hbox.html + + Q3HBox + Q3HBox + ( QWidget * parent = 0, const char * name = 0, Qt::WFlags f = 0 ) + + + Q3HBox + Q3HBox-2 + ( bool horizontal, QWidget * parent, const char * name, Qt::WFlags f = 0 ) + + + setSpacing + setSpacing + ( int space ) + + + setStretchFactor + setStretchFactor + ( QWidget * w, int stretch ) + + + + Q3HButtonGroup + q3hbuttongroup.html + + Q3HButtonGroup + Q3HButtonGroup + ( QWidget * parent = 0, const char * name = 0 ) + + + Q3HButtonGroup + Q3HButtonGroup-2 + ( const QString & title, QWidget * parent = 0, const char * name = 0 ) + + + + Q3Header + q3header.html + + Orientation + orientation-prop + + + + Q3Header + Q3Header + ( QWidget * parent = 0, const char * name = 0 ) + + + Q3Header + Q3Header-2 + ( int n, QWidget * parent = 0, const char * name = 0 ) + + + addLabel + addLabel + ( const QString & s, int size = -1 ) + + + addLabel + addLabel-2 + ( const QIcon & icon, const QString & s, int size = -1 ) + + + adjustHeaderSize + adjustHeaderSize + () + + + cellAt + cellAt + ( int pos ) + + + cellPos + cellPos + ( int i ) + + + cellSize + cellSize + ( int i ) + + + clicked + clicked + ( int section ) + + + headerWidth + headerWidth + () + + + iconSet + iconSet + ( int section ) + + + indexChange + indexChange + ( int section, int fromIndex, int toIndex ) + + + isClickEnabled + isClickEnabled + ( int section = -1 ) + + + isResizeEnabled + isResizeEnabled + ( int section = -1 ) + + + label + label + ( int section ) + + + mapToActual + mapToActual + ( int l ) + + + mapToIndex + mapToIndex + ( int section ) + + + mapToLogical + mapToLogical + ( int a ) + + + mapToSection + mapToSection + ( int index ) + + + moveCell + moveCell + ( int fromIdx, int toIdx ) + + + moveSection + moveSection + ( int section, int toIndex ) + + + moved + moved + ( int fromIndex, int toIndex ) + + + paintSection + paintSection + ( QPainter * p, int index, const QRect & fr ) + + + paintSectionLabel + paintSectionLabel + ( QPainter * p, int index, const QRect & fr ) + + + pressed + pressed + ( int section ) + + + released + released + ( int section ) + + + removeLabel + removeLabel + ( int section ) + + + resizeSection + resizeSection + ( int section, int s ) + + + sRect + sRect + ( int index ) + + + sectionAt + sectionAt + ( int pos ) + + + sectionClicked + sectionClicked + ( int index ) + + + sectionHandleDoubleClicked + sectionHandleDoubleClicked + ( int section ) + + + sectionPos + sectionPos + ( int section ) + + + sectionRect + sectionRect + ( int section ) + + + sectionSize + sectionSize + ( int section ) + + + setCellSize + setCellSize + ( int section, int s ) + + + setClickEnabled + setClickEnabled + ( bool enable, int section = -1 ) + + + setLabel + setLabel + ( int section, const QString & s, int size = -1 ) + + + setLabel + setLabel-2 + ( int section, const QIcon & icon, const QString & s, int size = -1 ) + + + setResizeEnabled + setResizeEnabled + ( bool enable, int section = -1 ) + + + setSortIndicator + setSortIndicator + ( int section, Qt::SortOrder order ) + + + setSortIndicator + setSortIndicator-2 + ( int section, bool ascending = true ) + + + sizeChange + sizeChange + ( int section, int oldSize, int newSize ) + + + SortOrder + sortIndicatorOrder + Q3Header::sortIndicatorOrder() + + + sortIndicatorSection + sortIndicatorSection + () + + + + Q3HttpHeader + q3httpheader.html + + Q3HttpHeader + Q3HttpHeader + () + + + Q3HttpHeader + Q3HttpHeader-2 + ( const Q3HttpHeader & header ) + + + Q3HttpHeader + Q3HttpHeader-3 + ( const QString & str ) + + + contentLength + contentLength + () + + + contentType + contentType + () + + + hasContentLength + hasContentLength + () + + + hasContentType + hasContentType + () + + + hasKey + hasKey + ( const QString & key ) + + + isValid + isValid + () + + + keys + keys + () + + + majorVersion + majorVersion + () + + + minorVersion + minorVersion + () + + + removeValue + removeValue + ( const QString & key ) + + + setContentLength + setContentLength + ( int len ) + + + setContentType + setContentType + ( const QString & type ) + + + setValue + setValue + ( const QString & key, const QString & value ) + + + toString + toString + () + + + value + value + ( const QString & key ) + + + operator= + operator-eq + ( const Q3HttpHeader & h ) + + + + Q3Http + q3http.html + + Error + Error-enum + + + + State + State-enum + + + + Q3Http + Q3Http + () + + + Q3Http + Q3Http-2 + ( QObject * parent, const char * name = 0 ) + + + Q3Http + Q3Http-3 + ( const QString & hostname, Q_UINT16 port = 80, QObject * parent = 0, const char * name = 0 ) + + + abort + abort + () + + + bytesAvailable + bytesAvailable + () + + + clearPendingRequests + clearPendingRequests + () + + + closeConnection + closeConnection + () + + + currentDestinationDevice + currentDestinationDevice + () + + + currentId + currentId + () + + + currentRequest + currentRequest + () + + + currentSourceDevice + currentSourceDevice + () + + + dataReadProgress + dataReadProgress + ( int done, int total ) + + + dataSendProgress + dataSendProgress + ( int done, int total ) + + + done + done + ( bool error ) + + + error + error + () + + + errorString + errorString + () + + + get + get + ( const QString & path, QIODevice * to = 0 ) + + + hasPendingRequests + hasPendingRequests + () + + + head + head + ( const QString & path ) + + + post + post + ( const QString & path, QIODevice * data, QIODevice * to = 0 ) + + + post + post-2 + ( const QString & path, const QByteArray & data, QIODevice * to = 0 ) + + + readAll + readAll + () + + + readBlock + readBlock + ( char * data, Q_ULONG maxlen ) + + + readyRead + readyRead + ( const Q3HttpResponseHeader & resp ) + + + request + request + ( const Q3HttpRequestHeader & header, QIODevice * data = 0, QIODevice * to = 0 ) + + + request + request-2 + ( const Q3HttpRequestHeader & header, const QByteArray & data, QIODevice * to = 0 ) + + + requestFinished + requestFinished + ( int id, bool error ) + + + requestStarted + requestStarted + ( int id ) + + + responseHeaderReceived + responseHeaderReceived + ( const Q3HttpResponseHeader & resp ) + + + setHost + setHost + ( const QString & hostname, Q_UINT16 port = 80 ) + + + state + state + () + + + stateChanged + stateChanged + ( int state ) + + + + Q3HttpRequestHeader + q3httprequestheader.html + + Q3HttpRequestHeader + Q3HttpRequestHeader + () + + + Q3HttpRequestHeader + Q3HttpRequestHeader-2 + ( const QString & method, const QString & path, int majorVer = 1, int minorVer = 1 ) + + + Q3HttpRequestHeader + Q3HttpRequestHeader-3 + ( const Q3HttpRequestHeader & header ) + + + Q3HttpRequestHeader + Q3HttpRequestHeader-4 + ( const QString & str ) + + + majorVersion + majorVersion + () + + + method + method + () + + + minorVersion + minorVersion + () + + + path + path + () + + + setRequest + setRequest + ( const QString & method, const QString & path, int majorVer = 1, int minorVer = 1 ) + + + + Q3HttpResponseHeader + q3httpresponseheader.html + + Q3HttpResponseHeader + Q3HttpResponseHeader-3 + () + + + Q3HttpResponseHeader + Q3HttpResponseHeader-4 + ( const Q3HttpResponseHeader & header ) + + + majorVersion + majorVersion + () + + + minorVersion + minorVersion + () + + + reasonPhrase + reasonPhrase + () + + + statusCode + statusCode + () + + + + Q3IconDrag + q3icondrag.html + + Q3IconDrag + Q3IconDrag + ( QWidget * dragSource, const char * name = 0 ) + + + append + append + ( const Q3IconDragItem & i, const QRect & pr, const QRect & tr ) + + + canDecode + canDecode + ( QMimeSource * e ) + + + encodedData + encodedData + ( const char * mime ) + + + + Q3IconDragItem + q3icondragitem.html + + Q3IconDragItem + Q3IconDragItem + () + + + data + data + () + + + setData + setData + ( const QByteArray & d ) + + + + Q3IconView + q3iconview.html + + Arrangement + Arrangement-enum + + + + ComparisonFlags + ComparisonFlags-typedef + + + + ItemTextPos + ItemTextPos-enum + + + + ResizeMode + ResizeMode-enum + + + + SelectionMode + SelectionMode-enum + + + + StringComparisonMode + StringComparisonMode-enum + + + + Q3IconView + Q3IconView + ( QWidget * parent = 0, const char * name = 0, Qt::WFlags f = 0 ) + + + adjustItems + adjustItems + () + + + arrangeItemsInGrid + arrangeItemsInGrid + ( const QSize & grid, bool update = true ) + + + arrangeItemsInGrid + arrangeItemsInGrid-2 + ( bool update = true ) + + + clear + clear + () + + + clearSelection + clearSelection + () + + + clicked + clicked + ( Q3IconViewItem * item ) + + + clicked + clicked-2 + ( Q3IconViewItem * item, const QPoint & pos ) + + + contextMenuRequested + contextMenuRequested + ( Q3IconViewItem * item, const QPoint & pos ) + + + currentChanged + currentChanged + ( Q3IconViewItem * item ) + + + currentItem + currentItem + () + + + doAutoScroll + doAutoScroll + () + + + doubleClicked + doubleClicked + ( Q3IconViewItem * item ) + + + dragObject + dragObject + () + + + drawBackground + drawBackground + ( QPainter * p, const QRect & r ) + + + drawRubber + drawRubber + ( QPainter * p ) + + + dropped + dropped + ( QDropEvent * e, const Q3ValueList<Q3IconDragItem> & lst ) + + + emitSelectionChanged + emitSelectionChanged + ( Q3IconViewItem * i = 0 ) + + + ensureItemVisible + ensureItemVisible + ( Q3IconViewItem * item ) + + + findFirstVisibleItem + findFirstVisibleItem + ( const QRect & r ) + + + findItem + findItem + ( const QPoint & pos ) + + + findItem + findItem-3 + ( const QString & text, ComparisonFlags compare = BeginsWith | Qt::CaseSensitive ) + + + findLastVisibleItem + findLastVisibleItem + ( const QRect & r ) + + + firstItem + firstItem + () + + + index + index + ( const Q3IconViewItem * item ) + + + insertInGrid + insertInGrid + ( Q3IconViewItem * item ) + + + insertItem + insertItem + ( Q3IconViewItem * item, Q3IconViewItem * after = 0L ) + + + invertSelection + invertSelection + () + + + isRenaming + isRenaming + () + + + itemRenamed + itemRenamed + ( Q3IconViewItem * item, const QString & name ) + + + itemRenamed + itemRenamed-2 + ( Q3IconViewItem * item ) + + + lastItem + lastItem + () + + + makeRowLayout + makeRowLayout + ( Q3IconViewItem * begin, int & y, bool & changed ) + + + mouseButtonClicked + mouseButtonClicked + ( int button, Q3IconViewItem * item, const QPoint & pos ) + + + mouseButtonPressed + mouseButtonPressed + ( int button, Q3IconViewItem * item, const QPoint & pos ) + + + moved + moved + () + + + onItem + onItem + ( Q3IconViewItem * item ) + + + onViewport + onViewport + () + + + pressed + pressed + ( Q3IconViewItem * item ) + + + pressed + pressed-2 + ( Q3IconViewItem * item, const QPoint & pos ) + + + repaintItem + repaintItem + ( Q3IconViewItem * item ) + + + repaintSelectedItems + repaintSelectedItems + () + + + returnPressed + returnPressed + ( Q3IconViewItem * item ) + + + rightButtonClicked + rightButtonClicked + ( Q3IconViewItem * item, const QPoint & pos ) + + + rightButtonPressed + rightButtonPressed + ( Q3IconViewItem * item, const QPoint & pos ) + + + selectAll + selectAll + ( bool select ) + + + selectionChanged + selectionChanged + () + + + selectionChanged + selectionChanged-2 + ( Q3IconViewItem * item ) + + + setCurrentItem + setCurrentItem + ( Q3IconViewItem * item ) + + + setSelected + setSelected + ( Q3IconViewItem * item, bool s, bool cb = false ) + + + setSorting + setSorting + ( bool sort, bool ascending = true ) + + + slotUpdate + slotUpdate + () + + + sort + sort + ( bool ascending = true ) + + + startDrag + startDrag + () + + + takeItem + takeItem + ( Q3IconViewItem * item ) + + + + Q3IconViewItem + q3iconviewitem.html + + Q3IconViewItem + Q3IconViewItem + ( Q3IconView * parent ) + + + Q3IconViewItem + Q3IconViewItem-2 + ( Q3IconView * parent, Q3IconViewItem * after ) + + + Q3IconViewItem + Q3IconViewItem-3 + ( Q3IconView * parent, const QString & text ) + + + Q3IconViewItem + Q3IconViewItem-4 + ( Q3IconView * parent, Q3IconViewItem * after, const QString & text ) + + + Q3IconViewItem + Q3IconViewItem-5 + ( Q3IconView * parent, const QString & text, const QPixmap & icon ) + + + Q3IconViewItem + Q3IconViewItem-6 + ( Q3IconView * parent, Q3IconViewItem * after, const QString & text, const QPixmap & icon ) + + + Q3IconViewItem + Q3IconViewItem-7 + ( Q3IconView * parent, const QString & text, const QPicture & picture ) + + + Q3IconViewItem + Q3IconViewItem-8 + ( Q3IconView * parent, Q3IconViewItem * after, const QString & text, const QPicture & picture ) + + + acceptDrop + acceptDrop + ( const QMimeSource * mime ) + + + calcRect + calcRect + ( const QString & text_ = QString() + + + compare + compare + ( Q3IconViewItem * i ) + + + contains + contains + ( const QPoint & pnt ) + + + dragEnabled + dragEnabled + () + + + dragEntered + dragEntered + () + + + dragLeft + dragLeft + () + + + dropEnabled + dropEnabled + () + + + dropped + dropped + ( QDropEvent * e, const Q3ValueList<Q3IconDragItem> & lst ) + + + height + height + () + + + iconView + iconView + () + + + index + index + () + + + intersects + intersects + ( const QRect & r ) + + + isSelectable + isSelectable + () + + + isSelected + isSelected + () + + + key + key + () + + + move + move + ( int x, int y ) + + + move + move-2 + ( const QPoint & pnt ) + + + moveBy + moveBy + ( int dx, int dy ) + + + moveBy + moveBy-2 + ( const QPoint & pnt ) + + + nextItem + nextItem + () + + + paintFocus + paintFocus + ( QPainter * p, const QColorGroup & cg ) + + + paintItem + paintItem + ( QPainter * p, const QColorGroup & cg ) + + + picture + picture + () + + + pixmap + pixmap + () + + + pixmapRect + pixmapRect + ( bool relative = true ) + + + pos + pos + () + + + prevItem + prevItem + () + + + rect + rect + () + + + removeRenameBox + removeRenameBox + () + + + rename + rename + () + + + renameEnabled + renameEnabled + () + + + repaint + repaint + () + + + rtti + rtti + () + + + setDragEnabled + setDragEnabled + ( bool allow ) + + + setDropEnabled + setDropEnabled + ( bool allow ) + + + setItemRect + setItemRect + ( const QRect & r ) + + + setKey + setKey + ( const QString & k ) + + + setPicture + setPicture + ( const QPicture & icon ) + + + setPixmap + setPixmap + ( const QPixmap & icon ) + + + setPixmap + setPixmap-2 + ( const QPixmap & icon, bool recalc, bool redraw = true ) + + + setPixmapRect + setPixmapRect + ( const QRect & r ) + + + setRenameEnabled + setRenameEnabled + ( bool allow ) + + + setSelectable + setSelectable + ( bool enable ) + + + setSelected + setSelected + ( bool s, bool cb ) + + + setSelected + setSelected-2 + ( bool s ) + + + setText + setText + ( const QString & text ) + + + setText + setText-2 + ( const QString & text, bool recalc, bool redraw = true ) + + + setTextRect + setTextRect + ( const QRect & r ) + + + size + size + () + + + text + text + () + + + textRect + textRect + ( bool relative = true ) + + + width + width + () + + + x + x + () + + + y + y + () + + + + Q3ImageDrag + q3imagedrag.html + + Q3ImageDrag + Q3ImageDrag + ( QImage image, QWidget * dragSource = 0, const char * name = 0 ) + + + Q3ImageDrag + Q3ImageDrag-2 + ( QWidget * dragSource = 0, const char * name = 0 ) + + + canDecode + canDecode + ( const QMimeSource * source ) + + + decode + decode + ( const QMimeSource * source, QImage & image ) + + + decode + decode-2 + ( const QMimeSource * source, QPixmap & pixmap ) + + + setImage + setImage + ( QImage image ) + + + + Q3IntCache + q3intcache.html + + Q3IntCache + Q3IntCache-2 + ( int maxCost = 100, int size = 17 ) + + + clear + clear + () + + + count + count + () + + + find + find + ( long k, bool ref = true ) + + + insert + insert + ( long k, const type * d, int c = 1, int p = 0 ) + + + isEmpty + isEmpty + () + + + maxCost + maxCost + () + + + remove + remove + ( long k ) + + + setMaxCost + setMaxCost + ( int m ) + + + size + size + () + + + statistics + statistics + () + + + take + take + ( long k ) + + + totalCost + totalCost + () + + + operator[] + operator-5b-5d + ( long k ) + + + + Q3IntCacheIterator + q3intcacheiterator.html + + Q3IntCacheIterator + Q3IntCacheIterator + ( const Q3IntCache<type> & cache ) + + + Q3IntCacheIterator + Q3IntCacheIterator-2 + ( const Q3IntCacheIterator<type> & ci ) + + + atFirst + atFirst + () + + + atLast + atLast + () + + + count + count + () + + + current + current + () + + + currentKey + currentKey + () + + + isEmpty + isEmpty + () + + + toFirst + toFirst + () + + + toLast + toLast + () + + + operator + operator-type--2a + type *() + + + operator() + operator-28-29 + () + + + operator++ + operator-2b-2b + () + + + operator+= + operator-2b-eq + ( uint jump ) + + + operator-- + operator-- + () + + + operator-= + operator--eq + ( uint jump ) + + + operator= + operator-eq + ( const Q3IntCacheIterator<type> & ci ) + + + + Q3IntDict + q3intdict.html + + Q3IntDict + Q3IntDict + ( int size = 17 ) + + + Q3IntDict + Q3IntDict-2 + ( const Q3IntDict<type> & dict ) + + + clear + clear + () + + + count + count + () + + + find + find + ( long key ) + + + insert + insert + ( long key, const type * item ) + + + isEmpty + isEmpty + () + + + read + read + ( QDataStream & s, Q3PtrCollection::Item & item ) + + + remove + remove + ( long key ) + + + replace + replace + ( long key, const type * item ) + + + resize + resize + ( uint newsize ) + + + size + size + () + + + statistics + statistics + () + + + take + take + ( long key ) + + + write + write + ( QDataStream & s, Q3PtrCollection::Item item ) + + + operator= + operator-eq + ( const Q3IntDict<type> & dict ) + + + operator[] + operator-5b-5d + ( long key ) + + + + Q3IntDictIterator + q3intdictiterator.html + + Q3IntDictIterator + Q3IntDictIterator + ( const Q3IntDict<type> & dict ) + + + count + count + () + + + current + current + () + + + currentKey + currentKey + () + + + isEmpty + isEmpty + () + + + toFirst + toFirst + () + + + operator + operator-type--2a + type *() + + + operator() + operator-28-29 + () + + + operator++ + operator-2b-2b + () + + + operator+= + operator-2b-eq + ( uint jump ) + + + + Q3ListBox + q3listbox.html + + ComparisonFlags + ComparisonFlags-typedef + + + + LayoutMode + LayoutMode-enum + + + + SelectionMode + SelectionMode-enum + + + + StringComparisonMode + StringComparisonMode-enum + + + + Q3ListBox + Q3ListBox + ( QWidget * parent = 0, const char * name = 0, Qt::WFlags f = 0 ) + + + autoBottomScrollBar + autoBottomScrollBar + () + + + autoScroll + autoScroll + () + + + autoScrollBar + autoScrollBar + () + + + autoUpdate + autoUpdate + () + + + bottomScrollBar + bottomScrollBar + () + + + cellHeight + cellHeight + ( int i ) + + + cellHeight + cellHeight-2 + () + + + cellWidth + cellWidth + () + + + cellWidth + cellWidth-2 + ( int i ) + + + centerCurrentItem + centerCurrentItem + () + + + changeItem + changeItem + ( const Q3ListBoxItem * lbi, int index ) + + + changeItem + changeItem-2 + ( const QString & text, int index ) + + + changeItem + changeItem-3 + ( const QPixmap & pixmap, int index ) + + + changeItem + changeItem-4 + ( const QPixmap & pixmap, const QString & text, int index ) + + + clear + clear + () + + + clearSelection + clearSelection + () + + + clicked + clicked + ( Q3ListBoxItem * item ) + + + clicked + clicked-2 + ( Q3ListBoxItem * item, const QPoint & pnt ) + + + contextMenuRequested + contextMenuRequested + ( Q3ListBoxItem * item, const QPoint & pos ) + + + currentChanged + currentChanged + ( Q3ListBoxItem * item ) + + + doLayout + doLayout + () + + + doubleClicked + doubleClicked + ( Q3ListBoxItem * item ) + + + dragSelect + dragSelect + () + + + ensureCurrentVisible + ensureCurrentVisible + () + + + findItem + findItem + ( const QString & text, ComparisonFlags compare = BeginsWith ) + + + findItem + findItem-2 + ( int yPos ) + + + firstItem + firstItem + () + + + highlighted + highlighted + ( int index ) + + + highlighted + highlighted-2 + ( Q3ListBoxItem * item ) + + + highlighted + highlighted-3 + ( const QString & text ) + + + inSort + inSort + ( const Q3ListBoxItem * lbi ) + + + inSort + inSort-2 + ( const QString & text ) + + + index + index + ( const Q3ListBoxItem * lbi ) + + + insertItem + insertItem + ( const Q3ListBoxItem * lbi, int index = -1 ) + + + insertItem + insertItem-2 + ( const Q3ListBoxItem * lbi, const Q3ListBoxItem * after ) + + + insertItem + insertItem-3 + ( const QString & text, int index = -1 ) + + + insertItem + insertItem-4 + ( const QPixmap & pixmap, int index = -1 ) + + + insertItem + insertItem-5 + ( const QPixmap & pixmap, const QString & text, int index = -1 ) + + + insertStrList + insertStrList + ( const char ** strings, int numStrings = -1, int index = -1 ) + + + insertStringList + insertStringList + ( const QStringList & list, int index = -1 ) + + + invertSelection + invertSelection + () + + + isRubberSelecting + isRubberSelecting + () + + + isSelected + isSelected + ( int i ) + + + isSelected + isSelected-2 + ( const Q3ListBoxItem * i ) + + + item + item + ( int index ) + + + itemAt + itemAt + ( const QPoint & p ) + + + itemHeight + itemHeight + ( int index = 0 ) + + + itemRect + itemRect + ( Q3ListBoxItem * item ) + + + itemVisible + itemVisible + ( int index ) + + + itemVisible + itemVisible-2 + ( const Q3ListBoxItem * item ) + + + maxItemWidth + maxItemWidth + () + + + mouseButtonClicked + mouseButtonClicked + ( int button, Q3ListBoxItem * item, const QPoint & pos ) + + + mouseButtonPressed + mouseButtonPressed + ( int button, Q3ListBoxItem * item, const QPoint & pos ) + + + numCols + numCols + () + + + onItem + onItem + ( Q3ListBoxItem * i ) + + + onViewport + onViewport + () + + + paintCell + paintCell + ( QPainter * p, int row, int col ) + + + pixmap + pixmap + ( int index ) + + + pressed + pressed + ( Q3ListBoxItem * item ) + + + pressed + pressed-2 + ( Q3ListBoxItem * item, const QPoint & pnt ) + + + removeItem + removeItem + ( int index ) + + + returnPressed + returnPressed + ( Q3ListBoxItem * item ) + + + rightButtonClicked + rightButtonClicked + ( Q3ListBoxItem * item, const QPoint & point ) + + + rightButtonPressed + rightButtonPressed + ( Q3ListBoxItem * item, const QPoint & point ) + + + scrollBar + scrollBar + () + + + selectAll + selectAll + ( bool select ) + + + selected + selected + ( int index ) + + + selected + selected-2 + ( Q3ListBoxItem * item ) + + + selected + selected-3 + ( const QString & text ) + + + selectedItem + selectedItem + () + + + selectionChanged + selectionChanged + () + + + selectionChanged + selectionChanged-2 + ( Q3ListBoxItem * item ) + + + setAutoBottomScrollBar + setAutoBottomScrollBar + ( bool enable ) + + + setAutoScroll + setAutoScroll + ( bool b ) + + + setAutoScrollBar + setAutoScrollBar + ( bool enable ) + + + setAutoUpdate + setAutoUpdate + ( bool b ) + + + setBottomItem + setBottomItem + ( int index ) + + + setBottomScrollBar + setBottomScrollBar + ( bool enable ) + + + setDragSelect + setDragSelect + ( bool b ) + + + setFixedVisibleLines + setFixedVisibleLines + ( int lines ) + + + setScrollBar + setScrollBar + ( bool enable ) + + + setSelected + setSelected + ( Q3ListBoxItem * item, bool select ) + + + setSelected + setSelected-2 + ( int index, bool select ) + + + setSmoothScrolling + setSmoothScrolling + ( bool b ) + + + smoothScrolling + smoothScrolling + () + + + sort + sort + ( bool ascending = true ) + + + takeItem + takeItem + ( const Q3ListBoxItem * item ) + + + text + text + ( int index ) + + + toggleCurrentItem + toggleCurrentItem + () + + + totalHeight + totalHeight + () + + + totalWidth + totalWidth + () + + + triggerUpdate + triggerUpdate + ( bool doLayout ) + + + updateCellWidth + updateCellWidth + () + + + updateItem + updateItem + ( int index ) + + + updateItem + updateItem-2 + ( Q3ListBoxItem * i ) + + + + Q3ListBoxItem + q3listboxitem.html + + Q3ListBoxItem + Q3ListBoxItem + ( Q3ListBox * listbox = 0 ) + + + Q3ListBoxItem + Q3ListBoxItem-2 + ( Q3ListBox * listbox, Q3ListBoxItem * after ) + + + current + current + () + + + height + height + ( const Q3ListBox * lb ) + + + isCurrent + isCurrent + () + + + isSelectable + isSelectable + () + + + isSelected + isSelected + () + + + listBox + listBox + () + + + next + next + () + + + paint + paint + ( QPainter * p ) + + + pixmap + pixmap + () + + + prev + prev + () + + + rtti + rtti + () + + + selected + selected + () + + + setCustomHighlighting + setCustomHighlighting + ( bool b ) + + + setSelectable + setSelectable + ( bool b ) + + + setText + setText + ( const QString & text ) + + + text + text + () + + + width + width + ( const Q3ListBox * lb ) + + + + Q3ListBoxPixmap + q3listboxpixmap.html + + Q3ListBoxPixmap + Q3ListBoxPixmap + ( Q3ListBox * listbox, const QPixmap & pixmap ) + + + Q3ListBoxPixmap + Q3ListBoxPixmap-2 + ( const QPixmap & pixmap ) + + + Q3ListBoxPixmap + Q3ListBoxPixmap-3 + ( Q3ListBox * listbox, const QPixmap & pixmap, Q3ListBoxItem * after ) + + + Q3ListBoxPixmap + Q3ListBoxPixmap-4 + ( Q3ListBox * listbox, const QPixmap & pix, const QString & text ) + + + Q3ListBoxPixmap + Q3ListBoxPixmap-5 + ( const QPixmap & pix, const QString & text ) + + + Q3ListBoxPixmap + Q3ListBoxPixmap-6 + ( Q3ListBox * listbox, const QPixmap & pix, const QString & text, Q3ListBoxItem * after ) + + + height + height + ( const Q3ListBox * lb ) + + + paint + paint + ( QPainter * painter ) + + + pixmap + pixmap + () + + + width + width + ( const Q3ListBox * lb ) + + + + Q3ListBoxText + q3listboxtext.html + + Q3ListBoxText + Q3ListBoxText + ( Q3ListBox * listbox, const QString & text = QString() + + + Q3ListBoxText + Q3ListBoxText-2 + ( const QString & text = QString() + + + Q3ListBoxText + Q3ListBoxText-3 + ( Q3ListBox * listbox, const QString & text, Q3ListBoxItem * after ) + + + height + height + ( const Q3ListBox * lb ) + + + paint + paint + ( QPainter * painter ) + + + width + width + ( const Q3ListBox * lb ) + + + + Q3ListView + q3listview.html + + ComparisonFlags + ComparisonFlags-typedef + + + + RenameAction + RenameAction-enum + + + + ResizeMode + ResizeMode-enum + + + + SelectionMode + SelectionMode-enum + + + + StringComparisonMode + StringComparisonMode-enum + + + + WidthMode + WidthMode-enum + + + + Q3ListView + Q3ListView + ( QWidget * parent = 0, const char * name = 0, Qt::WFlags f = 0 ) + + + addColumn + addColumn + ( const QString & label, int width = -1 ) + + + addColumn + addColumn-2 + ( const QIcon & icon, const QString & label, int width = -1 ) + + + adjustColumn + adjustColumn + ( int col ) + + + clear + clear + () + + + clearSelection + clearSelection + () + + + clicked + clicked + ( Q3ListViewItem * item ) + + + clicked + clicked-2 + ( Q3ListViewItem * item, const QPoint & pnt, int c ) + + + collapsed + collapsed + ( Q3ListViewItem * item ) + + + columnAlignment + columnAlignment + ( int column ) + + + columnText + columnText + ( int c ) + + + columnWidth + columnWidth + ( int c ) + + + columnWidthMode + columnWidthMode + ( int c ) + + + contentsMouseDoubleClickEvent + contentsMouseDoubleClickEvent + ( QMouseEvent * e ) + + + contentsMouseMoveEvent + contentsMouseMoveEvent + ( QMouseEvent * e ) + + + contentsMousePressEvent + contentsMousePressEvent + ( QMouseEvent * e ) + + + contentsMouseReleaseEvent + contentsMouseReleaseEvent + ( QMouseEvent * e ) + + + contextMenuRequested + contextMenuRequested + ( Q3ListViewItem * item, const QPoint & pos, int col ) + + + currentChanged + currentChanged + ( Q3ListViewItem * item ) + + + currentItem + currentItem + () + + + doAutoScroll + doAutoScroll + () + + + doubleClicked + doubleClicked + ( Q3ListViewItem * item ) + + + doubleClicked + doubleClicked-2 + ( Q3ListViewItem * item, const QPoint & point, int column ) + + + dragObject + dragObject + () + + + drawContentsOffset + drawContentsOffset + ( QPainter * p, int ox, int oy, int cx, int cy, int cw, int ch ) + + + dropped + dropped + ( QDropEvent * e ) + + + ensureItemVisible + ensureItemVisible + ( const Q3ListViewItem * i ) + + + eventFilter + eventFilter + ( QObject * o, QEvent * e ) + + + expanded + expanded + ( Q3ListViewItem * item ) + + + findItem + findItem + ( const QString & text, int column, ComparisonFlags compare = ExactMatch | Qt::CaseSensitive ) + + + firstChild + firstChild + () + + + header + header + () + + + hideColumn + hideColumn + ( int column ) + + + insertItem + insertItem + ( Q3ListViewItem * i ) + + + invertSelection + invertSelection + () + + + isOpen + isOpen + ( const Q3ListViewItem * item ) + + + isRenaming + isRenaming + () + + + isSelected + isSelected + ( const Q3ListViewItem * i ) + + + itemAt + itemAt + ( const QPoint & viewPos ) + + + itemPos + itemPos + ( const Q3ListViewItem * item ) + + + itemRect + itemRect + ( const Q3ListViewItem * item ) + + + itemRenamed + itemRenamed + ( Q3ListViewItem * item, int col, const QString & text ) + + + itemRenamed + itemRenamed-2 + ( Q3ListViewItem * item, int col ) + + + lastItem + lastItem + () + + + mouseButtonClicked + mouseButtonClicked + ( int button, Q3ListViewItem * item, const QPoint & pos, int c ) + + + mouseButtonPressed + mouseButtonPressed + ( int button, Q3ListViewItem * item, const QPoint & pos, int c ) + + + onItem + onItem + ( Q3ListViewItem * i ) + + + onViewport + onViewport + () + + + paintEmptyArea + paintEmptyArea + ( QPainter * p, const QRect & rect ) + + + pressed + pressed + ( Q3ListViewItem * item ) + + + pressed + pressed-2 + ( Q3ListViewItem * item, const QPoint & pnt, int c ) + + + removeColumn + removeColumn + ( int index ) + + + removeItem + removeItem + ( Q3ListViewItem * item ) + + + repaintItem + repaintItem + ( const Q3ListViewItem * item ) + + + resizeEvent + resizeEvent + ( QResizeEvent * e ) + + + returnPressed + returnPressed + ( Q3ListViewItem * item ) + + + rightButtonClicked + rightButtonClicked + ( Q3ListViewItem * item, const QPoint & point, int column ) + + + rightButtonPressed + rightButtonPressed + ( Q3ListViewItem * item, const QPoint & point, int column ) + + + selectAll + selectAll + ( bool select ) + + + selectedItem + selectedItem + () + + + selectionChanged + selectionChanged + () + + + selectionChanged + selectionChanged-2 + ( Q3ListViewItem * item ) + + + setColumnAlignment + setColumnAlignment + ( int column, int align ) + + + setColumnText + setColumnText + ( int column, const QString & label ) + + + setColumnText + setColumnText-2 + ( int column, const QIcon & icon, const QString & label ) + + + setColumnWidth + setColumnWidth + ( int column, int w ) + + + setColumnWidthMode + setColumnWidthMode + ( int c, WidthMode mode ) + + + setCurrentItem + setCurrentItem + ( Q3ListViewItem * i ) + + + setOpen + setOpen + ( Q3ListViewItem * item, bool open ) + + + setSelected + setSelected + ( Q3ListViewItem * item, bool selected ) + + + setSelectionAnchor + setSelectionAnchor + ( Q3ListViewItem * item ) + + + setSortColumn + setSortColumn + ( int column ) + + + setSortOrder + setSortOrder + ( Qt::SortOrder order ) + + + setSorting + setSorting + ( int column, bool ascending = true ) + + + sort + sort + () + + + sortColumn + sortColumn + () + + + SortOrder + sortOrder + Q3ListView::sortOrder() + + + spacePressed + spacePressed + ( Q3ListViewItem * item ) + + + startDrag + startDrag + () + + + takeItem + takeItem + ( Q3ListViewItem * i ) + + + triggerUpdate + triggerUpdate + () + + + updateContents + updateContents + () + + + + Q3ListViewItem + q3listviewitem.html + + Q3ListViewItem + Q3ListViewItem + ( Q3ListView * parent ) + + + Q3ListViewItem + Q3ListViewItem-2 + ( Q3ListViewItem * parent ) + + + Q3ListViewItem + Q3ListViewItem-3 + ( Q3ListView * parent, Q3ListViewItem * after ) + + + Q3ListViewItem + Q3ListViewItem-4 + ( Q3ListViewItem * parent, Q3ListViewItem * after ) + + + Q3ListViewItem + Q3ListViewItem-5 + ( Q3ListView * parent, const QString & label1, const QString & label2 = QString() + + + Q3ListViewItem + Q3ListViewItem-6 + ( Q3ListViewItem * parent, const QString & label1, const QString & label2 = QString() + + + Q3ListViewItem + Q3ListViewItem-7 + ( Q3ListView * parent, Q3ListViewItem * after, const QString & label1, const QString & label2 = QString() + + + Q3ListViewItem + Q3ListViewItem-8 + ( Q3ListViewItem * parent, Q3ListViewItem * after, const QString & label1, const QString & label2 = QString() + + + acceptDrop + acceptDrop + ( const QMimeSource * mime ) + + + activate + activate + () + + + activatedPos + activatedPos + ( QPoint & pos ) + + + cancelRename + cancelRename + ( int col ) + + + childCount + childCount + () + + + compare + compare + ( Q3ListViewItem * i, int col, bool ascending ) + + + depth + depth + () + + + dragEnabled + dragEnabled + () + + + dragEntered + dragEntered + () + + + dragLeft + dragLeft + () + + + dropEnabled + dropEnabled + () + + + dropped + dropped + ( QDropEvent * e ) + + + enforceSortOrder + enforceSortOrder + () + + + firstChild + firstChild + () + + + height + height + () + + + insertItem + insertItem + ( Q3ListViewItem * newChild ) + + + invalidateHeight + invalidateHeight + () + + + isEnabled + isEnabled + () + + + isExpandable + isExpandable + () + + + isOpen + isOpen + () + + + isSelectable + isSelectable + () + + + isSelected + isSelected + () + + + isVisible + isVisible + () + + + itemAbove + itemAbove + () + + + itemBelow + itemBelow + () + + + itemPos + itemPos + () + + + key + key + ( int column, bool ascending ) + + + listView + listView + () + + + moveItem + moveItem + ( Q3ListViewItem * after ) + + + multiLinesEnabled + multiLinesEnabled + () + + + nextSibling + nextSibling + () + + + okRename + okRename + ( int col ) + + + paintBranches + paintBranches + ( QPainter * p, const QColorGroup & cg, int w, int y, int h ) + + + paintCell + paintCell + ( QPainter * painter, const QColorGroup & cg, int column, int width, int align ) + + + paintFocus + paintFocus + ( QPainter * p, const QColorGroup & cg, const QRect & r ) + + + parent + parent + () + + + pixmap + pixmap + ( int column ) + + + removeItem + removeItem + ( Q3ListViewItem * item ) + + + renameEnabled + renameEnabled + ( int col ) + + + repaint + repaint + () + + + rtti + rtti + () + + + setDragEnabled + setDragEnabled + ( bool allow ) + + + setDropEnabled + setDropEnabled + ( bool allow ) + + + setEnabled + setEnabled + ( bool b ) + + + setExpandable + setExpandable + ( bool enable ) + + + setHeight + setHeight + ( int height ) + + + setMultiLinesEnabled + setMultiLinesEnabled + ( bool b ) + + + setOpen + setOpen + ( bool o ) + + + setPixmap + setPixmap + ( int column, const QPixmap & pm ) + + + setRenameEnabled + setRenameEnabled + ( int col, bool b ) + + + setSelectable + setSelectable + ( bool enable ) + + + setSelected + setSelected + ( bool s ) + + + setText + setText + ( int column, const QString & text ) + + + setVisible + setVisible + ( bool b ) + + + setup + setup + () + + + sort + sort + () + + + sortChildItems + sortChildItems + ( int column, bool ascending ) + + + startRename + startRename + ( int col ) + + + takeItem + takeItem + ( Q3ListViewItem * item ) + + + text + text + ( int column ) + + + totalHeight + totalHeight + () + + + width + width + ( const QFontMetrics & fm, const Q3ListView * lv, int c ) + + + widthChanged + widthChanged + ( int c = -1 ) + + + + Q3ListViewItemIterator + q3listviewitemiterator.html + + IteratorFlag + IteratorFlag-enum + + + + Q3ListViewItemIterator + Q3ListViewItemIterator + () + + + Q3ListViewItemIterator + Q3ListViewItemIterator-2 + ( Q3ListViewItem * item ) + + + Q3ListViewItemIterator + Q3ListViewItemIterator-3 + ( Q3ListViewItem * item, int iteratorFlags ) + + + Q3ListViewItemIterator + Q3ListViewItemIterator-4 + ( const Q3ListViewItemIterator & it ) + + + Q3ListViewItemIterator + Q3ListViewItemIterator-5 + ( Q3ListView * lv ) + + + Q3ListViewItemIterator + Q3ListViewItemIterator-6 + ( Q3ListView * lv, int iteratorFlags ) + + + current + current + () + + + operator* + operator-2a + () + + + operator++ + operator-2b-2b + () + + + operator++ + operator-2b-2b-2 + ( int ) + + + operator+= + operator-2b-eq + ( int j ) + + + operator-- + operator-- + () + + + operator-- + operator---2 + ( int ) + + + operator-= + operator--eq + ( int j ) + + + operator= + operator-eq + ( const Q3ListViewItemIterator & it ) + + + + Q3LocalFs + q3localfs.html + + Q3LocalFs + Q3LocalFs + () + + + + Q3MainWindow + q3mainwindow.html + + DockWindows + DockWindows-enum + + + + Q3MainWindow + Q3MainWindow + ( QWidget * parent = 0, const char * name = 0, Qt::WFlags f = Qt::WType_TopLevel ) + + + addDockWindow + addDockWindow + ( Q3DockWindow * dockWindow, Qt::Dock edge = Qt::DockTop, bool newLine = false ) + + + addDockWindow + addDockWindow-2 + ( Q3DockWindow * dockWindow, const QString & label, Qt::Dock edge = Qt::DockTop, bool newLine = false ) + + + addToolBar + addToolBar + ( Q3DockWindow * dockWindow, Qt::Dock position = Qt::DockTop, bool newLine = false ) + + + addToolBar + addToolBar-2 + ( Q3DockWindow * dockWindow, const QString & label, Qt::Dock position = Qt::DockTop, bool newLine = false ) + + + appropriate + appropriate + ( Q3DockWindow * dw ) + + + bottomDock + bottomDock + () + + + centralWidget + centralWidget + () + + + childEvent + childEvent + ( QChildEvent * e ) + + + createDockWindowMenu + createDockWindowMenu + ( DockWindows dockWindows = AllDockWindows ) + + + customize + customize + () + + + dockWindowPositionChanged + dockWindowPositionChanged + ( Q3DockWindow * dockWindow ) + + + dockWindows + dockWindows + ( Qt::Dock dock ) + + + dockWindows + dockWindows-2 + () + + + getLocation + getLocation + ( Q3DockWindow * dw, Qt::Dock & dock, int & index, bool & nl, int & extraOffset ) + + + hasDockWindow + hasDockWindow + ( Q3DockWindow * dw ) + + + isCustomizable + isCustomizable + () + + + isDockEnabled + isDockEnabled + ( Qt::Dock dock ) + + + isDockEnabled + isDockEnabled-2 + ( Q3DockArea * area ) + + + isDockEnabled + isDockEnabled-3 + ( Q3DockWindow * dw, Q3DockArea * area ) + + + isDockEnabled + isDockEnabled-4 + ( Q3DockWindow * tb, Qt::Dock dock ) + + + isDockMenuEnabled + isDockMenuEnabled + () + + + leftDock + leftDock + () + + + lineUpDockWindows + lineUpDockWindows + ( bool keepNewLines = false ) + + + lineUpToolBars + lineUpToolBars + ( bool keepNewLines = false ) + + + menuAboutToShow + menuAboutToShow + () + + + menuBar + menuBar + () + + + moveDockWindow + moveDockWindow + ( Q3DockWindow * dockWindow, Qt::Dock edge = Qt::DockTop ) + + + moveDockWindow + moveDockWindow-2 + ( Q3DockWindow * dockWindow, Qt::Dock edge, bool nl, int index, int extraOffset = -1 ) + + + moveToolBar + moveToolBar + ( Q3DockWindow * dockWindow, Qt::Dock position = Qt::DockTop ) + + + moveToolBar + moveToolBar-2 + ( Q3DockWindow * dockWindow, Qt::Dock position, bool nl, int index, int extraOffset = -1 ) + + + pixmapSizeChanged + pixmapSizeChanged + ( bool b ) + + + removeDockWindow + removeDockWindow + ( Q3DockWindow * dockWindow ) + + + removeToolBar + removeToolBar + ( Q3DockWindow * dockWindow ) + + + rightDock + rightDock + () + + + setAppropriate + setAppropriate + ( Q3DockWindow * dw, bool a ) + + + setCentralWidget + setCentralWidget + ( QWidget * w ) + + + setDockEnabled + setDockEnabled + ( Qt::Dock dock, bool enable ) + + + setDockEnabled + setDockEnabled-2 + ( Q3DockWindow * dw, Qt::Dock dock, bool enable ) + + + setDockMenuEnabled + setDockMenuEnabled + ( bool b ) + + + setToolBarsMovable + setToolBarsMovable + ( bool b ) + + + setUpLayout + setUpLayout + () + + + showDockMenu + showDockMenu + ( const QPoint & globalPos ) + + + statusBar + statusBar + () + + + toolBarPositionChanged + toolBarPositionChanged + ( Q3ToolBar * toolbar ) + + + toolBars + toolBars + ( Qt::Dock dock ) + + + toolBarsMovable + toolBarsMovable + () + + + topDock + topDock + () + + + usesTextLabelChanged + usesTextLabelChanged + ( bool b ) + + + whatsThis + whatsThis + () + + + + Q3MemArray + q3memarray.html + + ConstIterator + ConstIterator-typedef + + + + Iterator + Iterator-typedef + + + + Q3MemArray + Q3MemArray + ( int arg1, int arg2 ) + + + Q3MemArray + Q3MemArray-2 + () + + + Q3MemArray + Q3MemArray-3 + ( int size ) + + + Q3MemArray + Q3MemArray-4 + ( const Q3MemArray<type> & a ) + + + Q3MemArray + Q3MemArray-5 + ( const QVector<type> & vector ) + + + assign + assign + ( const Q3MemArray<type> & a ) + + + assign + assign-2 + ( const type * data, uint size ) + + + at + at + ( uint index ) + + + begin + begin + () + + + begin + begin-2 + () + + + bsearch + bsearch + ( const type & v ) + + + contains + contains + ( const type & v ) + + + copy + copy + () + + + count + count + () + + + data + data + () + + + detach + detach + () + + + duplicate + duplicate + ( const Q3MemArray<type> & a ) + + + duplicate + duplicate-2 + ( const type * data, uint size ) + + + end + end + () + + + end + end-2 + () + + + fill + fill + ( const type & v, int size = -1 ) + + + find + find + ( const type & v, uint index = 0 ) + + + isEmpty + isEmpty + () + + + isNull + isNull + () + + + nrefs + nrefs + () + + + resetRawData + resetRawData + ( const type * data, uint size ) + + + resize + resize + ( uint size, Optimization optim ) + + + resize + resize-2 + ( uint size ) + + + setRawData + setRawData + ( const type * data, uint size ) + + + size + size + () + + + sort + sort + () + + + truncate + truncate + ( uint pos ) + + + operator + operator-QVector-lttype-gt + QVector<type>() + + + operator + operator-const-type--2a + const type *() + + + operator!= + operator-not-eq + ( const Q3MemArray<type> & a ) + + + operator= + operator-eq + ( const Q3MemArray<type> & a ) + + + operator== + operator-eq-eq + ( const Q3MemArray<type> & a ) + + + operator[] + operator-5b-5d + ( int index ) + + + + Q3MimeSourceFactory + q3mimesourcefactory.html + + Q3MimeSourceFactory + Q3MimeSourceFactory + () + + + addFactory + addFactory + ( Q3MimeSourceFactory * f ) + + + addFilePath + addFilePath + ( const QString & p ) + + + data + data + ( const QString & abs_name ) + + + data + data-2 + ( const QString & abs_or_rel_name, const QString & context ) + + + defaultFactory + defaultFactory + () + + + filePath + filePath + () + + + makeAbsolute + makeAbsolute + ( const QString & abs_or_rel_name, const QString & context ) + + + removeFactory + removeFactory + ( Q3MimeSourceFactory * f ) + + + setData + setData + ( const QString & abs_name, QMimeSource * data ) + + + setDefaultFactory + setDefaultFactory + ( Q3MimeSourceFactory * factory ) + + + setExtensionType + setExtensionType + ( const QString & ext, const char * mimetype ) + + + setFilePath + setFilePath + ( const QStringList & path ) + + + setFilePath + setFilePath-2 + ( const QString & path ) + + + setImage + setImage + ( const QString & abs_name, const QImage & image ) + + + setPixmap + setPixmap + ( const QString & abs_name, const QPixmap & pixmap ) + + + setText + setText + ( const QString & abs_name, const QString & text ) + + + takeDefaultFactory + takeDefaultFactory + () + + + + Q3MultiLineEdit + q3multilineedit.html + + Alignment + alignment-prop + + + + Q3MultiLineEdit + Q3MultiLineEdit + ( QWidget * parent = 0, const char * name = 0 ) + + + autoUpdate + autoUpdate + () + + + backspace + backspace + () + + + cursorDown + cursorDown + ( bool mark = false ) + + + cursorLeft + cursorLeft + ( bool mark = false, bool wrap = true ) + + + cursorPoint + cursorPoint + () + + + cursorRight + cursorRight + ( bool mark = false, bool wrap = true ) + + + cursorUp + cursorUp + ( bool mark = false ) + + + cursorWordBackward + cursorWordBackward + ( bool mark ) + + + cursorWordForward + cursorWordForward + ( bool mark ) + + + deselect + deselect + () + + + end + end + ( bool mark = false ) + + + getMarkedRegion + getMarkedRegion + ( int * line1, int * col1, int * line2, int * col2 ) + + + hasMarkedText + hasMarkedText + () + + + home + home + ( bool mark = false ) + + + insertAndMark + insertAndMark + ( const QString & str, bool mark ) + + + insertAt + insertAt-2 + ( const QString & s, int line, int col, bool mark ) + + + insertLine + insertLine + ( const QString & txt, int line = -1 ) + + + killLine + killLine + () + + + lineLength + lineLength + ( int row ) + + + markedText + markedText + () + + + maxLines + maxLines + () + + + newLine + newLine + () + + + pageDown + pageDown + ( bool mark = false ) + + + pageUp + pageUp + ( bool mark = false ) + + + removeLine + removeLine + ( int paragraph ) + + + setCursorPosition + setCursorPosition-2 + ( int line, int col, bool mark ) + + + setMaxLines + setMaxLines + ( int max ) + + + textLine + textLine + ( int line ) + + + totalHeight + totalHeight + () + + + totalWidth + totalWidth + () + + + + Q3NetworkOperation + q3networkoperation.html + + Q3NetworkOperation + Q3NetworkOperation + ( Q3NetworkProtocol::Operation operation, const QString & arg0, const QString & arg1, const QString & arg2 ) + + + Q3NetworkOperation + Q3NetworkOperation-2 + ( Q3NetworkProtocol::Operation operation, const QByteArray & arg0, const QByteArray & arg1, const QByteArray & arg2 ) + + + arg + arg + ( int num ) + + + errorCode + errorCode + () + + + free + free + () + + + Operation + operation + Q3NetworkOperation::operation() + + + protocolDetail + protocolDetail + () + + + rawArg + rawArg + ( int num ) + + + setArg + setArg + ( int num, const QString & arg ) + + + setErrorCode + setErrorCode + ( int ec ) + + + setProtocolDetail + setProtocolDetail + ( const QString & detail ) + + + setRawArg + setRawArg + ( int num, const QByteArray & arg ) + + + setState + setState + ( Q3NetworkProtocol::State state ) + + + State + state + Q3NetworkOperation::state() + + + + Q3NetworkProtocol + q3networkprotocol.html + + ConnectionState + ConnectionState-enum + + + + Error + Error-enum + + + + Operation + Operation-enum + + + + State + State-enum + + + + Q3NetworkProtocol + Q3NetworkProtocol + () + + + addOperation + addOperation + ( Q3NetworkOperation * op ) + + + autoDelete + autoDelete + () + + + checkConnection + checkConnection + ( Q3NetworkOperation * op ) + + + clearOperationQueue + clearOperationQueue + () + + + connectionStateChanged + connectionStateChanged + ( int state, const QString & data ) + + + createdDirectory + createdDirectory + ( const QUrlInfo & i, Q3NetworkOperation * op ) + + + data + data + ( const QByteArray & data, Q3NetworkOperation * op ) + + + dataTransferProgress + dataTransferProgress + ( int bytesDone, int bytesTotal, Q3NetworkOperation * op ) + + + finished + finished + ( Q3NetworkOperation * op ) + + + getNetworkProtocol + getNetworkProtocol + ( const QString & protocol ) + + + hasOnlyLocalFileSystem + hasOnlyLocalFileSystem + () + + + itemChanged + itemChanged + ( Q3NetworkOperation * op ) + + + newChild + newChild + ( const QUrlInfo & i, Q3NetworkOperation * op ) + + + newChildren + newChildren + ( const Q3ValueList<QUrlInfo> & i, Q3NetworkOperation * op ) + + + operationGet + operationGet + ( Q3NetworkOperation * op ) + + + operationInProgress + operationInProgress + () + + + operationListChildren + operationListChildren + ( Q3NetworkOperation * op ) + + + operationMkDir + operationMkDir + ( Q3NetworkOperation * op ) + + + operationPut + operationPut + ( Q3NetworkOperation * op ) + + + operationRemove + operationRemove + ( Q3NetworkOperation * op ) + + + operationRename + operationRename + ( Q3NetworkOperation * op ) + + + registerNetworkProtocol + registerNetworkProtocol + ( const QString & protocol, Q3NetworkProtocolFactoryBase * protocolFactory ) + + + removed + removed + ( Q3NetworkOperation * op ) + + + setAutoDelete + setAutoDelete + ( bool b, int i = 10000 ) + + + setUrl + setUrl + ( Q3UrlOperator * u ) + + + start + start + ( Q3NetworkOperation * op ) + + + stop + stop + () + + + supportedOperations + supportedOperations + () + + + url + url + () + + + + Q3PaintDeviceMetrics + q3paintdevicemetrics.html + + Q3PaintDeviceMetrics + Q3PaintDeviceMetrics + ( const QPaintDevice * pd ) + + + depth + depth + () + + + height + height + () + + + heightMM + heightMM + () + + + logicalDpiX + logicalDpiX + () + + + logicalDpiY + logicalDpiY + () + + + numColors + numColors + () + + + width + width + () + + + widthMM + widthMM + () + + + + Q3Painter + q3painter.html + + Q3Painter + Q3Painter + () + + + Q3Painter + Q3Painter-2 + ( QPaintDevice * pdev ) + + + drawArc + drawArc + ( const QRect & r, int a, int alen ) + + + drawArc + drawArc-2 + ( int x, int y, int w, int h, int startAngle, int spanAngle ) + + + drawChord + drawChord + ( const QRect & r, int a, int alen ) + + + drawChord + drawChord-2 + ( int x, int y, int w, int h, int startAngle, int spanAngle ) + + + drawEllipse + drawEllipse + ( const QRect & r ) + + + drawEllipse + drawEllipse-2 + ( int x, int y, int width, int height ) + + + drawPie + drawPie + ( const QRect & r, int a, int alen ) + + + drawPie + drawPie-2 + ( int x, int y, int w, int h, int startAngle, int spanAngle ) + + + drawRect + drawRect + ( const QRect & r ) + + + drawRect + drawRect-2 + ( int x, int y, int w, int h ) + + + drawRoundRect + drawRoundRect + ( const QRect & r, int xrnd = 25, int yrnd = 25 ) + + + drawRoundRect + drawRoundRect-2 + ( int x, int y, int w, int h, int xrnd = 25, int yrnd = 25 ) + + + + Q3Picture + q3picture.html + + Q3Picture + Q3Picture + () + + + Q3Picture + Q3Picture-2 + ( const QPicture & other ) + + + load + load + ( QIODevice * device, const char * format = 0 ) + + + load + load-2 + ( const QString & fileName, const char * format = 0 ) + + + save + save + ( QIODevice * device, const char * format = 0 ) + + + save + save-2 + ( const QString & fileName, const char * format = 0 ) + + + + Q3PointArray + q3pointarray.html + + Q3PointArray + Q3PointArray + () + + + Q3PointArray + Q3PointArray-2 + ( const QRect & r, bool closed = false ) + + + Q3PointArray + Q3PointArray-3 + ( const QPolygon & other ) + + + copy + copy + () + + + cubicBezier + cubicBezier + () + + + isNull + isNull + () + + + makeArc + makeArc + ( int x, int y, int w, int h, int a1, int a2 ) + + + makeArc + makeArc-2 + ( int x, int y, int w, int h, int a1, int a2, const QMatrix & xf ) + + + makeEllipse + makeEllipse + ( int x, int y, int w, int h ) + + + + Q3PopupMenu + q3popupmenu.html + + Q3PopupMenu + Q3PopupMenu + ( QWidget * parent = 0, const char * name = 0 ) + + + exec + exec + () + + + exec + exec-2 + ( const QPoint & pos, int indexAtPoint = 0 ) + + + + Q3Process + q3process.html + + Communication + Communication-enum + + + + Q3Process + Q3Process + ( QObject * parent = 0, const char * name = 0 ) + + + Q3Process + Q3Process-2 + ( const QString & arg0, QObject * parent = 0, const char * name = 0 ) + + + Q3Process + Q3Process-3 + ( const QStringList & args, QObject * parent = 0, const char * name = 0 ) + + + addArgument + addArgument + ( const QString & arg ) + + + arguments + arguments + () + + + canReadLineStderr + canReadLineStderr + () + + + canReadLineStdout + canReadLineStdout + () + + + clearArguments + clearArguments + () + + + closeStdin + closeStdin + () + + + communication + communication + () + + + exitStatus + exitStatus + () + + + isRunning + isRunning + () + + + kill + kill + () + + + launch + launch + ( const QByteArray & buf, QStringList * env = 0 ) + + + launch + launch-2 + ( const QString & buf, QStringList * env = 0 ) + + + launchFinished + launchFinished + () + + + normalExit + normalExit + () + + + processExited + processExited + () + + + processIdentifier + processIdentifier + () + + + readLineStderr + readLineStderr + () + + + readLineStdout + readLineStdout + () + + + readStderr + readStderr + () + + + readStdout + readStdout + () + + + readyReadStderr + readyReadStderr + () + + + readyReadStdout + readyReadStdout + () + + + setArguments + setArguments + ( const QStringList & args ) + + + setCommunication + setCommunication + ( int commFlags ) + + + setWorkingDirectory + setWorkingDirectory + ( const QDir & dir ) + + + start + start + ( QStringList * env = 0 ) + + + tryTerminate + tryTerminate + () + + + workingDirectory + workingDirectory + () + + + writeToStdin + writeToStdin + ( const QByteArray & buf ) + + + writeToStdin + writeToStdin-2 + ( const QString & buf ) + + + wroteToStdin + wroteToStdin + () + + + + Q3ProgressBar + q3progressbar.html + + Q3ProgressBar + Q3ProgressBar-3 + ( QWidget * parent = 0, Qt::WFlags f = 0 ) + + + Q3ProgressBar + Q3ProgressBar-4 + ( int totalSteps, QWidget * parent = 0, Qt::WFlags f = 0 ) + + + reset + reset + () + + + setIndicator + setIndicator + ( QString & indicator, int progress, int totalSteps ) + + + Q3ProgressBar + Q3ProgressBar + ( QWidget * parent, const char * name, Qt::WFlags f = 0 ) + + + Q3ProgressBar + Q3ProgressBar-2 + ( int totalSteps, QWidget * parent, const char * name, Qt::WFlags f = 0 ) + + + + Q3ProgressDialog + q3progressdialog.html + + Q3ProgressDialog + Q3ProgressDialog-3 + ( QWidget * creator = 0, Qt::WFlags f = 0 ) + + + Q3ProgressDialog + Q3ProgressDialog-4 + ( const QString & labelText, const QString & cancelButtonText, int totalSteps, QWidget * creator = 0, Qt::WFlags f = 0 ) + + + cancel + cancel + () + + + canceled + canceled + () + + + forceShow + forceShow + () + + + reset + reset + () + + + setBar + setBar + ( Q3ProgressBar * bar ) + + + setCancelButton + setCancelButton + ( QPushButton * cancelButton ) + + + setCancelButtonText + setCancelButtonText + ( const QString & cancelButtonText ) + + + setLabel + setLabel + ( QLabel * label ) + + + sizeHint + sizeHint + () + + + Q3ProgressDialog + Q3ProgressDialog + ( QWidget * creator, const char * name, bool modal = false, Qt::WFlags f = 0 ) + + + Q3ProgressDialog + Q3ProgressDialog-2 + ( const QString & labelText, const QString & cancelButtonText, int totalSteps, QWidget * creator = 0, const char * name = 0, bool modal = false, Qt::WFlags f = 0 ) + + + + Q3PtrCollection + q3ptrcollection.html + + Item + Item-typedef + + + + Q3PtrCollection + Q3PtrCollection + () + + + Q3PtrCollection + Q3PtrCollection-2 + ( const Q3PtrCollection & source ) + + + autoDelete + autoDelete + () + + + clear + clear + () + + + count + count + () + + + deleteItem + deleteItem + ( Item d ) + + + newItem + newItem + ( Item d ) + + + setAutoDelete + setAutoDelete + ( bool enable ) + + + + Q3PtrDict + q3ptrdict.html + + Q3PtrDict + Q3PtrDict + ( int size = 17 ) + + + Q3PtrDict + Q3PtrDict-2 + ( const Q3PtrDict<type> & dict ) + + + clear + clear + () + + + count + count + () + + + find + find + ( void * key ) + + + insert + insert + ( void * key, const type * item ) + + + isEmpty + isEmpty + () + + + read + read + ( QDataStream & s, Q3PtrCollection::Item & item ) + + + remove + remove + ( void * key ) + + + replace + replace + ( void * key, const type * item ) + + + resize + resize + ( uint newsize ) + + + size + size + () + + + statistics + statistics + () + + + take + take + ( void * key ) + + + write + write + ( QDataStream & s, Q3PtrCollection::Item item ) + + + operator= + operator-eq + ( const Q3PtrDict<type> & dict ) + + + operator[] + operator-5b-5d + ( void * key ) + + + + Q3PtrDictIterator + q3ptrdictiterator.html + + Q3PtrDictIterator + Q3PtrDictIterator + ( const Q3PtrDict<type> & dict ) + + + count + count + () + + + current + current + () + + + currentKey + currentKey + () + + + isEmpty + isEmpty + () + + + toFirst + toFirst + () + + + operator + operator-type--2a + type *() + + + operator() + operator-28-29 + () + + + operator++ + operator-2b-2b + () + + + operator+= + operator-2b-eq + ( uint jump ) + + + + Q3PtrList + q3ptrlist.html + + Q3PtrList + Q3PtrList + () + + + Q3PtrList + Q3PtrList-2 + ( const Q3PtrList<type> & list ) + + + append + append + ( const type * item ) + + + at + at + ( uint index ) + + + at + at-2 + () + + + clear + clear + () + + + compareItems + compareItems + ( Q3PtrCollection::Item item1, Q3PtrCollection::Item item2 ) + + + contains + contains + ( const type * item ) + + + containsRef + containsRef + ( const type * item ) + + + count + count + () + + + current + current + () + + + currentNode + currentNode + () + + + find + find + ( const type * item ) + + + findNext + findNext + ( const type * item ) + + + findNextRef + findNextRef + ( const type * item ) + + + findRef + findRef + ( const type * item ) + + + first + first + () + + + getFirst + getFirst + () + + + getLast + getLast + () + + + inSort + inSort + ( const type * item ) + + + insert + insert + ( uint index, const type * item ) + + + isEmpty + isEmpty + () + + + last + last + () + + + next + next + () + + + prepend + prepend + ( const type * item ) + + + prev + prev + () + + + read + read + ( QDataStream & s, Q3PtrCollection::Item & item ) + + + remove + remove + ( uint index ) + + + remove + remove-2 + () + + + remove + remove-3 + ( const type * item ) + + + removeFirst + removeFirst + () + + + removeLast + removeLast + () + + + removeNode + removeNode + ( Q3LNode * node ) + + + removeRef + removeRef + ( const type * item ) + + + replace + replace + ( uint index, const type * item ) + + + sort + sort + () + + + take + take + ( uint index ) + + + take + take-2 + () + + + takeNode + takeNode + ( Q3LNode * node ) + + + toVector + toVector + ( Q3GVector * vec ) + + + write + write + ( QDataStream & s, Q3PtrCollection::Item item ) + + + operator!= + operator-not-eq + ( const Q3PtrList<type> & list ) + + + operator= + operator-eq + ( const Q3PtrList<type> & list ) + + + operator== + operator-eq-eq + ( const Q3PtrList<type> & list ) + + + + Q3PtrListIterator + q3ptrlistiterator.html + + Q3PtrListIterator + Q3PtrListIterator + ( const Q3PtrList<type> & list ) + + + atFirst + atFirst + () + + + atLast + atLast + () + + + count + count + () + + + current + current + () + + + isEmpty + isEmpty + () + + + toFirst + toFirst + () + + + toLast + toLast + () + + + operator + operator-type--2a + type *() + + + operator() + operator-28-29 + () + + + operator* + operator-2a + () + + + operator++ + operator-2b-2b + () + + + operator+= + operator-2b-eq + ( uint jump ) + + + operator-- + operator-- + () + + + operator-= + operator--eq + ( uint jump ) + + + operator= + operator-eq + ( const Q3PtrListIterator<type> & it ) + + + + Q3PtrQueue + q3ptrqueue.html + + Q3PtrQueue + Q3PtrQueue + () + + + Q3PtrQueue + Q3PtrQueue-2 + ( const Q3PtrQueue<type> & queue ) + + + autoDelete + autoDelete + () + + + clear + clear + () + + + count + count + () + + + current + current + () + + + dequeue + dequeue + () + + + enqueue + enqueue + ( const type * d ) + + + head + head + () + + + isEmpty + isEmpty + () + + + read + read + ( QDataStream & s, Q3PtrCollection::Item & item ) + + + remove + remove + () + + + setAutoDelete + setAutoDelete + ( bool enable ) + + + write + write + ( QDataStream & s, Q3PtrCollection::Item item ) + + + operator + operator-type--2a + type *() + + + operator= + operator-eq + ( const Q3PtrQueue<type> & queue ) + + + + Q3PtrStack + q3ptrstack.html + + Q3PtrStack + Q3PtrStack + () + + + Q3PtrStack + Q3PtrStack-2 + ( const Q3PtrStack<type> & s ) + + + autoDelete + autoDelete + () + + + clear + clear + () + + + count + count + () + + + current + current + () + + + isEmpty + isEmpty + () + + + pop + pop + () + + + push + push + ( const type * d ) + + + read + read + ( QDataStream & s, Q3PtrCollection::Item & item ) + + + remove + remove + () + + + setAutoDelete + setAutoDelete + ( bool enable ) + + + top + top + () + + + write + write + ( QDataStream & s, Q3PtrCollection::Item item ) + + + operator + operator-type--2a + type *() + + + operator= + operator-eq + ( const Q3PtrStack<type> & s ) + + + + Q3PtrVector + q3ptrvector.html + + Q3PtrVector + Q3PtrVector + () + + + Q3PtrVector + Q3PtrVector-2 + ( uint size ) + + + Q3PtrVector + Q3PtrVector-3 + ( const Q3PtrVector<type> & v ) + + + at + at + ( uint i ) + + + bsearch + bsearch + ( const type * d ) + + + clear + clear + () + + + compareItems + compareItems + ( Q3PtrCollection::Item d1, Q3PtrCollection::Item d2 ) + + + contains + contains + ( const type * d ) + + + containsRef + containsRef + ( const type * d ) + + + count + count + () + + + data + data + () + + + fill + fill + ( const type * d, int size = -1 ) + + + find + find + ( const type * d, uint i = 0 ) + + + findRef + findRef + ( const type * d, uint i = 0 ) + + + insert + insert + ( uint i, const type * d ) + + + isEmpty + isEmpty + () + + + isNull + isNull + () + + + read + read + ( QDataStream & s, Q3PtrCollection::Item & item ) + + + remove + remove + ( uint i ) + + + resize + resize + ( uint size ) + + + size + size + () + + + sort + sort + () + + + take + take + ( uint i ) + + + write + write + ( QDataStream & s, Q3PtrCollection::Item item ) + + + operator= + operator-eq + ( const Q3PtrVector<type> & v ) + + + operator== + operator-eq-eq + ( const Q3PtrVector<type> & v ) + + + operator[] + operator-5b-5d + ( int i ) + + + + Q3RangeControl + q3rangecontrol.html + + Q3RangeControl + Q3RangeControl + () + + + Q3RangeControl + Q3RangeControl-2 + ( int minValue, int maxValue, int lineStep, int pageStep, int value ) + + + addLine + addLine + () + + + addPage + addPage + () + + + bound + bound + ( int v ) + + + directSetValue + directSetValue + ( int value ) + + + lineStep + lineStepx + () + + + maxValue + maxValue + () + + + minValue + minValue + () + + + pageStep + pageStep + () + + + positionFromValue + positionFromValue + ( int logical_val, int span ) + + + prevValue + prevValue + () + + + rangeChange + rangeChange + () + + + setMaxValue + setMaxValue + ( int maxVal ) + + + setMinValue + setMinValue + ( int minVal ) + + + setRange + setRange + ( int minValue, int maxValue ) + + + setSteps + setSteps + ( int lineStep, int pageStep ) + + + setValue + setValue + ( int value ) + + + stepChange + stepChange + () + + + subtractLine + subtractLine + () + + + subtractPage + subtractPage + () + + + value + value + () + + + valueChange + valueChange + () + + + valueFromPosition + valueFromPosition + ( int pos, int span ) + + + + Q3ScrollView + q3scrollview.html + + ResizePolicy + ResizePolicy-enum + + + + ScrollBarMode + ScrollBarMode-enum + + + + Q3ScrollView + Q3ScrollView + ( QWidget * parent = 0, const char * name = 0, Qt::WFlags f = 0 ) + + + addChild + addChild + ( QWidget * child, int x = 0, int y = 0 ) + + + bottomMargin + bottomMargin + () + + + center + center + ( int x, int y ) + + + center + center-2 + ( int x, int y, float xmargin, float ymargin ) + + + childX + childX + ( QWidget * child ) + + + childY + childY + ( QWidget * child ) + + + clipper + clipper + () + + + contentsContextMenuEvent + contentsContextMenuEvent + ( QContextMenuEvent * e ) + + + contentsDragEnterEvent + contentsDragEnterEvent + ( QDragEnterEvent * event ) + + + contentsDragLeaveEvent + contentsDragLeaveEvent + ( QDragLeaveEvent * event ) + + + contentsDragMoveEvent + contentsDragMoveEvent + ( QDragMoveEvent * event ) + + + contentsDropEvent + contentsDropEvent + ( QDropEvent * event ) + + + contentsMouseDoubleClickEvent + contentsMouseDoubleClickEvent + ( QMouseEvent * e ) + + + contentsMouseMoveEvent + contentsMouseMoveEvent + ( QMouseEvent * e ) + + + contentsMousePressEvent + contentsMousePressEvent + ( QMouseEvent * e ) + + + contentsMouseReleaseEvent + contentsMouseReleaseEvent + ( QMouseEvent * e ) + + + contentsMoving + contentsMoving + ( int x, int y ) + + + contentsToViewport + contentsToViewport + ( int x, int y, int & vx, int & vy ) + + + contentsToViewport + contentsToViewport-2 + ( const QPoint & p ) + + + contentsWheelEvent + contentsWheelEvent + ( QWheelEvent * e ) + + + cornerWidget + cornerWidget + () + + + drawContents + drawContents + ( QPainter * p, int clipx, int clipy, int clipw, int cliph ) + + + drawContentsOffset + drawContentsOffset + ( QPainter * p, int offsetx, int offsety, int clipx, int clipy, int clipw, int cliph ) + + + enableClipper + enableClipper + ( bool y ) + + + ensureVisible + ensureVisible + ( int x, int y ) + + + ensureVisible + ensureVisible-2 + ( int x, int y, int xmargin, int ymargin ) + + + eventFilter + eventFilter + ( QObject * obj, QEvent * e ) + + + hasStaticBackground + hasStaticBackground + () + + + horizontalScrollBar + horizontalScrollBar + () + + + horizontalSliderPressed + horizontalSliderPressed + () + + + horizontalSliderReleased + horizontalSliderReleased + () + + + isHorizontalSliderPressed + isHorizontalSliderPressed + () + + + isVerticalSliderPressed + isVerticalSliderPressed + () + + + leftMargin + leftMargin + () + + + moveChild + moveChild + ( QWidget * child, int x, int y ) + + + removeChild + removeChild + ( QWidget * child ) + + + repaintContents + repaintContents + ( int x, int y, int w, int h, bool erase = true ) + + + repaintContents + repaintContents-2 + ( const QRect & r, bool erase = true ) + + + repaintContents + repaintContents-3 + ( bool erase = true ) + + + resizeContents + resizeContents + ( int w, int h ) + + + rightMargin + rightMargin + () + + + scrollBy + scrollBy + ( int dx, int dy ) + + + setContentsPos + setContentsPos + ( int x, int y ) + + + setCornerWidget + setCornerWidget + ( QWidget * corner ) + + + setHBarGeometry + setHBarGeometry + ( QScrollBar & hbar, int x, int y, int w, int h ) + + + setMargins + setMargins + ( int left, int top, int right, int bottom ) + + + setStaticBackground + setStaticBackground + ( bool y ) + + + setVBarGeometry + setVBarGeometry + ( QScrollBar & vbar, int x, int y, int w, int h ) + + + topMargin + topMargin + () + + + updateContents + updateContents + ( int x, int y, int w, int h ) + + + updateContents + updateContents-2 + ( const QRect & r ) + + + updateContents + updateContents-3 + () + + + updateScrollBars + updateScrollBars + () + + + verticalScrollBar + verticalScrollBar + () + + + verticalSliderPressed + verticalSliderPressed + () + + + verticalSliderReleased + verticalSliderReleased + () + + + viewport + viewport + () + + + viewportPaintEvent + viewportPaintEvent + ( QPaintEvent * pe ) + + + viewportResizeEvent + viewportResizeEvent + ( QResizeEvent * event ) + + + viewportSize + viewportSize + ( int x, int y ) + + + viewportToContents + viewportToContents + ( int vx, int vy, int & x, int & y ) + + + viewportToContents + viewportToContents-2 + ( const QPoint & vp ) + + + childIsVisible + childIsVisible + ( QWidget * child ) + + + showChild + showChild + ( QWidget * child, bool y = true ) + + + + Q3Semaphore + q3semaphore.html + + Q3Semaphore + Q3Semaphore + ( int maxcount ) + + + available + available + () + + + total + total + () + + + tryAccess + tryAccess + ( int n ) + + + operator++ + operator-2b-2b + ( int ) + + + operator+= + operator-2b-eq + ( int n ) + + + operator-- + operator-- + ( int ) + + + operator-= + operator--eq + ( int n ) + + + + Q3ServerSocket + q3serversocket.html + + Q3ServerSocket + Q3ServerSocket + ( Q_UINT16 port, int backlog = 1, QObject * parent = 0, const char * name = 0 ) + + + Q3ServerSocket + Q3ServerSocket-2 + ( const QHostAddress & address, Q_UINT16 port, int backlog = 1, QObject * parent = 0, const char * name = 0 ) + + + Q3ServerSocket + Q3ServerSocket-3 + ( QObject * parent = 0, const char * name = 0 ) + + + address + address + () + + + newConnection + newConnection + ( int socket ) + + + ok + ok + () + + + port + port + () + + + setSocket + setSocket + ( int socket ) + + + socket + socket + () + + + socketDevice + socketDevice + () + + + + Q3Shared + q3shared.html + + Q3Shared + Q3Shared + () + + + deref + deref + () + + + ref + ref + () + + + + Q3Signal + q3signal.html + + Q3Signal + Q3Signal + ( QObject * parent = 0, const char * name = 0 ) + + + activate + activate + () + + + connect + connect + ( const QObject * receiver, const char * member ) + + + disconnect + disconnect + ( const QObject * receiver, const char * member = 0 ) + + + setValue + setValue + ( const QVariant & value ) + + + value + value + () + + + block + block + ( bool b ) + + + isBlocked + isBlocked + () + + + parameter + parameter + () + + + setParameter + setParameter + ( int value ) + + + + Q3SimpleRichText + q3simplerichtext.html + + Q3SimpleRichText + Q3SimpleRichText + ( const QString & text, const QFont & fnt, const QString & context = QString() + + + Q3SimpleRichText + Q3SimpleRichText-2 + ( const QString & text, const QFont & fnt, const QString & context, const Q3StyleSheet * sheet, const Q3MimeSourceFactory * factory, int pageBreak = -1, const QColor & linkColor = Qt::blue, bool linkUnderline = true ) + + + adjustSize + adjustSize + () + + + anchorAt + anchorAt + ( const QPoint & pos ) + + + context + context + () + + + draw + draw + ( QPainter * p, int x, int y, const QRect & clipRect, const QColorGroup & cg, const QBrush * paper = 0 ) + + + draw + draw-2 + ( QPainter * p, int x, int y, const QRegion & clipRegion, const QColorGroup & cg, const QBrush * paper = 0 ) + + + height + height + () + + + inText + inText + ( const QPoint & pos ) + + + setDefaultFont + setDefaultFont + ( const QFont & f ) + + + setWidth + setWidth + ( QPainter * p, int w ) + + + setWidth + setWidth-2 + ( int w ) + + + width + width + () + + + widthUsed + widthUsed + () + + + + Q3SocketDevice + q3socketdevice.html + + Error + Error-enum + + + + Protocol + Protocol-enum + + + + Type + Type-enum + + + + Q3SocketDevice + Q3SocketDevice + ( Type type = Stream ) + + + Q3SocketDevice + Q3SocketDevice-2 + ( Type type, Protocol protocol, int dummy ) + + + Q3SocketDevice + Q3SocketDevice-3 + ( int socket, Type type ) + + + accept + accept + () + + + address + address + () + + + addressReusable + addressReusable + () + + + at + at + () + + + at + at-2 + ( Offset offset ) + + + bind + bind + ( const QHostAddress & address, Q_UINT16 port ) + + + blocking + blocking + () + + + bytesAvailable + bytesAvailable + () + + + connect + connect + ( const QHostAddress & addr, Q_UINT16 port ) + + + error + error + () + + + flush + flush + () + + + isValid + isValid + () + + + listen + listen + ( int backlog ) + + + open + open + ( int mode ) + + + peerAddress + peerAddress + () + + + peerPort + peerPort + () + + + port + port + () + + + protocol + protocol + () + + + readBlock + readBlock + ( char * data, Q_ULONG maxlen ) + + + readData + readData + ( char * data, qint64 maxlen ) + + + receiveBufferSize + receiveBufferSize + () + + + sendBufferSize + sendBufferSize + () + + + setAddressReusable + setAddressReusable + ( bool enable ) + + + setBlocking + setBlocking + ( bool enable ) + + + setError + setError + ( Error err ) + + + setReceiveBufferSize + setReceiveBufferSize + ( uint size ) + + + setSendBufferSize + setSendBufferSize + ( uint size ) + + + setSocket + setSocket + ( int socket, Type type ) + + + socket + socket + () + + + type + type + () + + + waitForMore + waitForMore + ( int msecs, bool * timeout = 0 ) + + + writeBlock + writeBlock + ( const char * data, Q_ULONG len ) + + + writeBlock + writeBlock-2 + ( const char * data, Q_ULONG len, const QHostAddress & host, Q_UINT16 port ) + + + writeData + writeData + ( const char * data, qint64 len ) + + + + Q3Socket + q3socket.html + + Error + Error-enum + + + + State + State-enum + + + + Q3Socket + Q3Socket + ( QObject * parent = 0, const char * name = 0 ) + + + address + address + () + + + at + at + () + + + at + at-2 + ( Offset index ) + + + atEnd + atEnd + () + + + bytesAvailable + bytesAvailable + () + + + bytesToWrite + bytesToWrite + () + + + bytesWritten + bytesWritten + ( int nbytes ) + + + canReadLine + canReadLine + () + + + clearPendingData + clearPendingData + () + + + close + close + () + + + connectToHost + connectToHost + ( const QString & host, Q_UINT16 port ) + + + connected + connected + () + + + connectionClosed + connectionClosed + () + + + delayedCloseFinished + delayedCloseFinished + () + + + error + error + ( int error ) + + + flush + flush + () + + + getch + getch + () + + + hostFound + hostFound + () + + + open + open + ( int m ) + + + peerAddress + peerAddress + () + + + peerName + peerName + () + + + peerPort + peerPort + () + + + port + port + () + + + putch + putch + ( int ch ) + + + readBufferSize + readBufferSize + () + + + readData + readData + ( char * data, qint64 maxlen ) + + + readyRead + readyRead + () + + + setReadBufferSize + setReadBufferSize + ( Q_ULONG bufSize ) + + + setSocket + setSocket + ( int socket ) + + + setSocketDevice + setSocketDevice + ( Q3SocketDevice * device ) + + + size + size + () + + + socket + socket + () + + + socketDevice + socketDevice + () + + + state + state + () + + + ungetch + ungetch + ( int ch ) + + + waitForMore + waitForMore + ( int msecs, bool * timeout ) + + + waitForMore + waitForMore-2 + ( int msecs ) + + + writeData + writeData + ( const char * data, qint64 len ) + + + + Q3SqlCursor + q3sqlcursor.html + + Mode + Mode-enum + + + + Q3SqlCursor + Q3SqlCursor + ( const QString & name = QString() + + + Q3SqlCursor + Q3SqlCursor-2 + ( const Q3SqlCursor & other ) + + + append + append + ( const Q3SqlFieldInfo & fieldInfo ) + + + calculateField + calculateField + ( const QString & name ) + + + canDelete + canDelete + () + + + canInsert + canInsert + () + + + canUpdate + canUpdate + () + + + clear + clear + () + + + del + del + ( bool invalidate = true ) + + + del + del-2 + ( const QString & filter, bool invalidate = true ) + + + editBuffer + editBuffer + ( bool copy = false ) + + + exec + exec + ( const QString & sql ) + + + filter + filter + () + + + index + index + ( const QStringList & fieldNames ) + + + index + index-2 + ( const QString & fieldName ) + + + insert + insert + ( int pos, const Q3SqlFieldInfo & fieldInfo ) + + + insert + insert-2 + ( bool invalidate = true ) + + + isCalculated + isCalculated + ( const QString & name ) + + + isNull + isNull + ( int i ) + + + isNull + isNull-2 + ( const QString & name ) + + + isReadOnly + isReadOnly + () + + + isTrimmed + isTrimmed + ( const QString & name ) + + + mode + mode + () + + + name + name + () + + + primaryIndex + primaryIndex + ( bool setFromCursor = true ) + + + primeDelete + primeDelete + () + + + primeInsert + primeInsert + () + + + primeUpdate + primeUpdate + () + + + remove + remove + ( int pos ) + + + select + select + ( const QString & filter, const QSqlIndex & sort = QSqlIndex() + + + select + select-2 + () + + + select + select-3 + ( const QSqlIndex & sort ) + + + select + select-4 + ( const QSqlIndex & filter, const QSqlIndex & sort ) + + + setCalculated + setCalculated + ( const QString & name, bool calculated ) + + + setFilter + setFilter + ( const QString & filter ) + + + setGenerated + setGenerated + ( const QString & name, bool generated ) + + + setGenerated + setGenerated-2 + ( int i, bool generated ) + + + setMode + setMode + ( int mode ) + + + setName + setName + ( const QString & name, bool autopopulate = true ) + + + setPrimaryIndex + setPrimaryIndex + ( const QSqlIndex & idx ) + + + setSort + setSort + ( const QSqlIndex & sort ) + + + setTrimmed + setTrimmed + ( const QString & name, bool trim ) + + + setValue + setValue-2 + ( const QString & name, const QVariant & val ) + + + sort + sort + () + + + toString + toString-2 + ( QSqlRecord * rec, const QString & prefix, const QString & fieldSep, const QString & sep ) + + + toString + toString-3 + ( const QString & prefix, QSqlField * field, const QString & fieldSep ) + + + toString + toString-4 + ( const QSqlIndex & i, QSqlRecord * rec, const QString & prefix, const QString & fieldSep, const QString & sep ) + + + update + update + ( bool invalidate = true ) + + + update + update-2 + ( const QString & filter, bool invalidate = true ) + + + value + value + ( int i ) + + + value + value-2 + ( const QString & name ) + + + operator= + operator-eq + ( const Q3SqlCursor & other ) + + + + Q3SqlEditorFactory + q3sqleditorfactory.html + + Q3SqlEditorFactory + Q3SqlEditorFactory + ( QObject * parent = 0 ) + + + createEditor + createEditor + ( QWidget * parent, const QVariant & variant ) + + + createEditor + createEditor-2 + ( QWidget * parent, const QSqlField * field ) + + + defaultFactory + defaultFactory + () + + + installDefaultFactory + installDefaultFactory + ( Q3SqlEditorFactory * factory ) + + + + Q3SqlFieldInfo + q3sqlfieldinfo.html + + Q3SqlFieldInfo + Q3SqlFieldInfo + ( const QString & name = QString() + + + Q3SqlFieldInfo + Q3SqlFieldInfo-2 + ( const QSqlField & other ) + + + defaultValue + defaultValue + () + + + isCalculated + isCalculated + () + + + isGenerated + isGenerated + () + + + isRequired + isRequired + () + + + isTrim + isTrim + () + + + length + length + () + + + name + name + () + + + precision + precision + () + + + setCalculated + setCalculated + ( bool calculated ) + + + setGenerated + setGenerated + ( bool generated ) + + + setTrim + setTrim + ( bool trim ) + + + toField + toField + () + + + Type + type + Q3SqlFieldInfo::type() + + + typeID + typeID + () + + + operator== + operator-eq-eq + ( const Q3SqlFieldInfo & other ) + + + + Q3SqlForm + q3sqlform.html + + Q3SqlForm + Q3SqlForm + ( QObject * parent = 0 ) + + + clear + clear + () + + + clearValues + clearValues + () + + + count + count + () + + + fieldToWidget + fieldToWidget + ( QSqlField * field ) + + + insert + insert + ( QWidget * widget, const QString & field ) + + + insert + insert-2 + ( QWidget * widget, QSqlField * field ) + + + installPropertyMap + installPropertyMap + ( Q3SqlPropertyMap * pmap ) + + + readField + readField + ( QWidget * widget ) + + + readFields + readFields + () + + + remove + remove + ( QWidget * widget ) + + + remove + remove-2 + ( const QString & field ) + + + setRecord + setRecord + ( QSqlRecord * buf ) + + + widget + widget + ( int i ) + + + widgetToField + widgetToField + ( QWidget * widget ) + + + writeField + writeField + ( QWidget * widget ) + + + writeFields + writeFields + () + + + + Q3SqlPropertyMap + q3sqlpropertymap.html + + Q3SqlPropertyMap + Q3SqlPropertyMap + () + + + defaultMap + defaultMap + () + + + insert + insert + ( const QString & classname, const QString & property ) + + + installDefaultMap + installDefaultMap + ( Q3SqlPropertyMap * map ) + + + property + property + ( QWidget * widget ) + + + remove + remove + ( const QString & classname ) + + + setProperty + setProperty + ( QWidget * widget, const QVariant & value ) + + + + Q3SqlRecordInfo + q3sqlrecordinfo.html + + Q3SqlRecordInfo + Q3SqlRecordInfo + () + + + Q3SqlRecordInfo + Q3SqlRecordInfo-2 + ( const Q3SqlFieldInfoList & other ) + + + Q3SqlRecordInfo + Q3SqlRecordInfo-3 + ( const QSqlRecord & other ) + + + contains + contains + ( const QString & fieldName ) + + + find + find + ( const QString & fieldName ) + + + toRecord + toRecord + () + + + + Q3SqlSelectCursor + q3sqlselectcursor.html + + Q3SqlSelectCursor + Q3SqlSelectCursor + ( const QString & query = QString() + + + Q3SqlSelectCursor + Q3SqlSelectCursor-2 + ( const Q3SqlSelectCursor & other ) + + + + Q3StoredDrag + q3storeddrag.html + + Q3StoredDrag + Q3StoredDrag + ( const char * mimeType, QWidget * dragSource = 0, const char * name = 0 ) + + + encodedData + encodedData + ( const char * format ) + + + setEncodedData + setEncodedData + ( const QByteArray & data ) + + + + Q3StrIList + q3strilist.html + + Q3StrIList + Q3StrIList + ( bool deepCopies = true ) + + + + Q3StrList + q3strlist.html + + Q3StrList + Q3StrList + ( bool deepCopies = true ) + + + Q3StrList + Q3StrList-2 + ( const Q3StrList & list ) + + + Q3StrList + Q3StrList-3 + ( const QList<QByteArray> & list ) + + + operator + operator-QList-ltQByteArray-gt + QList<QByteArray>() + + + operator= + operator-eq + ( const Q3StrList & list ) + + + operator= + operator-eq-2 + ( const QList<QByteArray> & list ) + + + + Q3StrListIterator + q3strlistiterator.html + + + Q3StyleSheet + q3stylesheet.html + + Q3StyleSheet + Q3StyleSheet + ( QObject * parent = 0, const char * name = 0 ) + + + convertFromPlainText + convertFromPlainText + ( const QString & plain, Q3StyleSheetItem::WhiteSpaceMode mode = Q3StyleSheetItem::WhiteSpacePre ) + + + defaultSheet + defaultSheet + () + + + error + error + ( const QString & msg ) + + + escape + escape + ( const QString & plain ) + + + item + item + ( const QString & name ) + + + item + item-2 + ( const QString & name ) + + + mightBeRichText + mightBeRichText + ( const QString & text ) + + + scaleFont + scaleFont + ( QFont & font, int logicalSize ) + + + setDefaultSheet + setDefaultSheet + ( Q3StyleSheet * sheet ) + + + + Q3StyleSheetItem + q3stylesheetitem.html + + DisplayMode + DisplayMode-enum + + + + ListStyle + ListStyle-enum + + + + Margin + Margin-enum + + + + VerticalAlignment + VerticalAlignment-enum + + + + WhiteSpaceMode + WhiteSpaceMode-enum + + + + Q3StyleSheetItem + Q3StyleSheetItem + ( Q3StyleSheet * parent, const QString & name ) + + + Q3StyleSheetItem + Q3StyleSheetItem-2 + ( const Q3StyleSheetItem & other ) + + + alignment + alignment + () + + + allowedInContext + allowedInContext + ( const Q3StyleSheetItem * s ) + + + color + color + () + + + contexts + contexts + () + + + definesFontItalic + definesFontItalic + () + + + definesFontStrikeOut + definesFontStrikeOut + () + + + definesFontUnderline + definesFontUnderline + () + + + displayMode + displayMode + () + + + fontFamily + fontFamily + () + + + fontItalic + fontItalic + () + + + fontSize + fontSize + () + + + fontStrikeOut + fontStrikeOut + () + + + fontUnderline + fontUnderline + () + + + fontWeight + fontWeight + () + + + isAnchor + isAnchor + () + + + lineSpacing + lineSpacing + () + + + listStyle + listStyle + () + + + logicalFontSize + logicalFontSize + () + + + logicalFontSizeStep + logicalFontSizeStep + () + + + margin + margin + ( Margin m ) + + + name + name + () + + + numberOfColumns + numberOfColumns + () + + + selfNesting + selfNesting + () + + + setAlignment + setAlignment + ( int f ) + + + setAnchor + setAnchor + ( bool anc ) + + + setColor + setColor + ( const QColor & c ) + + + setContexts + setContexts + ( const QString & c ) + + + setDisplayMode + setDisplayMode + ( DisplayMode m ) + + + setFontFamily + setFontFamily + ( const QString & fam ) + + + setFontItalic + setFontItalic + ( bool italic ) + + + setFontSize + setFontSize + ( int s ) + + + setFontStrikeOut + setFontStrikeOut + ( bool strikeOut ) + + + setFontUnderline + setFontUnderline + ( bool underline ) + + + setFontWeight + setFontWeight + ( int w ) + + + setListStyle + setListStyle + ( ListStyle s ) + + + setLogicalFontSize + setLogicalFontSize + ( int s ) + + + setLogicalFontSizeStep + setLogicalFontSizeStep + ( int s ) + + + setMargin + setMargin + ( Margin m, int v ) + + + setNumberOfColumns + setNumberOfColumns + ( int ncols ) + + + setSelfNesting + setSelfNesting + ( bool nesting ) + + + setVerticalAlignment + setVerticalAlignment + ( VerticalAlignment valign ) + + + setWhiteSpaceMode + setWhiteSpaceMode + ( WhiteSpaceMode m ) + + + styleSheet + styleSheet + () + + + styleSheet + styleSheet-2 + () + + + verticalAlignment + verticalAlignment + () + + + whiteSpaceMode + whiteSpaceMode + () + + + operator= + operator-eq + ( const Q3StyleSheetItem & other ) + + + + Q3SyntaxHighlighter + q3syntaxhighlighter.html + + Q3SyntaxHighlighter + Q3SyntaxHighlighter + ( Q3TextEdit * textEdit ) + + + currentParagraph + currentParagraph + () + + + highlightParagraph + highlightParagraph + ( const QString & text, int endStateOfLastPara ) + + + rehighlight + rehighlight + () + + + setFormat + setFormat + ( int start, int count, const QFont & font, const QColor & color ) + + + setFormat + setFormat-2 + ( int start, int count, const QColor & color ) + + + setFormat + setFormat-3 + ( int start, int count, const QFont & font ) + + + textEdit + textEdit + () + + + + Q3TabDialog + q3tabdialog.html + + Q3TabDialog + Q3TabDialog + ( QWidget * parent = 0, const char * name = 0, bool modal = false, Qt::WFlags f = 0 ) + + + aboutToShow + aboutToShow + () + + + addTab + addTab + ( QWidget * child, const QString & label ) + + + addTab + addTab-2 + ( QWidget * child, const QIcon & iconset, const QString & label ) + + + applyButtonPressed + applyButtonPressed + () + + + cancelButtonPressed + cancelButtonPressed + () + + + changeTab + changeTab + ( QWidget * w, const QIcon & iconset, const QString & label ) + + + changeTab + changeTab-2 + ( QWidget * w, const QString & label ) + + + currentChanged + currentChanged + ( QWidget * widget ) + + + currentPage + currentPage + () + + + defaultButtonPressed + defaultButtonPressed + () + + + hasApplyButton + hasApplyButton + () + + + hasCancelButton + hasCancelButton + () + + + hasDefaultButton + hasDefaultButton + () + + + hasHelpButton + hasHelpButton + () + + + hasOkButton + hasOkButton + () + + + helpButtonPressed + helpButtonPressed + () + + + insertTab + insertTab + ( QWidget * child, const QString & label, int index = -1 ) + + + insertTab + insertTab-2 + ( QWidget * child, const QIcon & iconset, const QString & label, int index = -1 ) + + + isTabEnabled + isTabEnabled + ( QWidget * w ) + + + removePage + removePage + ( QWidget * w ) + + + selected + selected + ( const QString & name ) + + + setApplyButton + setApplyButton + ( const QString & text ) + + + setApplyButton + setApplyButton-2 + () + + + setCancelButton + setCancelButton + ( const QString & text ) + + + setCancelButton + setCancelButton-2 + () + + + setDefaultButton + setDefaultButton + ( const QString & text ) + + + setDefaultButton + setDefaultButton-2 + () + + + setFont + setFont + ( const QFont & font ) + + + setHelpButton + setHelpButton + ( const QString & text ) + + + setHelpButton + setHelpButton-2 + () + + + setOkButton + setOkButton + ( const QString & text ) + + + setOkButton + setOkButton-2 + () + + + setTabBar + setTabBar + ( QTabBar * tb ) + + + setTabEnabled + setTabEnabled + ( QWidget * w, bool enable ) + + + showPage + showPage + ( QWidget * w ) + + + tabBar + tabBar + () + + + tabLabel + tabLabel + ( QWidget * w ) + + + isTabEnabled + isTabEnabled-2 + ( const char * name ) + + + setTabEnabled + setTabEnabled-2 + ( const char * name, bool enable ) + + + + Q3Table + q3table.html + + EditMode + EditMode-enum + + + + FocusStyle + FocusStyle-enum + + + + SelectionMode + SelectionMode-enum + + + + Q3Table + Q3Table + ( QWidget * parent = 0, const char * name = 0 ) + + + Q3Table + Q3Table-2 + ( int numRows, int numCols, QWidget * parent = 0, const char * name = 0 ) + + + activateNextCell + activateNextCell + () + + + addSelection + addSelection + ( const Q3TableSelection & s ) + + + adjustColumn + adjustColumn + ( int col ) + + + adjustRow + adjustRow + ( int row ) + + + beginEdit + beginEdit + ( int row, int col, bool replace ) + + + cellGeometry + cellGeometry + ( int row, int col ) + + + cellRect + cellRect + ( int row, int col ) + + + cellWidget + cellWidget + ( int row, int col ) + + + clearCell + clearCell + ( int row, int col ) + + + clearCellWidget + clearCellWidget + ( int row, int col ) + + + clearSelection + clearSelection + ( bool repaint = true ) + + + clicked + clicked + ( int row, int col, int button, const QPoint & mousePos ) + + + columnAt + columnAt + ( int x ) + + + columnClicked + columnClicked + ( int col ) + + + columnIndexChanged + columnIndexChanged + ( int section, int fromIndex, int toIndex ) + + + columnPos + columnPos + ( int col ) + + + columnWidth + columnWidth + ( int col ) + + + columnWidthChanged + columnWidthChanged + ( int col ) + + + contentsDragEnterEvent + contentsDragEnterEvent + ( QDragEnterEvent * e ) + + + contentsDragLeaveEvent + contentsDragLeaveEvent + ( QDragLeaveEvent * e ) + + + contentsDragMoveEvent + contentsDragMoveEvent + ( QDragMoveEvent * e ) + + + contentsDropEvent + contentsDropEvent + ( QDropEvent * e ) + + + contextMenuRequested + contextMenuRequested + ( int row, int col, const QPoint & pos ) + + + createEditor + createEditor + ( int row, int col, bool initFromCell ) + + + currEditCol + currEditCol + () + + + currEditRow + currEditRow + () + + + currentChanged + currentChanged + ( int row, int col ) + + + currentColumn + currentColumn + () + + + currentRow + currentRow + () + + + currentSelection + currentSelection + () + + + doubleClicked + doubleClicked + ( int row, int col, int button, const QPoint & mousePos ) + + + dragEnabled + dragEnabled + () + + + dragObject + dragObject + () + + + drawContents + drawContents + ( QPainter * p, int cx, int cy, int cw, int ch ) + + + dropped + dropped + ( QDropEvent * e ) + + + editCell + editCell + ( int row, int col, bool replace = false ) + + + editMode + editMode + () + + + endEdit + endEdit + ( int row, int col, bool accept, bool replace ) + + + ensureCellVisible + ensureCellVisible + ( int row, int col ) + + + hideColumn + hideColumn + ( int col ) + + + hideRow + hideRow + ( int row ) + + + horizontalHeader + horizontalHeader + () + + + indexOf + indexOf + ( int row, int col ) + + + insertColumns + insertColumns + ( int col, int count = 1 ) + + + insertRows + insertRows + ( int row, int count = 1 ) + + + insertWidget + insertWidget + ( int row, int col, QWidget * w ) + + + isColumnHidden + isColumnHidden + ( int col ) + + + isColumnReadOnly + isColumnReadOnly + ( int col ) + + + isColumnSelected + isColumnSelected + ( int col, bool full = false ) + + + isColumnStretchable + isColumnStretchable + ( int col ) + + + isEditing + isEditing + () + + + isRowHidden + isRowHidden + ( int row ) + + + isRowReadOnly + isRowReadOnly + ( int row ) + + + isRowSelected + isRowSelected + ( int row, bool full = false ) + + + isRowStretchable + isRowStretchable + ( int row ) + + + isSelected + isSelected + ( int row, int col ) + + + item + item + ( int row, int col ) + + + paintCell + paintCell + ( QPainter * p, int row, int col, const QRect & cr, bool selected, const QColorGroup & cg ) + + + paintCell + paintCell-2 + ( QPainter * p, int row, int col, const QRect & cr, bool selected ) + + + paintEmptyArea + paintEmptyArea + ( QPainter * p, int cx, int cy, int cw, int ch ) + + + paintFocus + paintFocus + ( QPainter * p, const QRect & cr ) + + + pixmap + pixmap + ( int row, int col ) + + + pressed + pressed + ( int row, int col, int button, const QPoint & mousePos ) + + + removeColumn + removeColumn + ( int col ) + + + removeColumns + removeColumns + ( const Q3MemArray<int> & cols ) + + + removeRow + removeRow + ( int row ) + + + removeRows + removeRows + ( const Q3MemArray<int> & rows ) + + + removeSelection + removeSelection + ( const Q3TableSelection & s ) + + + removeSelection + removeSelection-2 + ( int num ) + + + repaintSelections + repaintSelections + () + + + resizeData + resizeData + ( int len ) + + + rowAt + rowAt + ( int y ) + + + rowHeight + rowHeight + ( int row ) + + + rowHeightChanged + rowHeightChanged + ( int row ) + + + rowIndexChanged + rowIndexChanged + ( int section, int fromIndex, int toIndex ) + + + rowPos + rowPos + ( int row ) + + + selectCells + selectCells + ( int start_row, int start_col, int end_row, int end_col ) + + + selectColumn + selectColumn + ( int col ) + + + selectRow + selectRow + ( int row ) + + + selection + selection + ( int num ) + + + selectionChanged + selectionChanged + () + + + setCellContentFromEditor + setCellContentFromEditor + ( int row, int col ) + + + setCellWidget + setCellWidget + ( int row, int col, QWidget * e ) + + + setColumnLabels + setColumnLabels + ( const QStringList & labels ) + + + setColumnReadOnly + setColumnReadOnly + ( int col, bool ro ) + + + setColumnStretchable + setColumnStretchable + ( int col, bool stretch ) + + + setColumnWidth + setColumnWidth + ( int col, int w ) + + + setCurrentCell + setCurrentCell + ( int row, int col ) + + + setDragEnabled + setDragEnabled + ( bool b ) + + + setEditMode + setEditMode + ( EditMode mode, int row, int col ) + + + setItem + setItem + ( int row, int col, Q3TableItem * item ) + + + setLeftMargin + setLeftMargin + ( int m ) + + + setPixmap + setPixmap + ( int row, int col, const QPixmap & pix ) + + + setRowHeight + setRowHeight + ( int row, int h ) + + + setRowLabels + setRowLabels + ( const QStringList & labels ) + + + setRowReadOnly + setRowReadOnly + ( int row, bool ro ) + + + setRowStretchable + setRowStretchable + ( int row, bool stretch ) + + + setText + setText + ( int row, int col, const QString & text ) + + + setTopMargin + setTopMargin + ( int m ) + + + showColumn + showColumn + ( int col ) + + + showRow + showRow + ( int row ) + + + sortColumn + sortColumn + ( int col, bool ascending = true, bool wholeRows = false ) + + + startDrag + startDrag + () + + + swapCells + swapCells + ( int row1, int col1, int row2, int col2 ) + + + swapColumns + swapColumns + ( int col1, int col2, bool swapHeader = false ) + + + swapRows + swapRows + ( int row1, int row2, bool swapHeader = false ) + + + takeItem + takeItem + ( Q3TableItem * i ) + + + text + text + ( int row, int col ) + + + updateCell + updateCell + ( int row, int col ) + + + updateHeaderStates + updateHeaderStates + () + + + valueChanged + valueChanged + ( int row, int col ) + + + verticalHeader + verticalHeader + () + + + + Q3TableItem + q3tableitem.html + + EditType + EditType-enum + + + + Q3TableItem + Q3TableItem + ( Q3Table * table, EditType et ) + + + Q3TableItem + Q3TableItem-2 + ( Q3Table * table, EditType et, const QString & text ) + + + Q3TableItem + Q3TableItem-3 + ( Q3Table * table, EditType et, const QString & text, const QPixmap & p ) + + + alignment + alignment + () + + + col + col + () + + + colSpan + colSpan + () + + + createEditor + createEditor + () + + + editType + editType + () + + + isEnabled + isEnabled + () + + + isReplaceable + isReplaceable + () + + + key + key + () + + + paint + paint + ( QPainter * p, const QColorGroup & cg, const QRect & cr, bool selected ) + + + pixmap + pixmap + () + + + row + row + () + + + rowSpan + rowSpan + () + + + rtti + rtti + () + + + setCol + setCol + ( int c ) + + + setContentFromEditor + setContentFromEditor + ( QWidget * w ) + + + setEnabled + setEnabled + ( bool b ) + + + setPixmap + setPixmap + ( const QPixmap & p ) + + + setReplaceable + setReplaceable + ( bool b ) + + + setRow + setRow + ( int r ) + + + setSpan + setSpan + ( int rs, int cs ) + + + setText + setText + ( const QString & str ) + + + setWordWrap + setWordWrap + ( bool b ) + + + sizeHint + sizeHint + () + + + table + table + () + + + text + text + () + + + wordWrap + wordWrap + () + + + + Q3TableSelection + q3tableselection.html + + Q3TableSelection + Q3TableSelection + () + + + Q3TableSelection + Q3TableSelection-2 + ( int start_row, int start_col, int end_row, int end_col ) + + + anchorCol + anchorCol + () + + + anchorRow + anchorRow + () + + + bottomRow + bottomRow + () + + + expandTo + expandTo + ( int row, int col ) + + + init + init + ( int row, int col ) + + + isActive + isActive + () + + + isEmpty + isEmpty + () + + + leftCol + leftCol + () + + + numCols + numCols + () + + + numRows + numRows + () + + + rightCol + rightCol + () + + + topRow + topRow + () + + + operator!= + operator-not-eq + ( const Q3TableSelection & s ) + + + operator== + operator-eq-eq + ( const Q3TableSelection & s ) + + + + Q3TextBrowser + q3textbrowser.html + + Q3TextBrowser + Q3TextBrowser + ( QWidget * parent = 0, const char * name = 0 ) + + + anchorClicked + anchorClicked + ( const QString & name, const QString & link ) + + + backward + backward + () + + + backwardAvailable + backwardAvailable + ( bool available ) + + + forward + forward + () + + + forwardAvailable + forwardAvailable + ( bool available ) + + + highlighted + highlighted + ( const QString & link ) + + + home + home + () + + + keyPressEvent + keyPressEvent + ( QKeyEvent * e ) + + + linkClicked + linkClicked + ( const QString & link ) + + + reload + reload + () + + + setText + setText-2 + ( const QString & txt ) + + + sourceChanged + sourceChanged + ( const QString & src ) + + + + Q3TextDrag + q3textdrag.html + + Q3TextDrag + Q3TextDrag + ( const QString & text, QWidget * dragSource = 0, const char * name = 0 ) + + + Q3TextDrag + Q3TextDrag-2 + ( QWidget * dragSource = 0, const char * name = 0 ) + + + canDecode + canDecode + ( const QMimeSource * source ) + + + decode + decode + ( const QMimeSource * source, QString & string ) + + + decode + decode-2 + ( const QMimeSource * source, QString & string, QString & subtype ) + + + setSubtype + setSubtype + ( const QString & subtype ) + + + setText + setText + ( const QString & text ) + + + + Q3TextEdit + q3textedit.html + + CursorAction + CursorAction-enum + + + + KeyboardAction + KeyboardAction-enum + + + + VerticalAlignment + VerticalAlignment-enum + + + + WordWrap + WordWrap-enum + + + + WrapPolicy + WrapPolicy-enum + + + + TextFormat + textFormat-prop + + + + Q3TextEdit + Q3TextEdit + ( const QString & text, const QString & context = QString() + + + Q3TextEdit + Q3TextEdit-2 + ( QWidget * parent = 0, const char * name = 0 ) + + + alignment + alignment + () + + + anchorAt + anchorAt + ( const QPoint & pos, Qt::AnchorAttribute attr = Qt::AnchorHref ) + + + append + append + ( const QString & text ) + + + bold + bold + () + + + charAt + charAt + ( const QPoint & pos, int * para ) + + + clear + clear + () + + + clearParagraphBackground + clearParagraphBackground + ( int para ) + + + clicked + clicked + ( int para, int pos ) + + + color + color + () + + + context + context + () + + + copy + copy + () + + + copyAvailable + copyAvailable + ( bool yes ) + + + createPopupMenu + createPopupMenu + ( const QPoint & pos ) + + + createPopupMenu + createPopupMenu-2 + () + + + currentAlignmentChanged + currentAlignmentChanged + ( int a ) + + + currentColorChanged + currentColorChanged + ( const QColor & c ) + + + currentFont + currentFont + () + + + currentFontChanged + currentFontChanged + ( const QFont & f ) + + + currentVerticalAlignmentChanged + currentVerticalAlignmentChanged + ( Q3TextEdit::VerticalAlignment a ) + + + cursorPositionChanged + cursorPositionChanged-2 + ( int para, int pos ) + + + cut + cut + () + + + del + del + () + + + doKeyboardAction + doKeyboardAction + ( Q3TextEdit::KeyboardAction action ) + + + doubleClicked + doubleClicked + ( int para, int pos ) + + + ensureCursorVisible + ensureCursorVisible + () + + + family + family + () + + + find + find + ( const QString & expr, bool cs, bool wo, bool forward = true, int * para = 0, int * index = 0 ) + + + focusNextPrevChild + focusNextPrevChild + ( bool n ) + + + font + font + () + + + getCursorPosition + getCursorPosition + ( int * para, int * index ) + + + getSelection + getSelection + ( int * paraFrom, int * indexFrom, int * paraTo, int * indexTo, int selNum = 0 ) + + + heightForWidth + heightForWidth + ( int w ) + + + insert + insert + ( const QString & text, uint insertionFlags = CheckNewLines | RemoveSelected ) + + + insert + insert-2 + ( const QString & text, bool indent, bool checkNewLine = true, bool removeSelected = true ) + + + insertAt + insertAt + ( const QString & text, int para, int index ) + + + insertParagraph + insertParagraph + ( const QString & text, int para ) + + + isRedoAvailable + isRedoAvailable + () + + + isUndoAvailable + isUndoAvailable + () + + + italic + italic + () + + + keyPressEvent + keyPressEvent + ( QKeyEvent * e ) + + + lineOfChar + lineOfChar + ( int para, int index ) + + + lines + lines + () + + + linesOfParagraph + linesOfParagraph + ( int para ) + + + mimeSourceFactory + mimeSourceFactory + () + + + modificationChanged + modificationChanged + ( bool m ) + + + moveCursor + moveCursor + ( Q3TextEdit::CursorAction action, bool select ) + + + paragraphAt + paragraphAt + ( const QPoint & pos ) + + + paragraphBackgroundColor + paragraphBackgroundColor + ( int para ) + + + paragraphLength + paragraphLength + ( int para ) + + + paragraphRect + paragraphRect + ( int para ) + + + paragraphs + paragraphs + () + + + paste + paste + () + + + pasteSubType + pasteSubType + ( const QByteArray & subtype ) + + + placeCursor + placeCursor + ( const QPoint & pos, Q3TextCursor * c = 0 ) + + + pointSize + pointSize + () + + + redo + redo + () + + + redoAvailable + redoAvailable + ( bool yes ) + + + removeParagraph + removeParagraph + ( int para ) + + + removeSelectedText + removeSelectedText + ( int selNum = 0 ) + + + removeSelection + removeSelection + ( int selNum = 0 ) + + + repaintChanged + repaintChanged + () + + + returnPressed + returnPressed + () + + + scrollToAnchor + scrollToAnchor + ( const QString & name ) + + + scrollToBottom + scrollToBottom + () + + + selectAll + selectAll + ( bool select = true ) + + + selectionChanged + selectionChanged + () + + + setAlignment + setAlignment + ( int a ) + + + setBold + setBold + ( bool b ) + + + setColor + setColor + ( const QColor & c ) + + + setCurrentFont + setCurrentFont + ( const QFont & f ) + + + setCursorPosition + setCursorPosition + ( int para, int index ) + + + setFamily + setFamily + ( const QString & fontFamily ) + + + setItalic + setItalic + ( bool b ) + + + setMimeSourceFactory + setMimeSourceFactory + ( Q3MimeSourceFactory * factory ) + + + setParagraphBackgroundColor + setParagraphBackgroundColor + ( int para, const QColor & bg ) + + + setPointSize + setPointSize + ( int s ) + + + setSelection + setSelection + ( int paraFrom, int indexFrom, int paraTo, int indexTo, int selNum = 0 ) + + + setSelectionAttributes + setSelectionAttributes + ( int selNum, const QColor & back, bool invertText ) + + + setStyleSheet + setStyleSheet + ( Q3StyleSheet * styleSheet ) + + + setUnderline + setUnderline + ( bool b ) + + + setVerticalAlignment + setVerticalAlignment + ( Q3TextEdit::VerticalAlignment a ) + + + styleSheet + styleSheet + () + + + sync + sync + () + + + syntaxHighlighter + syntaxHighlighter + () + + + textChanged + textChanged + () + + + textCursor + textCursor + () + + + underline + underline + () + + + undo + undo + () + + + undoAvailable + undoAvailable + ( bool yes ) + + + verticalAlignment + verticalAlignment + () + + + zoomIn + zoomIn + ( int range ) + + + zoomIn + zoomIn-2 + () + + + zoomOut + zoomOut + ( int range ) + + + zoomOut + zoomOut-2 + () + + + zoomTo + zoomTo + ( int size ) + + + + Q3TextView + q3textview.html + + + Q3TimeEdit + q3timeedit.html + + Display + Display-enum + + + + Q3TimeEdit + Q3TimeEdit + ( QWidget * parent = 0, const char * name = 0 ) + + + Q3TimeEdit + Q3TimeEdit-2 + ( const QTime & time, QWidget * parent = 0, const char * name = 0 ) + + + sectionFormattedText + sectionFormattedText + ( int sec ) + + + separator + separator + () + + + setHour + setHour + ( int h ) + + + setMinute + setMinute + ( int m ) + + + setRange + setRange + ( const QTime & min, const QTime & max ) + + + setSecond + setSecond + ( int s ) + + + setSeparator + setSeparator + ( const QString & s ) + + + valueChanged + valueChanged + ( const QTime & time ) + + + + Q3ToolBar + q3toolbar.html + + Q3ToolBar + Q3ToolBar + ( const QString & label, Q3MainWindow * parent, Qt::ToolBarDock dock = Qt::DockTop, bool newLine = false, const char * name = 0 ) + + + Q3ToolBar + Q3ToolBar-2 + ( const QString & label, Q3MainWindow * mainWindow, QWidget * parent, bool newLine = false, const char * name = 0, Qt::WFlags f = 0 ) + + + Q3ToolBar + Q3ToolBar-3 + ( Q3MainWindow * parent = 0, const char * name = 0 ) + + + addSeparator + addSeparator + () + + + clear + clear + () + + + mainWindow + mainWindow + () + + + setStretchableWidget + setStretchableWidget + ( QWidget * w ) + + + + Q3UriDrag + q3uridrag.html + + Q3UriDrag + Q3UriDrag + ( const Q3StrList & uris, QWidget * dragSource = 0, const char * name = 0 ) + + + Q3UriDrag + Q3UriDrag-2 + ( QWidget * dragSource = 0, const char * name = 0 ) + + + canDecode + canDecode + ( const QMimeSource * source ) + + + decode + decode + ( const QMimeSource * source, Q3StrList & list ) + + + decodeLocalFiles + decodeLocalFiles + ( const QMimeSource * source, QStringList & list ) + + + decodeToUnicodeUris + decodeToUnicodeUris + ( const QMimeSource * source, QStringList & list ) + + + localFileToUri + localFileToUri + ( const QString & filename ) + + + setFileNames + setFileNames + ( const QStringList & filenames ) + + + setFileNames + setFileNames-2 + ( const QString & name ) + + + setFilenames + setFilenames-2x + ( const QString & name ) + + + setUnicodeUris + setUnicodeUris + ( const QStringList & list ) + + + setUris + setUris + ( const QList<QByteArray> & list ) + + + unicodeUriToUri + unicodeUriToUri + ( const QString & string ) + + + uriToLocalFile + uriToLocalFile + ( const char * string ) + + + uriToUnicodeUri + uriToUnicodeUri + ( const char * string ) + + + setFilenames + setFilenamesx + ( const QStringList & list ) + + + + Q3Url + q3url.html + + Q3Url + Q3Url + () + + + Q3Url + Q3Url-2 + ( const QString & url ) + + + Q3Url + Q3Url-3 + ( const Q3Url & url ) + + + Q3Url + Q3Url-4 + ( const Q3Url & url, const QString & relUrl, bool checkSlash = false ) + + + addPath + addPath + ( const QString & pa ) + + + cdUp + cdUp + () + + + decode + decode + ( QString & url ) + + + dirPath + dirPath + () + + + encode + encode + ( QString & url ) + + + encodedPathAndQuery + encodedPathAndQuery + () + + + fileName + fileName + () + + + hasHost + hasHost + () + + + hasPassword + hasPassword + () + + + hasPath + hasPath + () + + + hasPort + hasPort + () + + + hasRef + hasRef + () + + + hasUser + hasUser + () + + + host + host + () + + + isLocalFile + isLocalFile + () + + + isRelativeUrl + isRelativeUrl + ( const QString & url ) + + + isValid + isValid + () + + + parse + parse + ( const QString & url ) + + + password + password + () + + + path + path + ( bool correct = true ) + + + port + port + () + + + protocol + protocol + () + + + query + query + () + + + ref + ref + () + + + reset + reset + () + + + setEncodedPathAndQuery + setEncodedPathAndQuery + ( const QString & pathAndQuery ) + + + setFileName + setFileName + ( const QString & name ) + + + setHost + setHost + ( const QString & host ) + + + setPassword + setPassword + ( const QString & pass ) + + + setPath + setPath + ( const QString & path ) + + + setPort + setPort + ( int port ) + + + setProtocol + setProtocol + ( const QString & protocol ) + + + setQuery + setQuery + ( const QString & txt ) + + + setRef + setRef + ( const QString & txt ) + + + setUser + setUser + ( const QString & user ) + + + toString + toString + ( bool encodedPath = false, bool forcePrependProtocol = true ) + + + user + user + () + + + operator + operator-QString + QString() + + + operator= + operator-eq + ( const Q3Url & url ) + + + operator= + operator-eq-2 + ( const QString & url ) + + + operator== + operator-eq-eq + ( const Q3Url & url ) + + + operator== + operator-eq-eq-2 + ( const QString & url ) + + + + Q3UrlOperator + q3urloperator.html + + Q3UrlOperator + Q3UrlOperator + () + + + Q3UrlOperator + Q3UrlOperator-2 + ( const QString & url ) + + + Q3UrlOperator + Q3UrlOperator-3 + ( const Q3UrlOperator & url ) + + + Q3UrlOperator + Q3UrlOperator-4 + ( const Q3UrlOperator & url, const QString & relUrl, bool checkSlash = false ) + + + clearEntries + clearEntries + () + + + connectionStateChanged + connectionStateChanged + ( int state, const QString & data ) + + + copy + copy + ( const QString & from, const QString & to, bool move = false, bool toPath = true ) + + + copy + copy-2 + ( const QStringList & files, const QString & dest, bool move = false ) + + + createdDirectory + createdDirectory + ( const QUrlInfo & i, Q3NetworkOperation * op ) + + + data + data + ( const QByteArray & data, Q3NetworkOperation * op ) + + + dataTransferProgress + dataTransferProgress + ( int bytesDone, int bytesTotal, Q3NetworkOperation * op ) + + + deleteNetworkProtocol + deleteNetworkProtocol + () + + + finished + finished + ( Q3NetworkOperation * op ) + + + get + get + ( const QString & location = QString() + + + getNetworkProtocol + getNetworkProtocol + () + + + info + info + ( const QString & entry ) + + + isDir + isDir + ( bool * ok = 0 ) + + + itemChanged + itemChanged + ( Q3NetworkOperation * op ) + + + listChildren + listChildren + () + + + mkdir + mkdir + ( const QString & dirname ) + + + nameFilter + nameFilter + () + + + newChildren + newChildren + ( const Q3ValueList<QUrlInfo> & i, Q3NetworkOperation * op ) + + + put + put + ( const QByteArray & data, const QString & location = QString() + + + remove + remove + ( const QString & filename ) + + + removed + removed + ( Q3NetworkOperation * op ) + + + rename + rename + ( const QString & oldname, const QString & newname ) + + + setNameFilter + setNameFilter + ( const QString & nameFilter ) + + + start + start + ( Q3NetworkOperation * op ) + + + startedNextCopy + startedNextCopy + ( const Q3PtrList<Q3NetworkOperation> & lst ) + + + stop + stop + () + + + operator= + operator-eq + ( const Q3UrlOperator & url ) + + + operator= + operator-eq-2 + ( const QString & url ) + + + + Q3ValueListConstIterator + q3valuelistconstiterator.html + + Q3ValueListConstIterator + Q3ValueListConstIterator + () + + + Q3ValueListConstIterator + Q3ValueListConstIterator-2 + ( const Q3ValueListConstIterator & o ) + + + Q3ValueListConstIterator + Q3ValueListConstIterator-3 + ( const QLinkedList<T>::const_iterator & o ) + + + Q3ValueListConstIterator + Q3ValueListConstIterator-4 + ( const QLinkedList<T>::iterator & o ) + + + + Q3ValueList + q3valuelist.html + + ConstIterator + ConstIterator-typedef + + + + Iterator + Iterator-typedef + + + + const_iterator + const_iterator-typedef + + + + const_pointer + const_pointer-typedef + + + + const_reference + const_reference-typedef + + + + iterator + iterator-typedefx + + + + pointer + pointer-typedef + + + + reference + reference-typedef + + + + size_type + size_type-typedef + + + + value_type + value_type-typedef + + + + Q3ValueList + Q3ValueList + () + + + Q3ValueList + Q3ValueList-2 + ( const Q3ValueList<T> & l ) + + + Q3ValueList + Q3ValueList-3 + ( const QLinkedList<T> & l ) + + + Q3ValueList + Q3ValueList-4 + ( const QList<T> & l ) + + + Q3ValueList + Q3ValueList-5 + ( const std::list<T> & l ) + + + append + append + ( const T & x ) + + + at + at + ( Q3ValueList<T>::size_type i ) + + + at + at-2 + ( Q3ValueList<T>::size_type i ) + + + contains + contains + ( const T & x ) + + + fromLast + fromLast + () + + + fromLast + fromLast-2 + () + + + insert + insert + ( Q3ValueList<T>::Iterator it, const T & x ) + + + insert + insert-2 + ( Q3ValueList<T>::Iterator pos, Q3ValueList<T>::size_type n, const T & x ) + + + prepend + prepend + ( const T & x ) + + + remove + remove + ( Q3ValueList<T>::Iterator it ) + + + remove + remove-2 + ( const T & x ) + + + operator + operator-QList-ltT-gt + QList<T>() + + + operator!= + operator-not-eq + ( const Q3ValueList<T> & l ) + + + operator+ + operator-2b + ( const Q3ValueList<T> & l ) + + + operator+= + operator-2b-eq + ( const Q3ValueList<T> & l ) + + + operator+= + operator-2b-eq-2 + ( const T & x ) + + + operator<< + operator-lt-lt + ( const T & x ) + + + operator= + operator-eq + ( const Q3ValueList<T> & l ) + + + operator= + operator-eq-2 + ( const QList<T> & l ) + + + operator= + operator-eq-3 + ( const std::list<T> & l ) + + + operator== + operator-eq-eq + ( const Q3ValueList<T> & l ) + + + operator== + operator-eq-eq-2 + ( const std::list<T> & l ) + + + operator[] + operator-5b-5d + ( Q3ValueList<T>::size_type i ) + + + operator[] + operator-5b-5d-2 + ( Q3ValueList<T>::size_type i ) + + + + Q3ValueListIterator + q3valuelistiterator.html + + Q3ValueListIterator + Q3ValueListIterator + () + + + Q3ValueListIterator + Q3ValueListIterator-2 + ( const Q3ValueListIterator & o ) + + + Q3ValueListIterator + Q3ValueListIterator-3 + ( const QLinkedList<T>::iterator & o ) + + + + Q3ValueStack + q3valuestack.html + + Q3ValueStack + Q3ValueStack + () + + + pop + pop + () + + + push + push + ( const T & d ) + + + top + top + () + + + top + top-2 + () + + + + Q3ValueVector + q3valuevector.html + + Q3ValueVector + Q3ValueVector + () + + + Q3ValueVector + Q3ValueVector-2 + ( const Q3ValueVector<T> & v ) + + + Q3ValueVector + Q3ValueVector-3 + ( QVector<T>::size_type n, const T & val = T() + + + Q3ValueVector + Q3ValueVector-4 + ( const std::vector<T> & v ) + + + at + at + ( int i, bool * ok = 0 ) + + + at + at-2 + ( int i, bool * ok = 0 ) + + + resize + resize + ( int n, const T & val = T() + + + operator= + operator-eq + ( const Q3ValueVector<T> & v ) + + + operator= + operator-eq-2 + ( const std::vector<T> & v ) + + + + Q3VBox + q3vbox.html + + Q3VBox + Q3VBox + ( QWidget * parent = 0, const char * name = 0, Qt::WFlags f = 0 ) + + + + Q3VButtonGroup + q3vbuttongroup.html + + Q3VButtonGroup + Q3VButtonGroup + ( QWidget * parent = 0, const char * name = 0 ) + + + Q3VButtonGroup + Q3VButtonGroup-2 + ( const QString & title, QWidget * parent = 0, const char * name = 0 ) + + + + Q3WhatsThis + q3whatsthis.html + + Q3WhatsThis + Q3WhatsThis + ( QWidget * widget ) + + + add + add + ( QWidget * widget, const QString & text ) + + + clicked + clicked + ( const QString & href ) + + + display + display + ( const QString & text, const QPoint & pos = QCursor::pos() + + + enterWhatsThisMode + enterWhatsThisMode + () + + + inWhatsThisMode + inWhatsThisMode + () + + + leaveWhatsThisMode + leaveWhatsThisMode + ( const QString & text = QString() + + + remove + remove + ( QWidget * widget ) + + + text + text + ( const QPoint & pos ) + + + whatsThisButton + whatsThisButton + ( QWidget * parent ) + + + + Q3WidgetStack + q3widgetstack.html + + Q3WidgetStack + Q3WidgetStack + ( QWidget * parent, const char * name = 0, Qt::WFlags f = 0 ) + + + aboutToShow + aboutToShow + ( int id ) + + + aboutToShow + aboutToShow-2 + ( QWidget * widget ) + + + addWidget + addWidget + ( QWidget * w, int id = -1 ) + + + id + id + ( QWidget * widget ) + + + raiseWidget + raiseWidget + ( int id ) + + + raiseWidget + raiseWidget-2 + ( QWidget * w ) + + + removeWidget + removeWidget + ( QWidget * w ) + + + setChildGeometries + setChildGeometries + () + + + visibleWidget + visibleWidget + () + + + widget + widget + ( int id ) + + + + Q3Wizard + q3wizard.html + + Q3Wizard + Q3Wizard + ( QWidget * parent = 0, const char * name = 0, bool modal = false, Qt::WFlags f = 0 ) + + + addPage + addPage + ( QWidget * page, const QString & title ) + + + appropriate + appropriate + ( QWidget * page ) + + + back + back + () + + + backButton + backButton + () + + + cancelButton + cancelButton + () + + + currentPage + currentPage + () + + + finishButton + finishButton + () + + + help + help + () + + + helpButton + helpButton + () + + + helpClicked + helpClicked + () + + + indexOf + indexOf + ( QWidget * page ) + + + insertPage + insertPage + ( QWidget * page, const QString & title, int index ) + + + layOutButtonRow + layOutButtonRow + ( QHBoxLayout * layout ) + + + layOutTitleRow + layOutTitleRow + ( QHBoxLayout * layout, const QString & title ) + + + next + next + () + + + nextButton + nextButton + () + + + page + page + ( int index ) + + + pageCount + pageCount + () + + + removePage + removePage + ( QWidget * page ) + + + selected + selected + ( const QString & title ) + + + setAppropriate + setAppropriate + ( QWidget * page, bool appropriate ) + + + setBackEnabled + setBackEnabled + ( QWidget * page, bool enable ) + + + setFinishEnabled + setFinishEnabled + ( QWidget * page, bool enable ) + + + setHelpEnabled + setHelpEnabled + ( QWidget * page, bool enable ) + + + setNextEnabled + setNextEnabled + ( QWidget * page, bool enable ) + + + setTitle + setTitle + ( QWidget * page, const QString & title ) + + + showPage + showPage + ( QWidget * page ) + + + title + title + ( QWidget * page ) + + + setFinish + setFinish + ( QWidget * widget, bool finish ) + + + + QAbstractButton + qabstractbutton.html + + QAbstractButton + QAbstractButton + ( QWidget * parent = 0 ) + + + animateClick + animateClick + ( int msec = 100 ) + + + checkStateSet + checkStateSet + () + + + click + click + () + + + clicked + clicked + ( bool checked = false ) + + + group + group + () + + + hitButton + hitButton + ( const QPoint & pos ) + + + nextCheckState + nextCheckState + () + + + pressed + pressed + () + + + released + released + () + + + toggle + toggle + () + + + toggled + toggled + ( bool checked ) + + + QAbstractButton + QAbstractButton-2 + ( QWidget * parent, const char * name, Qt::WFlags f = 0 ) + + + accel + accel + () + + + iconSet + iconSet + () + + + isOn + isOn + () + + + isToggleButton + isToggleButton + () + + + pixmap + pixmap + () + + + setAccel + setAccel + ( const QKeySequence & key ) + + + setIconSet + setIconSet + ( const QIcon & icon ) + + + setOn + setOn + ( bool b ) + + + setPixmap + setPixmap + ( const QPixmap & p ) + + + setToggleButton + setToggleButton + ( bool b ) + + + + QAbstractEventDispatcher + qabstracteventdispatcher.html + + EventFilter + EventFilter-typedef + + + + TimerInfo + TimerInfo-typedef + + + + QAbstractEventDispatcher + QAbstractEventDispatcher + ( QObject * parent = 0 ) + + + aboutToBlock + aboutToBlock + () + + + awake + awake + () + + + filterEvent + filterEvent + ( void * message ) + + + flush + flush + () + + + hasPendingEvents + hasPendingEvents + () + + + instance + instance + ( QThread * thread = 0 ) + + + interrupt + interrupt + () + + + processEvents + processEvents + ( QEventLoop::ProcessEventsFlags flags ) + + + registerSocketNotifier + registerSocketNotifier + ( QSocketNotifier * notifier ) + + + registerTimer + registerTimer + ( int interval, QObject * object ) + + + registerTimer + registerTimer-2 + ( int timerId, int interval, QObject * object ) + + + registeredTimers + registeredTimers + ( QObject * object ) + + + setEventFilter + setEventFilter + ( EventFilter filter ) + + + unregisterSocketNotifier + unregisterSocketNotifier + ( QSocketNotifier * notifier ) + + + unregisterTimer + unregisterTimer + ( int timerId ) + + + unregisterTimers + unregisterTimers + ( QObject * object ) + + + wakeUp + wakeUp + () + + + + QAbstractExtensionFactory + qabstractextensionfactory.html + + extension + extension + ( QObject * object, const QString & iid ) + + + + QAbstractExtensionManager + qabstractextensionmanager.html + + extension + extension + ( QObject * object, const QString & iid ) + + + registerExtensions + registerExtensions + ( QAbstractExtensionFactory * factory, const QString & iid ) + + + unregisterExtensions + unregisterExtensions + ( QAbstractExtensionFactory * factory, const QString & iid ) + + + + QAbstractFileEngineHandler + qabstractfileenginehandler.html + + QAbstractFileEngineHandler + QAbstractFileEngineHandler + () + + + create + create + ( const QString & fileName ) + + + + QAbstractFileEngine + qabstractfileengine.html + + FileName + FileName-enum + + + + FileOwner + FileOwner-enum + + + + FileTime + FileTime-enum + + + + QAbstractFileEngine + QAbstractFileEngine + () + + + caseSensitive + caseSensitive + () + + + close + close + () + + + copy + copy + ( const QString & newName ) + + + create + create + ( const QString & fileName ) + + + entryList + entryList + ( QDir::Filters filters, const QStringList & filterNames ) + + + FileError + error + QAbstractFileEngine::error() + + + errorString + errorString + () + + + fileFlags + fileFlags + ( FileFlags type = FileInfoAll ) + + + fileName + fileName + ( FileName file = DefaultName ) + + + fileTime + fileTime + ( FileTime time ) + + + flush + flush + () + + + handle + handle + () + + + isRelativePath + isRelativePath + () + + + isSequential + isSequential + () + + + link + link + ( const QString & newName ) + + + mkdir + mkdir + ( const QString & dirName, bool createParentDirectories ) + + + open + open + ( QIODevice::OpenMode mode ) + + + owner + owner + ( FileOwner owner ) + + + ownerId + ownerId + ( FileOwner owner ) + + + pos + pos + () + + + read + read + ( char * data, qint64 maxlen ) + + + readLine + readLine + ( char * data, qint64 maxlen ) + + + remove + remove + () + + + rename + rename + ( const QString & newName ) + + + rmdir + rmdir + ( const QString & dirName, bool recurseParentDirectories ) + + + seek + seek + ( qint64 offset ) + + + setError + setError + ( QFile::FileError error, const QString & errorString ) + + + setFileName + setFileName + ( const QString & file ) + + + setPermissions + setPermissions + ( uint perms ) + + + setSize + setSize + ( qint64 size ) + + + size + size + () + + + write + write + ( const char * data, qint64 len ) + + + + QAbstractFormBuilder + qabstractformbuilder.html + + QAbstractFormBuilder + QAbstractFormBuilder + () + + + load + load + ( QIODevice * device, QWidget * parent = 0 ) + + + save + save + ( QIODevice * device, QWidget * widget ) + + + setWorkingDirectory + setWorkingDirectory + ( const QDir & directory ) + + + workingDirectory + workingDirectory + () + + + + QAbstractItemDelegate + qabstractitemdelegate.html + + EndEditHint + EndEditHint-enum + + + + QAbstractItemDelegate + QAbstractItemDelegate + ( QObject * parent = 0 ) + + + closeEditor + closeEditor + ( QWidget * editor, QAbstractItemDelegate::EndEditHint hint = NoHint ) + + + commitData + commitData + ( QWidget * editor ) + + + createEditor + createEditor + ( QWidget * parent, const QStyleOptionViewItem & option, const QModelIndex & index ) + + + editorEvent + editorEvent + ( QEvent * event, QAbstractItemModel * model, const QStyleOptionViewItem & option, const QModelIndex & index ) + + + elidedText + elidedText + ( const QFontMetrics & fontMetrics, int width, Qt::TextElideMode mode, const QString & text ) + + + paint + paint + ( QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index ) + + + setEditorData + setEditorData + ( QWidget * editor, const QModelIndex & index ) + + + setModelData + setModelData + ( QWidget * editor, QAbstractItemModel * model, const QModelIndex & index ) + + + sizeHint + sizeHint + ( const QStyleOptionViewItem & option, const QModelIndex & index ) + + + updateEditorGeometry + updateEditorGeometry + ( QWidget * editor, const QStyleOptionViewItem & option, const QModelIndex & index ) + + + + QAbstractItemModel + qabstractitemmodel.html + + QAbstractItemModel + QAbstractItemModel + ( QObject * parent = 0 ) + + + beginInsertColumns + beginInsertColumns + ( const QModelIndex & parent, int first, int last ) + + + beginInsertRows + beginInsertRows + ( const QModelIndex & parent, int first, int last ) + + + beginRemoveColumns + beginRemoveColumns + ( const QModelIndex & parent, int first, int last ) + + + beginRemoveRows + beginRemoveRows + ( const QModelIndex & parent, int first, int last ) + + + buddy + buddy + ( const QModelIndex & index ) + + + canFetchMore + canFetchMore + ( const QModelIndex & parent ) + + + changePersistentIndex + changePersistentIndex + ( const QModelIndex & from, const QModelIndex & to ) + + + changePersistentIndexList + changePersistentIndexList + ( const QModelIndexList & from, const QModelIndexList & to ) + + + columnCount + columnCount + ( const QModelIndex & parent = QModelIndex() + + + columnsAboutToBeInserted + columnsAboutToBeInserted + ( const QModelIndex & parent, int start, int end ) + + + columnsAboutToBeRemoved + columnsAboutToBeRemoved + ( const QModelIndex & parent, int start, int end ) + + + columnsInserted + columnsInserted + ( const QModelIndex & parent, int start, int end ) + + + columnsRemoved + columnsRemoved + ( const QModelIndex & parent, int start, int end ) + + + createIndex + createIndex + ( int row, int column, void * ptr = 0 ) + + + createIndex + createIndex-2 + ( int row, int column, int id ) + + + data + data + ( const QModelIndex & index, int role = Qt::DisplayRole ) + + + dataChanged + dataChanged + ( const QModelIndex & topLeft, const QModelIndex & bottomRight ) + + + dropMimeData + dropMimeData + ( const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent ) + + + endInsertColumns + endInsertColumns + () + + + endInsertRows + endInsertRows + () + + + endRemoveColumns + endRemoveColumns + () + + + endRemoveRows + endRemoveRows + () + + + fetchMore + fetchMore + ( const QModelIndex & parent ) + + + ItemFlags + flags + QAbstractItemModel::flags( const QModelIndex & index ) + + + hasChildren + hasChildren + ( const QModelIndex & parent = QModelIndex() + + + hasIndex + hasIndex + ( int row, int column, const QModelIndex & parent = QModelIndex() + + + headerData + headerData + ( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) + + + headerDataChanged + headerDataChanged + ( Qt::Orientation orientation, int first, int last ) + + + index + index + ( int row, int column, const QModelIndex & parent = QModelIndex() + + + insertColumn + insertColumn + ( int column, const QModelIndex & parent = QModelIndex() + + + insertColumns + insertColumns + ( int column, int count, const QModelIndex & parent = QModelIndex() + + + insertRow + insertRow + ( int row, const QModelIndex & parent = QModelIndex() + + + insertRows + insertRows + ( int row, int count, const QModelIndex & parent = QModelIndex() + + + itemData + itemData + ( const QModelIndex & index ) + + + layoutChanged + layoutChanged + () + + + match + match + ( const QModelIndex & start, int role, const QVariant & value, int hits = 1, Qt::MatchFlags flags = Qt::MatchFlags( Qt::MatchStartsWith | Qt::MatchWrap ) + + + mimeData + mimeData + ( const QModelIndexList & indexes ) + + + mimeTypes + mimeTypes + () + + + modelReset + modelReset + () + + + parent + parent + ( const QModelIndex & index ) + + + removeColumn + removeColumn + ( int column, const QModelIndex & parent = QModelIndex() + + + removeColumns + removeColumns + ( int column, int count, const QModelIndex & parent = QModelIndex() + + + removeRow + removeRow + ( int row, const QModelIndex & parent = QModelIndex() + + + removeRows + removeRows + ( int row, int count, const QModelIndex & parent = QModelIndex() + + + reset + reset + () + + + revert + revert + () + + + rowCount + rowCount + ( const QModelIndex & parent = QModelIndex() + + + rowsAboutToBeInserted + rowsAboutToBeInserted + ( const QModelIndex & parent, int start, int end ) + + + rowsAboutToBeRemoved + rowsAboutToBeRemoved + ( const QModelIndex & parent, int start, int end ) + + + rowsInserted + rowsInserted + ( const QModelIndex & parent, int start, int end ) + + + rowsRemoved + rowsRemoved + ( const QModelIndex & parent, int start, int end ) + + + setData + setData + ( const QModelIndex & index, const QVariant & value, int role = Qt::EditRole ) + + + setHeaderData + setHeaderData + ( int section, Qt::Orientation orientation, const QVariant & value, int role = Qt::EditRole ) + + + setItemData + setItemData + ( const QModelIndex & index, const QMap<int, QVariant> & roles ) + + + sibling + sibling + ( int row, int column, const QModelIndex & index ) + + + sort + sort + ( int column, Qt::SortOrder order = Qt::AscendingOrder ) + + + span + span + ( const QModelIndex & index ) + + + submit + submit + () + + + DropActions + supportedDropActions + QAbstractItemModel::supportedDropActions() + + + + QAbstractItemView + qabstractitemview.html + + CursorAction + CursorAction-enum + + + + DropIndicatorPosition + DropIndicatorPosition-enum + + + + ScrollHint + ScrollHint-enum + + + + SelectionBehavior + SelectionBehavior-enum + + + + SelectionMode + SelectionMode-enum + + + + State + State-enum + + + + TextElideMode + textElideMode-prop + + + + QAbstractItemView + QAbstractItemView + ( QWidget * parent = 0 ) + + + activated + activated + ( const QModelIndex & index ) + + + clearSelection + clearSelection + () + + + clicked + clicked + ( const QModelIndex & index ) + + + closeEditor + closeEditor + ( QWidget * editor, QAbstractItemDelegate::EndEditHint hint ) + + + closePersistentEditor + closePersistentEditor + ( const QModelIndex & index ) + + + commitData + commitData + ( QWidget * editor ) + + + currentChanged + currentChanged + ( const QModelIndex & current, const QModelIndex & previous ) + + + currentIndex + currentIndex + () + + + dataChanged + dataChanged + ( const QModelIndex & topLeft, const QModelIndex & bottomRight ) + + + dirtyRegionOffset + dirtyRegionOffset + () + + + doubleClicked + doubleClicked + ( const QModelIndex & index ) + + + dragEnterEvent + dragEnterEvent + ( QDragEnterEvent * event ) + + + dragLeaveEvent + dragLeaveEvent + ( QDragLeaveEvent * event ) + + + dragMoveEvent + dragMoveEvent + ( QDragMoveEvent * event ) + + + dropEvent + dropEvent + ( QDropEvent * event ) + + + dropIndicatorPosition + dropIndicatorPosition + () + + + edit + edit + ( const QModelIndex & index ) + + + edit + edit-2 + ( const QModelIndex & index, EditTrigger trigger, QEvent * event ) + + + editorDestroyed + editorDestroyed + ( QObject * editor ) + + + entered + entered + ( const QModelIndex & index ) + + + executeDelayedItemsLayout + executeDelayedItemsLayout + () + + + focusInEvent + focusInEvent + ( QFocusEvent * event ) + + + focusOutEvent + focusOutEvent + ( QFocusEvent * event ) + + + horizontalOffset + horizontalOffset + () + + + horizontalStepsPerItem + horizontalStepsPerItem + () + + + indexAt + indexAt + ( const QPoint & point ) + + + indexWidget + indexWidget + ( const QModelIndex & index ) + + + isIndexHidden + isIndexHidden + ( const QModelIndex & index ) + + + itemDelegate + itemDelegate + () + + + keyPressEvent + keyPressEvent + ( QKeyEvent * event ) + + + keyboardSearch + keyboardSearch + ( const QString & search ) + + + model + model + () + + + mouseDoubleClickEvent + mouseDoubleClickEvent + ( QMouseEvent * event ) + + + mouseMoveEvent + mouseMoveEvent + ( QMouseEvent * event ) + + + mousePressEvent + mousePressEvent + ( QMouseEvent * event ) + + + mouseReleaseEvent + mouseReleaseEvent + ( QMouseEvent * event ) + + + moveCursor + moveCursor + ( CursorAction cursorAction, Qt::KeyboardModifiers modifiers ) + + + openPersistentEditor + openPersistentEditor + ( const QModelIndex & index ) + + + pressed + pressed + ( const QModelIndex & index ) + + + reset + reset + () + + + resizeEvent + resizeEvent + ( QResizeEvent * event ) + + + rootIndex + rootIndex + () + + + rowsAboutToBeRemoved + rowsAboutToBeRemoved + ( const QModelIndex & parent, int start, int end ) + + + rowsInserted + rowsInserted + ( const QModelIndex & parent, int start, int end ) + + + scheduleDelayedItemsLayout + scheduleDelayedItemsLayout + () + + + scrollDirtyRegion + scrollDirtyRegion + ( int dx, int dy ) + + + scrollTo + scrollTo + ( const QModelIndex & index, ScrollHint hint = EnsureVisible ) + + + scrollToBottom + scrollToBottom + () + + + scrollToTop + scrollToTop + () + + + selectAll + selectAll + () + + + selectedIndexes + selectedIndexes + () + + + selectionChanged + selectionChanged + ( const QItemSelection & selected, const QItemSelection & deselected ) + + + SelectionFlags + selectionCommand + QAbstractItemView::selectionCommand( const QModelIndex & index, const QEvent * event = 0 ) + + + selectionModel + selectionModel + () + + + setCurrentIndex + setCurrentIndex + ( const QModelIndex & index ) + + + setDirtyRegion + setDirtyRegion + ( const QRegion & region ) + + + setHorizontalStepsPerItem + setHorizontalStepsPerItem + ( int steps ) + + + setIndexWidget + setIndexWidget + ( const QModelIndex & index, QWidget * widget ) + + + setItemDelegate + setItemDelegate + ( QAbstractItemDelegate * delegate ) + + + setModel + setModel + ( QAbstractItemModel * model ) + + + setRootIndex + setRootIndex + ( const QModelIndex & index ) + + + setSelection + setSelection + ( const QRect & rect, QItemSelectionModel::SelectionFlags flags ) + + + setSelectionModel + setSelectionModel + ( QItemSelectionModel * selectionModel ) + + + setState + setState + ( State state ) + + + setVerticalStepsPerItem + setVerticalStepsPerItem + ( int steps ) + + + sizeHintForColumn + sizeHintForColumn + ( int column ) + + + sizeHintForIndex + sizeHintForIndex + ( const QModelIndex & index ) + + + sizeHintForRow + sizeHintForRow + ( int row ) + + + startDrag + startDrag + ( Qt::DropActions supportedActions ) + + + state + state + () + + + timerEvent + timerEvent + ( QTimerEvent * event ) + + + verticalOffset + verticalOffset + () + + + verticalStepsPerItem + verticalStepsPerItem + () + + + viewOptions + viewOptions + () + + + viewportEntered + viewportEntered + () + + + viewportEvent + viewportEvent + ( QEvent * event ) + + + visualRect + visualRect + ( const QModelIndex & index ) + + + visualRegionForSelection + visualRegionForSelection + ( const QItemSelection & selection ) + + + + QAbstractListModel + qabstractlistmodel.html + + QAbstractListModel + QAbstractListModel + ( QObject * parent = 0 ) + + + index + index + ( int row, int column = 0, const QModelIndex & parent = QModelIndex() + + + + QAbstractPrintDialog + qabstractprintdialog.html + + PrintRange + PrintRange-enum + + + + QAbstractPrintDialog + QAbstractPrintDialog + ( QPrinter * printer, QWidget * parent = 0 ) + + + addEnabledOption + addEnabledOption + ( PrintDialogOption option ) + + + enabledOptions + enabledOptions + () + + + exec + exec + () + + + fromPage + fromPage + () + + + isOptionEnabled + isOptionEnabled + ( PrintDialogOption option ) + + + maxPage + maxPage + () + + + minPage + minPage + () + + + printRange + printRange + () + + + printer + printer + () + + + setEnabledOptions + setEnabledOptions + ( PrintDialogOptions options ) + + + setFromTo + setFromTo + ( int from, int to ) + + + setMinMax + setMinMax + ( int min, int max ) + + + setPrintRange + setPrintRange + ( PrintRange range ) + + + toPage + toPage + () + + + + QAbstractProxyModel + qabstractproxymodel.html + + QAbstractProxyModel + QAbstractProxyModel + ( QObject * parent = 0 ) + + + mapFromSource + mapFromSource + ( const QModelIndex & sourceIndex ) + + + mapSelectionFromSource + mapSelectionFromSource + ( const QItemSelection & sourceSelection ) + + + mapSelectionToSource + mapSelectionToSource + ( const QItemSelection & proxySelection ) + + + mapToSource + mapToSource + ( const QModelIndex & proxyIndex ) + + + setSourceModel + setSourceModel + ( QAbstractItemModel * sourceModel ) + + + sourceModel + sourceModel + () + + + + QAbstractScrollArea + qabstractscrollarea.html + + ScrollBarPolicy + horizontalScrollBarPolicy-prop + + + + ScrollBarPolicy + verticalScrollBarPolicy-prop + + + + QAbstractScrollArea + QAbstractScrollArea + ( QWidget * parent = 0 ) + + + contextMenuEvent + contextMenuEvent + ( QContextMenuEvent * e ) + + + dragEnterEvent + dragEnterEvent + ( QDragEnterEvent * event ) + + + dragLeaveEvent + dragLeaveEvent + ( QDragLeaveEvent * event ) + + + dragMoveEvent + dragMoveEvent + ( QDragMoveEvent * event ) + + + dropEvent + dropEvent + ( QDropEvent * event ) + + + event + event + ( QEvent * e ) + + + horizontalScrollBar + horizontalScrollBar + () + + + keyPressEvent + keyPressEvent + ( QKeyEvent * e ) + + + maximumViewportSize + maximumViewportSize + () + + + mouseDoubleClickEvent + mouseDoubleClickEvent + ( QMouseEvent * e ) + + + mouseMoveEvent + mouseMoveEvent + ( QMouseEvent * e ) + + + mousePressEvent + mousePressEvent + ( QMouseEvent * e ) + + + mouseReleaseEvent + mouseReleaseEvent + ( QMouseEvent * e ) + + + paintEvent + paintEvent + ( QPaintEvent * event ) + + + resizeEvent + resizeEvent + ( QResizeEvent * event ) + + + scrollContentsBy + scrollContentsBy + ( int dx, int dy ) + + + setViewportMargins + setViewportMargins + ( int left, int top, int right, int bottom ) + + + verticalScrollBar + verticalScrollBar + () + + + viewport + viewport + () + + + viewportEvent + viewportEvent + ( QEvent * e ) + + + wheelEvent + wheelEvent + ( QWheelEvent * e ) + + + + QAbstractSlider + qabstractslider.html + + SliderAction + SliderAction-enum + + + + SliderChange + SliderChange-enum + + + + Orientation + orientation-prop + + + + QAbstractSlider + QAbstractSlider + ( QWidget * parent = 0 ) + + + actionTriggered + actionTriggered + ( int action ) + + + rangeChanged + rangeChanged + ( int min, int max ) + + + repeatAction + repeatAction + () + + + setRange + setRange + ( int min, int max ) + + + setRepeatAction + setRepeatAction + ( SliderAction action, int thresholdTime = 500, int repeatTime = 50 ) + + + sliderChange + sliderChange + ( SliderChange change ) + + + sliderMoved + sliderMoved + ( int value ) + + + sliderPressed + sliderPressed + () + + + sliderReleased + sliderReleased + () + + + triggerAction + triggerAction + ( SliderAction action ) + + + valueChanged + valueChanged + ( int value ) + + + addLine + addLine + () + + + addPage + addPage + () + + + lineStep + lineStepx + () + + + maxValue + maxValue + () + + + minValue + minValue + () + + + setLineStep + setLineStep + ( int v ) + + + setMaxValue + setMaxValue + ( int v ) + + + setMinValue + setMinValue + ( int v ) + + + setSteps + setSteps + ( int single, int page ) + + + subtractLine + subtractLine + () + + + subtractPage + subtractPage + () + + + + QAbstractSocket + qabstractsocket.html + + NetworkLayerProtocol + NetworkLayerProtocol-enum + + + + SocketError + SocketError-enum + + + + SocketState + SocketState-enum + + + + SocketType + SocketType-enum + + + + QAbstractSocket + QAbstractSocket + ( SocketType socketType, QObject * parent ) + + + abort + abort + () + + + bytesAvailable + bytesAvailable + () + + + bytesToWrite + bytesToWrite + () + + + canReadLine + canReadLine + () + + + close + close + () + + + connectToHost + connectToHost + ( const QString & hostName, quint16 port, OpenMode openMode = ReadWrite ) + + + connectToHost + connectToHost-2 + ( const QHostAddress & address, quint16 port, OpenMode openMode = ReadWrite ) + + + connectToHostImplementation + connectToHostImplementation + ( const QString & hostName, quint16 port, OpenMode openMode = ReadWrite ) + + + connected + connected + () + + + disconnectFromHost + disconnectFromHost + () + + + disconnectFromHostImplementation + disconnectFromHostImplementation + () + + + disconnected + disconnected + () + + + error + error + () + + + error + error-2 + ( QAbstractSocket::SocketError socketError ) + + + flush + flush + () + + + hostFound + hostFound + () + + + isValid + isValid + () + + + localAddress + localAddress + () + + + localPort + localPort + () + + + peerAddress + peerAddress + () + + + peerName + peerName + () + + + peerPort + peerPort + () + + + proxy + proxy + () + + + readBufferSize + readBufferSize + () + + + setLocalAddress + setLocalAddress + ( const QHostAddress & address ) + + + setLocalPort + setLocalPort + ( quint16 port ) + + + setPeerAddress + setPeerAddress + ( const QHostAddress & address ) + + + setPeerName + setPeerName + ( const QString & name ) + + + setPeerPort + setPeerPort + ( quint16 port ) + + + setProxy + setProxy + ( const QNetworkProxy & networkProxy ) + + + setReadBufferSize + setReadBufferSize + ( qint64 size ) + + + setSocketDescriptor + setSocketDescriptor + ( int socketDescriptor, SocketState socketState = ConnectedState, OpenMode openMode = ReadWrite ) + + + setSocketError + setSocketError + ( SocketError socketError ) + + + setSocketState + setSocketState + ( SocketState state ) + + + socketDescriptor + socketDescriptor + () + + + socketType + socketType + () + + + state + state + () + + + stateChanged + stateChanged + ( QAbstractSocket::SocketState socketState ) + + + waitForConnected + waitForConnected + ( int msecs = 30000 ) + + + waitForDisconnected + waitForDisconnected + ( int msecs = 30000 ) + + + Error + Error-enum + + + + State + State-typedef + + + + connectionClosed + connectionClosed + () + + + delayedCloseFinished + delayedCloseFinished + () + + + setSocket + setSocket + ( int socket ) + + + socket + socket + () + + + waitForMore + waitForMore + ( int msecs, bool * timeout = 0 ) + + + + QAbstractSpinBox + qabstractspinbox.html + + ButtonSymbols + ButtonSymbols-enum + + + + Alignment + alignment-prop + + + + QAbstractSpinBox + QAbstractSpinBox + ( QWidget * parent = 0 ) + + + clear + clear + () + + + editingFinished + editingFinished + () + + + fixup + fixup + ( QString & input ) + + + interpretText + interpretText + () + + + lineEdit + lineEdit + () + + + selectAll + selectAll + () + + + setLineEdit + setLineEdit + ( QLineEdit * lineEdit ) + + + stepBy + stepBy + ( int steps ) + + + stepDown + stepDown + () + + + stepEnabled + stepEnabled + () + + + stepUp + stepUp + () + + + State + validate + QAbstractSpinBox::validate( QString & input, int & pos ) + + + + QAbstractTableModel + qabstracttablemodel.html + + QAbstractTableModel + QAbstractTableModel + ( QObject * parent = 0 ) + + + index + index + ( int row, int column, const QModelIndex & parent = QModelIndex() + + + + QAbstractTextDocumentLayout + qabstracttextdocumentlayout.html + + QAbstractTextDocumentLayout + QAbstractTextDocumentLayout + ( QTextDocument * document ) + + + anchorAt + anchorAt + ( const QPointF & position ) + + + blockBoundingRect + blockBoundingRect + ( const QTextBlock & block ) + + + document + document + () + + + documentChanged + documentChanged + ( int position, int charsRemoved, int charsAdded ) + + + documentSize + documentSize + () + + + documentSizeChanged + documentSizeChanged + ( const QSizeF & newSize ) + + + draw + draw + ( QPainter * painter, const PaintContext & context ) + + + drawInlineObject + drawInlineObject + ( QPainter * painter, const QRectF & rect, QTextInlineObject object, int posInDocument, const QTextFormat & format ) + + + format + format + ( int position ) + + + frameBoundingRect + frameBoundingRect + ( QTextFrame * frame ) + + + handlerForObject + handlerForObject + ( int objectType ) + + + hitTest + hitTest + ( const QPointF & point, Qt::HitTestAccuracy accuracy ) + + + pageCount + pageCount + () + + + pageCountChanged + pageCountChanged + ( int newPages ) + + + paintDevice + paintDevice + () + + + positionInlineObject + positionInlineObject + ( QTextInlineObject item, int posInDocument, const QTextFormat & format ) + + + registerHandler + registerHandler + ( int formatType, QObject * component ) + + + resizeInlineObject + resizeInlineObject + ( QTextInlineObject item, int posInDocument, const QTextFormat & format ) + + + setPaintDevice + setPaintDevice + ( QPaintDevice * device ) + + + update + update + ( const QRectF & rect = QRectF( 0., 0., 1000000000., 1000000000. ) + + + + QAbstractTextDocumentLayout::Selection + qabstracttextdocumentlayout-selection.html + + + QAccessibleBridge + qaccessiblebridge.html + + notifyAccessibilityUpdate + notifyAccessibilityUpdate + ( int reason, QAccessibleInterface * interface, int child ) + + + setRootObject + setRootObject + ( QAccessibleInterface * object ) + + + + QAccessibleBridgePlugin + qaccessiblebridgeplugin.html + + QAccessibleBridgePlugin + QAccessibleBridgePlugin + ( QObject * parent = 0 ) + + + create + create + ( const QString & key ) + + + keys + keys + () + + + + QAccessibleEvent + qaccessibleevent.html + + QAccessibleEvent + QAccessibleEvent + ( Type type, int child ) + + + child + child + () + + + setValue + setValue + ( const QString & text ) + + + value + value + () + + + + QAccessible + qaccessible.html + + Action + Action-enum + + + + Event + Event-enum + + + + InterfaceFactory + InterfaceFactory-typedef + + + + Role + Role-enum + + + + RootObjectHandler + RootObjectHandler-typedef + + + + Text + Text-enum + + + + UpdateHandler + UpdateHandler-typedef + + + + installFactory + installFactory + ( InterfaceFactory factory ) + + + installRootObjectHandler + installRootObjectHandler + ( RootObjectHandler handler ) + + + installUpdateHandler + installUpdateHandler + ( UpdateHandler handler ) + + + isActive + isActive + () + + + queryAccessibleInterface + queryAccessibleInterface + ( QObject * object ) + + + removeFactory + removeFactory + ( InterfaceFactory factory ) + + + setRootObject + setRootObject + ( QObject * object ) + + + updateAccessibility + updateAccessibility + ( QObject * object, int child, Event reason ) + + + + QAccessibleInterface + qaccessibleinterface.html + + actionText + actionText + ( int action, Text t, int child ) + + + childAt + childAt + ( int x, int y ) + + + childCount + childCount + () + + + doAction + doAction + ( int action, int child, const QVariantList & params = QVariantList() + + + indexOfChild + indexOfChild + ( const QAccessibleInterface * child ) + + + isValid + isValid + () + + + navigate + navigate + ( RelationFlag relation, int entry, QAccessibleInterface ** target ) + + + object + object + () + + + rect + rect + ( int child ) + + + relationTo + relationTo + ( int child, const QAccessibleInterface * other, int otherChild ) + + + role + role + ( int child ) + + + setText + setText + ( Text t, int child, const QString & text ) + + + state + state + ( int child ) + + + text + text + ( Text t, int child ) + + + userActionCount + userActionCount + ( int child ) + + + + QAccessibleObject + qaccessibleobject.html + + QAccessibleObject + QAccessibleObject + ( QObject * object ) + + + + QAccessiblePlugin + qaccessibleplugin.html + + QAccessiblePlugin + QAccessiblePlugin + ( QObject * parent = 0 ) + + + create + create + ( const QString & key, QObject * object ) + + + keys + keys + () + + + + QAccessibleWidget + qaccessiblewidget.html + + QAccessibleWidget + QAccessibleWidget + ( QWidget * w, Role role = Client, const QString & name = QString() + + + addControllingSignal + addControllingSignal + ( const QString & signal ) + + + parentObject + parentObject + () + + + setAccelerator + setAccelerator + ( const QString & accel ) + + + setDescription + setDescription + ( const QString & desc ) + + + setHelp + setHelp + ( const QString & help ) + + + setValue + setValue + ( const QString & value ) + + + widget + widget + () + + + + QActionEvent + qactionevent.html + + QActionEvent + QActionEvent + ( int type, QAction * action, QAction * before = 0 ) + + + action + action + () + + + before + before + () + + + + QActionGroup + qactiongroup.html + + QActionGroup + QActionGroup + ( QObject * parent ) + + + actions + actions + () + + + addAction + addAction + ( QAction * action ) + + + addAction + addAction-2 + ( const QString & text ) + + + addAction + addAction-3 + ( const QIcon & icon, const QString & text ) + + + checkedAction + checkedAction + () + + + hovered + hovered + ( QAction * action ) + + + removeAction + removeAction + ( QAction * action ) + + + setDisabled + setDisabled + ( bool b ) + + + triggered + triggered + ( QAction * action ) + + + add + add + ( QAction * a ) + + + addSeparator + addSeparator + () + + + addTo + addTo + ( QWidget * widget ) + + + selected + selected + ( QAction * action ) + + + + QAction + qaction.html + + ActionEvent + ActionEvent-enum + + + + ShortcutContext + shortcutContext-prop + + + + QAction + QAction + ( QObject * parent ) + + + QAction + QAction-2 + ( const QString & text, QObject * parent ) + + + QAction + QAction-3 + ( const QIcon & icon, const QString & text, QObject * parent ) + + + actionGroup + actionGroup + () + + + activate + activate + ( ActionEvent event ) + + + changed + changed + () + + + data + data + () + + + hover + hover + () + + + hovered + hovered + () + + + isSeparator + isSeparator + () + + + menu + menu + () + + + parentWidget + parentWidget + () + + + setActionGroup + setActionGroup + ( QActionGroup * group ) + + + setData + setData + ( const QVariant & data ) + + + setDisabled + setDisabled + ( bool b ) + + + setMenu + setMenu + ( QMenu * menu ) + + + setSeparator + setSeparator + ( bool b ) + + + showStatusText + showStatusText + ( QWidget * widget = 0 ) + + + toggle + toggle + () + + + toggled + toggled + ( bool checked ) + + + trigger + trigger + () + + + triggered + triggered + ( bool checked = false ) + + + QAction + QAction-4 + ( QObject * parent, const char * name ) + + + QAction + QAction-5 + ( const QString & text, const QKeySequence & shortcut, QObject * parent, const char * name ) + + + QAction + QAction-6 + ( const QIcon & icon, const QString & text, const QKeySequence & shortcut, QObject * parent, const char * name ) + + + accel + accel + () + + + activated + activated + ( int i = 0 ) + + + addTo + addTo + ( QWidget * w ) + + + iconSet + iconSet + () + + + isOn + isOn + () + + + isToggleAction + isToggleAction + () + + + menuText + menuText + () + + + removeFrom + removeFrom + ( QWidget * w ) + + + setAccel + setAccel + ( const QKeySequence & shortcut ) + + + setIconSet + setIconSet + ( const QIcon & i ) + + + setMenuText + setMenuText + ( const QString & text ) + + + setOn + setOn + ( bool b ) + + + setToggleAction + setToggleAction + ( bool b ) + + + + QApplication + qapplication.html + + ColorSpec + ColorSpec-enum + + + + Type + Type-enum + + + + LayoutDirection + layoutDirection-prop + + + + QApplication + QApplication + ( int & argc, char ** argv ) + + + QApplication + QApplication-2 + ( int & argc, char ** argv, bool GUIenabled ) + + + QApplication + QApplication-3 + ( int & argc, char ** argv, Type type ) + + + QApplication + QApplication-4 + ( Display * display, Qt::HANDLE visual = 0, Qt::HANDLE colormap = 0 ) + + + QApplication + QApplication-5 + ( Display * display, int & argc, char ** argv, Qt::HANDLE visual = 0, Qt::HANDLE colormap = 0 ) + + + aboutQt + aboutQt + () + + + activeModalWidget + activeModalWidget + () + + + activePopupWidget + activePopupWidget + () + + + activeWindow + activeWindow + () + + + allWidgets + allWidgets + () + + + beep + beep + () + + + changeOverrideCursor + changeOverrideCursor + ( const QCursor & cursor ) + + + clipboard + clipboard + () + + + closeAllWindows + closeAllWindows + () + + + colorSpec + colorSpec + () + + + commitData + commitData + ( QSessionManager & manager ) + + + desktop + desktop + () + + + desktopSettingsAware + desktopSettingsAware + () + + + exec + exec + () + + + focusChanged + focusChanged + ( QWidget * old, QWidget * now ) + + + focusWidget + focusWidget + () + + + font + font + ( const QWidget * widget = 0 ) + + + fontMetrics + fontMetrics + () + + + inputContext + inputContext + () + + + isEffectEnabled + isEffectEnabled + ( Qt::UIEffect effect ) + + + isLeftToRight + isLeftToRight + () + + + isRightToLeft + isRightToLeft + () + + + isSessionRestored + isSessionRestored + () + + + KeyboardModifiers + keyboardModifiers + QApplication::keyboardModifiers() + + + keypadNavigationEnabled + keypadNavigationEnabled + () + + + lastWindowClosed + lastWindowClosed + () + + + macEventFilter + macEventFilter + ( EventHandlerCallRef caller, EventRef event ) + + + MouseButtons + mouseButtons + QApplication::mouseButtons() + + + overrideCursor + overrideCursor + () + + + palette + palette + () + + + palette + palette-2 + ( const QWidget * widget ) + + + palette + palette-3 + ( const char * className ) + + + qwsDecoration + qwsDecoration + () + + + qwsEventFilter + qwsEventFilter + ( QWSEvent * event ) + + + qwsSetCustomColors + qwsSetCustomColors + ( QRgb * colorTable, int start, int numColors ) + + + qwsSetDecoration + qwsSetDecoration + ( QDecoration * decoration ) + + + qwsSetDecoration + qwsSetDecoration-2 + ( const QString & decoration ) + + + restoreOverrideCursor + restoreOverrideCursor + () + + + saveState + saveState + ( QSessionManager & manager ) + + + sessionId + sessionId + () + + + sessionKey + sessionKey + () + + + setActiveWindow + setActiveWindow + ( QWidget * active ) + + + setColorSpec + setColorSpec + ( int spec ) + + + setDesktopSettingsAware + setDesktopSettingsAware + ( bool on ) + + + setEffectEnabled + setEffectEnabled + ( Qt::UIEffect effect, bool enable = true ) + + + setFont + setFont + ( const QFont & font, const char * className = 0 ) + + + setInputContext + setInputContext + ( QInputContext * inputContext ) + + + setKeypadNavigationEnabled + setKeypadNavigationEnabled + ( bool enable ) + + + setOverrideCursor + setOverrideCursor + ( const QCursor & cursor ) + + + setPalette + setPalette + ( const QPalette & palette, const char * className = 0 ) + + + setStyle + setStyle + ( QStyle * style ) + + + setStyle + setStyle-2 + ( const QString & style ) + + + style + style + () + + + syncX + syncX + () + + + topLevelAt + topLevelAt + ( const QPoint & point ) + + + topLevelAt + topLevelAt-2 + ( int x, int y ) + + + topLevelWidgets + topLevelWidgets + () + + + type + type + () + + + widgetAt + widgetAt + ( const QPoint & point ) + + + widgetAt + widgetAt-4 + ( int x, int y ) + + + x11EventFilter + x11EventFilter + ( XEvent * event ) + + + x11ProcessEvent + x11ProcessEvent + ( XEvent * event ) + + + ColorMode + ColorMode-typedef + + + + colorMode + colorMode + () + + + flushX + flushX + () + + + hasGlobalMouseTracking + hasGlobalMouseTracking + () + + + Alignment + horizontalAlignment + QApplication::horizontalAlignment( Qt::Alignment align ) + + + MacintoshVersion + macVersion + QApplication::macVersion() + + + mainWidget + mainWidget + () + + + reverseLayout + reverseLayout + () + + + setColorMode + setColorMode + ( ColorMode mode ) + + + setFont + setFont-2 + ( const QFont & font, bool b, const char * className = 0 ) + + + setGlobalMouseTracking + setGlobalMouseTracking + ( bool dummy ) + + + setMainWidget + setMainWidget + ( QWidget * mainWidget ) + + + setOverrideCursor + setOverrideCursor-2 + ( const QCursor & cursor, bool replace ) + + + setPalette + setPalette-2 + ( const QPalette & pal, bool b, const char * className = 0 ) + + + setReverseLayout + setReverseLayout + ( bool reverse ) + + + setWinStyleHighlightColor + setWinStyleHighlightColor + ( const QColor & c ) + + + widgetAt + widgetAt-2 + ( int x, int y, bool child ) + + + widgetAt + widgetAt-3 + ( const QPoint & point, bool child ) + + + winStyleHighlightColor + winStyleHighlightColor + () + + + WindowsVersion + winVersion + QApplication::winVersion() + + + CustomColors + CustomColors-var + + + + NormalColors + NormalColors-var + + + + + QAssistantClient + qassistantclient.html + + QAssistantClient + QAssistantClient + ( const QString & path, QObject * parent = 0 ) + + + assistantClosed + assistantClosed + () + + + assistantOpened + assistantOpened + () + + + closeAssistant + closeAssistant + () + + + error + error + ( const QString & message ) + + + openAssistant + openAssistant + () + + + setArguments + setArguments + ( const QStringList & arguments ) + + + showPage + showPage + ( const QString & page ) + + + + QAxAggregated + qaxaggregated.html + + controllingUnknown + controllingUnknown + () + + + object + object + () + + + queryInterface + queryInterface + ( const QUuid & iid, void ** iface ) + + + widget + widget + () + + + + QAxBase + qaxbase.html + + PropertyBag + PropertyBag-typedef + + + + QAxBase + QAxBase + ( IUnknown * iface = 0 ) + + + asVariant + asVariant + () + + + clear + clear + () + + + disableClassInfo + disableClassInfo + () + + + disableEventSink + disableEventSink + () + + + disableMetaObject + disableMetaObject + () + + + dynamicCall + dynamicCall + ( const char * function, const QVariant & var1 = QVariant() + + + dynamicCall + dynamicCall-2 + ( const char * function, QList<QVariant> & vars ) + + + exception + exception + ( int code, const QString & source, const QString & desc, const QString & help ) + + + generateDocumentation + generateDocumentation + () + + + initialize + initialize + ( IUnknown ** ptr ) + + + initializeActive + initializeActive + ( IUnknown ** ptr ) + + + initializeFromFile + initializeFromFile + ( IUnknown ** ptr ) + + + initializeLicensed + initializeLicensed + ( IUnknown ** ptr ) + + + initializeRemote + initializeRemote + ( IUnknown ** ptr ) + + + isNull + isNull + () + + + propertyBag + propertyBag + () + + + propertyChanged + propertyChanged + ( const QString & name ) + + + propertyWritable + propertyWritable + ( const char * prop ) + + + queryInterface + queryInterface + ( const QUuid & uuid, void ** iface ) + + + querySubObject + querySubObject + ( const char * name, const QVariant & var1 = QVariant() + + + querySubObject + querySubObject-2 + ( const char * name, QList<QVariant> & vars ) + + + setPropertyBag + setPropertyBag + ( const PropertyBag & bag ) + + + setPropertyWritable + setPropertyWritable + ( const char * prop, bool ok ) + + + signal + signal + ( const QString & name, int argc, void * argv ) + + + verbs + verbs + () + + + + QAxBindable + qaxbindable.html + + QAxBindable + QAxBindable + () + + + clientSite + clientSite + () + + + createAggregate + createAggregate + () + + + propertyChanged + propertyChanged + ( const char * property ) + + + readData + readData + ( QIODevice * source, const QString & format ) + + + reportError + reportError + ( int code, const QString & src, const QString & desc, const QString & context = QString() + + + requestPropertyChange + requestPropertyChange + ( const char * property ) + + + writeData + writeData + ( QIODevice * sink ) + + + + QAxFactory + qaxfactory.html + + ServerType + ServerType-enum + + + + QAxFactory + QAxFactory + ( const QUuid & libid, const QUuid & appid ) + + + appID + appID + () + + + classID + classID + ( const QString & key ) + + + createObject + createObject + ( const QString & key ) + + + createObjectWrapper + createObjectWrapper + ( QObject * object, IDispatch ** wrapper ) + + + eventsID + eventsID + ( const QString & key ) + + + exposeToSuperClass + exposeToSuperClass + ( const QString & key ) + + + featureList + featureList + () + + + hasStockEvents + hasStockEvents + ( const QString & key ) + + + interfaceID + interfaceID + ( const QString & key ) + + + isServer + isServer + () + + + isService + isService + () + + + metaObject + metaObject + ( const QString & key ) + + + registerActiveObject + registerActiveObject + ( QObject * object ) + + + registerClass + registerClass + ( const QString & key, QSettings * settings ) + + + serverDirPath + serverDirPath + () + + + serverFilePath + serverFilePath + () + + + startServer + startServer + ( ServerType type = MultipleInstances ) + + + stayTopLevel + stayTopLevel + ( const QString & key ) + + + stopServer + stopServer + () + + + typeLibID + typeLibID + () + + + unregisterClass + unregisterClass + ( const QString & key, QSettings * settings ) + + + validateLicenseKey + validateLicenseKey + ( const QString & key, const QString & licenseKey ) + + + + QAxObject + qaxobject.html + + QAxObject + QAxObject + ( QObject * parent = 0 ) + + + QAxObject + QAxObject-2 + ( const QString & c, QObject * parent = 0 ) + + + QAxObject + QAxObject-3 + ( IUnknown * iface, QObject * parent = 0 ) + + + doVerb + doVerb + ( const QString & verb ) + + + + QAxScriptEngine + qaxscriptengine.html + + State + State-enum + + + + QAxScriptEngine + QAxScriptEngine + ( const QString & language, QAxScript * script ) + + + addItem + addItem + ( const QString & name ) + + + hasIntrospection + hasIntrospection + () + + + isValid + isValid + () + + + queryInterface + queryInterface + ( const QUuid & uuid, void ** iface ) + + + scriptLanguage + scriptLanguage + () + + + setState + setState + ( State st ) + + + state + state + () + + + + QAxScript + qaxscript.html + + FunctionFlags + FunctionFlags-enum + + + + QAxScript + QAxScript + ( const QString & name, QAxScriptManager * manager ) + + + call + call + ( const QString & function, const QVariant & var1 = QVariant() + + + call + call-2 + ( const QString & function, QList<QVariant> & arguments ) + + + entered + entered + () + + + error + error + ( int code, const QString & description, int sourcePosition, const QString & sourceText ) + + + finished + finished + () + + + finished + finished-2 + ( const QVariant & result ) + + + finished + finished-3 + ( int code, const QString & source, const QString & description, const QString & help ) + + + functions + functions + ( FunctionFlags flags = FunctionNames ) + + + load + load + ( const QString & code, const QString & language = QString() + + + scriptCode + scriptCode + () + + + scriptEngine + scriptEngine + () + + + scriptName + scriptName + () + + + stateChanged + stateChanged + ( int state ) + + + + QAxScriptManager + qaxscriptmanager.html + + QAxScriptManager + QAxScriptManager + ( QObject * parent = 0 ) + + + addObject + addObject + ( QAxBase * object ) + + + addObject + addObject-2 + ( QObject * object ) + + + call + call + ( const QString & function, const QVariant & var1 = QVariant() + + + call + call-2 + ( const QString & function, QList<QVariant> & arguments ) + + + error + error + ( QAxScript * script, int code, const QString & description, int sourcePosition, const QString & sourceText ) + + + functions + functions + ( QAxScript::FunctionFlags flags = QAxScript::FunctionNames ) + + + load + load + ( const QString & code, const QString & name, const QString & language ) + + + load + load-2 + ( const QString & file, const QString & name ) + + + registerEngine + registerEngine + ( const QString & name, const QString & extension, const QString & code = QString() + + + script + script + ( const QString & name ) + + + scriptFileFilter + scriptFileFilter + () + + + scriptNames + scriptNames + () + + + + QAxWidget + qaxwidget.html + + QAxWidget + QAxWidget + ( QWidget * parent = 0, Qt::WFlags f = 0 ) + + + QAxWidget + QAxWidget-2 + ( const QString & c, QWidget * parent = 0, Qt::WFlags f = 0 ) + + + QAxWidget + QAxWidget-3 + ( IUnknown * iface, QWidget * parent = 0, Qt::WFlags f = 0 ) + + + createAggregate + createAggregate + () + + + createHostWindow + createHostWindow + ( bool initialized ) + + + doVerb + doVerb + ( const QString & verb ) + + + translateKeyEvent + translateKeyEvent + ( int message, int keycode ) + + + + QBasicTimer + qbasictimer.html + + QBasicTimer + QBasicTimer + () + + + isActive + isActive + () + + + start + start + ( int msec, QObject * object ) + + + stop + stop + () + + + timerId + timerId + () + + + + QBitArray + qbitarray.html + + QBitArray + QBitArray + () + + + QBitArray + QBitArray-2 + ( int size, bool value = false ) + + + QBitArray + QBitArray-3 + ( const QBitArray & other ) + + + at + at + ( int i ) + + + clear + clear + () + + + clearBit + clearBit + ( int i ) + + + count + count + () + + + count + count-2 + ( bool on ) + + + fill + fill + ( bool value, int size = -1 ) + + + fill + fill-2 + ( bool value, int begin, int end ) + + + isEmpty + isEmpty + () + + + isNull + isNull + () + + + resize + resize + ( int size ) + + + setBit + setBit + ( int i ) + + + setBit + setBit-2 + ( int i, bool value ) + + + size + size + () + + + testBit + testBit + ( int i ) + + + toggleBit + toggleBit + ( int i ) + + + truncate + truncate + ( int pos ) + + + operator!= + operator-not-eq + ( const QBitArray & other ) + + + operator& + operator-and-eq + amp;=( const QBitArray & other ) + + + operator= + operator-eq + ( const QBitArray & other ) + + + operator== + operator-eq-eq + ( const QBitArray & other ) + + + operator[] + operator-5b-5d + ( int i ) + + + operator[] + operator-5b-5d-2 + ( int i ) + + + operator[] + operator-5b-5d-3 + ( uint i ) + + + operator[] + operator-5b-5d-4 + ( uint i ) + + + operator^= + operator-5e-eq + ( const QBitArray & other ) + + + operator|= + operator-7c-eq + ( const QBitArray & other ) + + + operator~ + operator-7e + () + + + + QBitmap + qbitmap.html + + QBitmap + QBitmap + () + + + QBitmap + QBitmap-2 + ( const QPixmap & pixmap ) + + + QBitmap + QBitmap-3 + ( int width, int height ) + + + QBitmap + QBitmap-4 + ( const QSize & size ) + + + QBitmap + QBitmap-5 + ( const QString & fileName, const char * format = 0 ) + + + clear + clear + () + + + fromData + fromData + ( const QSize & size, const uchar * bits, QImage::Format monoFormat = QImage::Format_MonoLSB ) + + + fromImage + fromImage + ( const QImage & image, Qt::ImageConversionFlags flags = Qt::AutoColor ) + + + transformed + transformed + ( const QMatrix & matrix ) + + + operator + operator-QVariant + QVariant() + + + operator= + operator-eq + ( const QPixmap & pixmap ) + + + QBitmap + QBitmap-6 + ( int width, int height, bool clear ) + + + QBitmap + QBitmap-7 + ( const QSize & size, bool clear ) + + + QBitmap + QBitmap-8 + ( int width, int height, const uchar * bits, bool isXbitmap = false ) + + + QBitmap + QBitmap-9 + ( const QImage & image ) + + + QBitmap + QBitmap-10 + ( const QSize & size, const uchar * bits, bool isXbitmap = false ) + + + xForm + xForm + ( const QMatrix & matrix ) + + + operator= + operator-eq-2 + ( const QImage & image ) + + + + QBoxLayout + qboxlayout.html + + Direction + Direction-enum + + + + QBoxLayout + QBoxLayout + ( Direction dir, QWidget * parent = 0 ) + + + addLayout + addLayout + ( QLayout * layout, int stretch = 0 ) + + + addSpacing + addSpacing + ( int size ) + + + addStretch + addStretch + ( int stretch = 0 ) + + + addStrut + addStrut + ( int size ) + + + addWidget + addWidget + ( QWidget * widget, int stretch = 0, Qt::Alignment alignment = 0 ) + + + direction + direction + () + + + insertItem + insertItem + ( int index, QLayoutItem * item ) + + + insertLayout + insertLayout + ( int index, QLayout * layout, int stretch = 0 ) + + + insertSpacing + insertSpacing + ( int index, int size ) + + + insertStretch + insertStretch + ( int index, int stretch = 0 ) + + + insertWidget + insertWidget + ( int index, QWidget * widget, int stretch = 0, Qt::Alignment alignment = 0 ) + + + invalidate + invalidate + () + + + setDirection + setDirection + ( Direction direction ) + + + setStretchFactor + setStretchFactor + ( QWidget * widget, int stretch ) + + + setStretchFactor + setStretchFactor-2 + ( QLayout * layout, int stretch ) + + + QBoxLayout + QBoxLayout-2 + ( QWidget * parent, Direction dir, int margin = 0, int spacing = -1, const char * name = 0 ) + + + QBoxLayout + QBoxLayout-3 + ( QLayout * parentLayout, Direction dir, int spacing = -1, const char * name = 0 ) + + + QBoxLayout + QBoxLayout-4 + ( Direction dir, int spacing, const char * name = 0 ) + + + findWidget + findWidget + ( QWidget * widget ) + + + + QBrush + qbrush.html + + QBrush + QBrush + () + + + QBrush + QBrush-2 + ( Qt::BrushStyle style ) + + + QBrush + QBrush-3 + ( const QColor & color, Qt::BrushStyle style = Qt::SolidPattern ) + + + QBrush + QBrush-4 + ( Qt::GlobalColor color, Qt::BrushStyle style = Qt::SolidPattern ) + + + QBrush + QBrush-5 + ( const QColor & color, const QPixmap & pixmap ) + + + QBrush + QBrush-6 + ( Qt::GlobalColor color, const QPixmap & pixmap ) + + + QBrush + QBrush-7 + ( const QPixmap & pixmap ) + + + QBrush + QBrush-8 + ( const QBrush & other ) + + + QBrush + QBrush-9 + ( const QGradient & gradient ) + + + color + color + () + + + gradient + gradient + () + + + isOpaque + isOpaque + () + + + setColor + setColor + ( const QColor & color ) + + + setColor + setColor-2 + ( Qt::GlobalColor color ) + + + setStyle + setStyle + ( Qt::BrushStyle style ) + + + setTexture + setTexture + ( const QPixmap & pixmap ) + + + BrushStyle + style + QBrush::style() + + + texture + texture + () + + + operator + operator-QVariant + QVariant() + + + operator!= + operator-not-eq + ( const QBrush & brush ) + + + operator= + operator-eq + ( const QBrush & brush ) + + + operator== + operator-eq-eq + ( const QBrush & brush ) + + + pixmap + pixmap + () + + + setPixmap + setPixmap + ( const QPixmap & pixmap ) + + + operator + operator-const-QColor--and + const QColor &() + + + + QBuffer + qbuffer.html + + QBuffer + QBuffer + ( QObject * parent = 0 ) + + + QBuffer + QBuffer-2 + ( QByteArray * byteArray, QObject * parent = 0 ) + + + buffer + buffer + () + + + buffer + buffer-2 + () + + + data + data + () + + + setBuffer + setBuffer + ( QByteArray * byteArray ) + + + setData + setData + ( const QByteArray & data ) + + + setData + setData-2 + ( const char * data, int size ) + + + + QButtonGroup + qbuttongroup.html + + QButtonGroup + QButtonGroup + ( QObject * parent = 0 ) + + + addButton + addButton + ( QAbstractButton * button ) + + + addButton + addButton-2 + ( QAbstractButton * button, int id ) + + + button + button + ( int id ) + + + buttonClicked + buttonClicked + ( QAbstractButton * button ) + + + buttonClicked + buttonClicked-2 + ( int id ) + + + buttons + buttons + () + + + checkedButton + checkedButton + () + + + checkedId + checkedId + () + + + id + id + ( QAbstractButton * button ) + + + removeButton + removeButton + ( QAbstractButton * button ) + + + setId + setId + ( QAbstractButton * button, int id ) + + + insert + insert + ( QAbstractButton * b ) + + + remove + remove + ( QAbstractButton * b ) + + + + QByteArray + qbytearray.html + + QByteArray + QByteArray + () + + + QByteArray + QByteArray-2 + ( const char * str ) + + + QByteArray + QByteArray-3 + ( const char * data, int size ) + + + QByteArray + QByteArray-4 + ( int size, char ch ) + + + QByteArray + QByteArray-5 + ( const QByteArray & other ) + + + append + append + ( const QByteArray & ba ) + + + append + append-2 + ( const QString & str ) + + + append + append-3 + ( const char * str ) + + + append + append-4 + ( char ch ) + + + at + at + ( int i ) + + + capacity + capacity + () + + + chop + chop + ( int n ) + + + clear + clear + () + + + constData + constData + () + + + contains + contains + ( const QByteArray & ba ) + + + contains + contains-2 + ( const char * str ) + + + contains + contains-3 + ( char ch ) + + + count + count + ( const QByteArray & ba ) + + + count + count-2 + ( const char * str ) + + + count + count-3 + ( char ch ) + + + count + count-4 + () + + + data + data + () + + + data + data-2 + () + + + endsWith + endsWith + ( const QByteArray & ba ) + + + endsWith + endsWith-2 + ( const char * str ) + + + endsWith + endsWith-3 + ( char ch ) + + + fill + fill + ( char ch, int size = -1 ) + + + fromBase64 + fromBase64 + ( const QByteArray & base64 ) + + + fromRawData + fromRawData + ( const char * data, int size ) + + + indexOf + indexOf + ( const QByteArray & ba, int from = 0 ) + + + indexOf + indexOf-2 + ( const QString & str, int from = 0 ) + + + indexOf + indexOf-3 + ( const char * str, int from = 0 ) + + + indexOf + indexOf-4 + ( char ch, int from = 0 ) + + + insert + insert + ( int i, const QByteArray & ba ) + + + insert + insert-2 + ( int i, const QString & str ) + + + insert + insert-3 + ( int i, const char * str ) + + + insert + insert-4 + ( int i, char ch ) + + + isEmpty + isEmpty + () + + + isNull + isNull + () + + + lastIndexOf + lastIndexOf + ( const QByteArray & ba, int from = -1 ) + + + lastIndexOf + lastIndexOf-2 + ( const QString & str, int from = -1 ) + + + lastIndexOf + lastIndexOf-3 + ( const char * str, int from = -1 ) + + + lastIndexOf + lastIndexOf-4 + ( char ch, int from = -1 ) + + + left + left + ( int len ) + + + leftJustified + leftJustified + ( int width, char fill = ' ', bool truncate = false ) + + + length + length + () + + + mid + mid + ( int pos, int len = -1 ) + + + number + number + ( int n, int base = 10 ) + + + number + number-2 + ( uint n, int base = 10 ) + + + number + number-3 + ( qlonglong n, int base = 10 ) + + + number + number-4 + ( qulonglong n, int base = 10 ) + + + number + number-5 + ( double n, char f = 'g', int prec = 6 ) + + + prepend + prepend + ( const QByteArray & ba ) + + + prepend + prepend-2 + ( const char * str ) + + + prepend + prepend-3 + ( char ch ) + + + push_back + push_back + ( const QByteArray & other ) + + + push_back + push_back-2 + ( const char * str ) + + + push_back + push_back-3 + ( char ch ) + + + push_front + push_front + ( const QByteArray & other ) + + + push_front + push_front-2 + ( const char * str ) + + + push_front + push_front-3 + ( char ch ) + + + remove + remove + ( int pos, int len ) + + + replace + replace + ( int pos, int len, const QByteArray & after ) + + + replace + replace-2 + ( int pos, int len, const char * after ) + + + replace + replace-3 + ( const QByteArray & before, const QByteArray & after ) + + + replace + replace-4 + ( const char * before, const QByteArray & after ) + + + replace + replace-5 + ( const QByteArray & before, const char * after ) + + + replace + replace-6 + ( const QString & before, const QByteArray & after ) + + + replace + replace-7 + ( const QString & before, const char * after ) + + + replace + replace-8 + ( const char * before, const char * after ) + + + replace + replace-9 + ( char before, const QByteArray & after ) + + + replace + replace-10 + ( char before, const QString & after ) + + + replace + replace-11 + ( char before, const char * after ) + + + replace + replace-12 + ( char before, char after ) + + + reserve + reserve + ( int size ) + + + resize + resize + ( int size ) + + + right + right + ( int len ) + + + rightJustified + rightJustified + ( int width, char fill = ' ', bool truncate = false ) + + + setNum + setNum + ( int n, int base = 10 ) + + + setNum + setNum-2 + ( uint n, int base = 10 ) + + + setNum + setNum-3 + ( short n, int base = 10 ) + + + setNum + setNum-4 + ( ushort n, int base = 10 ) + + + setNum + setNum-5 + ( qlonglong n, int base = 10 ) + + + setNum + setNum-6 + ( qulonglong n, int base = 10 ) + + + setNum + setNum-7 + ( double n, char f = 'g', int prec = 6 ) + + + setNum + setNum-8 + ( float n, char f = 'g', int prec = 6 ) + + + simplified + simplified + () + + + size + size + () + + + split + split + ( char sep ) + + + squeeze + squeeze + () + + + startsWith + startsWith + ( const QByteArray & ba ) + + + startsWith + startsWith-2 + ( const char * str ) + + + startsWith + startsWith-3 + ( char ch ) + + + toBase64 + toBase64 + () + + + toDouble + toDouble + ( bool * ok = 0 ) + + + toFloat + toFloat + ( bool * ok = 0 ) + + + toInt + toInt + ( bool * ok = 0, int base = 10 ) + + + toLong + toLong + ( bool * ok = 0, int base = 10 ) + + + toLongLong + toLongLong + ( bool * ok = 0, int base = 10 ) + + + toLower + toLower + () + + + toShort + toShort + ( bool * ok = 0, int base = 10 ) + + + toUInt + toUInt + ( bool * ok = 0, int base = 10 ) + + + toULong + toULong + ( bool * ok = 0, int base = 10 ) + + + toULongLong + toULongLong + ( bool * ok = 0, int base = 10 ) + + + toUShort + toUShort + ( bool * ok = 0, int base = 10 ) + + + toUpper + toUpper + () + + + trimmed + trimmed + () + + + truncate + truncate + ( int pos ) + + + operator + operator-const-char--2a + const char *() + + + operator + operator-const-void--2a + const void *() + + + operator!= + operator-not-eq + ( const QString & str ) + + + operator+= + operator-2b-eq + ( const QByteArray & ba ) + + + operator+= + operator-2b-eq-2 + ( const QString & str ) + + + operator+= + operator-2b-eq-3 + ( const char * str ) + + + operator+= + operator-2b-eq-4 + ( char ch ) + + + operator< + operator-lt + ( const QString & str ) + + + operator<= + operator-lt-eq + ( const QString & str ) + + + operator= + operator-eq + ( const QByteArray & other ) + + + operator= + operator-eq-2 + ( const char * str ) + + + operator== + operator-eq-eq + ( const QString & str ) + + + operator> + operator-gt + ( const QString & str ) + + + operator>= + operator-gt-eq + ( const QString & str ) + + + operator[] + operator-5b-5d + ( int i ) + + + operator[] + operator-5b-5d-2 + ( int i ) + + + operator[] + operator-5b-5d-3 + ( uint i ) + + + operator[] + operator-5b-5d-4 + ( uint i ) + + + + QByteArrayMatcher + qbytearraymatcher.html + + QByteArrayMatcher + QByteArrayMatcher + () + + + QByteArrayMatcher + QByteArrayMatcher-2 + ( const QByteArray & pattern ) + + + QByteArrayMatcher + QByteArrayMatcher-3 + ( const QByteArrayMatcher & other ) + + + indexIn + indexIn + ( const QByteArray & ba, int from = 0 ) + + + pattern + pattern + () + + + setPattern + setPattern + ( const QByteArray & pattern ) + + + operator= + operator-eq + ( const QByteArrayMatcher & other ) + + + QByteArray + QByteArray-6 + ( int size ) + + + duplicate + duplicate + ( const QByteArray & a ) + + + duplicate + duplicate-2 + ( const char * a, uint n ) + + + find + find + ( char c, int from = 0 ) + + + find + find-2 + ( const char * c, int from = 0 ) + + + find + find-3 + ( const QByteArray & ba, int from = 0 ) + + + find + find-4 + ( const QString & s, int from = 0 ) + + + findRev + findRev + ( char c, int from = -1 ) + + + findRev + findRev-2 + ( const char * c, int from = -1 ) + + + findRev + findRev-3 + ( const QByteArray & ba, int from = -1 ) + + + findRev + findRev-4 + ( const QString & s, int from = -1 ) + + + leftJustify + leftJustify + ( uint width, char fill = ' ', bool truncate = false ) + + + lower + lower + () + + + resetRawData + resetRawData + ( const char * data, uint n ) + + + rightJustify + rightJustify + ( uint width, char fill = ' ', bool truncate = false ) + + + setRawData + setRawData + ( const char * a, uint n ) + + + simplifyWhiteSpace + simplifyWhiteSpace + () + + + stripWhiteSpace + stripWhiteSpace + () + + + upper + upper + () + + + + QCache + qcache.html + + QCache + QCache + ( int maxCost = 100 ) + + + clear + clear + () + + + contains + contains + ( const Key & key ) + + + count + count + () + + + insert + insert + ( const Key & key, T * object, int cost = 1 ) + + + isEmpty + isEmpty + () + + + keys + keys + () + + + maxCost + maxCost + () + + + object + object + ( const Key & key ) + + + remove + remove + ( const Key & key ) + + + setMaxCost + setMaxCost + ( int cost ) + + + size + size + () + + + take + take + ( const Key & key ) + + + totalCost + totalCost + () + + + operator[] + operator-5b-5d + ( const Key & key ) + + + QCache + QCache-2 + ( int maxCost, int dummy ) + + + + QCDEStyle + qcdestyle.html + + QCDEStyle + QCDEStyle + ( bool useHighlightCols = false ) + + + + QChar + qchar.html + + Category + Category-enum + + + + Decomposition + Decomposition-enum + + + + Direction + Direction-enum + + + + Joining + Joining-enum + + + + SpecialCharacter + SpecialCharacter-enum + + + + UnicodeVersion + UnicodeVersion-enum + + + + QChar + QChar + () + + + QChar + QChar-2 + ( char ch ) + + + QChar + QChar-3 + ( uchar ch ) + + + QChar + QChar-4 + ( QLatin1Char ch ) + + + QChar + QChar-5 + ( uchar cell, uchar row ) + + + QChar + QChar-6 + ( ushort code ) + + + QChar + QChar-7 + ( short code ) + + + QChar + QChar-8 + ( uint code ) + + + QChar + QChar-9 + ( int code ) + + + QChar + QChar-10 + ( SpecialCharacter ch ) + + + category + category + () + + + cell + cell + () + + + combiningClass + combiningClass + () + + + decomposition + decomposition + () + + + decompositionTag + decompositionTag + () + + + digitValue + digitValue + () + + + direction + direction + () + + + fromAscii + fromAscii + ( char c ) + + + fromLatin1 + fromLatin1 + ( char c ) + + + hasMirrored + hasMirrored + () + + + isDigit + isDigit + () + + + isLetter + isLetter + () + + + isLetterOrNumber + isLetterOrNumber + () + + + isLower + isLower + () + + + isMark + isMark + () + + + isNull + isNull + () + + + isNumber + isNumber + () + + + isPrint + isPrint + () + + + isPunct + isPunct + () + + + isSpace + isSpace + () + + + isSymbol + isSymbol + () + + + isUpper + isUpper + () + + + joining + joining + () + + + mirroredChar + mirroredChar + () + + + row + row + () + + + toAscii + toAscii + () + + + toLatin1 + toLatin1 + () + + + toLower + toLower + () + + + toUpper + toUpper + () + + + unicode + unicode + () + + + unicode + unicode-2 + () + + + unicodeVersion + unicodeVersion + () + + + ascii + ascii + () + + + latin1 + latin1 + () + + + lower + lower + () + + + mirrored + mirrored + () + + + networkOrdered + networkOrdered + () + + + upper + upper + () + + + + QCheckBox + qcheckbox.html + + QCheckBox + QCheckBox + ( QWidget * parent = 0 ) + + + QCheckBox + QCheckBox-2 + ( const QString & text, QWidget * parent = 0 ) + + + CheckState + checkState + QCheckBox::checkState() + + + setCheckState + setCheckState + ( Qt::CheckState state ) + + + stateChanged + stateChanged + ( int state ) + + + ToggleState + ToggleState-enum + + + + QCheckBox + QCheckBox-3 + ( QWidget * parent, const char * name ) + + + QCheckBox + QCheckBox-4 + ( const QString & text, QWidget * parent, const char * name ) + + + setNoChange + setNoChange + () + + + setState + setState + ( ToggleState state ) + + + state + state + () + + + + QChildEvent + qchildevent.html + + QChildEvent + QChildEvent + ( Type type, QObject * child ) + + + added + added + () + + + child + child + () + + + polished + polished + () + + + removed + removed + () + + + inserted + inserted + () + + + + QClipboard + qclipboard.html + + Mode + Mode-enum + + + + clear + clear + ( Mode mode = Clipboard ) + + + dataChanged + dataChanged + () + + + image + image + ( Mode mode = Clipboard ) + + + mimeData + mimeData + ( Mode mode = Clipboard ) + + + ownsClipboard + ownsClipboard + () + + + ownsSelection + ownsSelection + () + + + pixmap + pixmap + ( Mode mode = Clipboard ) + + + selectionChanged + selectionChanged + () + + + setImage + setImage + ( const QImage & image, Mode mode = Clipboard ) + + + setMimeData + setMimeData + ( QMimeData * src, Mode mode = Clipboard ) + + + setPixmap + setPixmap + ( const QPixmap & pixmap, Mode mode = Clipboard ) + + + setText + setText + ( const QString & text, Mode mode = Clipboard ) + + + supportsSelection + supportsSelection + () + + + text + text + ( Mode mode = Clipboard ) + + + text + text-2 + ( QString & subtype, Mode mode = Clipboard ) + + + data + data + ( Mode mode = Clipboard ) + + + setData + setData + ( QMimeSource * src, Mode mode = Clipboard ) + + + + QCloseEvent + qcloseevent.html + + QCloseEvent + QCloseEvent + () + + + + QColorDialog + qcolordialog.html + + customColor + customColor + ( int i ) + + + customCount + customCount + () + + + getColor + getColor + ( const QColor & initial = Qt::white, QWidget * parent = 0 ) + + + getRgba + getRgba + ( QRgb initial, bool * ok = 0, QWidget * parent = 0 ) + + + setCustomColor + setCustomColor + ( int number, QRgb color ) + + + setStandardColor + setStandardColor + ( int number, QRgb color ) + + + getColor + getColor-2 + ( const QColor & init, QWidget * parent, const char * name ) + + + getRgba + getRgba-2 + ( QRgb rgba, bool * ok, QWidget * parent, const char * name ) + + + + QColorGroup + qcolorgroup.html + + QColorGroup + QColorGroup + () + + + QColorGroup + QColorGroup-2 + ( const QBrush & foreground, const QBrush & button, const QBrush & light, const QBrush & dark, const QBrush & mid, const QBrush & text, const QBrush & bright_text, const QBrush & base, const QBrush & background ) + + + QColorGroup + QColorGroup-3 + ( const QColor & foreground, const QColor & background, const QColor & light, const QColor & dark, const QColor & mid, const QColor & text, const QColor & base ) + + + QColorGroup + QColorGroup-4 + ( const QColorGroup & other ) + + + QColorGroup + QColorGroup-5 + ( const QPalette & pal ) + + + operator + operator-QVariant + QVariant() + + + operator!= + operator-not-eq + ( const QColorGroup & other ) + + + operator== + operator-eq-eq + ( const QColorGroup & other ) + + + background + background + () + + + base + base + () + + + brightText + brightText + () + + + button + button + () + + + buttonText + buttonText + () + + + dark + dark + () + + + foreground + foreground + () + + + highlight + highlight + () + + + highlightedText + highlightedText + () + + + light + light + () + + + link + link + () + + + linkVisited + linkVisited + () + + + mid + mid + () + + + midlight + midlight + () + + + shadow + shadow + () + + + text + text + () + + + + QColor + qcolor.html + + Spec + Spec-enum + + + + QColor + QColor + () + + + QColor + QColor-2 + ( int r, int g, int b, int a = 255 ) + + + QColor + QColor-3 + ( QRgb color ) + + + QColor + QColor-4 + ( const QString & name ) + + + QColor + QColor-5 + ( const char * name ) + + + QColor + QColor-6 + ( const QColor & color ) + + + QColor + QColor-8 + ( Qt::GlobalColor color ) + + + alpha + alpha + () + + + alphaF + alphaF + () + + + black + black + () + + + blackF + blackF + () + + + blue + blue + () + + + blueF + blueF + () + + + colorNames + colorNames + () + + + convertTo + convertTo + ( Spec colorSpec ) + + + cyan + cyan + () + + + cyanF + cyanF + () + + + dark + dark + ( int factor = 200 ) + + + fromCmyk + fromCmyk + ( int c, int m, int y, int k, int a = 255 ) + + + fromCmykF + fromCmykF + ( qreal c, qreal m, qreal y, qreal k, qreal a = 1.0 ) + + + fromHsv + fromHsv + ( int h, int s, int v, int a = 255 ) + + + fromHsvF + fromHsvF + ( qreal h, qreal s, qreal v, qreal a = 1.0 ) + + + fromRgb + fromRgb + ( QRgb rgb ) + + + fromRgb + fromRgb-2 + ( int r, int g, int b, int a = 255 ) + + + fromRgbF + fromRgbF + ( qreal r, qreal g, qreal b, qreal a = 1.0 ) + + + fromRgba + fromRgba + ( QRgb rgba ) + + + getCmyk + getCmyk + ( int * c, int * m, int * y, int * k, int * a = 0 ) + + + getCmykF + getCmykF + ( qreal * c, qreal * m, qreal * y, qreal * k, qreal * a = 0 ) + + + getHsv + getHsv + ( int * h, int * s, int * v, int * a = 0 ) + + + getHsvF + getHsvF + ( qreal * h, qreal * s, qreal * v, qreal * a = 0 ) + + + getRgb + getRgb + ( int * r, int * g, int * b, int * a = 0 ) + + + getRgbF + getRgbF + ( qreal * r, qreal * g, qreal * b, qreal * a = 0 ) + + + green + green + () + + + greenF + greenF + () + + + hue + hue + () + + + hueF + hueF + () + + + isValid + isValid + () + + + light + light + ( int factor = 150 ) + + + magenta + magenta + () + + + magentaF + magentaF + () + + + name + name + () + + + red + red + () + + + redF + redF + () + + + rgb + rgb + () + + + rgba + rgba + () + + + saturation + saturation + () + + + saturationF + saturationF + () + + + setAlpha + setAlpha + ( int alpha ) + + + setAlphaF + setAlphaF + ( qreal alpha ) + + + setBlue + setBlue + ( int blue ) + + + setBlueF + setBlueF + ( qreal blue ) + + + setCmyk + setCmyk + ( int c, int m, int y, int k, int a = 255 ) + + + setCmykF + setCmykF + ( qreal c, qreal m, qreal y, qreal k, qreal a = 1.0 ) + + + setGreen + setGreen + ( int green ) + + + setGreenF + setGreenF + ( qreal green ) + + + setHsv + setHsv + ( int h, int s, int v, int a = 255 ) + + + setHsvF + setHsvF + ( qreal h, qreal s, qreal v, qreal a = 1.0 ) + + + setNamedColor + setNamedColor + ( const QString & name ) + + + setRed + setRed + ( int red ) + + + setRedF + setRedF + ( qreal red ) + + + setRgb + setRgb + ( int r, int g, int b, int a = 255 ) + + + setRgb + setRgb-2 + ( QRgb rgb ) + + + setRgbF + setRgbF + ( qreal r, qreal g, qreal b, qreal a = 1.0 ) + + + setRgba + setRgba + ( QRgb rgba ) + + + spec + spec + () + + + toCmyk + toCmyk + () + + + toHsv + toHsv + () + + + toRgb + toRgb + () + + + value + value + () + + + valueF + valueF + () + + + yellow + yellow + () + + + yellowF + yellowF + () + + + operator + operator-QVariant + QVariant() + + + operator!= + operator-not-eq + ( const QColor & color ) + + + operator= + operator-eq + ( const QColor & color ) + + + operator= + operator-eq-2 + ( Qt::GlobalColor color ) + + + operator== + operator-eq-eq + ( const QColor & color ) + + + + QColormap + qcolormap.html + + Mode + Mode-enum + + + + QColormap + QColormap + ( const QColormap & colormap ) + + + colorAt + colorAt + ( uint pixel ) + + + colormap + colormap + () + + + depth + depth + () + + + hPal + hPal + () + + + instance + instance + ( int screen = -1 ) + + + mode + mode + () + + + pixel + pixel + ( const QColor & color ) + + + size + size + () + + + QColor + QColor-7 + ( int x, int y, int z, Spec colorSpec ) + + + getRgba + getRgba + ( int * r, int * g, int * b, int * a ) + + + hsv + hsv + ( int * h, int * s, int * v ) + + + pixel + pixel + ( int screen = -1 ) + + + rgb + rgb-2 + ( int * r, int * g, int * b ) + + + setRgba + setRgba-2 + ( int r, int g, int b, int a ) + + + + QComboBox + qcombobox.html + + InsertPolicy + InsertPolicy-enum + + + + SizeAdjustPolicy + SizeAdjustPolicy-enum + + + + CaseSensitivity + autoCompletionCaseSensitivity-prop + + + + QComboBox + QComboBox + ( QWidget * parent = 0 ) + + + activated + activated + ( int index ) + + + activated + activated-2 + ( const QString & text ) + + + addItem + addItem + ( const QString & text, const QVariant & userData = QVariant() + + + addItem + addItem-2 + ( const QIcon & icon, const QString & text, const QVariant & userData = QVariant() + + + addItems + addItems + ( const QStringList & texts ) + + + clear + clear + () + + + clearEditText + clearEditText + () + + + currentIndexChanged + currentIndexChanged + ( int index ) + + + currentIndexChanged + currentIndexChanged-2 + ( const QString & text ) + + + editTextChanged + editTextChanged + ( const QString & text ) + + + findData + findData + ( const QVariant & data, int role = Qt::UserRole, Qt::MatchFlags flags = Qt::MatchExactly | Qt::MatchCaseSensitive ) + + + findText + findText + ( const QString & text, Qt::MatchFlags flags = Qt::MatchExactly | Qt::MatchCaseSensitive ) + + + hidePopup + hidePopup + () + + + highlighted + highlighted + ( int index ) + + + highlighted + highlighted-2 + ( const QString & text ) + + + insertItem + insertItem + ( int index, const QString & text, const QVariant & userData = QVariant() + + + insertItem + insertItem-2 + ( int index, const QIcon & icon, const QString & text, const QVariant & userData = QVariant() + + + insertItems + insertItems + ( int index, const QStringList & list ) + + + itemData + itemData + ( int index, int role = Qt::UserRole ) + + + itemDelegate + itemDelegate + () + + + itemIcon + itemIcon + ( int index ) + + + itemText + itemText + ( int index ) + + + lineEdit + lineEdit + () + + + model + model + () + + + removeItem + removeItem + ( int index ) + + + rootModelIndex + rootModelIndex + () + + + setEditText + setEditText + ( const QString & text ) + + + setItemData + setItemData + ( int index, const QVariant & value, int role = Qt::UserRole ) + + + setItemDelegate + setItemDelegate + ( QAbstractItemDelegate * delegate ) + + + setItemIcon + setItemIcon + ( int index, const QIcon & icon ) + + + setItemText + setItemText + ( int index, const QString & text ) + + + setLineEdit + setLineEdit + ( QLineEdit * edit ) + + + setModel + setModel + ( QAbstractItemModel * model ) + + + setRootModelIndex + setRootModelIndex + ( const QModelIndex & index ) + + + setValidator + setValidator + ( const QValidator * validator ) + + + setView + setView + ( QAbstractItemView * itemView ) + + + showPopup + showPopup + () + + + validator + validator + () + + + view + view + () + + + Policy + Policy-typedef + + + + QComboBox + QComboBox-2 + ( QWidget * parent, const char * name ) + + + QComboBox + QComboBox-3 + ( bool rw, QWidget * parent, const char * name = 0 ) + + + changeItem + changeItem + ( const QString & text, int index ) + + + changeItem + changeItem-2 + ( const QPixmap & pixmap, int index ) + + + changeItem + changeItem-3 + ( const QPixmap & pixmap, const QString & text, int index ) + + + clearEdit + clearEdit + () + + + clearValidator + clearValidator + () + + + currentItem + currentItem + () + + + editable + editable + () + + + insertItem + insertItem-3 + ( const QString & text, int index = -1 ) + + + insertItem + insertItem-4 + ( const QPixmap & pixmap, int index = -1 ) + + + insertItem + insertItem-5 + ( const QPixmap & pixmap, const QString & text, int index = -1 ) + + + insertStringList + insertStringList + ( const QStringList & list, int index = -1 ) + + + insertionPolicy + insertionPolicy + () + + + pixmap + pixmap + ( int index ) + + + popup + popup + () + + + setCurrentItem + setCurrentItem + ( int index ) + + + setCurrentText + setCurrentText + ( const QString & text ) + + + setInsertionPolicy + setInsertionPolicy + ( InsertPolicy policy ) + + + text + text + ( int index ) + + + textChanged + textChanged + ( const QString & text ) + + + + QCommonStyle + qcommonstyle.html + + QCommonStyle + QCommonStyle + () + + + + QConicalGradient + qconicalgradient.html + + QConicalGradient + QConicalGradient + ( const QPointF & center, qreal angle ) + + + QConicalGradient + QConicalGradient-2 + ( qreal cx, qreal cy, qreal angle ) + + + angle + angle + () + + + center + center + () + + + + QConstString + qconststring.html + + QConstString + QConstString + ( const QChar * unicode, int size ) + + + string + string + () + + + + QContextMenuEvent + qcontextmenuevent.html + + Reason + Reason-enum + + + + QContextMenuEvent + QContextMenuEvent + ( Reason reason, const QPoint & pos, const QPoint & globalPos ) + + + QContextMenuEvent + QContextMenuEvent-2 + ( Reason reason, const QPoint & pos ) + + + globalPos + globalPos + () + + + globalX + globalX + () + + + globalY + globalY + () + + + pos + pos + () + + + reason + reason + () + + + x + x + () + + + y + y + () + + + QContextMenuEvent + QContextMenuEvent-3 + ( Reason reason, const QPoint & pos, const QPoint & globalPos, int dummy ) + + + QContextMenuEvent + QContextMenuEvent-4 + ( Reason reason, const QPoint & pos, int dummy ) + + + ButtonState + state + QContextMenuEvent::state() + + + + QCopChannel + qcopchannel.html + + QCopChannel + QCopChannel + ( const QString & channel, QObject * parent = 0 ) + + + channel + channel + () + + + isRegistered + isRegistered + ( const QString & channel ) + + + receive + receive + ( const QString & message, const QByteArray & data ) + + + received + received + ( const QString & message, const QByteArray & data ) + + + send + send + ( const QString & channel, const QString & message, const QByteArray & data ) + + + send + send-2 + ( const QString & channel, const QString & message ) + + + QCopChannel + QCopChannel-2 + ( const QString & channel, QObject * parent, const char * name ) + + + + QCoreApplication + qcoreapplication.html + + Encoding + Encoding-enum + + + + EventFilter + EventFilter-typedef + + + + QCoreApplication + QCoreApplication + ( int & argc, char ** argv ) + + + aboutToQuit + aboutToQuit + () + + + addLibraryPath + addLibraryPath + ( const QString & path ) + + + applicationDirPath + applicationDirPath + () + + + applicationFilePath + applicationFilePath + () + + + arguments + arguments + () + + + closingDown + closingDown + () + + + exec + exec + () + + + exit + exit + ( int returnCode = 0 ) + + + filterEvent + filterEvent + ( void * message, long * result ) + + + flush + flush + () + + + hasPendingEvents + hasPendingEvents + () + + + installTranslator + installTranslator + ( QTranslator * messageFile ) + + + instance + instance + () + + + libraryPaths + libraryPaths + () + + + notify + notify + ( QObject * receiver, QEvent * event ) + + + postEvent + postEvent + ( QObject * receiver, QEvent * event ) + + + processEvents + processEvents + ( QEventLoop::ProcessEventsFlags flags = QEventLoop::AllEvents ) + + + processEvents + processEvents-2 + ( QEventLoop::ProcessEventsFlags flags, int maxtime ) + + + quit + quit + () + + + removeLibraryPath + removeLibraryPath + ( const QString & path ) + + + removePostedEvents + removePostedEvents + ( QObject * receiver ) + + + removeTranslator + removeTranslator + ( QTranslator * messageFile ) + + + sendEvent + sendEvent + ( QObject * receiver, QEvent * event ) + + + sendPostedEvents + sendPostedEvents + ( QObject * receiver, int event_type ) + + + sendPostedEvents + sendPostedEvents-2 + () + + + setEventFilter + setEventFilter + ( EventFilter filter ) + + + setLibraryPaths + setLibraryPaths + ( const QStringList & paths ) + + + startingUp + startingUp + () + + + translate + translate + ( const char * context, const char * sourceText, const char * comment = 0, Encoding encoding = DefaultCodec ) + + + winEventFilter + winEventFilter + ( MSG * msg, long * result ) + + + argc + argc + () + + + argv + argv + () + + + enter_loop + enter_loop + () + + + exit_loop + exit_loop + () + + + lock + lock + () + + + locked + locked + () + + + loopLevel + loopLevel + () + + + processOneEvent + processOneEvent + () + + + tryLock + tryLock + () + + + unlock + unlock + ( bool wakeUpGui = true ) + + + + QCursor + qcursor.html + + QCursor + QCursor + () + + + QCursor + QCursor-2 + ( Qt::CursorShape shape ) + + + QCursor + QCursor-3 + ( const QBitmap & bitmap, const QBitmap & mask, int hotX = -1, int hotY = -1 ) + + + QCursor + QCursor-4 + ( const QPixmap & pixmap, int hotX = -1, int hotY = -1 ) + + + QCursor + QCursor-5 + ( const QCursor & c ) + + + QCursor + QCursor-6 + ( HCURSOR cursor ) + + + QCursor + QCursor-7 + ( Qt::HANDLE handle ) + + + QCursor + QCursor-8 + ( Qt::HANDLE cursor ) + + + bitmap + bitmap + () + + + handle + handle + () + + + HANDLE + handle-2 + QCursor::handle() + + + handle + handle-3 + () + + + hotSpot + hotSpot + () + + + mask + mask + () + + + pixmap + pixmap + () + + + pos + pos + () + + + setPos + setPos + ( int x, int y ) + + + setPos + setPos-2 + ( const QPoint & p ) + + + setShape + setShape + ( Qt::CursorShape shape ) + + + CursorShape + shape + QCursor::shape() + + + operator + operator-QVariant + QVariant() + + + operator= + operator-eq + ( const QCursor & c ) + + + + QCustomEvent + qcustomevent.html + + QCustomEvent + QCustomEvent + ( int type, void * data = 0 ) + + + data + data + () + + + setData + setData + ( void * data ) + + + + QDataStream + qdatastream.html + + ByteOrder + ByteOrder-enum + + + + Status + Status-enum + + + + Version + Version-enum + + + + QDataStream + QDataStream + () + + + QDataStream + QDataStream-2 + ( QIODevice * d ) + + + QDataStream + QDataStream-4 + ( QByteArray * a, QIODevice::OpenMode mode ) + + + QDataStream + QDataStream-5 + ( const QByteArray & a ) + + + atEnd + atEnd + () + + + byteOrder + byteOrder + () + + + device + device + () + + + readBytes + readBytes + ( char *& s, uint & l ) + + + readRawData + readRawData + ( char * s, int len ) + + + resetStatus + resetStatus + () + + + setByteOrder + setByteOrder + ( ByteOrder bo ) + + + setDevice + setDevice + ( QIODevice * d ) + + + setStatus + setStatus + ( Status status ) + + + setVersion + setVersion + ( int v ) + + + skipRawData + skipRawData + ( int len ) + + + status + status + () + + + unsetDevice + unsetDevice + () + + + version + version + () + + + writeBytes + writeBytes + ( const char * s, uint len ) + + + writeRawData + writeRawData + ( const char * s, int len ) + + + operator<< + operator-lt-lt + ( qint8 i ) + + + operator<< + operator-lt-lt-2 + ( bool i ) + + + operator<< + operator-lt-lt-3 + ( quint8 i ) + + + operator<< + operator-lt-lt-4 + ( quint16 i ) + + + operator<< + operator-lt-lt-5 + ( qint16 i ) + + + operator<< + operator-lt-lt-6 + ( qint32 i ) + + + operator<< + operator-lt-lt-7 + ( quint64 i ) + + + operator<< + operator-lt-lt-8 + ( qint64 i ) + + + operator<< + operator-lt-lt-9 + ( quint32 i ) + + + operator<< + operator-lt-lt-10 + ( float f ) + + + operator<< + operator-lt-lt-11 + ( double f ) + + + operator<< + operator-lt-lt-12 + ( const char * s ) + + + operator>> + operator-gt-gt + ( qint8 & i ) + + + operator>> + operator-gt-gt-2 + ( bool & i ) + + + operator>> + operator-gt-gt-3 + ( quint8 & i ) + + + operator>> + operator-gt-gt-4 + ( quint16 & i ) + + + operator>> + operator-gt-gt-5 + ( qint16 & i ) + + + operator>> + operator-gt-gt-6 + ( quint32 & i ) + + + operator>> + operator-gt-gt-7 + ( qint32 & i ) + + + operator>> + operator-gt-gt-8 + ( quint64 & i ) + + + operator>> + operator-gt-gt-9 + ( qint64 & i ) + + + operator>> + operator-gt-gt-10 + ( float & f ) + + + operator>> + operator-gt-gt-11 + ( double & f ) + + + operator>> + operator-gt-gt-12 + ( char *& s ) + + + QDataStream + QDataStream-3 + ( QByteArray * array, int mode ) + + + eof + eof + () + + + isPrintableData + isPrintableData + () + + + readRawBytes + readRawBytes + ( char * str, uint len ) + + + setPrintableData + setPrintableData + ( bool enable ) + + + writeRawBytes + writeRawBytes + ( const char * str, uint len ) + + + + QDateEdit + qdateedit.html + + QDateEdit + QDateEdit + ( QWidget * parent = 0 ) + + + QDateEdit + QDateEdit-2 + ( const QDate & date, QWidget * parent = 0 ) + + + + QDate + qdate.html + + QDate + QDate + () + + + QDate + QDate-2 + ( int y, int m, int d ) + + + addDays + addDays + ( int ndays ) + + + addMonths + addMonths + ( int nmonths ) + + + addYears + addYears + ( int nyears ) + + + currentDate + currentDate-2 + () + + + day + day + () + + + dayOfWeek + dayOfWeek + () + + + dayOfYear + dayOfYear + () + + + daysInMonth + daysInMonth + () + + + daysInYear + daysInYear + () + + + daysTo + daysTo + ( const QDate & d ) + + + fromJulianDay + fromJulianDay + ( int jd ) + + + fromString + fromString + ( const QString & string, Qt::DateFormat format = Qt::TextDate ) + + + fromString + fromString-2 + ( const QString & string, const QString & format ) + + + isLeapYear + isLeapYear + ( int year ) + + + isNull + isNull + () + + + isValid + isValid + () + + + isValid + isValid-2 + ( int y, int m, int d ) + + + longDayName + longDayName + ( int weekday ) + + + longMonthName + longMonthName + ( int month ) + + + month + month + () + + + setYMD + setYMD + ( int y, int m, int d ) + + + shortDayName + shortDayName + ( int weekday ) + + + shortMonthName + shortMonthName + ( int month ) + + + toJulianDay + toJulianDay + () + + + toString + toString + ( const QString & format ) + + + toString + toString-2 + ( Qt::DateFormat format = Qt::TextDate ) + + + weekNumber + weekNumber + ( int * yearNumber = 0 ) + + + year + year + () + + + operator!= + operator-not-eq + ( const QDate & d ) + + + operator< + operator-lt + ( const QDate & d ) + + + operator<= + operator-lt-eq + ( const QDate & d ) + + + operator== + operator-eq-eq + ( const QDate & d ) + + + operator> + operator-gt + ( const QDate & d ) + + + operator>= + operator-gt-eq + ( const QDate & d ) + + + currentDate + currentDate + ( Qt::TimeSpec spec ) + + + dayName + dayName + ( int weekday ) + + + leapYear + leapYear + ( int year ) + + + monthName + monthName + ( int month ) + + + + QDateTimeEdit + qdatetimeedit.html + + QDateTimeEdit + QDateTimeEdit + ( QWidget * parent = 0 ) + + + QDateTimeEdit + QDateTimeEdit-2 + ( const QDateTime & datetime, QWidget * parent = 0 ) + + + QDateTimeEdit + QDateTimeEdit-3 + ( const QDate & date, QWidget * parent = 0 ) + + + QDateTimeEdit + QDateTimeEdit-4 + ( const QTime & time, QWidget * parent = 0 ) + + + dateChanged + dateChanged + ( const QDate & date ) + + + dateTimeChanged + dateTimeChanged + ( const QDateTime & datetime ) + + + dateTimeFromText + dateTimeFromText + ( const QString & text ) + + + sectionText + sectionText + ( Section section ) + + + setDateRange + setDateRange + ( const QDate & min, const QDate & max ) + + + setTimeRange + setTimeRange + ( const QTime & min, const QTime & max ) + + + textFromDateTime + textFromDateTime + ( const QDateTime & dateTime ) + + + timeChanged + timeChanged + ( const QTime & time ) + + + + QDateTime + qdatetime.html + + QDateTime + QDateTime + () + + + QDateTime + QDateTime-2 + ( const QDate & date ) + + + QDateTime + QDateTime-3 + ( const QDate & date, const QTime & time, Qt::TimeSpec spec = Qt::LocalTime ) + + + QDateTime + QDateTime-4 + ( const QDateTime & other ) + + + addDays + addDays + ( int ndays ) + + + addMSecs + addMSecs + ( qint64 msecs ) + + + addMonths + addMonths + ( int nmonths ) + + + addSecs + addSecs + ( int nsecs ) + + + addYears + addYears + ( int nyears ) + + + currentDateTime + currentDateTime + () + + + date + date + () + + + daysTo + daysTo + ( const QDateTime & other ) + + + fromString + fromString + ( const QString & string, Qt::DateFormat format = Qt::TextDate ) + + + fromString + fromString-2 + ( const QString & string, const QString & format ) + + + isNull + isNull + () + + + isValid + isValid + () + + + secsTo + secsTo + ( const QDateTime & other ) + + + setDate + setDate + ( const QDate & date ) + + + setTime + setTime + ( const QTime & time ) + + + setTimeSpec + setTimeSpec + ( Qt::TimeSpec spec ) + + + setTime_t + setTime_t + ( uint seconds ) + + + time + time + () + + + TimeSpec + timeSpec + QDateTime::timeSpec() + + + toLocalTime + toLocalTime + () + + + toString + toString + ( const QString & format ) + + + toString + toString-2 + ( Qt::DateFormat format = Qt::TextDate ) + + + toTimeSpec + toTimeSpec + ( Qt::TimeSpec specification ) + + + toTime_t + toTime_t + () + + + toUTC + toUTC + () + + + operator!= + operator-not-eq + ( const QDateTime & other ) + + + operator< + operator-lt + ( const QDateTime & other ) + + + operator<= + operator-lt-eq + ( const QDateTime & other ) + + + operator= + operator-eq + ( const QDateTime & other ) + + + operator== + operator-eq-eq + ( const QDateTime & other ) + + + operator> + operator-gt + ( const QDateTime & other ) + + + operator>= + operator-gt-eq + ( const QDateTime & other ) + + + currentDateTime + currentDateTime-2 + ( Qt::TimeSpec spec ) + + + setTime_t + setTime_t-2 + ( uint secsSince1Jan1970UTC, Qt::TimeSpec spec ) + + + + QDecorationFactory + qdecorationfactory.html + + create + create + ( const QString & key ) + + + keys + keys + () + + + + QDecoration + qdecoration.html + + DecorationRegion + DecorationRegion-enum + + + + DecorationState + DecorationState-enum + + + + QDecoration + QDecoration + () + + + buildSysMenu + buildSysMenu + ( QWidget * widget, QMenu * menu ) + + + menuTriggered + menuTriggered + ( QWidget * widget, QAction * action ) + + + paint + paint + ( QPainter * painter, const QWidget * widget, int decorationRegion = All, DecorationState state = Normal ) + + + region + region + ( const QWidget * widget, const QRect & rectangle, int decorationRegion = All ) + + + region + region-2 + ( const QWidget * widget, int decorationRegion = All ) + + + regionAt + regionAt + ( const QWidget * widget, const QPoint & point ) + + + regionClicked + regionClicked + ( QWidget * widget, int region ) + + + regionDoubleClicked + regionDoubleClicked + ( QWidget * widget, int region ) + + + startMove + startMove + ( QWidget * widget ) + + + startResize + startResize + ( QWidget * widget ) + + + + QDecorationPlugin + qdecorationplugin.html + + QDecorationPlugin + QDecorationPlugin + ( QObject * parent = 0 ) + + + create + create + ( const QString & key ) + + + keys + keys + () + + + + QDesignerActionEditorInterface + qdesigneractioneditorinterface.html + + QDesignerActionEditorInterface + QDesignerActionEditorInterface + ( QWidget * parent, Qt::WindowFlags flags = 0 ) + + + core + core + () + + + manageAction + manageAction + ( QAction * action ) + + + setFormWindow + setFormWindow + ( QDesignerFormWindowInterface * formWindow ) + + + unmanageAction + unmanageAction + ( QAction * action ) + + + + QDesignerContainerExtension + qdesignercontainerextension.html + + addWidget + addWidget + ( QWidget * page ) + + + count + count + () + + + currentIndex + currentIndex + () + + + insertWidget + insertWidget + ( int index, QWidget * page ) + + + remove + remove + ( int index ) + + + setCurrentIndex + setCurrentIndex + ( int index ) + + + widget + widget + ( int index ) + + + + QDesignerCustomWidgetCollectionInterface + qdesignercustomwidgetcollectioninterface.html + + customWidgets + customWidgets + () + + + + QDesignerCustomWidgetInterface + qdesignercustomwidgetinterface.html + + codeTemplate + codeTemplate + () + + + createWidget + createWidget + ( QWidget * parent ) + + + domXml + domXml + () + + + group + group + () + + + icon + icon + () + + + includeFile + includeFile + () + + + initialize + initialize + ( QDesignerFormEditorInterface * formEditor ) + + + isContainer + isContainer + () + + + isInitialized + isInitialized + () + + + name + name + () + + + toolTip + toolTip + () + + + whatsThis + whatsThis + () + + + + QDesignerFormEditorInterface + qdesignerformeditorinterface.html + + QDesignerFormEditorInterface + QDesignerFormEditorInterface + ( QObject * parent = 0 ) + + + actionEditor + actionEditor + () + + + extensionManager + extensionManager + () + + + formWindowManager + formWindowManager + () + + + objectInspector + objectInspector + () + + + propertyEditor + propertyEditor + () + + + setActionEditor + setActionEditor + ( QDesignerActionEditorInterface * actionEditor ) + + + setObjectInspector + setObjectInspector + ( QDesignerObjectInspectorInterface * objectInspector ) + + + setPropertyEditor + setPropertyEditor + ( QDesignerPropertyEditorInterface * propertyEditor ) + + + setWidgetBox + setWidgetBox + ( QDesignerWidgetBoxInterface * widgetBox ) + + + topLevel + topLevel + () + + + widgetBox + widgetBox + () + + + + QDesignerFormWindowCursorInterface + qdesignerformwindowcursorinterface.html + + MoveMode + MoveMode-enum + + + + MoveOperation + MoveOperation-enum + + + + current + current + () + + + formWindow + formWindow + () + + + hasSelection + hasSelection + () + + + isWidgetSelected + isWidgetSelected + ( QWidget * widget ) + + + movePosition + movePosition + ( MoveOperation operation, MoveMode mode = MoveAnchor ) + + + position + position + () + + + resetWidgetProperty + resetWidgetProperty + ( QWidget * widget, const QString & name ) + + + selectedWidget + selectedWidget + ( int index ) + + + selectedWidgetCount + selectedWidgetCount + () + + + setPosition + setPosition + ( int position, MoveMode mode = MoveAnchor ) + + + setProperty + setProperty + ( const QString & name, const QVariant & value ) + + + setWidgetProperty + setWidgetProperty + ( QWidget * widget, const QString & name, const QVariant & value ) + + + widget + widget + ( int index ) + + + widgetCount + widgetCount + () + + + + QDesignerFormWindowInterface + qdesignerformwindowinterface.html + + QDesignerFormWindowInterface + QDesignerFormWindowInterface + ( QWidget * parent = 0, Qt::WindowFlags flags = 0 ) + + + aboutToUnmanageWidget + aboutToUnmanageWidget + ( QWidget * widget ) + + + absoluteDir + absoluteDir + () + + + activated + activated + ( QWidget * widget ) + + + addResourceFile + addResourceFile + ( const QString & path ) + + + author + author + () + + + changed + changed + () + + + clearSelection + clearSelection + ( bool update = true ) + + + comment + comment + () + + + contents + contents + () + + + core + core + () + + + cursor + cursor + () + + + emitSelectionChanged + emitSelectionChanged + () + + + exportMacro + exportMacro + () + + + featureChanged + featureChanged + ( Feature feature ) + + + features + features + () + + + fileName + fileName + () + + + fileNameChanged + fileNameChanged + ( const QString & fileName ) + + + findFormWindow + findFormWindow + ( QWidget * widget ) + + + geometryChanged + geometryChanged + () + + + grid + grid + () + + + hasFeature + hasFeature + ( Feature feature ) + + + includeHints + includeHints + () + + + isDirty + isDirty + () + + + isManaged + isManaged + ( QWidget * widget ) + + + layoutDefault + layoutDefault + ( int * margin, int * spacing ) + + + layoutFunction + layoutFunction + ( QString * margin, QString * spacing ) + + + mainContainer + mainContainer + () + + + mainContainerChanged + mainContainerChanged + ( QWidget * mainContainer ) + + + manageWidget + manageWidget + ( QWidget * widget ) + + + pixmapFunction + pixmapFunction + () + + + removeResourceFile + removeResourceFile + ( const QString & path ) + + + resourceFiles + resourceFiles + () + + + resourceFilesChanged + resourceFilesChanged + () + + + selectWidget + selectWidget + ( QWidget * widget, bool select = true ) + + + selectionChanged + selectionChanged + () + + + setAuthor + setAuthor + ( const QString & author ) + + + setComment + setComment + ( const QString & comment ) + + + setContents + setContents + ( QIODevice * device ) + + + setContents + setContents-2 + ( const QString & contents ) + + + setDirty + setDirty + ( bool dirty ) + + + setExportMacro + setExportMacro + ( const QString & exportMacro ) + + + setFeatures + setFeatures + ( Feature features ) + + + setFileName + setFileName + ( const QString & fileName ) + + + setGrid + setGrid + ( const QPoint & grid ) + + + setIncludeHints + setIncludeHints + ( const QStringList & includeHints ) + + + setLayoutDefault + setLayoutDefault + ( int margin, int spacing ) + + + setLayoutFunction + setLayoutFunction + ( const QString & margin, const QString & spacing ) + + + setMainContainer + setMainContainer + ( QWidget * mainContainer ) + + + setPixmapFunction + setPixmapFunction + ( const QString & pixmapFunction ) + + + unmanageWidget + unmanageWidget + ( QWidget * widget ) + + + widgetManaged + widgetManaged + ( QWidget * widget ) + + + widgetRemoved + widgetRemoved + ( QWidget * widget ) + + + widgetUnmanaged + widgetUnmanaged + ( QWidget * widget ) + + + + QDesignerFormWindowManagerInterface + qdesignerformwindowmanagerinterface.html + + QDesignerFormWindowManagerInterface + QDesignerFormWindowManagerInterface + ( QObject * parent = 0 ) + + + actionAdjustSize + actionAdjustSize + () + + + actionBreakLayout + actionBreakLayout + () + + + actionCopy + actionCopy + () + + + actionCut + actionCut + () + + + actionDelete + actionDelete + () + + + actionGridLayout + actionGridLayout + () + + + actionHorizontalLayout + actionHorizontalLayout + () + + + actionLower + actionLower + () + + + actionPaste + actionPaste + () + + + actionRaise + actionRaise + () + + + actionRedo + actionRedo + () + + + actionSelectAll + actionSelectAll + () + + + actionSplitHorizontal + actionSplitHorizontal + () + + + actionSplitVertical + actionSplitVertical + () + + + actionUndo + actionUndo + () + + + actionVerticalLayout + actionVerticalLayout + () + + + activeFormWindow + activeFormWindow + () + + + activeFormWindowChanged + activeFormWindowChanged + ( QDesignerFormWindowInterface * formWindow ) + + + addFormWindow + addFormWindow + ( QDesignerFormWindowInterface * formWindow ) + + + core + core + () + + + createFormWindow + createFormWindow + ( QWidget * parent = 0, Qt::WindowFlags flags = 0 ) + + + formWindow + formWindow + ( int index ) + + + formWindowAdded + formWindowAdded + ( QDesignerFormWindowInterface * formWindow ) + + + formWindowCount + formWindowCount + () + + + formWindowRemoved + formWindowRemoved + ( QDesignerFormWindowInterface * formWindow ) + + + removeFormWindow + removeFormWindow + ( QDesignerFormWindowInterface * formWindow ) + + + setActiveFormWindow + setActiveFormWindow + ( QDesignerFormWindowInterface * formWindow ) + + + + QDesignerMemberSheetExtension + qdesignermembersheetextension.html + + count + count + () + + + declaredInClass + declaredInClass + ( int index ) + + + indexOf + indexOf + ( const QString & name ) + + + inheritedFromWidget + inheritedFromWidget + ( int index ) + + + isSignal + isSignal + ( int index ) + + + isSlot + isSlot + ( int index ) + + + isVisible + isVisible + ( int index ) + + + memberGroup + memberGroup + ( int index ) + + + memberName + memberName + ( int index ) + + + parameterNames + parameterNames + ( int index ) + + + parameterTypes + parameterTypes + ( int index ) + + + setMemberGroup + setMemberGroup + ( int index, const QString & group ) + + + setVisible + setVisible + ( int index, bool visible ) + + + signature + signature + ( int index ) + + + + QDesignerObjectInspectorInterface + qdesignerobjectinspectorinterface.html + + QDesignerObjectInspectorInterface + QDesignerObjectInspectorInterface + ( QWidget * parent, Qt::WindowFlags flags = 0 ) + + + core + core + () + + + setFormWindow + setFormWindow + ( QDesignerFormWindowInterface * formWindow ) + + + + QDesignerPropertyEditorInterface + qdesignerpropertyeditorinterface.html + + QDesignerPropertyEditorInterface + QDesignerPropertyEditorInterface + ( QWidget * parent, Qt::WindowFlags flags = 0 ) + + + core + core + () + + + currentPropertyName + currentPropertyName + () + + + isReadOnly + isReadOnly + () + + + object + object + () + + + propertyChanged + propertyChanged + ( const QString & name, const QVariant & value ) + + + setObject + setObject + ( QObject * object ) + + + setPropertyValue + setPropertyValue + ( const QString & name, const QVariant & value, bool changed = true ) + + + setReadOnly + setReadOnly + ( bool readOnly ) + + + + QDesignerPropertySheetExtension + qdesignerpropertysheetextension.html + + count + count + () + + + hasReset + hasReset + ( int index ) + + + indexOf + indexOf + ( const QString & name ) + + + isAttribute + isAttribute + ( int index ) + + + isChanged + isChanged + ( int index ) + + + isVisible + isVisible + ( int index ) + + + property + property + ( int index ) + + + propertyGroup + propertyGroup + ( int index ) + + + propertyName + propertyName + ( int index ) + + + reset + reset + ( int index ) + + + setAttribute + setAttribute + ( int index, bool attribute ) + + + setChanged + setChanged + ( int index, bool changed ) + + + setProperty + setProperty + ( int index, const QVariant & value ) + + + setPropertyGroup + setPropertyGroup + ( int index, const QString & group ) + + + setVisible + setVisible + ( int index, bool visible ) + + + + QDesignerTaskMenuExtension + qdesignertaskmenuextension.html + + preferredEditAction + preferredEditAction + () + + + taskActions + taskActions + () + + + + QDesignerWidgetBoxInterface + qdesignerwidgetboxinterface.html + + QDesignerWidgetBoxInterface + QDesignerWidgetBoxInterface + ( QWidget * parent = 0, Qt::WindowFlags flags = 0 ) + + + fileName + fileName + () + + + load + load + () + + + save + save + () + + + setFileName + setFileName + ( const QString & fileName ) + + + + QDesktopWidget + qdesktopwidget.html + + QDesktopWidget + QDesktopWidget + () + + + availableGeometry + availableGeometry + ( int screen = -1 ) + + + availableGeometry + availableGeometry-2 + ( const QWidget * widget ) + + + availableGeometry + availableGeometry-3 + ( const QPoint & p ) + + + isVirtualDesktop + isVirtualDesktop + () + + + numScreens + numScreens + () + + + primaryScreen + primaryScreen + () + + + resized + resized + ( int screen ) + + + screen + screen + ( int screen = -1 ) + + + screenGeometry + screenGeometry + ( int screen = -1 ) + + + screenGeometry + screenGeometry-2 + ( const QWidget * widget ) + + + screenGeometry + screenGeometry-3 + ( const QPoint & p ) + + + screenNumber + screenNumber + ( const QWidget * widget = 0 ) + + + screenNumber + screenNumber-2 + ( const QPoint & point ) + + + workAreaResized + workAreaResized + ( int screen ) + + + + QDial + qdial.html + + QDial + QDial + ( QWidget * parent = 0 ) + + + + QDialog + qdialog.html + + DialogCode + DialogCode-enum + + + + QDialog + QDialog + ( QWidget * parent = 0, Qt::WFlags f = 0 ) + + + accept + accept + () + + + accepted + accepted + () + + + done + done + ( int r ) + + + exec + exec + () + + + extension + extension + () + + + finished + finished + ( int result ) + + + Orientation + orientation + QDialog::orientation() + + + reject + reject + () + + + rejected + rejected + () + + + result + result + () + + + setExtension + setExtension + ( QWidget * extension ) + + + setOrientation + setOrientation + ( Qt::Orientation orientation ) + + + setResult + setResult + ( int i ) + + + showExtension + showExtension + ( bool showIt ) + + + QDialog + QDialog-2 + ( QWidget * parent, const char * name, bool modal = false, Qt::WFlags f = 0 ) + + + QDial + QDial-2 + ( int minValue, int maxValue, int pageStep, int value, QWidget * parent = 0, const char * name = 0 ) + + + QDial + QDial-3 + ( QWidget * parent, const char * name ) + + + dialMoved + dialMoved + ( int value ) + + + dialPressed + dialPressed + () + + + dialReleased + dialReleased + () + + + + QDirectPainter + qdirectpainter.html + + frameBuffer + frameBuffer + () + + + linestep + linestep + () + + + lock + lock + () + + + region + region + () + + + reserveRegion + reserveRegion + ( const QRegion & region ) + + + screenDepth + screenDepth + () + + + screenHeight + screenHeight + () + + + screenWidth + screenWidth + () + + + unlock + unlock + () + + + + QDir + qdir.html + + FilterSpec + FilterSpec-typedef + + + + SortSpec + SortSpec-typedef + + + + QDir + QDir + ( const QDir & dir ) + + + QDir + QDir-2 + ( const QString & path = QString() + + + QDir + QDir-3 + ( const QString & path, const QString & nameFilter, SortFlags sort = SortFlags( Name | IgnoreCase ) + + + absoluteFilePath + absoluteFilePath + ( const QString & fileName ) + + + absolutePath + absolutePath + () + + + addResourceSearchPath + addResourceSearchPath + ( const QString & path ) + + + canonicalPath + canonicalPath + () + + + cd + cd + ( const QString & dirName ) + + + cdUp + cdUp + () + + + cleanPath + cleanPath + ( const QString & path ) + + + convertSeparators + convertSeparators + ( const QString & pathName ) + + + count + count + () + + + current + current + () + + + currentPath + currentPath + () + + + dirName + dirName + () + + + drives + drives + () + + + entryInfoList + entryInfoList + ( const QStringList & nameFilters, Filters filters = NoFilter, SortFlags sort = NoSort ) + + + entryInfoList + entryInfoList-3 + ( Filters filters = NoFilter, SortFlags sort = NoSort ) + + + entryList + entryList + ( const QStringList & nameFilters, Filters filters = NoFilter, SortFlags sort = NoSort ) + + + entryList + entryList-3 + ( Filters filters = NoFilter, SortFlags sort = NoSort ) + + + exists + exists + ( const QString & name ) + + + exists + exists-2 + () + + + filePath + filePath + ( const QString & fileName ) + + + filter + filter + () + + + home + home + () + + + homePath + homePath + () + + + isAbsolute + isAbsolute + () + + + isAbsolutePath + isAbsolutePath + ( const QString & path ) + + + isReadable + isReadable + () + + + isRelative + isRelative + () + + + isRelativePath + isRelativePath + ( const QString & path ) + + + isRoot + isRoot + () + + + makeAbsolute + makeAbsolute + () + + + match + match + ( const QString & filter, const QString & fileName ) + + + match + match-2 + ( const QStringList & filters, const QString & fileName ) + + + mkdir + mkdir + ( const QString & dirName ) + + + mkpath + mkpath + ( const QString & dirPath ) + + + nameFilters + nameFilters + () + + + path + path + () + + + refresh + refresh + () + + + relativeFilePath + relativeFilePath + ( const QString & fileName ) + + + remove + remove + ( const QString & fileName ) + + + rename + rename + ( const QString & oldName, const QString & newName ) + + + rmdir + rmdir + ( const QString & dirName ) + + + rmpath + rmpath + ( const QString & dirPath ) + + + root + root + () + + + rootPath + rootPath + () + + + separator + separator + () + + + setCurrent + setCurrent + ( const QString & path ) + + + setFilter + setFilter + ( Filters filters ) + + + setNameFilters + setNameFilters + ( const QStringList & nameFilters ) + + + setPath + setPath + ( const QString & path ) + + + setSorting + setSorting + ( SortFlags sort ) + + + sorting + sorting + () + + + temp + temp + () + + + tempPath + tempPath + () + + + operator!= + operator-not-eq + ( const QDir & dir ) + + + operator= + operator-eq + ( const QDir & dir ) + + + operator== + operator-eq-eq + ( const QDir & dir ) + + + operator[] + operator-5b-5d + ( int pos ) + + + + QDirModel + qdirmodel.html + + Roles + Roles-enum + + + + QDirModel + QDirModel + ( const QStringList & nameFilters, QDir::Filters filters, QDir::SortFlags sort, QObject * parent = 0 ) + + + QDirModel + QDirModel-2 + ( QObject * parent = 0 ) + + + columnCount + columnCount + ( const QModelIndex & parent ) + + + data + data + ( const QModelIndex & index, int role = Qt::DisplayRole ) + + + dropMimeData + dropMimeData + ( const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent ) + + + fileIcon + fileIcon + ( const QModelIndex & index ) + + + fileInfo + fileInfo + ( const QModelIndex & index ) + + + fileName + fileName + ( const QModelIndex & index ) + + + filePath + filePath + ( const QModelIndex & index ) + + + Filters + filter + QDirModel::filter() + + + ItemFlags + flags + QDirModel::flags( const QModelIndex & index ) + + + hasChildren + hasChildren + ( const QModelIndex & parent ) + + + headerData + headerData + ( int section, Qt::Orientation orientation, int role ) + + + iconProvider + iconProvider + () + + + index + index + ( int row, int column, const QModelIndex & parent = QModelIndex() + + + index + index-2 + ( const QString & path, int column = 0 ) + + + isDir + isDir + ( const QModelIndex & index ) + + + mimeData + mimeData + ( const QModelIndexList & indexes ) + + + mimeTypes + mimeTypes + () + + + mkdir + mkdir + ( const QModelIndex & parent, const QString & name ) + + + nameFilters + nameFilters + () + + + parent + parent + ( const QModelIndex & child ) + + + refresh + refresh + ( const QModelIndex & parent = QModelIndex() + + + remove + remove + ( const QModelIndex & index ) + + + rmdir + rmdir + ( const QModelIndex & index ) + + + rowCount + rowCount + ( const QModelIndex & parent ) + + + setData + setData + ( const QModelIndex & index, const QVariant & value, int role ) + + + setFilter + setFilter + ( QDir::Filters filters ) + + + setIconProvider + setIconProvider + ( QFileIconProvider * provider ) + + + setNameFilters + setNameFilters + ( const QStringList & filters ) + + + setSorting + setSorting + ( QDir::SortFlags sort ) + + + sort + sort + ( int column, Qt::SortOrder order ) + + + SortFlags + sorting + QDirModel::sorting() + + + DropActions + supportedDropActions + QDirModel::supportedDropActions() + + + operator= + operator-eq-2 + ( const QString & path ) + + + absFilePath + absFilePath + ( const QString & fileName, bool acceptAbsPath = true ) + + + absPath + absPath + () + + + cleanDirPath + cleanDirPath + ( const QString & name ) + + + convertToAbs + convertToAbs + () + + + currentDirPath + currentDirPath + () + + + entryInfoList + entryInfoList-2 + ( const QString & nameFilter, Filters filters = NoFilter, SortFlags sort = NoSort ) + + + entryList + entryList-2 + ( const QString & nameFilter, Filters filters = NoFilter, SortFlags sort = NoSort ) + + + homeDirPath + homeDirPath + () + + + matchAllDirs + matchAllDirs + () + + + mkdir + mkdir-2 + ( const QString & dirName, bool acceptAbsPath ) + + + nameFilter + nameFilter + () + + + rmdir + rmdir-2 + ( const QString & dirName, bool acceptAbsPath ) + + + rootDirPath + rootDirPath + () + + + setMatchAllDirs + setMatchAllDirs + ( bool on ) + + + setNameFilter + setNameFilter + ( const QString & nameFilter ) + + + + QDockWidget + qdockwidget.html + + DockWidgetAreas + allowedAreas-prop + + + + QDockWidget + QDockWidget + ( const QString & title, QWidget * parent = 0, Qt::WFlags flags = 0 ) + + + QDockWidget + QDockWidget-2 + ( QWidget * parent = 0, Qt::WFlags flags = 0 ) + + + allowedAreasChanged + allowedAreasChanged + ( Qt::DockWidgetAreas allowedAreas ) + + + featuresChanged + featuresChanged + ( QDockWidget::DockWidgetFeatures features ) + + + isAreaAllowed + isAreaAllowed + ( Qt::DockWidgetArea area ) + + + setWidget + setWidget + ( QWidget * widget ) + + + toggleViewAction + toggleViewAction + () + + + topLevelChanged + topLevelChanged + ( bool topLevel ) + + + widget + widget + () + + + + QDomAttr + qdomattr.html + + QDomAttr + QDomAttr + () + + + QDomAttr + QDomAttr-2 + ( const QDomAttr & x ) + + + name + name + () + + + NodeType + nodeType + QDomAttr::nodeType() + + + ownerElement + ownerElement + () + + + setValue + setValue + ( const QString & v ) + + + specified + specified + () + + + value + value + () + + + operator= + operator-eq + ( const QDomAttr & x ) + + + + QDomCDATASection + qdomcdatasection.html + + QDomCDATASection + QDomCDATASection + () + + + QDomCDATASection + QDomCDATASection-2 + ( const QDomCDATASection & x ) + + + NodeType + nodeType + QDomCDATASection::nodeType() + + + operator= + operator-eq + ( const QDomCDATASection & x ) + + + + QDomCharacterData + qdomcharacterdata.html + + QDomCharacterData + QDomCharacterData + () + + + QDomCharacterData + QDomCharacterData-2 + ( const QDomCharacterData & x ) + + + appendData + appendData + ( const QString & arg ) + + + data + data + () + + + deleteData + deleteData + ( unsigned long offset, unsigned long count ) + + + insertData + insertData + ( unsigned long offset, const QString & arg ) + + + length + length + () + + + NodeType + nodeType + QDomCharacterData::nodeType() + + + replaceData + replaceData + ( unsigned long offset, unsigned long count, const QString & arg ) + + + setData + setData + ( const QString & v ) + + + substringData + substringData + ( unsigned long offset, unsigned long count ) + + + operator= + operator-eq + ( const QDomCharacterData & x ) + + + + QDomComment + qdomcomment.html + + QDomComment + QDomComment + () + + + QDomComment + QDomComment-2 + ( const QDomComment & x ) + + + NodeType + nodeType + QDomComment::nodeType() + + + operator= + operator-eq + ( const QDomComment & x ) + + + + QDomDocumentFragment + qdomdocumentfragment.html + + QDomDocumentFragment + QDomDocumentFragment + () + + + QDomDocumentFragment + QDomDocumentFragment-2 + ( const QDomDocumentFragment & x ) + + + NodeType + nodeType + QDomDocumentFragment::nodeType() + + + operator= + operator-eq + ( const QDomDocumentFragment & x ) + + + + QDomDocument + qdomdocument.html + + QDomDocument + QDomDocument + () + + + QDomDocument + QDomDocument-2 + ( const QString & name ) + + + QDomDocument + QDomDocument-3 + ( const QDomDocumentType & doctype ) + + + QDomDocument + QDomDocument-4 + ( const QDomDocument & x ) + + + createAttribute + createAttribute + ( const QString & name ) + + + createAttributeNS + createAttributeNS + ( const QString & nsURI, const QString & qName ) + + + createCDATASection + createCDATASection + ( const QString & value ) + + + createComment + createComment + ( const QString & value ) + + + createDocumentFragment + createDocumentFragment + () + + + createElement + createElement + ( const QString & tagName ) + + + createElementNS + createElementNS + ( const QString & nsURI, const QString & qName ) + + + createEntityReference + createEntityReference + ( const QString & name ) + + + createProcessingInstruction + createProcessingInstruction + ( const QString & target, const QString & data ) + + + createTextNode + createTextNode + ( const QString & value ) + + + doctype + doctype + () + + + documentElement + documentElement + () + + + elementById + elementById + ( const QString & elementId ) + + + elementsByTagName + elementsByTagName + ( const QString & tagname ) + + + elementsByTagNameNS + elementsByTagNameNS + ( const QString & nsURI, const QString & localName ) + + + implementation + implementation + () + + + importNode + importNode + ( const QDomNode & importedNode, bool deep ) + + + NodeType + nodeType + QDomDocument::nodeType() + + + setContent + setContent + ( const QByteArray & data, bool namespaceProcessing, QString * errorMsg = 0, int * errorLine = 0, int * errorColumn = 0 ) + + + setContent + setContent-2 + ( const QString & text, bool namespaceProcessing, QString * errorMsg = 0, int * errorLine = 0, int * errorColumn = 0 ) + + + setContent + setContent-3 + ( QIODevice * dev, bool namespaceProcessing, QString * errorMsg = 0, int * errorLine = 0, int * errorColumn = 0 ) + + + setContent + setContent-4 + ( const QString & text, QString * errorMsg = 0, int * errorLine = 0, int * errorColumn = 0 ) + + + setContent + setContent-5 + ( const QByteArray & buffer, QString * errorMsg = 0, int * errorLine = 0, int * errorColumn = 0 ) + + + setContent + setContent-6 + ( QIODevice * dev, QString * errorMsg = 0, int * errorLine = 0, int * errorColumn = 0 ) + + + setContent + setContent-7 + ( QXmlInputSource * source, QXmlReader * reader, QString * errorMsg = 0, int * errorLine = 0, int * errorColumn = 0 ) + + + toByteArray + toByteArray + ( int indent = 1 ) + + + toString + toString + ( int indent = 1 ) + + + operator= + operator-eq + ( const QDomDocument & x ) + + + + QDomDocumentType + qdomdocumenttype.html + + QDomDocumentType + QDomDocumentType + () + + + QDomDocumentType + QDomDocumentType-2 + ( const QDomDocumentType & n ) + + + entities + entities + () + + + internalSubset + internalSubset + () + + + name + name + () + + + NodeType + nodeType + QDomDocumentType::nodeType() + + + notations + notations + () + + + publicId + publicId + () + + + systemId + systemId + () + + + operator= + operator-eq + ( const QDomDocumentType & n ) + + + + QDomElement + qdomelement.html + + QDomElement + QDomElement + () + + + QDomElement + QDomElement-2 + ( const QDomElement & x ) + + + attribute + attributex + ( const QString & name, const QString & defValue = QString() + + + attributeNS + attributeNS + ( const QString nsURI, const QString & localName, const QString & defValue = QString() + + + attributeNode + attributeNode + ( const QString & name ) + + + attributeNodeNS + attributeNodeNS + ( const QString & nsURI, const QString & localName ) + + + attributes + attributes + () + + + elementsByTagName + elementsByTagName + ( const QString & tagname ) + + + elementsByTagNameNS + elementsByTagNameNS + ( const QString & nsURI, const QString & localName ) + + + hasAttribute + hasAttribute + ( const QString & name ) + + + hasAttributeNS + hasAttributeNS + ( const QString & nsURI, const QString & localName ) + + + NodeType + nodeType + QDomElement::nodeType() + + + removeAttribute + removeAttribute + ( const QString & name ) + + + removeAttributeNS + removeAttributeNS + ( const QString & nsURI, const QString & localName ) + + + removeAttributeNode + removeAttributeNode + ( const QDomAttr & oldAttr ) + + + setAttribute + setAttribute + ( const QString & name, const QString & value ) + + + setAttribute + setAttribute-2 + ( const QString & name, int value ) + + + setAttribute + setAttribute-3 + ( const QString & name, uint value ) + + + setAttribute + setAttribute-4 + ( const QString & name, qlonglong value ) + + + setAttribute + setAttribute-5 + ( const QString & name, qulonglong value ) + + + setAttribute + setAttribute-6 + ( const QString & name, float value ) + + + setAttribute + setAttribute-7 + ( const QString & name, double value ) + + + setAttributeNS + setAttributeNS + ( const QString nsURI, const QString & qName, const QString & value ) + + + setAttributeNS + setAttributeNS-2 + ( const QString nsURI, const QString & qName, int value ) + + + setAttributeNS + setAttributeNS-3 + ( const QString nsURI, const QString & qName, uint value ) + + + setAttributeNS + setAttributeNS-4 + ( const QString nsURI, const QString & qName, qlonglong value ) + + + setAttributeNS + setAttributeNS-5 + ( const QString nsURI, const QString & qName, qulonglong value ) + + + setAttributeNS + setAttributeNS-6 + ( const QString nsURI, const QString & qName, double value ) + + + setAttributeNode + setAttributeNode + ( const QDomAttr & newAttr ) + + + setAttributeNodeNS + setAttributeNodeNS + ( const QDomAttr & newAttr ) + + + setTagName + setTagName + ( const QString & name ) + + + tagName + tagName + () + + + text + text + () + + + operator= + operator-eq + ( const QDomElement & x ) + + + + QDomEntity + qdomentity.html + + QDomEntity + QDomEntity + () + + + QDomEntity + QDomEntity-2 + ( const QDomEntity & x ) + + + NodeType + nodeType + QDomEntity::nodeType() + + + notationName + notationName + () + + + publicId + publicId + () + + + systemId + systemId + () + + + operator= + operator-eq + ( const QDomEntity & x ) + + + + QDomEntityReference + qdomentityreference.html + + QDomEntityReference + QDomEntityReference + () + + + QDomEntityReference + QDomEntityReference-2 + ( const QDomEntityReference & x ) + + + NodeType + nodeType + QDomEntityReference::nodeType() + + + operator= + operator-eq + ( const QDomEntityReference & x ) + + + + QDomImplementation + qdomimplementation.html + + InvalidDataPolicy + InvalidDataPolicy-enum + + + + QDomImplementation + QDomImplementation + () + + + QDomImplementation + QDomImplementation-2 + ( const QDomImplementation & x ) + + + createDocument + createDocument + ( const QString & nsURI, const QString & qName, const QDomDocumentType & doctype ) + + + createDocumentType + createDocumentType + ( const QString & qName, const QString & publicId, const QString & systemId ) + + + hasFeature + hasFeature + ( const QString & feature, const QString & version ) + + + invalidDataPolicy + invalidDataPolicy + () + + + isNull + isNull + () + + + setInvalidDataPolicy + setInvalidDataPolicy + ( InvalidDataPolicy policy ) + + + operator!= + operator-not-eq + ( const QDomImplementation & x ) + + + operator= + operator-eq + ( const QDomImplementation & x ) + + + operator== + operator-eq-eq + ( const QDomImplementation & x ) + + + + QDomNamedNodeMap + qdomnamednodemap.html + + QDomNamedNodeMap + QDomNamedNodeMap + () + + + QDomNamedNodeMap + QDomNamedNodeMap-2 + ( const QDomNamedNodeMap & n ) + + + contains + contains + ( const QString & name ) + + + count + count + () + + + isEmpty + isEmpty + () + + + item + item + ( int index ) + + + length + length + () + + + namedItem + namedItem + ( const QString & name ) + + + namedItemNS + namedItemNS + ( const QString & nsURI, const QString & localName ) + + + removeNamedItem + removeNamedItem + ( const QString & name ) + + + removeNamedItemNS + removeNamedItemNS + ( const QString & nsURI, const QString & localName ) + + + setNamedItem + setNamedItem + ( const QDomNode & newNode ) + + + setNamedItemNS + setNamedItemNS + ( const QDomNode & newNode ) + + + size + size + () + + + operator!= + operator-not-eq + ( const QDomNamedNodeMap & n ) + + + operator= + operator-eq + ( const QDomNamedNodeMap & n ) + + + operator== + operator-eq-eq + ( const QDomNamedNodeMap & n ) + + + + QDomNode + qdomnode.html + + NodeType + NodeType-enum + + + + QDomNode + QDomNode + () + + + QDomNode + QDomNode-2 + ( const QDomNode & n ) + + + appendChild + appendChild + ( const QDomNode & newChild ) + + + attributes + attributes + () + + + childNodes + childNodes + () + + + clear + clear + () + + + cloneNode + cloneNode + ( bool deep = true ) + + + columnNumber + columnNumber + () + + + firstChild + firstChild + () + + + firstChildElement + firstChildElement + ( const QString & tagName = QString() + + + hasAttributes + hasAttributes + () + + + hasChildNodes + hasChildNodes + () + + + insertAfter + insertAfter + ( const QDomNode & newChild, const QDomNode & refChild ) + + + insertBefore + insertBefore + ( const QDomNode & newChild, const QDomNode & refChild ) + + + isAttr + isAttr + () + + + isCDATASection + isCDATASection + () + + + isCharacterData + isCharacterData + () + + + isComment + isComment + () + + + isDocument + isDocument + () + + + isDocumentFragment + isDocumentFragment + () + + + isDocumentType + isDocumentType + () + + + isElement + isElement + () + + + isEntity + isEntity + () + + + isEntityReference + isEntityReference + () + + + isNotation + isNotation + () + + + isNull + isNull + () + + + isProcessingInstruction + isProcessingInstruction + () + + + isSupported + isSupported + ( const QString & feature, const QString & version ) + + + isText + isText + () + + + lastChild + lastChild + () + + + lastChildElement + lastChildElement + ( const QString & tagName = QString() + + + lineNumber + lineNumber + () + + + localName + localName + () + + + namedItem + namedItem + ( const QString & name ) + + + namespaceURI + namespaceURI + () + + + nextSibling + nextSibling + () + + + nextSiblingElement + nextSiblingElement + ( const QString & tagName = QString() + + + nodeName + nodeName + () + + + nodeType + nodeType + () + + + nodeValue + nodeValue + () + + + normalize + normalize + () + + + ownerDocument + ownerDocument + () + + + parentNode + parentNode + () + + + prefix + prefix + () + + + previousSibling + previousSibling + () + + + previousSiblingElement + previousSiblingElement + ( const QString & tagName = QString() + + + removeChild + removeChild + ( const QDomNode & oldChild ) + + + replaceChild + replaceChild + ( const QDomNode & newChild, const QDomNode & oldChild ) + + + save + save + ( QTextStream & str, int indent ) + + + setNodeValue + setNodeValue + ( const QString & v ) + + + setPrefix + setPrefix + ( const QString & pre ) + + + toAttr + toAttr + () + + + toCDATASection + toCDATASection + () + + + toCharacterData + toCharacterData + () + + + toComment + toComment + () + + + toDocument + toDocument + () + + + toDocumentFragment + toDocumentFragment + () + + + toDocumentType + toDocumentType + () + + + toElement + toElement + () + + + toEntity + toEntity + () + + + toEntityReference + toEntityReference + () + + + toNotation + toNotation + () + + + toProcessingInstruction + toProcessingInstruction + () + + + toText + toText + () + + + operator!= + operator-not-eq + ( const QDomNode & n ) + + + operator= + operator-eq + ( const QDomNode & n ) + + + operator== + operator-eq-eq + ( const QDomNode & n ) + + + + QDomNodeList + qdomnodelist.html + + QDomNodeList + QDomNodeList + () + + + QDomNodeList + QDomNodeList-2 + ( const QDomNodeList & n ) + + + at + at + ( int index ) + + + count + count + () + + + isEmpty + isEmpty + () + + + item + item + ( int index ) + + + length + length + () + + + size + size + () + + + operator!= + operator-not-eq + ( const QDomNodeList & n ) + + + operator= + operator-eq + ( const QDomNodeList & n ) + + + operator== + operator-eq-eq + ( const QDomNodeList & n ) + + + + QDomNotation + qdomnotation.html + + QDomNotation + QDomNotation + () + + + QDomNotation + QDomNotation-2 + ( const QDomNotation & x ) + + + NodeType + nodeType + QDomNotation::nodeType() + + + publicId + publicId + () + + + systemId + systemId + () + + + operator= + operator-eq + ( const QDomNotation & x ) + + + + QDomProcessingInstruction + qdomprocessinginstruction.html + + QDomProcessingInstruction + QDomProcessingInstruction + () + + + QDomProcessingInstruction + QDomProcessingInstruction-2 + ( const QDomProcessingInstruction & x ) + + + data + data + () + + + NodeType + nodeType + QDomProcessingInstruction::nodeType() + + + setData + setData + ( const QString & d ) + + + target + target + () + + + operator= + operator-eq + ( const QDomProcessingInstruction & x ) + + + + QDomText + qdomtext.html + + QDomText + QDomText + () + + + QDomText + QDomText-2 + ( const QDomText & x ) + + + NodeType + nodeType + QDomText::nodeType() + + + splitText + splitText + ( int offset ) + + + operator= + operator-eq + ( const QDomText & x ) + + + + QDoubleSpinBox + qdoublespinbox.html + + QDoubleSpinBox + QDoubleSpinBox + ( QWidget * parent = 0 ) + + + setRange + setRange + ( double min, double max ) + + + textFromValue + textFromValue + ( double v ) + + + valueChanged + valueChanged + ( double d ) + + + valueChanged + valueChanged-2 + ( const QString & text ) + + + valueFromText + valueFromText + ( const QString & text ) + + + + QDoubleValidator + qdoublevalidator.html + + QDoubleValidator + QDoubleValidator + ( QObject * parent ) + + + QDoubleValidator + QDoubleValidator-2 + ( double bottom, double top, int decimals, QObject * parent ) + + + setRange + setRange + ( double minimum, double maximum, int decimals = 0 ) + + + State + validate + QDoubleValidator::validate( QString & input, int & pos ) + + + QDoubleValidator + QDoubleValidator-3 + ( QObject * parent, const char * name ) + + + QDoubleValidator + QDoubleValidator-4 + ( double bottom, double top, int decimals, QObject * parent, const char * name ) + + + + QDragEnterEvent + qdragenterevent.html + + QDragEnterEvent + QDragEnterEvent + ( const QPoint & point, Qt::DropActions actions, const QMimeData * data, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers ) + + + + QDrag + qdrag.html + + QDrag + QDrag + ( QWidget * dragSource ) + + + actionChanged + actionChanged + ( Qt::DropAction action ) + + + hotSpot + hotSpot + () + + + mimeData + mimeData + () + + + pixmap + pixmap + () + + + setDragCursor + setDragCursor + ( const QPixmap & cursor, Qt::DropAction action ) + + + setHotSpot + setHotSpot + ( const QPoint & hotspot ) + + + setMimeData + setMimeData + ( QMimeData * data ) + + + setPixmap + setPixmap + ( const QPixmap & pixmap ) + + + source + source + () + + + DropAction + start + QDrag::start( Qt::DropActions request = Qt::CopyAction ) + + + target + target + () + + + targetChanged + targetChanged + ( QWidget * newTarget ) + + + + QDragLeaveEvent + qdragleaveevent.html + + QDragLeaveEvent + QDragLeaveEvent + () + + + + QDragMoveEvent + qdragmoveevent.html + + QDragMoveEvent + QDragMoveEvent + ( const QPoint & pos, Qt::DropActions actions, const QMimeData * data, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type = DragMove ) + + + accept + accept + ( const QRect & rectangle ) + + + accept + accept-3 + () + + + answerRect + answerRect + () + + + ignore + ignore + ( const QRect & rectangle ) + + + ignore + ignore-2 + () + + + accept + accept-2 + ( bool y ) + + + + QDropEvent + qdropevent.html + + QDropEvent + QDropEvent + ( const QPoint & pos, Qt::DropActions actions, const QMimeData * data, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type = Drop ) + + + acceptProposedAction + acceptProposedAction + () + + + DropAction + dropAction + QDropEvent::dropAction() + + + KeyboardModifiers + keyboardModifiers + QDropEvent::keyboardModifiers() + + + mimeData + mimeData + () + + + MouseButtons + mouseButtons + QDropEvent::mouseButtons() + + + pos + pos + () + + + DropActions + possibleActions + QDropEvent::possibleActions() + + + DropAction + proposedAction + QDropEvent::proposedAction() + + + setDropAction + setDropAction + ( Qt::DropAction action ) + + + source + source + () + + + Action + Action-enum + + + + accept + accept-2 + ( bool accept ) + + + acceptAction + acceptAction + ( bool accept = true ) + + + action + action + () + + + data + data + ( const char * f ) + + + encodedData + encodedData + ( const char * format ) + + + format + format + ( int n = 0 ) + + + provides + provides + ( const char * mimeType ) + + + setPoint + setPoint + ( const QPoint & point ) + + + + QErrorMessage + qerrormessage.html + + QErrorMessage + QErrorMessage + ( QWidget * parent = 0 ) + + + qtHandler + qtHandler + () + + + showMessage + showMessage + ( const QString & message ) + + + message + message + ( const QString & message ) + + + + QEvent + qevent.html + + Type + Type-enum + + + + QEvent + QEvent + ( Type type ) + + + accept + accept + () + + + ignore + ignore + () + + + spontaneous + spontaneous + () + + + type + type + () + + + + QEventLoop + qeventloop.html + + QEventLoop + QEventLoop + ( QObject * parent = 0 ) + + + exec + exec + ( ProcessEventsFlags flags = AllEvents ) + + + exit + exit + ( int returnCode = 0 ) + + + isRunning + isRunning + () + + + processEvents + processEvents + ( ProcessEventsFlags flags = AllEvents ) + + + processEvents + processEvents-2 + ( ProcessEventsFlags flags, int maxTime ) + + + quit + quit + () + + + wakeUp + wakeUp + () + + + + QExtensionFactory + qextensionfactory.html + + QExtensionFactory + QExtensionFactory + ( QExtensionManager * parent = 0 ) + + + createExtension + createExtension + ( QObject * object, const QString & iid, QObject * parent ) + + + extension + extension + ( QObject * object, const QString & iid ) + + + extensionManager + extensionManager + () + + + + QExtensionManager + qextensionmanager.html + + QExtensionManager + QExtensionManager + ( QObject * parent = 0 ) + + + extension + extension + ( QObject * object, const QString & iid ) + + + registerExtensions + registerExtensions + ( QAbstractExtensionFactory * factory, const QString & iid = QString() + + + unregisterExtensions + unregisterExtensions + ( QAbstractExtensionFactory * factory, const QString & iid = QString() + + + + QFileDialog + qfiledialog.html + + AcceptMode + AcceptMode-enum + + + + DialogLabel + DialogLabel-enum + + + + FileMode + FileMode-enum + + + + Mode + Mode-typedef + + + + ViewMode + ViewMode-enum + + + + QFileDialog + QFileDialog + ( QWidget * parent, Qt::WFlags flags ) + + + QFileDialog + QFileDialog-2 + ( QWidget * parent = 0, const QString & caption = QString() + + + currentChanged + currentChanged + ( const QString & path ) + + + directory + directory + () + + + filesSelected + filesSelected + ( const QStringList & selected ) + + + filters + filters + () + + + getExistingDirectory + getExistingDirectory + ( QWidget * parent = 0, const QString & caption = QString() + + + getOpenFileName + getOpenFileName + ( QWidget * parent = 0, const QString & caption = QString() + + + getOpenFileNames + getOpenFileNames + ( QWidget * parent = 0, const QString & caption = QString() + + + getSaveFileName + getSaveFileName + ( QWidget * parent = 0, const QString & caption = QString() + + + history + history + () + + + iconProvider + iconProvider + () + + + itemDelegate + itemDelegate + () + + + labelText + labelText + ( DialogLabel label ) + + + selectFile + selectFile + ( const QString & filename ) + + + selectFilter + selectFilter + ( const QString & filter ) + + + selectedFiles + selectedFiles + () + + + selectedFilter + selectedFilter + () + + + setDirectory + setDirectory + ( const QString & directory ) + + + setDirectory + setDirectory-2 + ( const QDir & directory ) + + + setFilter + setFilter + ( const QString & filter ) + + + setFilters + setFilters + ( const QStringList & filters ) + + + setHistory + setHistory + ( const QStringList & paths ) + + + setIconProvider + setIconProvider + ( QFileIconProvider * provider ) + + + setItemDelegate + setItemDelegate + ( QAbstractItemDelegate * delegate ) + + + setLabelText + setLabelText + ( DialogLabel label, const QString & text ) + + + getExistingDirectory + getExistingDirectory-2 + ( const QString & dir, QWidget * parent = 0, const char * name = 0, const QString & caption = QString() + + + getOpenFileName + getOpenFileName-2 + ( const QString & dir, const QString & filter = QString() + + + getOpenFileNames + getOpenFileNames-2 + ( const QString & filter, const QString & dir = QString() + + + getSaveFileName + getSaveFileName-2 + ( const QString & dir, const QString & filter = QString() + + + mode + mode + () + + + selectedFile + selectedFile + () + + + setDir + setDir + ( const QString & directory ) + + + setDir + setDir-2 + ( const QDir & directory ) + + + setMode + setMode + ( FileMode m ) + + + + QFile + qfile.html + + DecoderFn + DecoderFn-typedef + + + + EncoderFn + EncoderFn-typedef + + + + FileError + FileError-enum + + + + PermissionSpec + PermissionSpec-typedef + + + + QFile + QFile-2 + ( const QString & name ) + + + QFile + QFile-3 + ( QObject * parent ) + + + QFile + QFile-4 + ( const QString & name, QObject * parent ) + + + atEnd + atEnd + () + + + copy + copy + ( const QString & newName ) + + + copy + copy-2 + ( const QString & fileName, const QString & newName ) + + + decodeName + decodeName + ( const QByteArray & localFileName ) + + + decodeName + decodeName-2 + ( const char * localFileName ) + + + encodeName + encodeName + ( const QString & fileName ) + + + error + error + () + + + exists + exists + ( const QString & fileName ) + + + exists + exists-2 + () + + + fileName + fileName + () + + + flush + flush + () + + + handle + handle + () + + + isSequential + isSequential + () + + + link + link + ( const QString & linkName ) + + + link + link-2 + ( const QString & fileName, const QString & linkName ) + + + open + open + ( OpenMode mode ) + + + open + open-4 + ( FILE * fh, OpenMode mode ) + + + open + open-5 + ( int fd, OpenMode mode ) + + + permissions + permissions + () + + + permissions + permissions-2 + ( const QString & fileName ) + + + readLink + readLink + ( const QString & fileName ) + + + readLink + readLink-2 + () + + + remove + remove + () + + + remove + remove-2 + ( const QString & fileName ) + + + rename + rename + ( const QString & newName ) + + + rename + rename-2 + ( const QString & oldName, const QString & newName ) + + + resize + resize + ( qint64 sz ) + + + resize + resize-2 + ( const QString & fileName, qint64 sz ) + + + setDecodingFunction + setDecodingFunction + ( DecoderFn function ) + + + setEncodingFunction + setEncodingFunction + ( EncoderFn function ) + + + setFileName + setFileName + ( const QString & name ) + + + setPermissions + setPermissions + ( Permissions permissions ) + + + setPermissions + setPermissions-2 + ( const QString & fileName, Permissions permissions ) + + + size + size + () + + + unsetError + unsetError + () + + + + QFileIconProvider + qfileiconprovider.html + + IconType + IconType-enum + + + + QFileIconProvider + QFileIconProvider + () + + + icon + icon + ( IconType type ) + + + icon + icon-2 + ( const QFileInfo & info ) + + + type + type + ( const QFileInfo & info ) + + + + QFileInfo + qfileinfo.html + + QFileInfo + QFileInfo + () + + + QFileInfo + QFileInfo-2 + ( const QString & file ) + + + QFileInfo + QFileInfo-3 + ( const QFile & file ) + + + QFileInfo + QFileInfo-4 + ( const QDir & dir, const QString & file ) + + + QFileInfo + QFileInfo-5 + ( const QFileInfo & fileinfo ) + + + absoluteDir + absoluteDir + () + + + absoluteFilePath + absoluteFilePath + () + + + absolutePath + absolutePath + () + + + baseName + baseName + () + + + caching + caching + () + + + canonicalFilePath + canonicalFilePath + () + + + canonicalPath + canonicalPath + () + + + completeBaseName + completeBaseName + () + + + completeSuffix + completeSuffix + () + + + created + created + () + + + dir + dir + () + + + exists + exists + () + + + fileName + fileName + () + + + filePath + filePath + () + + + group + group + () + + + groupId + groupId + () + + + isAbsolute + isAbsolute + () + + + isDir + isDir + () + + + isExecutable + isExecutable + () + + + isFile + isFile + () + + + isHidden + isHidden + () + + + isReadable + isReadable + () + + + isRelative + isRelative + () + + + isRoot + isRoot + () + + + isSymLink + isSymLink + () + + + isWritable + isWritable + () + + + lastModified + lastModified + () + + + lastRead + lastRead + () + + + makeAbsolute + makeAbsolute + () + + + owner + owner + () + + + ownerId + ownerId + () + + + path + path + () + + + permission + permission + ( QFile::Permissions permissions ) + + + Permissions + permissions + QFileInfo::permissions() + + + readLink + readLink + () + + + refresh + refresh + () + + + setCaching + setCaching + ( bool enable ) + + + setFile + setFile + ( const QString & file ) + + + setFile + setFile-2 + ( const QFile & file ) + + + setFile + setFile-3 + ( const QDir & dir, const QString & file ) + + + size + size + () + + + suffix + suffix + () + + + operator!= + operator-not-eq + ( const QFileInfo & fileinfo ) + + + operator!= + operator-not-eq-2 + ( const QFileInfo & fileinfo ) + + + operator= + operator-eq + ( const QFileInfo & fileinfo ) + + + operator== + operator-eq-eq + ( const QFileInfo & fileinfo ) + + + operator== + operator-eq-eq-2 + ( const QFileInfo & fileinfo ) + + + absFilePath + absFilePath + () + + + baseName + baseName-2 + ( bool complete ) + + + convertToAbs + convertToAbs + () + + + dir + dir-2 + ( bool absPath ) + + + dirPath + dirPath + ( bool absPath = false ) + + + extension + extension + ( bool complete = true ) + + + permission + permission-2 + ( PermissionSpec permissions ) + + + + QFileOpenEvent + qfileopenevent.html + + file + file + () + + + name + name + () + + + open + open-2 + ( OpenMode flags, FILE * f ) + + + open + open-3 + ( OpenMode flags, int fd ) + + + setName + setName + ( const QString & name ) + + + + QFlag + qflag.html + + QFlag + QFlag + ( int value ) + + + operator + operator-int + int() + + + + QFlags + qflags.html + + enum_type + enum_type-typedef + + + + QFlags + QFlags + ( const QFlags & other ) + + + QFlags + QFlags-2 + ( Enum flag ) + + + QFlags + QFlags-3 + ( Zero zero = 0 ) + + + QFlags + QFlags-4 + ( QFlag value ) + + + operator + operator-int + int() + + + operator! + operator-not + () + + + operator& + operator-and + amp;( int mask ) + + + operator& + operator-and-2 + amp;( uint mask ) + + + operator& + operator-and-3 + amp;( Enum mask ) + + + operator& + operator-and-eq + amp;=( int mask ) + + + operator& + operator-and-eq-2 + amp;=( uint mask ) + + + operator= + operator-eq + ( const QFlags & other ) + + + operator^ + operator-5e + ( QFlags other ) + + + operator^ + operator-5e-2 + ( Enum other ) + + + operator^= + operator-5e-eq + ( QFlags other ) + + + operator^= + operator-5e-eq-2 + ( Enum other ) + + + operator| + operator-7c + ( QFlags other ) + + + operator| + operator-7c-2 + ( Enum other ) + + + operator|= + operator-7c-eq + ( QFlags other ) + + + operator|= + operator-7c-eq-2 + ( Enum other ) + + + operator~ + operator-7e + () + + + + QFocusEvent + qfocusevent.html + + QFocusEvent + QFocusEvent + ( Type type, Qt::FocusReason reason = Qt::OtherFocusReason ) + + + gotFocus + gotFocus + () + + + lostFocus + lostFocus + () + + + FocusReason + reason + QFocusEvent::reason() + + + Reason + Reason-enum + + + + + QFocusFrame + qfocusframe.html + + QFocusFrame + QFocusFrame + ( QWidget * parent = 0 ) + + + setWidget + setWidget + ( QWidget * widget ) + + + widget + widget + () + + + + QFontDatabase + qfontdatabase.html + + WritingSystem + WritingSystem-enum + + + + QFontDatabase + QFontDatabase + () + + + bold + bold + ( const QString & family, const QString & style ) + + + families + families + ( WritingSystem writingSystem = Any ) + + + font + font + ( const QString & family, const QString & style, int pointSize ) + + + isBitmapScalable + isBitmapScalable + ( const QString & family, const QString & style = QString() + + + isFixedPitch + isFixedPitch + ( const QString & family, const QString & style = QString() + + + isScalable + isScalable + ( const QString & family, const QString & style = QString() + + + isSmoothlyScalable + isSmoothlyScalable + ( const QString & family, const QString & style = QString() + + + italic + italic + ( const QString & family, const QString & style ) + + + pointSizes + pointSizes + ( const QString & family, const QString & style = QString() + + + smoothSizes + smoothSizes + ( const QString & family, const QString & style ) + + + standardSizes + standardSizes + () + + + styleString + styleString + ( const QFont & font ) + + + styleString + styleString-2 + ( const QFontInfo & fontInfo ) + + + styles + styles + ( const QString & family ) + + + weight + weight + ( const QString & family, const QString & style ) + + + writingSystemName + writingSystemName + ( WritingSystem writingSystem ) + + + writingSystemSample + writingSystemSample + ( WritingSystem writingSystem ) + + + writingSystems + writingSystems + () + + + + QFontDialog + qfontdialog.html + + getFont + getFont + ( bool * ok, const QFont & initial, QWidget * parent = 0 ) + + + getFont + getFont-2 + ( bool * ok, const QFont & def, QWidget * parent, const char * name ) + + + getFont + getFont-3 + ( bool * ok, QWidget * parent, const char * name ) + + + getFont + getFont-5 + ( bool * ok, QWidget * parent = 0 ) + + + + QFont + qfont.html + + Stretch + Stretch-enum + + + + Style + Style-enum + + + + StyleHint + StyleHint-enum + + + + StyleStrategy + StyleStrategy-enum + + + + Weight + Weight-enum + + + + QFont + QFont + () + + + QFont + QFont-2 + ( const QString & family, int pointSize = -1, int weight = -1, bool italic = false ) + + + QFont + QFont-3 + ( const QFont & font, QPaintDevice * pd ) + + + QFont + QFont-4 + ( const QFont & font ) + + + bold + bold + () + + + defaultFamily + defaultFamily + () + + + exactMatch + exactMatch + () + + + family + family + () + + + fixedPitch + fixedPitch + () + + + fromString + fromString + ( const QString & descrip ) + + + handle + handle + () + + + insertSubstitution + insertSubstitution + ( const QString & familyName, const QString & substituteName ) + + + insertSubstitutions + insertSubstitutions + ( const QString & familyName, const QStringList & substituteNames ) + + + isCopyOf + isCopyOf + ( const QFont & f ) + + + italic + italic + () + + + kerning + kerning + () + + + key + key + () + + + lastResortFamily + lastResortFamily + () + + + lastResortFont + lastResortFont + () + + + overline + overline + () + + + pixelSize + pixelSize + () + + + pointSize + pointSize + () + + + pointSizeF + pointSizeF + () + + + rawMode + rawMode + () + + + rawName + rawName + () + + + removeSubstitution + removeSubstitution + ( const QString & familyName ) + + + resolve + resolve + ( const QFont & other ) + + + setBold + setBold + ( bool enable ) + + + setFamily + setFamily + ( const QString & family ) + + + setFixedPitch + setFixedPitch + ( bool enable ) + + + setItalic + setItalic + ( bool enable ) + + + setKerning + setKerning + ( bool enable ) + + + setOverline + setOverline + ( bool enable ) + + + setPixelSize + setPixelSize + ( int pixelSize ) + + + setPointSize + setPointSize + ( int pointSize ) + + + setPointSizeF + setPointSizeF + ( qreal pointSize ) + + + setRawMode + setRawMode + ( bool enable ) + + + setRawName + setRawName + ( const QString & name ) + + + setStretch + setStretch + ( int factor ) + + + setStrikeOut + setStrikeOut + ( bool enable ) + + + setStyle + setStyle + ( Style style ) + + + setStyleHint + setStyleHint + ( StyleHint hint, StyleStrategy strategy = PreferDefault ) + + + setStyleStrategy + setStyleStrategy + ( StyleStrategy s ) + + + setUnderline + setUnderline + ( bool enable ) + + + setWeight + setWeight + ( int weight ) + + + stretch + stretch + () + + + strikeOut + strikeOut + () + + + style + style + () + + + styleHint + styleHint + () + + + styleStrategy + styleStrategy + () + + + substitute + substitute + ( const QString & familyName ) + + + substitutes + substitutes + ( const QString & familyName ) + + + substitutions + substitutions + () + + + toString + toString + () + + + underline + underline + () + + + weight + weight + () + + + operator + operator-QVariant + QVariant() + + + operator!= + operator-not-eq + ( const QFont & f ) + + + operator< + operator-lt + ( const QFont & f ) + + + operator= + operator-eq + ( const QFont & font ) + + + operator== + operator-eq-eq + ( const QFont & f ) + + + + QFontInfo + qfontinfo.html + + QFontInfo + QFontInfo + ( const QFont & font ) + + + QFontInfo + QFontInfo-2 + ( const QFontInfo & fi ) + + + bold + bold + () + + + exactMatch + exactMatch + () + + + family + family + () + + + fixedPitch + fixedPitch + () + + + italic + italic + () + + + pixelSize + pixelSize + () + + + pointSize + pointSize + () + + + pointSizeF + pointSizeF + () + + + rawMode + rawMode + () + + + Style + style + QFontInfo::style() + + + StyleHint + styleHint + QFontInfo::styleHint() + + + weight + weight + () + + + operator= + operator-eq + ( const QFontInfo & fi ) + + + + QFontMetricsF + qfontmetricsf.html + + QFontMetricsF + QFontMetricsF + ( const QFont & font ) + + + QFontMetricsF + QFontMetricsF-2 + ( const QFont & font, QPaintDevice * paintdevice ) + + + QFontMetricsF + QFontMetricsF-3 + ( const QFontMetricsF & fm ) + + + ascent + ascent + () + + + boundingRect + boundingRect + ( const QString & text ) + + + boundingRect + boundingRect-2 + ( QChar ch ) + + + boundingRect + boundingRect-3 + ( const QRectF & rect, int flags, const QString & text, int tabstops = 0, int * tabarray = 0 ) + + + descent + descent + () + + + height + height + () + + + inFont + inFont + ( QChar ch ) + + + leading + leading + () + + + leftBearing + leftBearing + ( QChar ch ) + + + lineSpacing + lineSpacing + () + + + lineWidth + lineWidth + () + + + maxWidth + maxWidth + () + + + minLeftBearing + minLeftBearing + () + + + minRightBearing + minRightBearing + () + + + overlinePos + overlinePos + () + + + rightBearing + rightBearing + ( QChar ch ) + + + size + size + ( int flags, const QString & text, int tabstops = 0, int * tabarray = 0 ) + + + strikeOutPos + strikeOutPos + () + + + underlinePos + underlinePos + () + + + width + width + ( const QString & text ) + + + width + width-2 + ( QChar ch ) + + + xHeight + xHeight + () + + + operator!= + operator-not-eq + ( const QFontMetricsF & other ) + + + operator!= + operator-not-eq-2 + ( const QFontMetricsF & other ) + + + operator= + operator-eq + ( const QFontMetricsF & fm ) + + + operator== + operator-eq-eq + ( const QFontMetricsF & other ) + + + operator== + operator-eq-eq-2 + ( const QFontMetricsF & other ) + + + + QFontMetrics + qfontmetrics.html + + QFontMetrics + QFontMetrics + ( const QFont & font ) + + + QFontMetrics + QFontMetrics-2 + ( const QFont & font, QPaintDevice * paintdevice ) + + + QFontMetrics + QFontMetrics-3 + ( const QFontMetrics & fm ) + + + ascent + ascent + () + + + boundingRect + boundingRect + ( QChar ch ) + + + boundingRect + boundingRect-2 + ( const QString & str ) + + + boundingRect + boundingRect-5 + ( int x, int y, int width, int height, int flags, const QString & text, int tabstops = 0, int * tabarray = 0 ) + + + boundingRect + boundingRect-6 + ( const QRect & r, int flgs, const QString & str, int tabstops = 0, int * tabarray = 0 ) + + + charWidth + charWidth + ( const QString & str, int pos ) + + + descent + descent + () + + + height + height + () + + + inFont + inFont + ( QChar ch ) + + + leading + leading + () + + + leftBearing + leftBearing + ( QChar ch ) + + + lineSpacing + lineSpacing + () + + + lineWidth + lineWidth + () + + + maxWidth + maxWidth + () + + + minLeftBearing + minLeftBearing + () + + + minRightBearing + minRightBearing + () + + + overlinePos + overlinePos + () + + + rightBearing + rightBearing + ( QChar ch ) + + + size + size + ( int flgs, const QString & text, int tabstops = 0, int * tabarray = 0 ) + + + strikeOutPos + strikeOutPos + () + + + underlinePos + underlinePos + () + + + width + width + ( const QString & str, int len = -1 ) + + + width + width-2 + ( QChar ch ) + + + xHeight + xHeight + () + + + operator!= + operator-not-eq + ( const QFontMetrics & other ) + + + operator= + operator-eq + ( const QFontMetrics & fm ) + + + operator== + operator-eq-eq + ( const QFontMetrics & other ) + + + operator== + operator-eq-eq-2 + ( const QFontMetrics & other ) + + + boundingRect + boundingRect-3 + ( const QString & text, int len ) + + + boundingRect + boundingRect-4 + ( int x, int y, int w, int h, int flags, const QString & str, int len, int tabstops = 0, int * tabarray = 0 ) + + + size + size-2 + ( int flags, const QString & str, int len, int tabstops = 0, int * tabarray = 0 ) + + + defaultFont + defaultFont + () + + + pointSizeFloat + pointSizeFloat + () + + + setDefaultFont + setDefaultFont + ( const QFont & f ) + + + setPixelSizeFloat + setPixelSizeFloat + ( qreal pixelSize ) + + + setPointSizeFloat + setPointSizeFloat + ( qreal size ) + + + + QFormBuilder + qformbuilder.html + + QFormBuilder + QFormBuilder + () + + + addPluginPath + addPluginPath + ( const QString & pluginPath ) + + + clearPluginPaths + clearPluginPaths + () + + + customWidgets + customWidgets + () + + + pluginPaths + pluginPaths + () + + + setPluginPath + setPluginPath + ( const QStringList & pluginPaths ) + + + + QFrame + qframe.html + + Shadow + Shadow-enum + + + + Shape + Shape-enum + + + + QFrame + QFrame + ( QWidget * parent = 0, Qt::WFlags f = 0 ) + + + frameStyle + frameStyle + () + + + setFrameStyle + setFrameStyle + ( int style ) + + + Shadow_Mask + Shadow_Mask-var + + + + Shape_Mask + Shape_Mask-var + + + + QFrame + QFrame-2 + ( QWidget * parent, const char * name, Qt::WFlags f = 0 ) + + + + QFSFileEngine + qfsfileengine.html + + QFSFileEngine + QFSFileEngine + () + + + QFSFileEngine + QFSFileEngine-2 + ( const QString & file ) + + + currentPath + currentPath + ( const QString & fileName = QString() + + + drives + drives + () + + + fileFlags + fileFlags + ( FileFlags type ) + + + fileName + fileName + ( QAbstractFileEngine::FileName file ) + + + homePath + homePath + () + + + open + open-2 + ( QIODevice::OpenMode flags, FILE * fh ) + + + open + open-3 + ( QIODevice::OpenMode flags, int fd ) + + + ownerId + ownerId + ( QAbstractFileEngine::FileOwner ) + + + rootPath + rootPath + () + + + setCurrentPath + setCurrentPath + ( const QString & path ) + + + tempPath + tempPath + () + + + + QFtp + qftp.html + + Command + Command-enum + + + + Error + Error-enum + + + + State + State-enum + + + + TransferMode + TransferMode-enum + + + + TransferType + TransferType-enum + + + + QFtp + QFtp + ( QObject * parent = 0 ) + + + abort + abort + () + + + bytesAvailable + bytesAvailable + () + + + cd + cd + ( const QString & dir ) + + + clearPendingCommands + clearPendingCommands + () + + + close + close + () + + + commandFinished + commandFinished + ( int id, bool error ) + + + commandStarted + commandStarted + ( int id ) + + + connectToHost + connectToHost + ( const QString & host, quint16 port = 21 ) + + + currentCommand + currentCommand + () + + + currentDevice + currentDevice + () + + + currentId + currentId + () + + + dataTransferProgress + dataTransferProgress + ( qint64 done, qint64 total ) + + + done + done + ( bool error ) + + + error + error + () + + + errorString + errorString + () + + + get + get + ( const QString & file, QIODevice * dev = 0, TransferType type = Binary ) + + + hasPendingCommands + hasPendingCommands + () + + + list + list + ( const QString & dir = QString() + + + listInfo + listInfo + ( const QUrlInfo & i ) + + + login + login + ( const QString & user = QString() + + + mkdir + mkdir + ( const QString & dir ) + + + put + put + ( QIODevice * dev, const QString & file, TransferType type = Binary ) + + + put + put-2 + ( const QByteArray & data, const QString & file, TransferType type = Binary ) + + + rawCommand + rawCommand + ( const QString & command ) + + + rawCommandReply + rawCommandReply + ( int replyCode, const QString & detail ) + + + read + read + ( char * data, qint64 maxlen ) + + + readAll + readAll + () + + + readyRead + readyRead + () + + + remove + remove + ( const QString & file ) + + + rename + rename + ( const QString & oldname, const QString & newname ) + + + rmdir + rmdir + ( const QString & dir ) + + + setProxy + setProxy + ( const QString & host, quint16 port ) + + + setTransferMode + setTransferMode + ( TransferMode mode ) + + + state + state + () + + + stateChanged + stateChanged + ( int state ) + + + QFtp + QFtp-2 + ( QObject * parent, const char * name ) + + + readBlock + readBlock + ( char * data, quint64 maxlen ) + + + + QGenericArgument + qgenericargument.html + + QGenericArgument + QGenericArgument + ( const char * name = 0, const void * data = 0 ) + + + data + data + () + + + name + name + () + + + + QGenericReturnArgument + qgenericreturnargument.html + + QGenericReturnArgument + QGenericReturnArgument + ( const char * name = 0, void * data = 0 ) + + + + QGLColormap + qglcolormap.html + + QGLColormap + QGLColormap + () + + + QGLColormap + QGLColormap-2 + ( const QGLColormap & map ) + + + entryColor + entryColor + ( int idx ) + + + entryRgb + entryRgb + ( int idx ) + + + find + find + ( QRgb color ) + + + findNearest + findNearest + ( QRgb color ) + + + isEmpty + isEmpty + () + + + setEntries + setEntries + ( int count, const QRgb * colors, int base = 0 ) + + + setEntry + setEntry + ( int idx, QRgb color ) + + + setEntry + setEntry-2 + ( int idx, const QColor & color ) + + + size + size + () + + + operator= + operator-eq + ( const QGLColormap & map ) + + + + QGLContext + qglcontext.html + + QGLContext + QGLContext + ( const QGLFormat & format, QPaintDevice * device ) + + + bindTexture + bindTexture + ( const QImage & image, GLenum target = GL_TEXTURE_2D, GLint format = GL_RGBA8 ) + + + bindTexture + bindTexture-2 + ( const QString & fileName ) + + + bindTexture + bindTexture-3 + ( const QPixmap & pixmap, GLenum target = GL_TEXTURE_2D, GLint format = GL_RGBA8 ) + + + chooseContext + chooseContext + ( const QGLContext * shareContext = 0 ) + + + chooseMacVisual + chooseMacVisual + ( GDHandle ) + + + choosePixelFormat + choosePixelFormat + ( void * dummyPfd, HDC pdc ) + + + chooseVisual + chooseVisual + () + + + create + create + ( const QGLContext * shareContext = 0 ) + + + currentContext + currentContext + () + + + deleteTexture + deleteTexture + ( GLuint id ) + + + device + device + () + + + deviceIsPixmap + deviceIsPixmap + () + + + doneCurrent + doneCurrent + () + + + format + format + () + + + generateFontDisplayLists + generateFontDisplayLists + ( const QFont & font, int listBase ) + + + getProcAddress + getProcAddress + ( const QString & proc ) + + + initialized + initialized + () + + + isSharing + isSharing + () + + + isValid + isValid + () + + + makeCurrent + makeCurrent + () + + + overlayTransparentColor + overlayTransparentColor + () + + + requestedFormat + requestedFormat + () + + + reset + reset + () + + + setFormat + setFormat + ( const QGLFormat & format ) + + + setInitialized + setInitialized + ( bool on ) + + + setTextureCacheLimit + setTextureCacheLimit + ( int size ) + + + setWindowCreated + setWindowCreated + ( bool on ) + + + swapBuffers + swapBuffers + () + + + textureCacheLimit + textureCacheLimit + () + + + windowCreated + windowCreated + () + + + + QGLFormat + qglformat.html + + QGLFormat + QGLFormat + () + + + QGLFormat + QGLFormat-2 + ( QGL::FormatOptions options, int plane = 0 ) + + + QGLFormat + QGLFormat-3 + ( const QGLFormat & other ) + + + accum + accum + () + + + accumBufferSize + accumBufferSize + () + + + alpha + alpha + () + + + alphaBufferSize + alphaBufferSize + () + + + defaultFormat + defaultFormat + () + + + defaultOverlayFormat + defaultOverlayFormat + () + + + depth + depth + () + + + depthBufferSize + depthBufferSize + () + + + directRendering + directRendering + () + + + doubleBuffer + doubleBuffer + () + + + hasOpenGL + hasOpenGL + () + + + hasOpenGLOverlays + hasOpenGLOverlays + () + + + hasOverlay + hasOverlay + () + + + plane + plane + () + + + rgba + rgba + () + + + sampleBuffers + sampleBuffers + () + + + samples + samples + () + + + setAccum + setAccum + ( bool enable ) + + + setAccumBufferSize + setAccumBufferSize + ( int size ) + + + setAlpha + setAlpha + ( bool enable ) + + + setAlphaBufferSize + setAlphaBufferSize + ( int size ) + + + setDefaultFormat + setDefaultFormat + ( const QGLFormat & f ) + + + setDefaultOverlayFormat + setDefaultOverlayFormat + ( const QGLFormat & f ) + + + setDepth + setDepth + ( bool enable ) + + + setDepthBufferSize + setDepthBufferSize + ( int size ) + + + setDirectRendering + setDirectRendering + ( bool enable ) + + + setDoubleBuffer + setDoubleBuffer + ( bool enable ) + + + setOption + setOption + ( QGL::FormatOptions opt ) + + + setOverlay + setOverlay + ( bool enable ) + + + setPlane + setPlane + ( int plane ) + + + setRgba + setRgba + ( bool enable ) + + + setSampleBuffers + setSampleBuffers + ( bool enable ) + + + setSamples + setSamples + ( int numSamples ) + + + setStencil + setStencil + ( bool enable ) + + + setStencilBufferSize + setStencilBufferSize + ( int size ) + + + setStereo + setStereo + ( bool enable ) + + + stencil + stencil + () + + + stencilBufferSize + stencilBufferSize + () + + + stereo + stereo + () + + + testOption + testOption + ( QGL::FormatOptions opt ) + + + operator= + operator-eq + ( const QGLFormat & other ) + + + + QGLPixelBuffer + qglpixelbuffer.html + + QGLPixelBuffer + QGLPixelBuffer + ( const QSize & size, const QGLFormat & format = QGLFormat::defaultFormat() + + + bindTexture + bindTexture + ( const QImage & image, GLenum target = GL_TEXTURE_2D ) + + + bindTexture + bindTexture-2 + ( const QPixmap & pixmap, GLenum target = GL_TEXTURE_2D ) + + + bindTexture + bindTexture-3 + ( const QString & fileName ) + + + bindToDynamicTexture + bindToDynamicTexture + ( GLuint texture_id ) + + + deleteTexture + deleteTexture + ( GLuint texture_id ) + + + doneCurrent + doneCurrent + () + + + format + format + () + + + generateDynamicTexture + generateDynamicTexture + () + + + HANDLE + handle + QGLPixelBuffer::handle() + + + hasOpenGLPbuffers + hasOpenGLPbuffers + () + + + isValid + isValid + () + + + makeCurrent + makeCurrent + () + + + releaseFromDynamicTexture + releaseFromDynamicTexture + () + + + size + size + () + + + toImage + toImage + () + + + updateDynamicTexture + updateDynamicTexture + ( GLuint texture_id ) + + + + QGLWidget + qglwidget.html + + QGLWidget + QGLWidget + ( QWidget * parent = 0, const QGLWidget * shareWidget = 0, Qt::WFlags f = 0 ) + + + QGLWidget + QGLWidget-2 + ( QGLContext * context, QWidget * parent = 0, const QGLWidget * shareWidget = 0, Qt::WFlags f = 0 ) + + + QGLWidget + QGLWidget-3 + ( const QGLFormat & format, QWidget * parent = 0, const QGLWidget * shareWidget = 0, Qt::WFlags f = 0 ) + + + autoBufferSwap + autoBufferSwap + () + + + bindTexture + bindTexture + ( const QImage & image, GLenum target = GL_TEXTURE_2D, GLint format = GL_RGBA8 ) + + + bindTexture + bindTexture-2 + ( const QPixmap & pixmap, GLenum target = GL_TEXTURE_2D, GLint format = GL_RGBA8 ) + + + bindTexture + bindTexture-3 + ( const QString & fileName ) + + + colormap + colormap + () + + + context + context + () + + + convertToGLFormat + convertToGLFormat + ( const QImage & img ) + + + deleteTexture + deleteTexture + ( GLuint id ) + + + doneCurrent + doneCurrent + () + + + doubleBuffer + doubleBuffer + () + + + fontDisplayListBase + fontDisplayListBase + ( const QFont & fnt, int listBase = 2000 ) + + + format + format + () + + + glDraw + glDraw + () + + + glInit + glInit + () + + + grabFrameBuffer + grabFrameBuffer + ( bool withAlpha = false ) + + + initializeGL + initializeGL + () + + + initializeOverlayGL + initializeOverlayGL + () + + + isSharing + isSharing + () + + + isValid + isValid + () + + + makeCurrent + makeCurrent + () + + + makeOverlayCurrent + makeOverlayCurrent + () + + + overlayContext + overlayContext + () + + + paintEvent + paintEvent + ( QPaintEvent * event ) + + + paintGL + paintGL + () + + + paintOverlayGL + paintOverlayGL + () + + + qglClearColor + qglClearColor + ( const QColor & c ) + + + qglColor + qglColor + ( const QColor & c ) + + + renderPixmap + renderPixmap + ( int w = 0, int h = 0, bool useContext = false ) + + + renderText + renderText + ( int x, int y, const QString & str, const QFont & fnt = QFont() + + + renderText + renderText-2 + ( double x, double y, double z, const QString & str, const QFont & fnt = QFont() + + + resizeEvent + resizeEvent + ( QResizeEvent * event ) + + + resizeGL + resizeGL + ( int width, int height ) + + + resizeOverlayGL + resizeOverlayGL + ( int width, int height ) + + + setAutoBufferSwap + setAutoBufferSwap + ( bool on ) + + + setColormap + setColormap + ( const QGLColormap & cmap ) + + + setMouseTracking + setMouseTracking + ( bool enable ) + + + swapBuffers + swapBuffers + () + + + updateGL + updateGL + () + + + updateOverlayGL + updateOverlayGL + () + + + setFormat + setFormat + ( const QGLFormat & format ) + + + QGLWidget + QGLWidget-4 + ( QWidget * parent, const char * name, const QGLWidget * shareWidget = 0, Qt::WFlags f = 0 ) + + + QGLWidget + QGLWidget-5 + ( const QGLFormat & format, QWidget * parent, const char * name, const QGLWidget * shareWidget = 0, Qt::WFlags f = 0 ) + + + QGLWidget + QGLWidget-6 + ( QGLContext * context, QWidget * parent, const char * name, const QGLWidget * shareWidget = 0, Qt::WFlags f = 0 ) + + + + QGradient + qgradient.html + + Spread + Spread-enum + + + + Type + Type-enum + + + + setColorAt + setColorAt + ( qreal position, const QColor & color ) + + + setSpread + setSpread + ( Spread method ) + + + setStops + setStops + ( const QGradientStops & stopPoints ) + + + spread + spread + () + + + stops + stops + () + + + type + type + () + + + operator== + operator-eq-eq + ( const QGradient & gradient ) + + + + QGridLayout + qgridlayout.html + + QGridLayout + QGridLayout + ( QWidget * parent ) + + + QGridLayout + QGridLayout-2 + () + + + addItem + addItem + ( QLayoutItem * item, int row, int column, int rowSpan = 1, int columnSpan = 1, Qt::Alignment alignment = 0 ) + + + addLayout + addLayout + ( QLayout * layout, int row, int column, Qt::Alignment alignment = 0 ) + + + addLayout + addLayout-2 + ( QLayout * layout, int row, int column, int rowSpan, int columnSpan, Qt::Alignment alignment = 0 ) + + + addWidget + addWidget + ( QWidget * widget, int row, int column, Qt::Alignment alignment = 0 ) + + + addWidget + addWidget-2 + ( QWidget * widget, int fromRow, int fromColumn, int rowSpan, int columnSpan, Qt::Alignment alignment = 0 ) + + + cellRect + cellRect + ( int row, int column ) + + + columnCount + columnCount + () + + + columnMinimumWidth + columnMinimumWidth + ( int column ) + + + columnStretch + columnStretch + ( int column ) + + + getItemPosition + getItemPosition + ( int index, int * row, int * column, int * rowSpan, int * columnSpan ) + + + Corner + originCorner + QGridLayout::originCorner() + + + rowCount + rowCount + () + + + rowMinimumHeight + rowMinimumHeight + ( int row ) + + + rowStretch + rowStretch + ( int row ) + + + setColumnMinimumWidth + setColumnMinimumWidth + ( int column, int minSize ) + + + setColumnStretch + setColumnStretch + ( int column, int stretch ) + + + setOriginCorner + setOriginCorner + ( Qt::Corner corner ) + + + setRowMinimumHeight + setRowMinimumHeight + ( int row, int minSize ) + + + setRowStretch + setRowStretch + ( int row, int stretch ) + + + QGridLayout + QGridLayout-3 + ( QWidget * parent, int nRows, int nCols = 1, int margin = 0, int space = -1, const char * name = 0 ) + + + QGridLayout + QGridLayout-4 + ( int nRows, int nCols = 1, int spacing = -1, const char * name = 0 ) + + + QGridLayout + QGridLayout-5 + ( QLayout * parentLayout, int nRows = 1, int nCols = 1, int spacing = -1, const char * name = 0 ) + + + addColSpacing + addColSpacing + ( int col, int minsize ) + + + addMultiCell + addMultiCell + ( QLayoutItem * l, int fromRow, int toRow, int fromCol, int toCol, Qt::Alignment align = 0 ) + + + addMultiCellLayout + addMultiCellLayout + ( QLayout * layout, int fromRow, int toRow, int fromCol, int toCol, Qt::Alignment align = 0 ) + + + addMultiCellWidget + addMultiCellWidget + ( QWidget * widget, int fromRow, int toRow, int fromCol, int toCol, Qt::Alignment align = 0 ) + + + addRowSpacing + addRowSpacing + ( int row, int minsize ) + + + cellGeometry + cellGeometry + ( int row, int column ) + + + colSpacing + colSpacing + ( int col ) + + + colStretch + colStretch + ( int col ) + + + expand + expand + ( int nRows, int nCols ) + + + findWidget + findWidget + ( QWidget * w, int * row, int * column ) + + + numCols + numCols + () + + + numRows + numRows + () + + + Corner + origin + QGridLayout::origin() + + + rowSpacing + rowSpacing + ( int row ) + + + setColSpacing + setColSpacing + ( int col, int minSize ) + + + setColStretch + setColStretch + ( int col, int stretch ) + + + setOrigin + setOrigin + ( Qt::Corner corner ) + + + setRowSpacing + setRowSpacing + ( int row, int minSize ) + + + + QGroupBox + qgroupbox.html + + Alignment + alignment-prop + + + + QGroupBox + QGroupBox + ( QWidget * parent = 0 ) + + + QGroupBox + QGroupBox-2 + ( const QString & title, QWidget * parent = 0 ) + + + toggled + toggled + ( bool on ) + + + QGroupBox + QGroupBox-3 + ( QWidget * parent, const char * name ) + + + QGroupBox + QGroupBox-4 + ( const QString & title, QWidget * parent, const char * name ) + + + + QHash::const_iterator + qhash-const-iterator.html + + const_iterator + const_iterator + () + + + const_iterator + const_iterator-3 + ( const iterator & other ) + + + key + key + () + + + value + value + () + + + operator!= + operator-not-eq + ( const const_iterator & other ) + + + operator* + operator-2a + () + + + operator+ + operator-2b + ( int j ) + + + operator++ + operator-2b-2b + () + + + operator++ + operator-2b-2b-2 + ( int ) + + + operator+= + operator-2b-eq + ( int j ) + + + operator- + operator- + ( int j ) + + + operator-- + operator-- + () + + + operator-- + operator---2 + ( int ) + + + operator-= + operator--eq + ( int j ) + + + operator-& + operator--gt + gt;() + + + operator== + operator-eq-eq + ( const const_iterator & other ) + + + + QHash + qhash.html + + ConstIterator + ConstIterator-typedef + + + + Iterator + Iterator-typedef + + + + QHash + QHash + () + + + QHash + QHash-2 + ( const QHash<Key, T> & other ) + + + begin + begin + () + + + begin + begin-2 + () + + + capacity + capacity + () + + + clear + clear + () + + + constBegin + constBegin + () + + + constEnd + constEnd + () + + + constFind + constFind + ( const Key & key ) + + + contains + contains + ( const Key & key ) + + + count + count + ( const Key & key ) + + + count + count-2 + () + + + empty + empty + () + + + end + end + () + + + end + end-2 + () + + + erase + erase + ( iterator pos ) + + + find + find + ( const Key & key ) + + + find + find-2 + ( const Key & key ) + + + insert + insert + ( const Key & key, const T & value ) + + + insertMulti + insertMulti + ( const Key & key, const T & value ) + + + isEmpty + isEmpty + () + + + key + key + ( const T & value ) + + + keys + keys + () + + + keys + keys-2 + ( const T & value ) + + + remove + remove + ( const Key & key ) + + + reserve + reserve + ( int size ) + + + size + size + () + + + squeeze + squeeze + () + + + take + take + ( const Key & key ) + + + unite + unite + ( const QHash<Key, T> & other ) + + + value + value + ( const Key & key ) + + + value + value-2 + ( const Key & key, const T & defaultValue ) + + + values + values + () + + + values + values-2 + ( const Key & key ) + + + operator!= + operator-not-eq + ( const QHash<Key, T> & other ) + + + operator= + operator-eq + ( const QHash<Key, T> & other ) + + + operator== + operator-eq-eq + ( const QHash<Key, T> & other ) + + + operator[] + operator-5b-5d + ( const Key & key ) + + + operator[] + operator-5b-5d-2 + ( const Key & key ) + + + + QHash::iterator + qhash-iterator.html + + iterator + iterator + () + + + key + key + () + + + value + value + () + + + operator!= + operator-not-eq + ( const iterator & other ) + + + operator!= + operator-not-eq-2 + ( const const_iterator & other ) + + + operator* + operator-2a + () + + + operator+ + operator-2b + ( int j ) + + + operator++ + operator-2b-2b + () + + + operator++ + operator-2b-2b-2 + ( int ) + + + operator+= + operator-2b-eq + ( int j ) + + + operator- + operator- + ( int j ) + + + operator-- + operator-- + () + + + operator-- + operator---2 + ( int ) + + + operator-= + operator--eq + ( int j ) + + + operator-& + operator--gt + gt;() + + + operator== + operator-eq-eq + ( const iterator & other ) + + + operator== + operator-eq-eq-2 + ( const const_iterator & other ) + + + + QHashIterator + qhashiterator.html + + QHashIterator + QHashIterator + ( const QHash<Key, T> & hash ) + + + findNext + findNext + ( const T & value ) + + + findPrevious + findPrevious + ( const T & value ) + + + hasNext + hasNext + () + + + hasPrevious + hasPrevious + () + + + key + key + () + + + next + next + () + + + peekNext + peekNext + () + + + peekPrevious + peekPrevious + () + + + previous + previous + () + + + toBack + toBack + () + + + toFront + toFront + () + + + value + value + () + + + operator= + operator-eq + ( const QHash<Key, T> & hash ) + + + + QHBoxLayout + qhboxlayout.html + + QHBoxLayout + QHBoxLayout + () + + + QHBoxLayout + QHBoxLayout-2 + ( QWidget * parent ) + + + QHBoxLayout + QHBoxLayout-3 + ( QWidget * parent, int margin, int spacing = -1, const char * name = 0 ) + + + QHBoxLayout + QHBoxLayout-4 + ( QLayout * parentLayout, int spacing = -1, const char * name = 0 ) + + + QHBoxLayout + QHBoxLayout-5 + ( int spacing, const char * name = 0 ) + + + + QHeaderView + qheaderview.html + + ResizeMode + ResizeMode-enum + + + + Alignment + defaultAlignment-prop + + + + QHeaderView + QHeaderView + ( Qt::Orientation orientation, QWidget * parent = 0 ) + + + count + count + () + + + headerDataChanged + headerDataChanged + ( Qt::Orientation orientation, int logicalFirst, int logicalLast ) + + + hiddenSectionCount + hiddenSectionCount + () + + + hideSection + hideSection + ( int logicalIndex ) + + + horizontalOffset + horizontalOffset + () + + + isClickable + isClickable + () + + + isMovable + isMovable + () + + + isSectionHidden + isSectionHidden + ( int logicalIndex ) + + + length + length + () + + + logicalIndex + logicalIndex + ( int visualIndex ) + + + logicalIndexAt + logicalIndexAt + ( int position ) + + + logicalIndexAt + logicalIndexAt-2 + ( int x, int y ) + + + logicalIndexAt + logicalIndexAt-3 + ( const QPoint & pos ) + + + moveSection + moveSection + ( int from, int to ) + + + offset + offset + () + + + Orientation + orientation + QHeaderView::orientation() + + + paintSection + paintSection + ( QPainter * painter, const QRect & rect, int logicalIndex ) + + + resizeMode + resizeMode + ( int logicalIndex ) + + + resizeSection + resizeSection + ( int logicalIndex, int size ) + + + resizeSections + resizeSections + ( QHeaderView::ResizeMode mode ) + + + sectionAutoResize + sectionAutoResize + ( int logicalIndex, QHeaderView::ResizeMode mode ) + + + sectionClicked + sectionClicked + ( int logicalIndex ) + + + sectionCountChanged + sectionCountChanged + ( int oldCount, int newCount ) + + + sectionDoubleClicked + sectionDoubleClicked + ( int logicalIndex ) + + + sectionHandleDoubleClicked + sectionHandleDoubleClicked + ( int logicalIndex ) + + + sectionMoved + sectionMoved + ( int logicalIndex, int oldVisualIndex, int newVisualIndex ) + + + sectionPosition + sectionPosition + ( int logicalIndex ) + + + sectionPressed + sectionPressed + ( int logicalIndex ) + + + sectionResized + sectionResized + ( int logicalIndex, int oldSize, int newSize ) + + + sectionSize + sectionSize + ( int logicalIndex ) + + + sectionSizeFromContents + sectionSizeFromContents + ( int logicalIndex ) + + + sectionSizeHint + sectionSizeHint + ( int logicalIndex ) + + + sectionViewportPosition + sectionViewportPosition + ( int logicalIndex ) + + + sectionsAboutToBeRemoved + sectionsAboutToBeRemoved + ( const QModelIndex & parent, int logicalFirst, int logicalLast ) + + + sectionsHidden + sectionsHidden + () + + + sectionsInserted + sectionsInserted + ( const QModelIndex & parent, int logicalFirst, int logicalLast ) + + + sectionsMoved + sectionsMoved + () + + + setClickable + setClickable + ( bool clickable ) + + + setMovable + setMovable + ( bool movable ) + + + setOffset + setOffset + ( int offset ) + + + setResizeMode + setResizeMode + ( ResizeMode mode ) + + + setResizeMode + setResizeMode-2 + ( int logicalIndex, ResizeMode mode ) + + + setSectionHidden + setSectionHidden + ( int logicalIndex, bool hide ) + + + setSortIndicator + setSortIndicator + ( int logicalIndex, Qt::SortOrder order ) + + + showSection + showSection + ( int logicalIndex ) + + + sizeHint + sizeHint + () + + + SortOrder + sortIndicatorOrder + QHeaderView::sortIndicatorOrder() + + + sortIndicatorSection + sortIndicatorSection + () + + + stretchSectionCount + stretchSectionCount + () + + + verticalOffset + verticalOffset + () + + + visualIndex + visualIndex + ( int logicalIndex ) + + + visualIndexAt + visualIndexAt + ( int position ) + + + + QHelpEvent + qhelpevent.html + + QHelpEvent + QHelpEvent + ( Type type, const QPoint & pos, const QPoint & globalPos ) + + + globalPos + globalPos + () + + + globalX + globalX + () + + + globalY + globalY + () + + + pos + pos + () + + + x + x + () + + + y + y + () + + + + QHideEvent + qhideevent.html + + QHideEvent + QHideEvent + () + + + + QHostAddress + qhostaddress.html + + SpecialAddress + SpecialAddress-enum + + + + QHostAddress + QHostAddress + () + + + QHostAddress + QHostAddress-2 + ( quint32 ip4Addr ) + + + QHostAddress + QHostAddress-3 + ( quint8 * ip6Addr ) + + + QHostAddress + QHostAddress-4 + ( const Q_IPV6ADDR & ip6Addr ) + + + QHostAddress + QHostAddress-5 + ( const sockaddr * sockaddr ) + + + QHostAddress + QHostAddress-6 + ( const QString & address ) + + + QHostAddress + QHostAddress-7 + ( const QHostAddress & address ) + + + QHostAddress + QHostAddress-8 + ( SpecialAddress address ) + + + clear + clear + () + + + isNull + isNull + () + + + NetworkLayerProtocol + protocol + QHostAddress::protocol() + + + scopeId + scopeId + () + + + setAddress + setAddress + ( quint32 ip4Addr ) + + + setAddress + setAddress-2 + ( quint8 * ip6Addr ) + + + setAddress + setAddress-3 + ( const Q_IPV6ADDR & ip6Addr ) + + + setAddress + setAddress-4 + ( const QString & address ) + + + setAddress + setAddress-5 + ( const sockaddr * sockaddr ) + + + setScopeId + setScopeId + ( const QString & id ) + + + toIPv4Address + toIPv4Address + () + + + toIPv6Address + toIPv6Address + () + + + toString + toString + () + + + operator= + operator-eq + ( const QHostAddress & address ) + + + operator= + operator-eq-2 + ( const QString & address ) + + + operator== + operator-eq-eq + ( const QHostAddress & other ) + + + operator== + operator-eq-eq-2 + ( SpecialAddress other ) + + + ip4Addr + ip4Addr + () + + + isIPv4Address + isIPv4Address + () + + + isIPv6Address + isIPv6Address + () + + + isIp4Addr + isIp4Addr + () + + + + QHostInfo + qhostinfo.html + + HostInfoError + HostInfoError-enum + + + + QHostInfo + QHostInfo + ( int id = -1 ) + + + QHostInfo + QHostInfo-2 + ( const QHostInfo & other ) + + + abortHostLookup + abortHostLookup + ( int id ) + + + addresses + addresses + () + + + error + error + () + + + errorString + errorString + () + + + fromName + fromName + ( const QString & name ) + + + hostName + hostName + () + + + localHostName + localHostName + () + + + lookupHost + lookupHost + ( const QString & name, QObject * receiver, const char * member ) + + + lookupId + lookupId + () + + + setAddresses + setAddresses + ( const QList<QHostAddress> & addresses ) + + + setError + setError + ( HostInfoError error ) + + + setErrorString + setErrorString + ( const QString & str ) + + + setHostName + setHostName + ( const QString & hostName ) + + + setLookupId + setLookupId + ( int id ) + + + operator= + operator-eq + ( const QHostInfo & other ) + + + + QHoverEvent + qhoverevent.html + + QHoverEvent + QHoverEvent + ( Type type, const QPoint & pos, const QPoint & oldPos ) + + + oldPos + oldPos + () + + + pos + pos + () + + + + QHttpHeader + qhttpheader.html + + QHttpHeader + QHttpHeader + () + + + QHttpHeader + QHttpHeader-2 + ( const QHttpHeader & header ) + + + QHttpHeader + QHttpHeader-3 + ( const QString & str ) + + + addValue + addValue + ( const QString & key, const QString & value ) + + + allValues + allValues + ( const QString & key ) + + + contentLength + contentLength + () + + + contentType + contentType + () + + + hasContentLength + hasContentLength + () + + + hasContentType + hasContentType + () + + + hasKey + hasKey + ( const QString & key ) + + + isValid + isValid + () + + + keys + keys + () + + + majorVersion + majorVersion + () + + + minorVersion + minorVersion + () + + + removeAllValues + removeAllValues + ( const QString & key ) + + + removeValue + removeValue + ( const QString & key ) + + + setContentLength + setContentLength + ( int len ) + + + setContentType + setContentType + ( const QString & type ) + + + setValue + setValue + ( const QString & key, const QString & value ) + + + setValues + setValues + ( const QList<QPair<QString, QString> > & values ) + + + toString + toString + () + + + value + value + ( const QString & key ) + + + values + values + () + + + operator= + operator-eq + ( const QHttpHeader & h ) + + + + QHttp + qhttp.html + + Error + Error-enum + + + + State + State-enum + + + + QHttp + QHttp + ( QObject * parent = 0 ) + + + QHttp + QHttp-2 + ( const QString & hostName, quint16 port = 80, QObject * parent = 0 ) + + + abort + abort + () + + + bytesAvailable + bytesAvailable + () + + + clearPendingRequests + clearPendingRequests + () + + + close + close + () + + + currentDestinationDevice + currentDestinationDevice + () + + + currentId + currentId + () + + + currentRequest + currentRequest + () + + + currentSourceDevice + currentSourceDevice + () + + + dataReadProgress + dataReadProgress + ( int done, int total ) + + + dataSendProgress + dataSendProgress + ( int done, int total ) + + + done + done + ( bool error ) + + + error + error + () + + + errorString + errorString + () + + + get + get + ( const QString & path, QIODevice * to = 0 ) + + + hasPendingRequests + hasPendingRequests + () + + + head + head + ( const QString & path ) + + + lastResponse + lastResponse + () + + + post + post + ( const QString & path, QIODevice * data, QIODevice * to = 0 ) + + + post + post-2 + ( const QString & path, const QByteArray & data, QIODevice * to = 0 ) + + + read + read + ( char * data, qint64 maxlen ) + + + readAll + readAll + () + + + readyRead + readyRead + ( const QHttpResponseHeader & resp ) + + + request + request + ( const QHttpRequestHeader & header, QIODevice * data = 0, QIODevice * to = 0 ) + + + request + request-2 + ( const QHttpRequestHeader & header, const QByteArray & data, QIODevice * to = 0 ) + + + requestFinished + requestFinished + ( int id, bool error ) + + + requestStarted + requestStarted + ( int id ) + + + responseHeaderReceived + responseHeaderReceived + ( const QHttpResponseHeader & resp ) + + + setHost + setHost + ( const QString & hostName, quint16 port = 80 ) + + + setProxy + setProxy + ( const QString & host, int port, const QString & username = QString() + + + setSocket + setSocket + ( QTcpSocket * socket ) + + + setUser + setUser + ( const QString & userName, const QString & password = QString() + + + state + state + () + + + stateChanged + stateChanged + ( int state ) + + + closeConnection + closeConnection + () + + + readBlock + readBlock + ( char * data, quint64 maxlen ) + + + + QHttpRequestHeader + qhttprequestheader.html + + QHttpRequestHeader + QHttpRequestHeader + () + + + QHttpRequestHeader + QHttpRequestHeader-2 + ( const QString & method, const QString & path, int majorVer = 1, int minorVer = 1 ) + + + QHttpRequestHeader + QHttpRequestHeader-3 + ( const QHttpRequestHeader & header ) + + + QHttpRequestHeader + QHttpRequestHeader-4 + ( const QString & str ) + + + majorVersion + majorVersion + () + + + method + method + () + + + minorVersion + minorVersion + () + + + path + path + () + + + setRequest + setRequest + ( const QString & method, const QString & path, int majorVer = 1, int minorVer = 1 ) + + + operator= + operator-eq + ( const QHttpRequestHeader & header ) + + + + QHttpResponseHeader + qhttpresponseheader.html + + QHttpResponseHeader + QHttpResponseHeader + () + + + QHttpResponseHeader + QHttpResponseHeader-2 + ( const QHttpResponseHeader & header ) + + + QHttpResponseHeader + QHttpResponseHeader-3 + ( const QString & str ) + + + QHttpResponseHeader + QHttpResponseHeader-4 + ( int code, const QString & text = QString() + + + majorVersion + majorVersion + () + + + minorVersion + minorVersion + () + + + reasonPhrase + reasonPhrase + () + + + setStatusLine + setStatusLine + ( int code, const QString & text = QString() + + + statusCode + statusCode + () + + + operator= + operator-eq + ( const QHttpResponseHeader & header ) + + + + QIconDragEvent + qicondragevent.html + + QIconDragEvent + QIconDragEvent + () + + + + QIconEngine + qiconengine.html + + actualSize + actualSize + ( const QSize & size, QIcon::Mode mode, QIcon::State state ) + + + addFile + addFile + ( const QString & fileName, const QSize & size, QIcon::Mode mode, QIcon::State state ) + + + addPixmap + addPixmap + ( const QPixmap & pixmap, QIcon::Mode mode, QIcon::State state ) + + + paint + paint + ( QPainter * painter, const QRect & rect, QIcon::Mode mode, QIcon::State state ) + + + pixmap + pixmap + ( const QSize & size, QIcon::Mode mode, QIcon::State state ) + + + + QIconEnginePlugin + qiconengineplugin.html + + QIconEnginePlugin + QIconEnginePlugin + ( QObject * parent = 0 ) + + + create + create + ( const QString & filename ) + + + keys + keys + () + + + + QIcon + qicon.html + + Mode + Mode-enum + + + + State + State-enum + + + + QIcon + QIcon + () + + + QIcon + QIcon-2 + ( const QPixmap & pixmap ) + + + QIcon + QIcon-3 + ( const QIcon & other ) + + + QIcon + QIcon-4 + ( const QString & fileName ) + + + QIcon + QIcon-5 + ( QIconEngine * engine ) + + + actualSize + actualSize + ( const QSize & size, Mode mode = Normal, State state = Off ) + + + addFile + addFile + ( const QString & fileName, const QSize & size = QSize() + + + addPixmap + addPixmap + ( const QPixmap & pixmap, Mode mode = Normal, State state = Off ) + + + isNull + isNull + () + + + paint + paint + ( QPainter * painter, const QRect & rect, Qt::Alignment alignment = Qt::AlignCenter, Mode mode = Normal, State state = Off ) + + + paint + paint-2 + ( QPainter * painter, int x, int y, int w, int h, Qt::Alignment alignment = Qt::AlignCenter, Mode mode = Normal, State state = Off ) + + + pixmap + pixmap + ( const QSize & size, Mode mode = Normal, State state = Off ) + + + pixmap + pixmap-5 + ( int w, int h, Mode mode = Normal, State state = Off ) + + + pixmap + pixmap-6 + ( int extent, Mode mode = Normal, State state = Off ) + + + serialNumber + serialNumber + () + + + operator + operator-QVariant + QVariant() + + + operator= + operator-eq + ( const QIcon & other ) + + + Size + Size-enum + + + + pixmap + pixmap-2 + ( Size size, Mode mode, State state = Off ) + + + pixmap + pixmap-3 + ( Size size, bool enabled, State state = Off ) + + + pixmap + pixmap-4 + () + + + pixmapSize + pixmapSize + ( Size which ) + + + reset + reset + ( const QPixmap & pixmap, Size size ) + + + setPixmap + setPixmap + ( const QPixmap & pixmap, Size size, Mode mode = Normal, State state = Off ) + + + setPixmap + setPixmap-2 + ( const QString & fileName, Size size, Mode mode = Normal, State state = Off ) + + + setPixmapSize + setPixmapSize + ( Size which, const QSize & size ) + + + + QImage + qimage.html + + Format + Format-enum + + + + InvertMode + InvertMode-enum + + + + QImage + QImage + () + + + QImage + QImage-2 + ( const QSize & size, Format format ) + + + QImage + QImage-3 + ( int width, int height, Format format ) + + + QImage + QImage-4 + ( uchar * data, int width, int height, Format format ) + + + QImage + QImage-5 + ( const char * const[] xpm ) + + + QImage + QImage-6 + ( const QString & fileName, const char * format = 0 ) + + + QImage + QImage-7 + ( const char * fileName, const char * format = 0 ) + + + QImage + QImage-8 + ( const QImage & image ) + + + allGray + allGray + () + + + alphaChannel + alphaChannel + () + + + bits + bits + () + + + bits + bits-2 + () + + + bytesPerLine + bytesPerLine + () + + + color + color + ( int i ) + + + colorTable + colorTable + () + + + convertToFormat + convertToFormat + ( Format format, Qt::ImageConversionFlags flags = Qt::AutoColor ) + + + convertToFormat + convertToFormat-2 + ( Format format, const QVector<QRgb> & colorTable, Qt::ImageConversionFlags flags = Qt::AutoColor ) + + + copy + copy + ( const QRect & rectangle = QRect() + + + copy + copy-4 + ( int x, int y, int width, int height ) + + + createAlphaMask + createAlphaMask + ( Qt::ImageConversionFlags flags = Qt::AutoColor ) + + + createHeuristicMask + createHeuristicMask + ( bool clipTight = true ) + + + depth + depth + () + + + dotsPerMeterX + dotsPerMeterX + () + + + dotsPerMeterY + dotsPerMeterY + () + + + fill + fill + ( uint pixelValue ) + + + format + format + () + + + fromData + fromData + ( const uchar * data, int size, const char * format = 0 ) + + + fromData + fromData-2 + ( const QByteArray & data, const char * format = 0 ) + + + hasAlphaChannel + hasAlphaChannel + () + + + height + height + () + + + invertPixels + invertPixels + ( InvertMode mode = InvertRgb ) + + + isGrayscale + isGrayscale + () + + + isNull + isNull + () + + + load + load + ( const QString & fileName, const char * format = 0 ) + + + load + load-2 + ( QIODevice * device, const char * format ) + + + loadFromData + loadFromData + ( const uchar * data, int len, const char * format = 0 ) + + + loadFromData + loadFromData-2 + ( const QByteArray & data, const char * format = 0 ) + + + mirrored + mirrored + ( bool horizontal = false, bool vertical = true ) + + + numBytes + numBytes + () + + + numColors + numColors + () + + + offset + offset + () + + + pixel + pixel + ( int x, int y ) + + + pixelIndex + pixelIndex + ( int x, int y ) + + + rect + rect + () + + + rgbSwapped + rgbSwapped + () + + + save + save + ( const QString & fileName, const char * format, int quality = -1 ) + + + save + save-2 + ( QIODevice * device, const char * format, int quality = -1 ) + + + scaled + scaled + ( const QSize & size, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio, Qt::TransformationMode transformMode = Qt::FastTransformation ) + + + scaled + scaled-2 + ( int width, int height, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio, Qt::TransformationMode transformMode = Qt::FastTransformation ) + + + scaledToHeight + scaledToHeight + ( int height, Qt::TransformationMode mode = Qt::FastTransformation ) + + + scaledToWidth + scaledToWidth + ( int width, Qt::TransformationMode mode = Qt::FastTransformation ) + + + scanLine + scanLine + ( int i ) + + + scanLine + scanLine-2 + ( int i ) + + + serialNumber + serialNumber + () + + + setAlphaChannel + setAlphaChannel + ( const QImage & alphaChannel ) + + + setColor + setColor + ( int index, QRgb colorValue ) + + + setColorTable + setColorTable + ( const QVector<QRgb> colors ) + + + setDotsPerMeterX + setDotsPerMeterX + ( int x ) + + + setDotsPerMeterY + setDotsPerMeterY + ( int y ) + + + setNumColors + setNumColors + ( int numColors ) + + + setOffset + setOffset + ( const QPoint & offset ) + + + setPixel + setPixel + ( int x, int y, uint index_or_rgb ) + + + setText + setText + ( const QString & key, const QString & text ) + + + size + size + () + + + text + text + ( const QString & key = QString() + + + textKeys + textKeys + () + + + transformed + transformed + ( const QMatrix & matrix, Qt::TransformationMode mode = Qt::FastTransformation ) + + + trueMatrix + trueMatrix + ( const QMatrix & matrix, int width, int height ) + + + valid + valid + ( int x, int y ) + + + width + width + () + + + operator + operator-QVariant + QVariant() + + + operator!= + operator-not-eq + ( const QImage & image ) + + + operator= + operator-eq + ( const QImage & image ) + + + operator== + operator-eq-eq + ( const QImage & image ) + + + + QImageIOHandler + qimageiohandler.html + + ImageOption + ImageOption-enum + + + + QImageIOHandler + QImageIOHandler + () + + + canRead + canRead + () + + + currentImageNumber + currentImageNumber + () + + + currentImageRect + currentImageRect + () + + + device + device + () + + + format + format + () + + + imageCount + imageCount + () + + + jumpToImage + jumpToImage + ( int imageNumber ) + + + jumpToNextImage + jumpToNextImage + () + + + loopCount + loopCount + () + + + nextImageDelay + nextImageDelay + () + + + option + option + ( ImageOption option ) + + + read + read + ( QImage * image ) + + + setDevice + setDevice + ( QIODevice * device ) + + + setFormat + setFormat + ( const QByteArray & format ) + + + setFormat + setFormat-2 + ( const QByteArray & format ) + + + setOption + setOption + ( ImageOption option, const QVariant & value ) + + + supportsOption + supportsOption + ( ImageOption option ) + + + write + write + ( const QImage & image ) + + + name + name + () + + + + QImageIOPlugin + qimageioplugin.html + + QImageIOPlugin + QImageIOPlugin + ( QObject * parent = 0 ) + + + capabilities + capabilities + ( QIODevice * device, const QByteArray & format ) + + + create + create + ( QIODevice * device, const QByteArray & format = QByteArray() + + + keys + keys + () + + + setText + setText-2 + ( const char * key, const char * language, const QString & text ) + + + text + text-2 + ( const char * key, const char * language = 0 ) + + + text + text-3 + ( const QImageTextKeyLang & keywordAndLanguage ) + + + textLanguages + textLanguages + () + + + textList + textList + () + + + Endian + Endian-enum + + + + QImage + QImage-9 + ( int width, int height, int depth, int numColors = 0, Endian bitOrder = IgnoreEndian ) + + + QImage + QImage-10 + ( const QSize & size, int depth, int numColors = 0, Endian bitOrder = IgnoreEndian ) + + + QImage + QImage-11 + ( uchar * data, int width, int height, int depth, const QRgb * colortable, int numColors, Endian bitOrder ) + + + QImage + QImage-12 + ( uchar * data, int width, int height, int depth, int bytesPerLine, const QRgb * colortable, int numColors, Endian bitOrder ) + + + QImage + QImage-13 + ( const QByteArray & data ) + + + bitOrder + bitOrder + () + + + convertBitOrder + convertBitOrder + ( Endian bitOrder ) + + + convertDepth + convertDepth + ( int depth, Qt::ImageConversionFlags flags = Qt::AutoColor ) + + + convertDepthWithPalette + convertDepthWithPalette + ( int depth, QRgb * palette, int palette_count, Qt::ImageConversionFlags flags = Qt::AutoColor ) + + + copy + copy-2 + ( int x, int y, int w, int h, Qt::ImageConversionFlags flags ) + + + copy + copy-3 + ( const QRect & rect, Qt::ImageConversionFlags flags ) + + + create + create + ( int width, int height, int depth, int numColors = 0, Endian bitOrder = IgnoreEndian ) + + + create + create-2 + ( const QSize & size, int depth, int numColors = 0, Endian bitOrder = IgnoreEndian ) + + + hasAlphaBuffer + hasAlphaBuffer + () + + + invertPixels + invertPixels-2 + ( bool invertAlpha ) + + + jumpTable + jumpTable + () + + + jumpTable + jumpTable-2 + () + + + mirror + mirror + ( bool horizontal = false, bool vertical = true ) + + + reset + reset + () + + + scaleHeight + scaleHeight + ( int h ) + + + scaleWidth + scaleWidth + ( int w ) + + + setAlphaBuffer + setAlphaBuffer + ( bool enable ) + + + smoothScale + smoothScale + ( int width, int height, Qt::AspectRatioMode mode = Qt::IgnoreAspectRatio ) + + + smoothScale + smoothScale-2 + ( const QSize & size, Qt::AspectRatioMode mode = Qt::IgnoreAspectRatio ) + + + swapRGB + swapRGB + () + + + systemBitOrder + systemBitOrder + () + + + systemByteOrder + systemByteOrder + () + + + xForm + xForm + ( const QMatrix & matrix ) + + + ImageConversionFlags + bitBlt + flags = Qt::AutoColor ) + + + + QImageReader + qimagereader.html + + ImageReaderError + ImageReaderError-enum + + + + QImageReader + QImageReader + () + + + QImageReader + QImageReader-2 + ( QIODevice * device, const QByteArray & format = QByteArray() + + + QImageReader + QImageReader-3 + ( const QString & fileName, const QByteArray & format = QByteArray() + + + backgroundColor + backgroundColor + () + + + canRead + canRead + () + + + clipRect + clipRect + () + + + currentImageNumber + currentImageNumber + () + + + currentImageRect + currentImageRect + () + + + device + device + () + + + error + error + () + + + errorString + errorString + () + + + fileName + fileName + () + + + format + format + () + + + imageCount + imageCount + () + + + imageFormat + imageFormat + ( const QString & fileName ) + + + imageFormat + imageFormat-2 + ( QIODevice * device ) + + + jumpToImage + jumpToImage + ( int imageNumber ) + + + jumpToNextImage + jumpToNextImage + () + + + loopCount + loopCount + () + + + nextImageDelay + nextImageDelay + () + + + read + read + () + + + scaledClipRect + scaledClipRect + () + + + scaledSize + scaledSize + () + + + setBackgroundColor + setBackgroundColor + ( const QColor & color ) + + + setClipRect + setClipRect + ( const QRect & rect ) + + + setDevice + setDevice + ( QIODevice * device ) + + + setFileName + setFileName + ( const QString & fileName ) + + + setFormat + setFormat + ( const QByteArray & format ) + + + setScaledClipRect + setScaledClipRect + ( const QRect & rect ) + + + setScaledSize + setScaledSize + ( const QSize & size ) + + + size + size + () + + + supportedImageFormats + supportedImageFormats + () + + + supportsAnimation + supportsAnimation + () + + + text + text + ( const QString & key ) + + + textKeys + textKeys + () + + + + QImageWriter + qimagewriter.html + + ImageWriterError + ImageWriterError-enum + + + + QImageWriter + QImageWriter + () + + + QImageWriter + QImageWriter-2 + ( QIODevice * device, const QByteArray & format ) + + + QImageWriter + QImageWriter-3 + ( const QString & fileName, const QByteArray & format = QByteArray() + + + canWrite + canWrite + () + + + device + device + () + + + error + error + () + + + errorString + errorString + () + + + fileName + fileName + () + + + format + format + () + + + gamma + gamma + () + + + quality + quality + () + + + setDevice + setDevice + ( QIODevice * device ) + + + setFileName + setFileName + ( const QString & fileName ) + + + setFormat + setFormat + ( const QByteArray & format ) + + + setGamma + setGamma + ( float gamma ) + + + setQuality + setQuality + ( int quality ) + + + setText + setText + ( const QString & key, const QString & text ) + + + supportedImageFormats + supportedImageFormats + () + + + write + write + ( const QImage & image ) + + + description + description + () + + + setDescription + setDescription + ( const QString & description ) + + + + QInputContextFactory + qinputcontextfactory.html + + create + create + ( const QString & key, QObject * parent ) + + + description + description + ( const QString & key ) + + + displayName + displayName + ( const QString & key ) + + + keys + keys + () + + + languages + languages + ( const QString & key ) + + + + QInputContext + qinputcontext.html + + StandardFormat + StandardFormat-enum + + + + QInputContext + QInputContext + ( QObject * parent = 0 ) + + + actions + actions + () + + + filterEvent + filterEvent + ( const QEvent * event ) + + + font + font + () + + + identifierName + identifierName + () + + + isComposing + isComposing + () + + + language + language + () + + + mouseHandler + mouseHandler + ( int x, QMouseEvent * event ) + + + reset + reset + () + + + sendEvent + sendEvent + ( const QInputMethodEvent & event ) + + + standardFormat + standardFormat + ( StandardFormat s ) + + + update + update + () + + + widgetDestroyed + widgetDestroyed + ( QWidget * widget ) + + + x11FilterEvent + x11FilterEvent + ( QWidget * keywidget, XEvent * event ) + + + + QInputContextPlugin + qinputcontextplugin.html + + QInputContextPlugin + QInputContextPlugin + ( QObject * parent = 0 ) + + + create + create + ( const QString & key ) + + + description + description + ( const QString & key ) + + + displayName + displayName + ( const QString & key ) + + + keys + keys + () + + + languages + languages + ( const QString & key ) + + + + QInputDialog + qinputdialog.html + + getDouble + getDouble + ( QWidget * parent, const QString & title, const QString & label, double value = 0, double minValue = -2147483647, double maxValue = 2147483647, int decimals = 1, bool * ok = 0, Qt::WFlags f = 0 ) + + + getInteger + getInteger + ( QWidget * parent, const QString & title, const QString & label, int value = 0, int minValue = -2147483647, int maxValue = 2147483647, int step = 1, bool * ok = 0, Qt::WFlags f = 0 ) + + + getItem + getItem + ( QWidget * parent, const QString & title, const QString & label, const QStringList & list, int current = 0, bool editable = true, bool * ok = 0, Qt::WFlags f = 0 ) + + + getText + getText + ( QWidget * parent, const QString & title, const QString & label, QLineEdit::EchoMode mode = QLineEdit::Normal, const QString & text = QString() + + + getDouble + getDouble-2 + ( const QString & title, const QString & label, double value = 0, double minValue = -2147483647, double maxValue = 2147483647, int decimals = 1, bool * ok = 0, QWidget * parent = 0, const char * name = 0, Qt::WFlags f = 0 ) + + + getInteger + getInteger-2 + ( const QString & title, const QString & label, int value = 0, int minValue = -2147483647, int maxValue = 2147483647, int step = 1, bool * ok = 0, QWidget * parent = 0, const char * name = 0, Qt::WFlags f = 0 ) + + + getItem + getItem-2 + ( const QString & title, const QString & label, const QStringList & list, int current = 0, bool editable = true, bool * ok = 0, QWidget * parent = 0, const char * name = 0, Qt::WFlags f = 0 ) + + + getText + getText-2 + ( const QString & title, const QString & label, QLineEdit::EchoMode echo = QLineEdit::Normal, const QString & text = QString() + + + + QInputEvent + qinputevent.html + + KeyboardModifiers + modifiers + QInputEvent::modifiers() + + + + QInputMethodEvent::Attribute + qinputmethodevent-attribute.html + + Attribute + Attribute + ( AttributeType type, int start, int length, QVariant value ) + + + + QInputMethodEvent + qinputmethodevent.html + + AttributeType + AttributeType-enum + + + + QInputMethodEvent + QInputMethodEvent + () + + + QInputMethodEvent + QInputMethodEvent-2 + ( const QString & preeditText, const QList<Attribute> & attributes ) + + + QInputMethodEvent + QInputMethodEvent-3 + ( const QInputMethodEvent & other ) + + + attributes + attributes + () + + + commitString + commitString + () + + + preeditString + preeditString + () + + + replacementLength + replacementLength + () + + + replacementStart + replacementStart + () + + + setCommitString + setCommitString + ( const QString & commitString, int replaceFrom = 0, int replaceLength = 0 ) + + + + QIntValidator + qintvalidator.html + + QIntValidator + QIntValidator + ( QObject * parent ) + + + QIntValidator + QIntValidator-2 + ( int minimum, int maximum, QObject * parent ) + + + setRange + setRange + ( int bottom, int top ) + + + State + validate + QIntValidator::validate( QString & input, int & pos ) + + + QIntValidator + QIntValidator-3 + ( QObject * parent, const char * name ) + + + QIntValidator + QIntValidator-4 + ( int minimum, int maximum, QObject * parent, const char * name ) + + + + QIODevice + qiodevice.html + + QIODevice + QIODevice + () + + + QIODevice + QIODevice-2 + ( QObject * parent ) + + + aboutToClose + aboutToClose + () + + + atEnd + atEnd + () + + + bytesAvailable + bytesAvailable + () + + + bytesToWrite + bytesToWrite + () + + + bytesWritten + bytesWritten + ( qint64 bytes ) + + + canReadLine + canReadLine + () + + + close + close + () + + + errorString + errorString + () + + + getChar + getChar + ( char * c ) + + + isOpen + isOpen + () + + + isReadable + isReadable + () + + + isSequential + isSequential + () + + + isTextModeEnabled + isTextModeEnabled + () + + + isWritable + isWritable + () + + + open + open + ( OpenMode mode ) + + + openMode + openMode + () + + + peek + peek + ( char * data, qint64 maxSize ) + + + peek + peek-2 + ( qint64 maxSize ) + + + pos + pos + () + + + putChar + putChar + ( char c ) + + + read + read + ( char * data, qint64 maxSize ) + + + read + read-2 + ( qint64 maxSize ) + + + readAll + readAll + () + + + readData + readData + ( char * data, qint64 maxSize ) + + + readLine + readLine + ( char * data, qint64 maxSize ) + + + readLine + readLine-2 + ( qint64 maxSize = 0 ) + + + readLineData + readLineData + ( char * data, qint64 maxSize ) + + + readyRead + readyRead + () + + + reset + reset + () + + + seek + seek + ( qint64 pos ) + + + setErrorString + setErrorString + ( const QString & str ) + + + setOpenMode + setOpenMode + ( OpenMode openMode ) + + + setTextModeEnabled + setTextModeEnabled + ( bool enabled ) + + + size + size + () + + + ungetChar + ungetChar + ( char c ) + + + waitForBytesWritten + waitForBytesWritten + ( int msecs ) + + + waitForReadyRead + waitForReadyRead + ( int msecs ) + + + write + write + ( const char * data, qint64 maxSize ) + + + write + write-2 + ( const QByteArray & byteArray ) + + + writeData + writeData + ( const char * data, qint64 maxSize ) + + + Offset + Offset-typedef + + + + Status + Status-typedef + + + + at + at + () + + + at + at-2 + ( Offset offset ) + + + flags + flags + () + + + getch + getch + () + + + isAsynchronous + isAsynchronous + () + + + isBuffered + isBuffered + () + + + isCombinedAccess + isCombinedAccess + () + + + isDirectAccess + isDirectAccess + () + + + isInactive + isInactive + () + + + isRaw + isRaw + () + + + isSequentialAccess + isSequentialAccess + () + + + isSynchronous + isSynchronous + () + + + isTranslated + isTranslated + () + + + mode + mode + () + + + putch + putch + ( int ch ) + + + readBlock + readBlock + ( char * data, quint64 size ) + + + resetStatus + resetStatus + () + + + state + state + () + + + status + status + () + + + ungetch + ungetch + ( int ch ) + + + writeBlock + writeBlock + ( const char * data, quint64 size ) + + + writeBlock + writeBlock-2 + ( const QByteArray & data ) + + + + QItemDelegate + qitemdelegate.html + + QItemDelegate + QItemDelegate + ( QObject * parent = 0 ) + + + createEditor + createEditor + ( QWidget * parent, const QStyleOptionViewItem & option, const QModelIndex & index ) + + + drawCheck + drawCheck + ( QPainter * painter, const QStyleOptionViewItem & option, const QRect & rect, Qt::CheckState state ) + + + drawDecoration + drawDecoration + ( QPainter * painter, const QStyleOptionViewItem & option, const QRect & rect, const QPixmap & pixmap ) + + + drawDisplay + drawDisplay + ( QPainter * painter, const QStyleOptionViewItem & option, const QRect & rect, const QString & text ) + + + drawFocus + drawFocus + ( QPainter * painter, const QStyleOptionViewItem & option, const QRect & rect ) + + + eventFilter + eventFilter + ( QObject * object, QEvent * event ) + + + itemEditorFactory + itemEditorFactory + () + + + paint + paint + ( QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index ) + + + setEditorData + setEditorData + ( QWidget * editor, const QModelIndex & index ) + + + setItemEditorFactory + setItemEditorFactory + ( QItemEditorFactory * factory ) + + + setModelData + setModelData + ( QWidget * editor, QAbstractItemModel * model, const QModelIndex & index ) + + + sizeHint + sizeHint + ( const QStyleOptionViewItem & option, const QModelIndex & index ) + + + updateEditorGeometry + updateEditorGeometry + ( QWidget * editor, const QStyleOptionViewItem & option, const QModelIndex & index ) + + + + QItemEditorCreatorBase + qitemeditorcreatorbase.html + + createWidget + createWidget + ( QWidget * parent ) + + + valuePropertyName + valuePropertyName + () + + + + QItemEditorFactory + qitemeditorfactory.html + + QItemEditorFactory + QItemEditorFactory + () + + + createEditor + createEditor + ( QVariant::Type type, QWidget * parent ) + + + defaultFactory + defaultFactory + () + + + registerEditor + registerEditor + ( QVariant::Type type, QItemEditorCreatorBase * creator ) + + + setDefaultFactory + setDefaultFactory + ( QItemEditorFactory * factory ) + + + valuePropertyName + valuePropertyName + ( QVariant::Type type ) + + + + QItemSelection + qitemselection.html + + QItemSelection + QItemSelection + () + + + QItemSelection + QItemSelection-2 + ( const QModelIndex & topLeft, const QModelIndex & bottomRight ) + + + contains + contains + ( const QModelIndex & index ) + + + indexes + indexes + () + + + merge + merge + ( const QItemSelection & other, QItemSelectionModel::SelectionFlags command ) + + + select + select + ( const QModelIndex & topLeft, const QModelIndex & bottomRight ) + + + split + split + ( const QItemSelectionRange & range, const QItemSelectionRange & other, QItemSelection * result ) + + + + QItemSelectionModel + qitemselectionmodel.html + + QItemSelectionModel + QItemSelectionModel + ( QAbstractItemModel * model ) + + + QItemSelectionModel + QItemSelectionModel-2 + ( QAbstractItemModel * model, QObject * parent ) + + + clear + clear + () + + + columnIntersectsSelection + columnIntersectsSelection + ( int column, const QModelIndex & parent ) + + + currentChanged + currentChanged + ( const QModelIndex & current, const QModelIndex & previous ) + + + currentColumnChanged + currentColumnChanged + ( const QModelIndex & current, const QModelIndex & previous ) + + + currentIndex + currentIndex + () + + + currentRowChanged + currentRowChanged + ( const QModelIndex & current, const QModelIndex & previous ) + + + emitSelectionChanged + emitSelectionChanged + ( const QItemSelection & newSelection, const QItemSelection & oldSelection ) + + + isColumnSelected + isColumnSelected + ( int column, const QModelIndex & parent ) + + + isRowSelected + isRowSelected + ( int row, const QModelIndex & parent ) + + + isSelected + isSelected + ( const QModelIndex & index ) + + + model + model + () + + + reset + reset + () + + + rowIntersectsSelection + rowIntersectsSelection + ( int row, const QModelIndex & parent ) + + + select + select + ( const QModelIndex & index, QItemSelectionModel::SelectionFlags command ) + + + select + select-2 + ( const QItemSelection & selection, QItemSelectionModel::SelectionFlags command ) + + + selectedIndexes + selectedIndexes + () + + + selection + selection + () + + + selectionChanged + selectionChanged + ( const QItemSelection & selected, const QItemSelection & deselected ) + + + setCurrentIndex + setCurrentIndex + ( const QModelIndex & index, QItemSelectionModel::SelectionFlags command ) + + + + QItemSelectionRange + qitemselectionrange.html + + QItemSelectionRange + QItemSelectionRange + () + + + QItemSelectionRange + QItemSelectionRange-2 + ( const QItemSelectionRange & other ) + + + QItemSelectionRange + QItemSelectionRange-3 + ( const QModelIndex & topLeft, const QModelIndex & bottomRight ) + + + QItemSelectionRange + QItemSelectionRange-4 + ( const QModelIndex & index ) + + + bottom + bottom + () + + + bottomRight + bottomRight + () + + + contains + contains + ( const QModelIndex & index ) + + + height + height + () + + + indexes + indexes + () + + + intersect + intersect + ( const QItemSelectionRange & other ) + + + intersects + intersects + ( const QItemSelectionRange & other ) + + + isValid + isValid + () + + + left + left + () + + + model + model + () + + + parent + parent + () + + + right + right + () + + + top + top + () + + + topLeft + topLeft + () + + + width + width + () + + + operator!= + operator-not-eq + ( const QItemSelectionRange & other ) + + + operator== + operator-eq-eq + ( const QItemSelectionRange & other ) + + + + QKbdDriverFactory + qkbddriverfactory.html + + create + create + ( const QString & key, const QString & device ) + + + keys + keys + () + + + + QKbdDriverPlugin + qkbddriverplugin.html + + QKbdDriverPlugin + QKbdDriverPlugin + ( QObject * parent = 0 ) + + + create + create + ( const QString & key, const QString & device ) + + + keys + keys + () + + + + QKeyEvent + qkeyevent.html + + QKeyEvent + QKeyEvent + ( Type type, int key, Qt::KeyboardModifiers modifiers, const QString & text = QString() + + + count + count + () + + + isAutoRepeat + isAutoRepeat + () + + + key + key + () + + + KeyboardModifiers + modifiers + QKeyEvent::modifiers() + + + text + text + () + + + QKeyEvent + QKeyEvent-2 + ( Type type, int key, int ascii, int modifiers, const QString & text = QString() + + + ascii + ascii + () + + + ButtonState + state + QKeyEvent::state() + + + ButtonState + stateAfter + QKeyEvent::stateAfter() + + + + QKeySequence + qkeysequence.html + + SequenceFormat + SequenceFormat-enum + + + + SequenceMatch + SequenceMatch-enum + + + + QKeySequence + QKeySequence + () + + + QKeySequence + QKeySequence-2 + ( const QString & key ) + + + QKeySequence + QKeySequence-3 + ( int k1, int k2 = 0, int k3 = 0, int k4 = 0 ) + + + QKeySequence + QKeySequence-4 + ( const QKeySequence & keysequence ) + + + count + count + () + + + fromString + fromString + ( const QString & str, SequenceFormat format = PortableText ) + + + isEmpty + isEmpty + () + + + matches + matches + ( const QKeySequence & seq ) + + + mnemonic + mnemonic + ( const QString & text ) + + + toString + toString + ( SequenceFormat format = PortableText ) + + + operator + operator-QString + QString() + + + operator + operator-QVariant + QVariant() + + + operator!= + operator-not-eq + ( const QKeySequence & other ) + + + operator< + operator-lt + ( const QKeySequence & other ) + + + operator<= + operator-lt-eq + ( const QKeySequence & other ) + + + operator= + operator-eq + ( const QKeySequence & other ) + + + operator== + operator-eq-eq + ( const QKeySequence & other ) + + + operator> + operator-gt + ( const QKeySequence & other ) + + + operator>= + operator-gt-eq + ( const QKeySequence & other ) + + + operator[] + operator-5b-5d + ( uint index ) + + + operator + operator-int + int() + + + + QLabel + qlabel.html + + Alignment + alignment-prop + + + + TextFormat + textFormat-prop + + + + QLabel + QLabel + ( QWidget * parent = 0, Qt::WFlags f = 0 ) + + + QLabel + QLabel-2 + ( const QString & text, QWidget * parent = 0, Qt::WFlags f = 0 ) + + + buddy + buddy + () + + + clear + clear + () + + + movie + movie + () + + + picture + picture + () + + + setBuddy + setBuddy + ( QWidget * buddy ) + + + setMovie + setMovie + ( QMovie * movie ) + + + setNum + setNum + ( int num ) + + + setNum + setNum-2 + ( double num ) + + + setPicture + setPicture + ( const QPicture & picture ) + + + QLabel + QLabel-3 + ( QWidget * parent, const char * name, Qt::WFlags f = 0 ) + + + QLabel + QLabel-4 + ( const QString & text, QWidget * parent, const char * name, Qt::WFlags f = 0 ) + + + QLabel + QLabel-5 + ( QWidget * buddy, const QString & text, QWidget * parent = 0, const char * name = 0, Qt::WFlags f = 0 ) + + + setAlignment + setAlignment-2 + ( int alignment ) + + + + QLatin1Char + qlatin1char.html + + QLatin1Char + QLatin1Char + ( char c ) + + + toLatin1 + toLatin1 + () + + + unicode + unicode + () + + + + QLatin1String + qlatin1string.html + + QLatin1String + QLatin1String + ( const char * str ) + + + latin1 + latin1 + () + + + operator!= + operator-not-eq + ( const QString & other ) + + + operator< + operator-lt + ( const QString & other ) + + + operator<= + operator-lt-eq + ( const QString & other ) + + + operator= + operator-eq + ( const QLatin1String & other ) + + + operator== + operator-eq-eq + ( const QString & other ) + + + operator> + operator-gt + ( const QString & other ) + + + operator>= + operator-gt-eq + ( const QString & other ) + + + + QLayout + qlayout.html + + SizeConstraint + SizeConstraint-enum + + + + QLayout + QLayout + ( QWidget * parent ) + + + QLayout + QLayout-2 + () + + + activate + activate + () + + + addChildLayout + addChildLayout + ( QLayout * l ) + + + addChildWidget + addChildWidget + ( QWidget * w ) + + + addItem + addItem + ( QLayoutItem * item ) + + + addWidget + addWidget + ( QWidget * w ) + + + alignmentRect + alignmentRect + ( const QRect & r ) + + + closestAcceptableSize + closestAcceptableSize + ( const QWidget * widget, const QSize & size ) + + + count + count + () + + + Orientations + expandingDirections + QLayout::expandingDirections() + + + indexOf + indexOf + ( QWidget * widget ) + + + isEnabled + isEnabled + () + + + itemAt + itemAt + ( int index ) + + + maximumSize + maximumSize + () + + + menuBar + menuBar + () + + + minimumSize + minimumSize + () + + + parentWidget + parentWidget + () + + + removeItem + removeItem + ( QLayoutItem * item ) + + + removeWidget + removeWidget + ( QWidget * widget ) + + + setAlignment + setAlignment + ( QWidget * w, Qt::Alignment alignment ) + + + setAlignment + setAlignment-2 + ( QLayout * l, Qt::Alignment alignment ) + + + setEnabled + setEnabled + ( bool enable ) + + + setMenuBar + setMenuBar + ( QWidget * widget ) + + + takeAt + takeAt + ( int index ) + + + update + update + () + + + + QLayoutItem + qlayoutitem.html + + QLayoutItem + QLayoutItem + ( Qt::Alignment alignment = 0 ) + + + Alignment + alignment + QLayoutItem::alignment() + + + Orientations + expandingDirections + QLayoutItem::expandingDirections() + + + geometry + geometry + () + + + hasHeightForWidth + hasHeightForWidth + () + + + heightForWidth + heightForWidth + ( int w ) + + + invalidate + invalidate + () + + + isEmpty + isEmpty + () + + + layout + layout + () + + + maximumSize + maximumSize + () + + + minimumHeightForWidth + minimumHeightForWidth + ( int w ) + + + minimumSize + minimumSize + () + + + setAlignment + setAlignment + ( Qt::Alignment alignment ) + + + setGeometry + setGeometry + ( const QRect & r ) + + + sizeHint + sizeHint + () + + + spacerItem + spacerItem + () + + + widget + widget + () + + + QLayout + QLayout-4 + ( QWidget * parent, int margin, int spacing = -1, const char * name = 0 ) + + + QLayout + QLayout-5 + ( QLayout * parentLayout, int spacing = -1, const char * name = 0 ) + + + QLayout + QLayout-6 + ( int spacing, const char * name = 0 ) + + + add + add + ( QWidget * widget ) + + + autoAdd + autoAdd + () + + + defaultBorder + defaultBorder + () + + + deleteAllItems + deleteAllItems + () + + + freeze + freeze + ( int w = 0, int h = 0 ) + + + isTopLevel + isTopLevel + () + + + iterator + iterator + () + + + mainWidget + mainWidget + () + + + remove + remove + ( QWidget * widget ) + + + resizeMode + resizeMode + () + + + setAutoAdd + setAutoAdd + ( bool a ) + + + setResizeMode + setResizeMode + ( SizeConstraint constraint ) + + + + QLCDNumber + qlcdnumber.html + + Mode + Mode-enum + + + + SegmentStyle + SegmentStyle-enum + + + + QLCDNumber + QLCDNumber + ( QWidget * parent = 0 ) + + + QLCDNumber + QLCDNumber-2 + ( uint numDigits, QWidget * parent = 0 ) + + + checkOverflow + checkOverflow + ( double num ) + + + checkOverflow + checkOverflow-2 + ( int num ) + + + overflow + overflow + () + + + setBinMode + setBinMode + () + + + setDecMode + setDecMode + () + + + setHexMode + setHexMode + () + + + setOctMode + setOctMode + () + + + QLCDNumber + QLCDNumber-3 + ( QWidget * parent, const char * name ) + + + QLCDNumber + QLCDNumber-4 + ( uint numDigits, QWidget * parent, const char * name ) + + + + QLibrary + qlibrary.html + + QLibrary + QLibrary + ( QObject * parent = 0 ) + + + QLibrary + QLibrary-2 + ( const QString & fileName, QObject * parent = 0 ) + + + QLibrary + QLibrary-3 + ( const QString & fileName, int verNum, QObject * parent = 0 ) + + + isLibrary + isLibrary + ( const QString & fileName ) + + + isLoaded + isLoaded + () + + + load + load + () + + + resolve + resolve + ( const char * symbol ) + + + resolve + resolve-2 + ( const QString & fileName, const char * symbol ) + + + resolve + resolve-3 + ( const QString & fileName, int verNum, const char * symbol ) + + + setFileNameAndVersion + setFileNameAndVersion + ( const QString & fileName, int versionNumber ) + + + unload + unload + () + + + + QLibraryInfo + qlibraryinfo.html + + LibraryLocation + LibraryLocation-enum + + + + buildKey + buildKey + () + + + licensedProducts + licensedProducts + () + + + licensee + licensee + () + + + location + location + ( LibraryLocation loc ) + + + library + library + () + + + setAutoUnload + setAutoUnload + ( bool b ) + + + + QLinearGradient + qlineargradient.html + + QLinearGradient + QLinearGradient + ( const QPointF & start, const QPointF & finalStop ) + + + QLinearGradient + QLinearGradient-2 + ( qreal x1, qreal y1, qreal x2, qreal y2 ) + + + finalStop + finalStop + () + + + start + start + () + + + + QLineEdit + qlineedit.html + + EchoMode + EchoMode-enum + + + + Alignment + alignment-prop + + + + QLineEdit + QLineEdit + ( QWidget * parent = 0 ) + + + QLineEdit + QLineEdit-2 + ( const QString & contents, QWidget * parent = 0 ) + + + backspace + backspace + () + + + clear + clear + () + + + contextMenuEvent + contextMenuEvent + ( QContextMenuEvent * event ) + + + copy + copy + () + + + createStandardContextMenu + createStandardContextMenu + () + + + cursorBackward + cursorBackward + ( bool mark, int steps = 1 ) + + + cursorForward + cursorForward + ( bool mark, int steps = 1 ) + + + cursorPositionAt + cursorPositionAt + ( const QPoint & pos ) + + + cursorPositionChanged + cursorPositionChanged + ( int old, int new ) + + + cursorWordBackward + cursorWordBackward + ( bool mark ) + + + cursorWordForward + cursorWordForward + ( bool mark ) + + + cut + cut + () + + + del + del + () + + + deselect + deselect + () + + + editingFinished + editingFinished + () + + + end + end + ( bool mark ) + + + home + home + ( bool mark ) + + + insert + insert + ( const QString & newText ) + + + keyPressEvent + keyPressEvent + ( QKeyEvent * event ) + + + minimumSizeHint + minimumSizeHint + () + + + paste + paste + () + + + redo + redo + () + + + returnPressed + returnPressed + () + + + selectAll + selectAll + () + + + selectionChanged + selectionChanged + () + + + selectionStart + selectionStart + () + + + setSelection + setSelection + ( int start, int length ) + + + setValidator + setValidator + ( const QValidator * v ) + + + sizeHint + sizeHint + () + + + textChanged + textChanged + ( const QString & text ) + + + textEdited + textEdited + ( const QString & text ) + + + undo + undo + () + + + validator + validator + () + + + QLineEdit + QLineEdit-3 + ( QWidget * parent, const char * name ) + + + QLineEdit + QLineEdit-4 + ( const QString & contents, QWidget * parent, const char * name ) + + + QLineEdit + QLineEdit-5 + ( const QString & contents, const QString & inputMask, QWidget * parent = 0, const char * name = 0 ) + + + characterAt + characterAt + ( int xpos, QChar * chr ) + + + clearModified + clearModified + () + + + clearValidator + clearValidator + () + + + cursorLeft + cursorLeft + ( bool mark, int steps = 1 ) + + + cursorRight + cursorRight + ( bool mark, int steps = 1 ) + + + edited + edited + () + + + frame + frame + () + + + getSelection + getSelection + ( int * start, int * end ) + + + hasMarkedText + hasMarkedText + () + + + lostFocus + lostFocus + () + + + markedText + markedText + () + + + repaintArea + repaintArea + ( int a, int b ) + + + setEdited + setEdited + ( bool on ) + + + validateAndSet + validateAndSet + ( const QString & newText, int newPos, int newMarkAnchor, int newMarkDrag ) + + + + QLineF + qlinef.html + + IntersectType + IntersectType-enum + + + + QLineF + QLineF + () + + + QLineF + QLineF-2 + ( const QPointF & p1, const QPointF & p2 ) + + + QLineF + QLineF-3 + ( qreal x1, qreal y1, qreal x2, qreal y2 ) + + + QLineF + QLineF-4 + ( const QLine & line ) + + + p1 + p1 + () + + + p2 + p2 + () + + + x1 + x1 + () + + + x2 + x2 + () + + + y1 + y1 + () + + + y2 + y2 + () + + + angle + angle + ( const QLineF & line ) + + + dx + dx + () + + + dy + dy + () + + + intersect + intersect + ( const QLineF & line, QPointF * intersectionPoint ) + + + isNull + isNull + () + + + length + length + () + + + normalVector + normalVector + () + + + pointAt + pointAt + ( qreal t ) + + + setLength + setLength + ( qreal length ) + + + toLine + toLine + () + + + translate + translate + ( const QPointF & offset ) + + + translate + translate-2 + ( qreal dx, qreal dy ) + + + unitVector + unitVector + () + + + operator!= + operator-not-eq + ( const QLineF & line ) + + + operator== + operator-eq-eq + ( const QLineF & line ) + + + + QLine + qline.html + + QLine + QLine + () + + + QLine + QLine-2 + ( const QPoint & p1, const QPoint & p2 ) + + + QLine + QLine-3 + ( int x1, int y1, int x2, int y2 ) + + + p1 + p1 + () + + + p2 + p2 + () + + + x1 + x1 + () + + + x2 + x2 + () + + + y1 + y1 + () + + + y2 + y2 + () + + + dx + dx + () + + + dy + dy + () + + + isNull + isNull + () + + + translate + translate + ( const QPoint & offset ) + + + translate + translate-2 + ( int dx, int dy ) + + + operator!= + operator-not-eq + ( const QLine & line ) + + + operator== + operator-eq-eq + ( const QLine & line ) + + + + QLinkedList::const_iterator + qlinkedlist-const-iterator.html + + const_iterator + const_iterator + () + + + const_iterator + const_iterator-3 + ( const const_iterator & other ) + + + const_iterator + const_iterator-4 + ( iterator other ) + + + operator!= + operator-not-eq + ( const const_iterator & other ) + + + operator* + operator-2a + () + + + operator+ + operator-2b + ( int j ) + + + operator++ + operator-2b-2b + () + + + operator++ + operator-2b-2b-2 + ( int ) + + + operator+= + operator-2b-eq + ( int j ) + + + operator- + operator- + ( int j ) + + + operator-- + operator-- + () + + + operator-- + operator---2 + ( int ) + + + operator-= + operator--eq + ( int j ) + + + operator-& + operator--gt + gt;() + + + operator= + operator-eq + ( const const_iterator & other ) + + + operator== + operator-eq-eq + ( const const_iterator & other ) + + + + QLinkedList + qlinkedlist.html + + ConstIterator + ConstIterator-typedef + + + + Iterator + Iterator-typedef + + + + const_pointer + const_pointer-typedef + + + + const_reference + const_reference-typedef + + + + pointer + pointer-typedef + + + + reference + reference-typedef + + + + size_type + size_type-typedef + + + + value_type + value_type-typedef + + + + QLinkedList + QLinkedList + () + + + QLinkedList + QLinkedList-2 + ( const QLinkedList<T> & other ) + + + append + append + ( const T & value ) + + + back + back + () + + + back + back-2 + () + + + begin + begin + () + + + begin + begin-2 + () + + + clear + clear + () + + + constBegin + constBegin + () + + + constEnd + constEnd + () + + + contains + contains + ( const T & value ) + + + count + count + ( const T & value ) + + + count + count-2 + () + + + empty + empty + () + + + end + end + () + + + end + end-2 + () + + + erase + erase + ( iterator pos ) + + + erase + erase-2 + ( iterator begin, iterator end ) + + + first + first + () + + + first + first-2 + () + + + fromStdList + fromStdList + ( const std::list<T> & list ) + + + front + front + () + + + front + front-2 + () + + + insert + insert + ( iterator before, const T & value ) + + + isEmpty + isEmpty + () + + + last + last + () + + + last + last-2 + () + + + pop_back + pop_back + () + + + pop_front + pop_front + () + + + prepend + prepend + ( const T & value ) + + + push_back + push_back + ( const T & value ) + + + push_front + push_front + ( const T & value ) + + + removeAll + removeAll + ( const T & value ) + + + removeFirst + removeFirst + () + + + removeLast + removeLast + () + + + size + size + () + + + takeFirst + takeFirst + () + + + takeLast + takeLast + () + + + list + toStdList + <T> QLinkedList::toStdList() + + + operator!= + operator-not-eq + ( const QLinkedList<T> & other ) + + + operator+ + operator-2b + ( const QLinkedList<T> & other ) + + + operator+= + operator-2b-eq + ( const QLinkedList<T> & other ) + + + operator+= + operator-2b-eq-2 + ( const T & value ) + + + operator<< + operator-lt-lt + ( const QLinkedList<T> & other ) + + + operator<< + operator-lt-lt-2 + ( const T & value ) + + + operator= + operator-eq + ( const QLinkedList<T> & other ) + + + operator== + operator-eq-eq + ( const QLinkedList<T> & other ) + + + + QLinkedList::iterator + qlinkedlist-iterator.html + + iterator + iterator + () + + + iterator + iterator-3 + ( const iterator & other ) + + + operator!= + operator-not-eq + ( const iterator & other ) + + + operator!= + operator-not-eq-2 + ( const const_iterator & other ) + + + operator* + operator-2a + () + + + operator+ + operator-2b + ( int j ) + + + operator++ + operator-2b-2b + () + + + operator++ + operator-2b-2b-2 + ( int ) + + + operator+= + operator-2b-eq + ( int j ) + + + operator- + operator- + ( int j ) + + + operator-- + operator-- + () + + + operator-- + operator---2 + ( int ) + + + operator-= + operator--eq + ( int j ) + + + operator-& + operator--gt + gt;() + + + operator= + operator-eq + ( const iterator & other ) + + + operator== + operator-eq-eq + ( const iterator & other ) + + + operator== + operator-eq-eq-2 + ( const const_iterator & other ) + + + + QLinkedListIterator + qlinkedlistiterator.html + + QLinkedListIterator + QLinkedListIterator + ( const QLinkedList<T> & list ) + + + findNext + findNext + ( const T & value ) + + + findPrevious + findPrevious + ( const T & value ) + + + hasNext + hasNext + () + + + hasPrevious + hasPrevious + () + + + next + next + () + + + peekNext + peekNext + () + + + peekPrevious + peekPrevious + () + + + previous + previous + () + + + toBack + toBack + () + + + toFront + toFront + () + + + operator= + operator-eq + ( const QLinkedList<T> & list ) + + + find + find + ( iterator from, const T & t ) + + + find + find-2 + ( const T & t ) + + + find + find-3 + ( const_iterator from, const T & t ) + + + find + find-4 + ( const T & t ) + + + findIndex + findIndex + ( const T & t ) + + + remove + remove + ( iterator pos ) + + + + QLinuxFbScreen + qlinuxfbscreen.html + + QLinuxFbScreen + QLinuxFbScreen + ( int displayId ) + + + cache + cache + ( int amount ) + + + clearCache + clearCache + ( QScreen * instance, int clientId ) + + + deleteEntry + deleteEntry + ( uchar * memoryBlock ) + + + set + set + ( unsigned int index, unsigned int red, unsigned int green, unsigned int blue ) + + + uncache + uncache + ( uchar * memoryBlock ) + + + useOffscreen + useOffscreen + () + + + + QList::const_iterator + qlist-const-iterator.html + + const_iterator + const_iterator + () + + + const_iterator + const_iterator-3 + ( const const_iterator & other ) + + + const_iterator + const_iterator-4 + ( const iterator & other ) + + + operator!= + operator-not-eq + ( const const_iterator & other ) + + + operator* + operator-2a + () + + + operator+ + operator-2b + ( int j ) + + + operator++ + operator-2b-2b + () + + + operator++ + operator-2b-2b-2 + ( int ) + + + operator+= + operator-2b-eq + ( int j ) + + + operator- + operator- + ( int j ) + + + operator- + operator--2 + ( const_iterator other ) + + + operator-- + operator-- + () + + + operator-- + operator---2 + ( int ) + + + operator-= + operator--eq + ( int j ) + + + operator-& + operator--gt + gt;() + + + operator< + operator-lt + ( const const_iterator & other ) + + + operator<= + operator-lt-eq + ( const const_iterator & other ) + + + operator== + operator-eq-eq + ( const const_iterator & other ) + + + operator> + operator-gt + ( const const_iterator & other ) + + + operator>= + operator-gt-eq + ( const const_iterator & other ) + + + operator[] + operator-5b-5d + ( int j ) + + + + QList + qlist.html + + ConstIterator + ConstIterator-typedef + + + + Iterator + Iterator-typedef + + + + const_pointer + const_pointer-typedef + + + + const_reference + const_reference-typedef + + + + pointer + pointer-typedef + + + + reference + reference-typedef + + + + size_type + size_type-typedef + + + + value_type + value_type-typedef + + + + QList + QList + () + + + QList + QList-2 + ( const QList<T> & other ) + + + append + append + ( const T & value ) + + + at + at + ( int i ) + + + back + back + () + + + back + back-2 + () + + + begin + begin + () + + + begin + begin-2 + () + + + clear + clear + () + + + constBegin + constBegin + () + + + constEnd + constEnd + () + + + contains + contains + ( const T & value ) + + + count + count + ( const T & value ) + + + count + count-2 + () + + + empty + empty + () + + + end + end + () + + + end + end-2 + () + + + erase + erase + ( iterator pos ) + + + erase + erase-2 + ( iterator begin, iterator end ) + + + first + first + () + + + first + first-2 + () + + + fromSet + fromSet + ( const QSet<T> & set ) + + + fromStdList + fromStdList + ( const std::list<T> & list ) + + + fromVector + fromVector + ( const QVector<T> & vector ) + + + front + front + () + + + front + front-2 + () + + + indexOf + indexOf + ( const T & value, int from = 0 ) + + + insert + insert + ( int i, const T & value ) + + + insert + insert-2 + ( iterator before, const T & value ) + + + isEmpty + isEmpty + () + + + last + last + () + + + last + last-2 + () + + + lastIndexOf + lastIndexOf + ( const T & value, int from = -1 ) + + + mid + mid + ( int pos, int length = -1 ) + + + move + move + ( int from, int to ) + + + pop_back + pop_back + () + + + pop_front + pop_front + () + + + prepend + prepend + ( const T & value ) + + + push_back + push_back + ( const T & value ) + + + push_front + push_front + ( const T & value ) + + + removeAll + removeAll + ( const T & value ) + + + removeAt + removeAt + ( int i ) + + + removeFirst + removeFirst + () + + + removeLast + removeLast + () + + + replace + replace + ( int i, const T & value ) + + + size + size + () + + + swap + swap + ( int i, int j ) + + + takeAt + takeAt + ( int i ) + + + takeFirst + takeFirst + () + + + takeLast + takeLast + () + + + toSet + toSet + () + + + list + toStdList + <T> QList::toStdList() + + + toVector + toVector + () + + + value + value + ( int i ) + + + value + value-2 + ( int i, const T & defaultValue ) + + + operator!= + operator-not-eq + ( const QList<T> & other ) + + + operator+ + operator-2b + ( const QList<T> & other ) + + + operator+= + operator-2b-eq + ( const QList<T> & other ) + + + operator+= + operator-2b-eq-2 + ( const T & value ) + + + operator<< + operator-lt-lt + ( const QList<T> & other ) + + + operator<< + operator-lt-lt-2 + ( const T & value ) + + + operator= + operator-eq + ( const QList<T> & other ) + + + operator== + operator-eq-eq + ( const QList<T> & other ) + + + operator[] + operator-5b-5d + ( int i ) + + + operator[] + operator-5b-5d-2 + ( int i ) + + + + QList::iterator + qlist-iterator.html + + iterator + iterator + () + + + iterator + iterator-3 + ( const iterator & other ) + + + operator!= + operator-not-eq + ( const iterator & other ) + + + operator!= + operator-not-eq-2 + ( const const_iterator & other ) + + + operator* + operator-2a + () + + + operator+ + operator-2b + ( int j ) + + + operator++ + operator-2b-2b + () + + + operator++ + operator-2b-2b-2 + ( int ) + + + operator+= + operator-2b-eq + ( int j ) + + + operator- + operator- + ( int j ) + + + operator- + operator--2 + ( iterator other ) + + + operator-- + operator-- + () + + + operator-- + operator---2 + ( int ) + + + operator-= + operator--eq + ( int j ) + + + operator-& + operator--gt + gt;() + + + operator< + operator-lt + ( const iterator & other ) + + + operator< + operator-lt-2 + ( const const_iterator & other ) + + + operator<= + operator-lt-eq + ( const iterator & other ) + + + operator<= + operator-lt-eq-2 + ( const const_iterator & other ) + + + operator== + operator-eq-eq + ( const iterator & other ) + + + operator== + operator-eq-eq-2 + ( const const_iterator & other ) + + + operator> + operator-gt + ( const iterator & other ) + + + operator> + operator-gt-2 + ( const const_iterator & other ) + + + operator>= + operator-gt-eq + ( const iterator & other ) + + + operator>= + operator-gt-eq-2 + ( const const_iterator & other ) + + + operator[] + operator-5b-5d + ( int j ) + + + + QListIterator + qlistiterator.html + + QListIterator + QListIterator + ( const QList<T> & list ) + + + findNext + findNext + ( const T & value ) + + + findPrevious + findPrevious + ( const T & value ) + + + hasNext + hasNext + () + + + hasPrevious + hasPrevious + () + + + next + next + () + + + peekNext + peekNext + () + + + peekPrevious + peekPrevious + () + + + previous + previous + () + + + toBack + toBack + () + + + toFront + toFront + () + + + operator= + operator-eq + ( const QList<T> & list ) + + + find + find + ( const T & t ) + + + find + find-2 + ( const T & t ) + + + find + find-3 + ( iterator from, const T & t ) + + + find + find-4 + ( const_iterator from, const T & t ) + + + findIndex + findIndex + ( const T & t ) + + + remove + remove + ( iterator pos ) + + + remove + remove-2 + ( const T & t ) + + + + QListView + qlistview.html + + Flow + Flow-enum + + + + LayoutMode + LayoutMode-enum + + + + Movement + Movement-enum + + + + ResizeMode + ResizeMode-enum + + + + ViewMode + ViewMode-enum + + + + QListView + QListView + ( QWidget * parent = 0 ) + + + clearPropertyFlags + clearPropertyFlags + () + + + event + event + ( QEvent * e ) + + + isRowHidden + isRowHidden + ( int row ) + + + rectForIndex + rectForIndex + ( const QModelIndex & index ) + + + setPositionForIndex + setPositionForIndex + ( const QPoint & position, const QModelIndex & index ) + + + setRowHidden + setRowHidden + ( int row, bool hide ) + + + + QListWidget + qlistwidget.html + + QListWidget + QListWidget + ( QWidget * parent = 0 ) + + + addItem + addItem + ( const QString & label ) + + + addItem + addItem-2 + ( QListWidgetItem * item ) + + + addItems + addItems + ( const QStringList & labels ) + + + clear + clear + () + + + closePersistentEditor + closePersistentEditor + ( QListWidgetItem * item ) + + + currentItem + currentItem + () + + + currentItemChanged + currentItemChanged + ( QListWidgetItem * current, QListWidgetItem * previous ) + + + currentRowChanged + currentRowChanged + ( int currentRow ) + + + currentTextChanged + currentTextChanged + ( const QString & currentText ) + + + dropMimeData + dropMimeData + ( int index, const QMimeData * data, Qt::DropAction action ) + + + editItem + editItem + ( QListWidgetItem * item ) + + + event + event + ( QEvent * e ) + + + findItems + findItems + ( const QString & text, Qt::MatchFlags flags ) + + + indexFromItem + indexFromItem + ( QListWidgetItem * item ) + + + insertItem + insertItem + ( int row, QListWidgetItem * item ) + + + insertItem + insertItem-2 + ( int row, const QString & label ) + + + insertItems + insertItems + ( int row, const QStringList & labels ) + + + isItemHidden + isItemHidden + ( const QListWidgetItem * item ) + + + isItemSelected + isItemSelected + ( const QListWidgetItem * item ) + + + item + item + ( int row ) + + + itemActivated + itemActivated + ( QListWidgetItem * item ) + + + itemAt + itemAt + ( const QPoint & p ) + + + itemAt + itemAt-2 + ( int x, int y ) + + + itemChanged + itemChanged + ( QListWidgetItem * item ) + + + itemClicked + itemClicked + ( QListWidgetItem * item ) + + + itemDoubleClicked + itemDoubleClicked + ( QListWidgetItem * item ) + + + itemEntered + itemEntered + ( QListWidgetItem * item ) + + + itemFromIndex + itemFromIndex + ( const QModelIndex & index ) + + + itemPressed + itemPressed + ( QListWidgetItem * item ) + + + itemSelectionChanged + itemSelectionChanged + () + + + itemWidget + itemWidget + ( QListWidgetItem * item ) + + + items + items + ( const QMimeData * data ) + + + mimeData + mimeData + ( const QList<QListWidgetItem *> items ) + + + mimeTypes + mimeTypes + () + + + openPersistentEditor + openPersistentEditor + ( QListWidgetItem * item ) + + + row + row + ( const QListWidgetItem * item ) + + + scrollToItem + scrollToItem + ( const QListWidgetItem * item, QAbstractItemView::ScrollHint hint = EnsureVisible ) + + + selectedItems + selectedItems + () + + + setCurrentItem + setCurrentItem + ( QListWidgetItem * item ) + + + setItemHidden + setItemHidden + ( const QListWidgetItem * item, bool hide ) + + + setItemSelected + setItemSelected + ( const QListWidgetItem * item, bool select ) + + + setItemWidget + setItemWidget + ( QListWidgetItem * item, QWidget * widget ) + + + sortItems + sortItems + ( Qt::SortOrder order = Qt::AscendingOrder ) + + + DropActions + supportedDropActions + QListWidget::supportedDropActions() + + + takeItem + takeItem + ( int row ) + + + visualItemRect + visualItemRect + ( const QListWidgetItem * item ) + + + + QListWidgetItem + qlistwidgetitem.html + + QListWidgetItem + QListWidgetItem + ( QListWidget * parent = 0, int type = Type ) + + + QListWidgetItem + QListWidgetItem-2 + ( const QString & text, QListWidget * parent = 0, int type = Type ) + + + QListWidgetItem + QListWidgetItem-3 + ( const QIcon & icon, const QString & text, QListWidget * parent = 0, int type = Type ) + + + QListWidgetItem + QListWidgetItem-4 + ( const QListWidgetItem & other ) + + + backgroundColor + backgroundColor + () + + + CheckState + checkState + QListWidgetItem::checkState() + + + clone + clone + () + + + data + data + ( int role ) + + + ItemFlags + flags + QListWidgetItem::flags() + + + font + font + () + + + icon + icon + () + + + listWidget + listWidget + () + + + read + read + ( QDataStream & in ) + + + setBackgroundColor + setBackgroundColor + ( const QColor & color ) + + + setCheckState + setCheckState + ( Qt::CheckState state ) + + + setData + setData + ( int role, const QVariant & value ) + + + setFlags + setFlags + ( Qt::ItemFlags flags ) + + + setFont + setFont + ( const QFont & font ) + + + setIcon + setIcon + ( const QIcon & icon ) + + + setSizeHint + setSizeHint + ( const QSize & size ) + + + setStatusTip + setStatusTip + ( const QString & statusTip ) + + + setText + setText + ( const QString & text ) + + + setTextAlignment + setTextAlignment + ( int alignment ) + + + setTextColor + setTextColor + ( const QColor & color ) + + + setToolTip + setToolTip + ( const QString & toolTip ) + + + setWhatsThis + setWhatsThis + ( const QString & whatsThis ) + + + sizeHint + sizeHint + () + + + statusTip + statusTip + () + + + text + text + () + + + textAlignment + textAlignment + () + + + textColor + textColor + () + + + toolTip + toolTip + () + + + type + type + () + + + whatsThis + whatsThis + () + + + write + write + ( QDataStream & out ) + + + operator< + operator-lt + ( const QListWidgetItem & other ) + + + operator= + operator-eq + ( const QListWidgetItem & other ) + + + Type + Type-var + + + + UserType + UserType-var + + + + + QLocale + qlocale.html + + Country + Country-enum + + + + FormatType + FormatType-enum + + + + Language + Language-enum + + + + QLocale + QLocale + () + + + QLocale + QLocale-2 + ( const QString & name ) + + + QLocale + QLocale-3 + ( Language language, Country country = AnyCountry ) + + + QLocale + QLocale-4 + ( const QLocale & other ) + + + c + c + () + + + country + country + () + + + countryToString + countryToString + ( Country country ) + + + dateFormat + dateFormat + ( FormatType format = LongFormat ) + + + decimalPoint + decimalPoint + () + + + exponential + exponential + () + + + groupSeparator + groupSeparator + () + + + language + language + () + + + languageToString + languageToString + ( Language language ) + + + name + name + () + + + negativeSign + negativeSign + () + + + percent + percent + () + + + setDefault + setDefault + ( const QLocale & locale ) + + + system + system + () + + + timeFormat + timeFormat + ( FormatType format = LongFormat ) + + + toDouble + toDouble + ( const QString & s, bool * ok = 0 ) + + + toFloat + toFloat + ( const QString & s, bool * ok = 0 ) + + + toInt + toInt + ( const QString & s, bool * ok = 0, int base = 0 ) + + + toLongLong + toLongLong + ( const QString & s, bool * ok = 0, int base = 0 ) + + + toShort + toShort + ( const QString & s, bool * ok = 0, int base = 0 ) + + + toString + toString + ( qlonglong i ) + + + toString + toString-2 + ( const QDate & date, const QString & format ) + + + toString + toString-3 + ( const QDate & date, FormatType format = LongFormat ) + + + toString + toString-4 + ( const QTime & time, const QString & format ) + + + toString + toString-5 + ( const QTime & time, FormatType format = LongFormat ) + + + toString + toString-6 + ( qulonglong i ) + + + toString + toString-7 + ( double i, char f = 'g', int prec = 6 ) + + + toString + toString-8 + ( short i ) + + + toString + toString-9 + ( ushort i ) + + + toString + toString-10 + ( int i ) + + + toString + toString-11 + ( uint i ) + + + toString + toString-12 + ( float i, char f = 'g', int prec = 6 ) + + + toUInt + toUInt + ( const QString & s, bool * ok = 0, int base = 0 ) + + + toULongLong + toULongLong + ( const QString & s, bool * ok = 0, int base = 0 ) + + + toUShort + toUShort + ( const QString & s, bool * ok = 0, int base = 0 ) + + + zeroDigit + zeroDigit + () + + + operator!= + operator-not-eq + ( const QLocale & other ) + + + operator= + operator-eq + ( const QLocale & other ) + + + operator== + operator-eq-eq + ( const QLocale & other ) + + + + QMacMime + qmacmime.html + + QMacMime + QMacMime + ( char t ) + + + all + all + ( QMacMimeType t ) + + + canConvert + canConvert + ( const QString & mime, int flav ) + + + convertFromMime + convertFromMime + ( const QString & mime, QVariant data, int flav ) + + + convertToMime + convertToMime + ( const QString & mime, QList<QByteArray> data, int flav ) + + + convertor + convertor + ( QMacMimeType t, const QString & mime, int flav ) + + + convertorName + convertorName + () + + + countFlavors + countFlavors + () + + + flavor + flavor + ( int index ) + + + flavorFor + flavorFor + ( const QString & mime ) + + + flavorToMime + flavorToMime + ( QMacMimeType t, int flav ) + + + mimeFor + mimeFor + ( int flav ) + + + + QMacStyle + qmacstyle.html + + FocusRectPolicy + FocusRectPolicy-enum + + + + WidgetSizePolicy + WidgetSizePolicy-enum + + + + QMacStyle + QMacStyle + () + + + focusRectPolicy + focusRectPolicy + ( const QWidget * w ) + + + setFocusRectPolicy + setFocusRectPolicy + ( QWidget * w, FocusRectPolicy policy ) + + + setWidgetSizePolicy + setWidgetSizePolicy + ( const QWidget * w, WidgetSizePolicy policy ) + + + widgetSizePolicy + widgetSizePolicy + ( const QWidget * w ) + + + + QMainWindow + qmainwindow.html + + ToolButtonStyle + toolButtonStyle-prop + + + + QMainWindow + QMainWindow + ( QWidget * parent = 0, Qt::WFlags flags = 0 ) + + + addDockWidget + addDockWidget + ( Qt::DockWidgetArea area, QDockWidget * dockwidget ) + + + addDockWidget + addDockWidget-2 + ( Qt::DockWidgetArea area, QDockWidget * dockwidget, Qt::Orientation orientation ) + + + addToolBar + addToolBar + ( Qt::ToolBarArea area, QToolBar * toolbar ) + + + addToolBar + addToolBar-2 + ( QToolBar * toolbar ) + + + addToolBar + addToolBar-3 + ( const QString & title ) + + + addToolBarBreak + addToolBarBreak + ( Qt::ToolBarArea area = Qt::TopToolBarArea ) + + + centralWidget + centralWidget + () + + + DockWidgetArea + corner + QMainWindow::corner( Qt::Corner corner ) + + + createPopupMenu + createPopupMenu + () + + + DockWidgetArea + dockWidgetArea + QMainWindow::dockWidgetArea( QDockWidget * dockwidget ) + + + iconSizeChanged + iconSizeChanged + ( const QSize & iconSize ) + + + insertToolBar + insertToolBar + ( QToolBar * before, QToolBar * toolbar ) + + + insertToolBarBreak + insertToolBarBreak + ( QToolBar * before ) + + + menuBar + menuBar + () + + + removeDockWidget + removeDockWidget + ( QDockWidget * dockwidget ) + + + removeToolBar + removeToolBar + ( QToolBar * toolbar ) + + + restoreState + restoreState + ( const QByteArray & state, int version = 0 ) + + + saveState + saveState + ( int version = 0 ) + + + setCentralWidget + setCentralWidget + ( QWidget * widget ) + + + setCorner + setCorner + ( Qt::Corner corner, Qt::DockWidgetArea area ) + + + setMenuBar + setMenuBar + ( QMenuBar * menuBar ) + + + setStatusBar + setStatusBar + ( QStatusBar * statusbar ) + + + splitDockWidget + splitDockWidget + ( QDockWidget * first, QDockWidget * second, Qt::Orientation orientation ) + + + statusBar + statusBar + () + + + ToolBarArea + toolBarArea + QMainWindow::toolBarArea( QToolBar * toolbar ) + + + toolButtonStyleChanged + toolButtonStyleChanged + ( Qt::ToolButtonStyle toolButtonStyle ) + + + QMainWindow + QMainWindow-2 + ( QWidget * parent, const char * name, Qt::WFlags flags = 0 ) + + + + QMap::const_iterator + qmap-const-iterator.html + + const_iterator + const_iterator + () + + + const_iterator + const_iterator-3 + ( const iterator & other ) + + + key + key + () + + + value + value + () + + + operator!= + operator-not-eq + ( const const_iterator & other ) + + + operator* + operator-2a + () + + + operator+ + operator-2b + ( int j ) + + + operator++ + operator-2b-2b + () + + + operator++ + operator-2b-2b-2 + ( int ) + + + operator+= + operator-2b-eq + ( int j ) + + + operator- + operator- + ( int j ) + + + operator-- + operator-- + () + + + operator-- + operator---2 + ( int ) + + + operator-= + operator--eq + ( int j ) + + + operator-& + operator--gt + gt;() + + + operator== + operator-eq-eq + ( const const_iterator & other ) + + + data + data + () + + + + QMap + qmap.html + + ConstIterator + ConstIterator-typedef + + + + Iterator + Iterator-typedef + + + + QMap + QMap + () + + + QMap + QMap-2 + ( const QMap<Key, T> & other ) + + + QMap + QMap-3 + ( const std::map<Key, T> & other ) + + + begin + begin + () + + + begin + begin-2 + () + + + clear + clear + () + + + constBegin + constBegin + () + + + constEnd + constEnd + () + + + constFind + constFind + ( const Key & key ) + + + contains + contains + ( const Key & key ) + + + count + count + ( const Key & key ) + + + count + count-2 + () + + + empty + empty + () + + + end + end + () + + + end + end-2 + () + + + erase + erase + ( iterator pos ) + + + find + find + ( const Key & key ) + + + find + find-2 + ( const Key & key ) + + + insert + insert + ( const Key & key, const T & value ) + + + insertMulti + insertMulti + ( const Key & key, const T & value ) + + + isEmpty + isEmpty + () + + + key + key + ( const T & value ) + + + keys + keys + () + + + keys + keys-2 + ( const T & value ) + + + lowerBound + lowerBound + ( const Key & key ) + + + lowerBound + lowerBound-2 + ( const Key & key ) + + + remove + remove + ( const Key & key ) + + + size + size + () + + + take + take + ( const Key & key ) + + + map + toStdMap + <Key, T> QMap::toStdMap() + + + unite + unite + ( const QMap<Key, T> & other ) + + + upperBound + upperBound + ( const Key & key ) + + + upperBound + upperBound-2 + ( const Key & key ) + + + value + value + ( const Key & key ) + + + value + value-2 + ( const Key & key, const T & defaultValue ) + + + values + values + () + + + values + values-2 + ( const Key & key ) + + + operator!= + operator-not-eq + ( const QMap<Key, T> & other ) + + + operator= + operator-eq + ( const QMap<Key, T> & other ) + + + operator== + operator-eq-eq + ( const QMap<Key, T> & other ) + + + operator[] + operator-5b-5d + ( const Key & key ) + + + operator[] + operator-5b-5d-2 + ( const Key & key ) + + + + QMap::iterator + qmap-iterator.html + + iterator + iterator + () + + + key + key + () + + + value + value + () + + + operator!= + operator-not-eq + ( const iterator & other ) + + + operator!= + operator-not-eq-2 + ( const const_iterator & other ) + + + operator* + operator-2a + () + + + operator+ + operator-2b + ( int j ) + + + operator++ + operator-2b-2b + () + + + operator++ + operator-2b-2b-2 + ( int ) + + + operator+= + operator-2b-eq + ( int j ) + + + operator- + operator- + ( int j ) + + + operator-- + operator-- + () + + + operator-- + operator---2 + ( int ) + + + operator-= + operator--eq + ( int j ) + + + operator-& + operator--gt + gt;() + + + operator== + operator-eq-eq + ( const iterator & other ) + + + operator== + operator-eq-eq-2 + ( const const_iterator & other ) + + + + QMapIterator + qmapiterator.html + + QMapIterator + QMapIterator + ( const QMap<Key, T> & map ) + + + findNext + findNext + ( const T & value ) + + + findPrevious + findPrevious + ( const T & value ) + + + hasNext + hasNext + () + + + hasPrevious + hasPrevious + () + + + key + key + () + + + next + next + () + + + peekNext + peekNext + () + + + peekPrevious + peekPrevious + () + + + previous + previous + () + + + toBack + toBack + () + + + toFront + toFront + () + + + value + value + () + + + operator= + operator-eq + ( const QMap<Key, T> & map ) + + + data + data + () + + + erase + erase-2 + ( const Key & key ) + + + insert + insert-2 + ( const Key & key, const T & value, bool overwrite ) + + + remove + remove-2 + ( iterator it ) + + + replace + replace + ( const Key & key, const T & value ) + + + + QMatrix + qmatrix.html + + QMatrix + QMatrix + () + + + QMatrix + QMatrix-2 + ( qreal m11, qreal m12, qreal m21, qreal m22, qreal dx, qreal dy ) + + + QMatrix + QMatrix-3 + ( const QMatrix & matrix ) + + + m11 + m11 + () + + + m12 + m12 + () + + + m21 + m21 + () + + + m22 + m22 + () + + + det + det + () + + + dx + dx + () + + + dy + dy + () + + + inverted + inverted + ( bool * invertible = 0 ) + + + isIdentity + isIdentity + () + + + isInvertible + isInvertible + () + + + map + map + ( qreal x, qreal y, qreal * tx, qreal * ty ) + + + map + map-3 + ( int x, int y, int * tx, int * ty ) + + + map + map-4 + ( const QPointF & point ) + + + map + map-5 + ( const QPoint & point ) + + + map + map-6 + ( const QLineF & line ) + + + map + map-7 + ( const QLine & line ) + + + map + map-8 + ( const QPolygonF & polygon ) + + + map + map-9 + ( const QPolygon & polygon ) + + + map + map-10 + ( const QRegion & region ) + + + map + map-11 + ( const QPainterPath & path ) + + + mapRect + mapRect + ( const QRectF & rectangle ) + + + mapRect + mapRect-2 + ( const QRect & rectangle ) + + + mapToPolygon + mapToPolygon + ( const QRect & rectangle ) + + + reset + reset + () + + + rotate + rotate + ( qreal degrees ) + + + scale + scale + ( qreal sx, qreal sy ) + + + setMatrix + setMatrix + ( qreal m11, qreal m12, qreal m21, qreal m22, qreal dx, qreal dy ) + + + shear + shear + ( qreal sh, qreal sv ) + + + translate + translate + ( qreal dx, qreal dy ) + + + operator!= + operator-not-eq + ( const QMatrix & matrix ) + + + operator* + operator-2a + ( const QMatrix & matrix ) + + + operator*= + operator-2a-eq + ( const QMatrix & matrix ) + + + operator= + operator-eq + ( const QMatrix & matrix ) + + + operator== + operator-eq-eq + ( const QMatrix & matrix ) + + + invert + invert + ( bool * invertible = 0 ) + + + map + map-2 + ( const QRect & rect ) + + + mapToRegion + mapToRegion + ( const QRect & rectangle ) + + + + QMenuBar + qmenubar.html + + QMenuBar + QMenuBar + ( QWidget * parent = 0 ) + + + activeAction + activeAction + () + + + addAction + addAction + ( const QString & text ) + + + addAction + addAction-2 + ( const QString & text, const QObject * receiver, const char * member ) + + + addMenu + addMenu + ( QMenu * menu ) + + + addMenu + addMenu-2 + ( const QString & title ) + + + addMenu + addMenu-3 + ( const QIcon & icon, const QString & title ) + + + addSeparator + addSeparator + () + + + clear + clear + () + + + hovered + hovered + ( QAction * action ) + + + insertMenu + insertMenu + ( QAction * before, QMenu * menu ) + + + setActiveAction + setActiveAction + ( QAction * act ) + + + triggered + triggered + ( QAction * action ) + + + Separator + Separator-enum + + + + QMenuBar + QMenuBar-2 + ( QWidget * parent, const char * name ) + + + accel + accel + ( int id ) + + + activateItemAt + activateItemAt + ( int index ) + + + activated + activated + ( int itemId ) + + + autoGeometry + autoGeometry + () + + + changeItem + changeItem + ( int id, const QString & text ) + + + changeItem + changeItem-2 + ( int id, const QPixmap & pixmap ) + + + changeItem + changeItem-3 + ( int id, const QIcon & icon, const QString & text ) + + + connectItem + connectItem + ( int id, const QObject * receiver, const char * member ) + + + count + count + () + + + disconnectItem + disconnectItem + ( int id, const QObject * receiver, const char * member ) + + + findItem + findItem + ( int id ) + + + frameWidth + frameWidth + () + + + highlighted + highlighted + ( int itemId ) + + + iconSet + iconSet + ( int id ) + + + idAt + idAt + ( int index ) + + + indexOf + indexOf + ( int id ) + + + insertItem + insertItem + ( const QString & text, const QObject * receiver, const char * member, const QKeySequence & shortcut = 0, int id = -1, int index = -1 ) + + + insertItem + insertItem-2 + ( const QIcon & icon, const QString & text, const QObject * receiver, const char * member, const QKeySequence & shortcut = 0, int id = -1, int index = -1 ) + + + insertItem + insertItem-3 + ( const QPixmap & pixmap, const QObject * receiver, const char * member, const QKeySequence & shortcut = 0, int id = -1, int index = -1 ) + + + insertItem + insertItem-4 + ( const QString & text, int id = -1, int index = -1 ) + + + insertItem + insertItem-5 + ( const QIcon & icon, const QString & text, int id = -1, int index = -1 ) + + + insertItem + insertItem-6 + ( const QString & text, QMenu * popup, int id = -1, int index = -1 ) + + + insertItem + insertItem-7 + ( const QIcon & icon, const QString & text, QMenu * popup, int id = -1, int index = -1 ) + + + insertItem + insertItem-8 + ( const QPixmap & pixmap, int id = -1, int index = -1 ) + + + insertItem + insertItem-9 + ( const QPixmap & pixmap, QMenu * popup, int id = -1, int index = -1 ) + + + insertSeparator + insertSeparator + ( int index = -1 ) + + + isItemActive + isItemActive + ( int id ) + + + isItemChecked + isItemChecked + ( int id ) + + + isItemEnabled + isItemEnabled + ( int id ) + + + isItemVisible + isItemVisible + ( int id ) + + + itemAtPos + itemAtPos + ( const QPoint & p ) + + + itemParameter + itemParameter + ( int id ) + + + itemRect + itemRect + ( int index ) + + + pixmap + pixmap + ( int id ) + + + removeItem + removeItem + ( int id ) + + + removeItemAt + removeItemAt + ( int index ) + + + separator + separator + () + + + setAccel + setAccel + ( const QKeySequence & key, int id ) + + + setAutoGeometry + setAutoGeometry + ( bool b ) + + + setItemChecked + setItemChecked + ( int id, bool check ) + + + setItemEnabled + setItemEnabled + ( int id, bool enable ) + + + setItemParameter + setItemParameter + ( int id, int param ) + + + setItemVisible + setItemVisible + ( int id, bool visible ) + + + setSeparator + setSeparator + ( Separator sep ) + + + setWhatsThis + setWhatsThis + ( int id, const QString & w ) + + + text + text + ( int id ) + + + whatsThis + whatsThis + ( int id ) + + + + QMenu + qmenu.html + + QMenu + QMenu + ( QWidget * parent = 0 ) + + + QMenu + QMenu-2 + ( const QString & title, QWidget * parent = 0 ) + + + aboutToShow + aboutToShow + () + + + actionAt + actionAt + ( const QPoint & pt ) + + + actionGeometry + actionGeometry + ( QAction * act ) + + + activeAction + activeAction + () + + + addAction + addAction + ( const QString & text ) + + + addAction + addAction-2 + ( const QIcon & icon, const QString & text ) + + + addAction + addAction-3 + ( const QString & text, const QObject * receiver, const char * member, const QKeySequence & shortcut = 0 ) + + + addAction + addAction-4 + ( const QIcon & icon, const QString & text, const QObject * receiver, const char * member, const QKeySequence & shortcut = 0 ) + + + addMenu + addMenu + ( QMenu * menu ) + + + addMenu + addMenu-2 + ( const QString & title ) + + + addMenu + addMenu-3 + ( const QIcon & icon, const QString & title ) + + + addSeparator + addSeparator + () + + + clear + clear + () + + + columnCount + columnCount + () + + + defaultAction + defaultAction + () + + + exec + exec + () + + + exec + exec-2 + ( const QPoint & p, QAction * action = 0 ) + + + exec + exec-3 + ( QList<QAction *> actions, const QPoint & pos, QAction * at = 0 ) + + + hideTearOffMenu + hideTearOffMenu + () + + + hovered + hovered + ( QAction * action ) + + + insertMenu + insertMenu + ( QAction * before, QMenu * menu ) + + + insertSeparator + insertSeparator + ( QAction * before ) + + + isTearOffMenuVisible + isTearOffMenuVisible + () + + + menuAction + menuAction + () + + + popup + popup + ( const QPoint & p, QAction * atAction = 0 ) + + + setActiveAction + setActiveAction + ( QAction * act ) + + + setDefaultAction + setDefaultAction + ( QAction * act ) + + + triggered + triggered + ( QAction * action ) + + + + QMenuItem + qmenuitem.html + + QMenuItem + QMenuItem + () + + + id + id + () + + + signalValue + signalValue + () + + + aboutToHide + aboutToHide + () + + + accel + accel + ( int id ) + + + activateItemAt + activateItemAt + ( int index ) + + + activated + activated + ( int itemId ) + + + changeItem + changeItem + ( int id, const QString & text ) + + + changeItem + changeItem-2 + ( int id, const QPixmap & pixmap ) + + + changeItem + changeItem-3 + ( int id, const QIcon & icon, const QString & text ) + + + columns + columns + () + + + connectItem + connectItem + ( int id, const QObject * receiver, const char * member ) + + + count + count + () + + + disconnectItem + disconnectItem + ( int id, const QObject * receiver, const char * member ) + + + findItem + findItem + ( int id ) + + + findPopup + findPopup + ( QMenu * popup, int * index ) + + + frameWidth + frameWidth + () + + + highlighted + highlighted + ( int itemId ) + + + iconSet + iconSet + ( int id ) + + + idAt + idAt + ( int index ) + + + indexOf + indexOf + ( int id ) + + + insertItem + insertItem + ( const QString & text, const QObject * receiver, const char * member, const QKeySequence & shortcut = 0, int id = -1, int index = -1 ) + + + insertItem + insertItem-2 + ( const QIcon & icon, const QString & text, const QObject * receiver, const char * member, const QKeySequence & shortcut = 0, int id = -1, int index = -1 ) + + + insertItem + insertItem-3 + ( const QPixmap & pixmap, const QObject * receiver, const char * member, const QKeySequence & shortcut = 0, int id = -1, int index = -1 ) + + + insertItem + insertItem-4 + ( const QString & text, int id = -1, int index = -1 ) + + + insertItem + insertItem-5 + ( const QIcon & icon, const QString & text, int id = -1, int index = -1 ) + + + insertItem + insertItem-6 + ( const QString & text, QMenu * popup, int id = -1, int index = -1 ) + + + insertItem + insertItem-7 + ( const QIcon & icon, const QString & text, QMenu * popup, int id = -1, int index = -1 ) + + + insertItem + insertItem-8 + ( const QPixmap & pixmap, int id = -1, int index = -1 ) + + + insertItem + insertItem-9 + ( const QPixmap & pixmap, QMenu * popup, int id = -1, int index = -1 ) + + + insertItem + insertItem-10 + ( QMenuItem * item, int id = -1, int index = -1 ) + + + insertSeparator + insertSeparator-2 + ( int index = -1 ) + + + insertTearOffHandle + insertTearOffHandle + ( int a = 0, int b = 0 ) + + + isCheckable + isCheckable + () + + + isItemActive + isItemActive + ( int id ) + + + isItemChecked + isItemChecked + ( int id ) + + + isItemEnabled + isItemEnabled + ( int id ) + + + isItemVisible + isItemVisible + ( int id ) + + + itemAtPos + itemAtPos + ( const QPoint & p, bool ignoreSeparator = true ) + + + itemFont + itemFont + ( int id ) + + + itemGeometry + itemGeometry + ( int index ) + + + itemHeight + itemHeight + ( int index ) + + + itemHeight + itemHeight-2 + ( QMenuItem * mi ) + + + itemParameter + itemParameter + ( int id ) + + + pixmap + pixmap + ( int id ) + + + popup + popup-2 + ( const QPoint & pos, int indexAtPoint ) + + + removeItem + removeItem + ( int id ) + + + removeItemAt + removeItemAt + ( int index ) + + + setAccel + setAccel + ( const QKeySequence & key, int id ) + + + setActiveItem + setActiveItem + ( int id ) + + + setCheckable + setCheckable + ( bool checkable ) + + + setId + setId + ( int index, int id ) + + + setItemChecked + setItemChecked + ( int id, bool check ) + + + setItemEnabled + setItemEnabled + ( int id, bool enable ) + + + setItemFont + setItemFont + ( int id, const QFont & font ) + + + setItemParameter + setItemParameter + ( int id, int param ) + + + setItemVisible + setItemVisible + ( int id, bool visible ) + + + setWhatsThis + setWhatsThis + ( int id, const QString & w ) + + + text + text + ( int id ) + + + whatsThis + whatsThis + ( int id ) + + + + QMessageBox + qmessagebox.html + + Button + Button-enum + + + + Icon + Icon-enum + + + + TextFormat + textFormat-prop + + + + QMessageBox + QMessageBox + ( QWidget * parent = 0 ) + + + QMessageBox + QMessageBox-2 + ( const QString & caption, const QString & text, Icon icon, int button0, int button1, int button2, QWidget * parent = 0, Qt::WFlags f = Qt::Dialog | Qt::MSWindowsFixedSizeDialogHint ) + + + about + about + ( QWidget * parent, const QString & caption, const QString & text ) + + + aboutQt + aboutQt + ( QWidget * parent, const QString & caption = QString() + + + buttonText + buttonText + ( int button ) + + + critical + critical + ( QWidget * parent, const QString & caption, const QString & text, int button0, int button1, int button2 = 0 ) + + + critical + critical-2 + ( QWidget * parent, const QString & caption, const QString & text, const QString & button0Text = QString() + + + information + information + ( QWidget * parent, const QString & caption, const QString & text, int button0, int button1 = 0, int button2 = 0 ) + + + information + information-2 + ( QWidget * parent, const QString & caption, const QString & text, const QString & button0Text = QString() + + + question + question + ( QWidget * parent, const QString & caption, const QString & text, int button0, int button1 = 0, int button2 = 0 ) + + + question + question-2 + ( QWidget * parent, const QString & caption, const QString & text, const QString & button0Text = QString() + + + setButtonText + setButtonText + ( int button, const QString & text ) + + + standardIcon + standardIcon-2 + ( Icon icon ) + + + warning + warning + ( QWidget * parent, const QString & caption, const QString & text, int button0, int button1, int button2 = 0 ) + + + warning + warning-2 + ( QWidget * parent, const QString & caption, const QString & text, const QString & button0Text = QString() + + + QMessageBox + QMessageBox-3 + ( const QString & caption, const QString & text, Icon icon, int button0, int button1, int button2, QWidget * parent, const char * name, bool modal, Qt::WFlags f = Qt::Dialog | Qt::MSWindowsFixedSizeDialogHint ) + + + QMessageBox + QMessageBox-4 + ( QWidget * parent, const char * name ) + + + message + message + ( const QString & caption, const QString & text, const QString & buttonText = QString() + + + query + query + ( const QString & caption, const QString & text, const QString & yesButtonText = QString() + + + standardIcon + standardIcon + ( Icon icon, Qt::GUIStyle style ) + + + + QMetaClassInfo + qmetaclassinfo.html + + name + name + () + + + value + value + () + + + + QMetaEnum + qmetaenum.html + + isFlag + isFlag + () + + + isValid + isValid + () + + + key + key + ( int index ) + + + keyCount + keyCount + () + + + keyToValue + keyToValue + ( const char * key ) + + + keysToValue + keysToValue + ( const char * keys ) + + + name + name + () + + + scope + scope + () + + + value + value + ( int index ) + + + valueToKey + valueToKey + ( int value ) + + + valueToKeys + valueToKeys + ( int value ) + + + + QMetaMethod + qmetamethod.html + + MethodType + MethodType-enum + + + + access + access + () + + + methodType + methodType + () + + + parameterNames + parameterNames + () + + + parameterTypes + parameterTypes + () + + + signature + signature + () + + + tag + tag + () + + + typeName + typeName + () + + + + QMetaObject + qmetaobject.html + + checkConnectArgs + checkConnectArgs + ( const char * signal, const char * method ) + + + classInfo + classInfo + ( int index ) + + + classInfoCount + classInfoCount + () + + + classInfoOffset + classInfoOffset + () + + + className + className + () + + + connectSlotsByName + connectSlotsByName + ( QObject * o ) + + + enumerator + enumerator + ( int index ) + + + enumeratorCount + enumeratorCount + () + + + enumeratorOffset + enumeratorOffset + () + + + indexOfClassInfo + indexOfClassInfo + ( const char * name ) + + + indexOfEnumerator + indexOfEnumerator + ( const char * name ) + + + indexOfMethod + indexOfMethod + ( const char * method ) + + + indexOfProperty + indexOfProperty + ( const char * name ) + + + indexOfSignal + indexOfSignal + ( const char * signal ) + + + indexOfSlot + indexOfSlot + ( const char * slot ) + + + invokeMethod + invokeMethod + ( QObject * obj, const char * member, Qt::ConnectionType type, QGenericReturnArgument ret, QGenericArgument val0 = QGenericArgument( 0 ) + + + invokeMethod + invokeMethod-2 + ( QObject * obj, const char * member, QGenericReturnArgument ret, QGenericArgument val0 = QGenericArgument( 0 ) + + + invokeMethod + invokeMethod-3 + ( QObject * obj, const char * member, Qt::ConnectionType type, QGenericArgument val0 = QGenericArgument( 0 ) + + + invokeMethod + invokeMethod-4 + ( QObject * obj, const char * member, QGenericArgument val0 = QGenericArgument( 0 ) + + + method + method + ( int index ) + + + methodCount + methodCount + () + + + methodOffset + methodOffset + () + + + normalizedSignature + normalizedSignature + ( const char * method ) + + + property + property + ( int index ) + + + propertyCount + propertyCount + () + + + propertyOffset + propertyOffset + () + + + superClass + superClass + () + + + + QMetaProperty + qmetaproperty.html + + enumerator + enumerator + () + + + isDesignable + isDesignable + ( const QObject * object = 0 ) + + + isEditable + isEditable + ( const QObject * object = 0 ) + + + isEnumType + isEnumType + () + + + isFlagType + isFlagType + () + + + isReadable + isReadable + () + + + isResettable + isResettable + () + + + isScriptable + isScriptable + ( const QObject * object = 0 ) + + + isStored + isStored + ( const QObject * object = 0 ) + + + isUser + isUser + ( const QObject * object = 0 ) + + + isValid + isValid + () + + + isWritable + isWritable + () + + + name + name + () + + + read + read + ( const QObject * object ) + + + reset + reset + ( QObject * object ) + + + Type + type + QMetaProperty::type() + + + typeName + typeName + () + + + write + write + ( QObject * object, const QVariant & value ) + + + + QMetaType + qmetatype.html + + Type + Type-enum + + + + construct + construct + ( int type, const void * copy ) + + + destroy + destroy + ( int type, void * data ) + + + isRegistered + isRegistered + ( int type ) + + + load + load + ( QDataStream & stream, int type, void * data ) + + + save + save + ( QDataStream & stream, int type, const void * data ) + + + type + type + ( const char * typeName ) + + + typeName + typeName + ( int type ) + + + + QMimeData + qmimedata.html + + QMimeData + QMimeData + () + + + clear + clear + () + + + colorData + colorData + () + + + data + data + ( const QString & mimetype ) + + + formats + formats + () + + + hasColor + hasColor + () + + + hasFormat + hasFormat + ( const QString & mimetype ) + + + hasHtml + hasHtml + () + + + hasImage + hasImage + () + + + hasText + hasText + () + + + hasUrls + hasUrls + () + + + html + html + () + + + imageData + imageData + () + + + retrieveData + retrieveData + ( const QString & mimetype, QVariant::Type type ) + + + setColorData + setColorData + ( const QVariant & color ) + + + setData + setData + ( const QString & mimetype, const QByteArray & data ) + + + setHtml + setHtml + ( const QString & html ) + + + setImageData + setImageData + ( const QVariant & image ) + + + setText + setText + ( const QString & text ) + + + setUrls + setUrls + ( const QList<QUrl> & urls ) + + + text + text + () + + + urls + urls + () + + + + QMimeSource + qmimesource.html + + encodedData + encodedData + ( const char * format ) + + + format + format + ( int i = 0 ) + + + provides + provides + ( const char * mimeType ) + + + + QModelIndex + qmodelindex.html + + QModelIndex + QModelIndex + () + + + QModelIndex + QModelIndex-2 + ( const QModelIndex & other ) + + + child + child + ( int row, int column ) + + + column + column + () + + + data + data + ( int role = Qt::DisplayRole ) + + + internalId + internalId + () + + + internalPointer + internalPointer + () + + + isValid + isValid + () + + + model + model + () + + + parent + parent + () + + + row + row + () + + + sibling + sibling + ( int row, int column ) + + + operator!= + operator-not-eq + ( const QModelIndex & other ) + + + operator< + operator-lt + ( const QModelIndex & other ) + + + operator== + operator-eq-eq + ( const QModelIndex & other ) + + + + QMotifStyle + qmotifstyle.html + + QMotifStyle + QMotifStyle + ( bool useHighlightCols = false ) + + + eventFilter + eventFilter + ( QObject * o, QEvent * e ) + + + setUseHighlightColors + setUseHighlightColors + ( bool arg ) + + + useHighlightColors + useHighlightColors + () + + + + QMouseDriverFactory + qmousedriverfactory.html + + create + create + ( const QString & key, const QString & device ) + + + keys + keys + () + + + + QMouseDriverPlugin + qmousedriverplugin.html + + QMouseDriverPlugin + QMouseDriverPlugin + ( QObject * parent = 0 ) + + + create + create + ( const QString & key, const QString & device ) + + + keys + keys + () + + + + QMouseEvent + qmouseevent.html + + QMouseEvent + QMouseEvent + ( Type type, const QPoint & position, Qt::MouseButton button, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers ) + + + QMouseEvent + QMouseEvent-2 + ( Type type, const QPoint & pos, const QPoint & globalPos, Qt::MouseButton button, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers ) + + + MouseButton + button + QMouseEvent::button() + + + MouseButtons + buttons + QMouseEvent::buttons() + + + globalPos + globalPos + () + + + globalX + globalX + () + + + globalY + globalY + () + + + pos + pos + () + + + x + x + () + + + y + y + () + + + QMouseEvent + QMouseEvent-3 + ( Type type, const QPoint & pos, Qt::ButtonState button, int state ) + + + QMouseEvent + QMouseEvent-4 + ( Type type, const QPoint & pos, const QPoint & globalPos, Qt::ButtonState button, int state ) + + + ButtonState + state + QMouseEvent::state() + + + ButtonState + stateAfter + QMouseEvent::stateAfter() + + + + QMoveEvent + qmoveevent.html + + QMoveEvent + QMoveEvent + ( const QPoint & pos, const QPoint & oldPos ) + + + oldPos + oldPos + () + + + pos + pos + () + + + + QMovie + qmovie.html + + CacheMode + CacheMode-enum + + + + MovieState + MovieState-enum + + + + QMovie + QMovie + ( QObject * parent = 0 ) + + + QMovie + QMovie-2 + ( QIODevice * device, const QByteArray & format = QByteArray() + + + QMovie + QMovie-3 + ( const QString & fileName, const QByteArray & format = QByteArray() + + + backgroundColor + backgroundColor + () + + + currentFrameNumber + currentFrameNumber + () + + + currentImage + currentImage + () + + + currentPixmap + currentPixmap + () + + + device + device + () + + + error + error + ( QImageReader::ImageReaderError error ) + + + fileName + fileName + () + + + finished + finished + () + + + format + format + () + + + frameChanged + frameChanged + ( int frameNumber ) + + + frameCount + frameCount + () + + + frameRect + frameRect + () + + + isValid + isValid + () + + + jumpToFrame + jumpToFrame + ( int frameNumber ) + + + jumpToNextFrame + jumpToNextFrame + () + + + loopCount + loopCount + () + + + nextFrameDelay + nextFrameDelay + () + + + resized + resized + ( const QSize & size ) + + + scaledSize + scaledSize + () + + + setBackgroundColor + setBackgroundColor + ( const QColor & color ) + + + setDevice + setDevice + ( QIODevice * device ) + + + setFileName + setFileName + ( const QString & fileName ) + + + setFormat + setFormat + ( const QByteArray & format ) + + + setPaused + setPaused + ( bool paused ) + + + setScaledSize + setScaledSize + ( const QSize & size ) + + + start + start + () + + + started + started + () + + + state + state + () + + + stateChanged + stateChanged + ( QMovie::MovieState state ) + + + stop + stop + () + + + supportedFormats + supportedFormats + () + + + updated + updated + ( const QRect & rect ) + + + finished + finished-2 + () + + + frameImage + frameImage + () + + + frameNumber + frameNumber + () + + + framePixmap + framePixmap + () + + + isNull + isNull + () + + + pause + pause + () + + + paused + paused + () + + + restart + restart + () + + + running + running + () + + + step + step + () + + + unpause + unpause + () + + + + QMultiHash + qmultihash.html + + QMultiHash + QMultiHash + () + + + QMultiHash + QMultiHash-2 + ( const QHash<Key, T> & other ) + + + insert + insert + ( const Key & key, const T & value ) + + + replace + replace + ( const Key & key, const T & value ) + + + operator+ + operator-2b + ( const QMultiHash & other ) + + + operator+= + operator-2b-eq + ( const QMultiHash & other ) + + + + QMultiMap + qmultimap.html + + QMultiMap + QMultiMap + () + + + QMultiMap + QMultiMap-2 + ( const QMap<Key, T> & other ) + + + insert + insert + ( const Key & key, const T & value ) + + + replace + replace + ( const Key & key, const T & value ) + + + operator+ + operator-2b + ( const QMultiMap & other ) + + + operator+= + operator-2b-eq + ( const QMultiMap & other ) + + + + QMutableHashIterator + qmutablehashiterator.html + + QMutableHashIterator + QMutableHashIterator + ( QHash<Key, T> & hash ) + + + findNext + findNext + ( const T & value ) + + + findPrevious + findPrevious + ( const T & value ) + + + hasNext + hasNext + () + + + hasPrevious + hasPrevious + () + + + key + key + () + + + next + next + () + + + peekNext + peekNext + () + + + peekPrevious + peekPrevious + () + + + previous + previous + () + + + remove + remove + () + + + setValue + setValue + ( const T & value ) + + + toBack + toBack + () + + + toFront + toFront + () + + + value + value + () + + + value + value-2 + () + + + operator= + operator-eq + ( QHash<Key, T> & hash ) + + + + QMutableLinkedListIterator + qmutablelinkedlistiterator.html + + QMutableLinkedListIterator + QMutableLinkedListIterator + ( QLinkedList<T> & list ) + + + findNext + findNext + ( const T & value ) + + + findPrevious + findPrevious + ( const T & value ) + + + hasNext + hasNext + () + + + hasPrevious + hasPrevious + () + + + insert + insert + ( const T & value ) + + + next + next + () + + + peekNext + peekNext + () + + + peekPrevious + peekPrevious + () + + + previous + previous + () + + + remove + remove + () + + + setValue + setValue + ( const T & value ) + + + toBack + toBack + () + + + toFront + toFront + () + + + value + value + () + + + value + value-2 + () + + + operator= + operator-eq + ( QLinkedList<T> & list ) + + + + QMutableListIterator + qmutablelistiterator.html + + QMutableListIterator + QMutableListIterator + ( QList<T> & list ) + + + findNext + findNext + ( const T & value ) + + + findPrevious + findPrevious + ( const T & value ) + + + hasNext + hasNext + () + + + hasPrevious + hasPrevious + () + + + insert + insert + ( const T & value ) + + + next + next + () + + + peekNext + peekNext + () + + + peekPrevious + peekPrevious + () + + + previous + previous + () + + + remove + remove + () + + + setValue + setValue + ( const T & value ) + + + toBack + toBack + () + + + toFront + toFront + () + + + value + value + () + + + value + value-2 + () + + + operator= + operator-eq + ( QList<T> & list ) + + + + QMutableMapIterator + qmutablemapiterator.html + + QMutableMapIterator + QMutableMapIterator + ( QMap<Key, T> & map ) + + + findNext + findNext + ( const T & value ) + + + findPrevious + findPrevious + ( const T & value ) + + + hasNext + hasNext + () + + + hasPrevious + hasPrevious + () + + + key + key + () + + + next + next + () + + + peekNext + peekNext + () + + + peekPrevious + peekPrevious + () + + + previous + previous + () + + + remove + remove + () + + + setValue + setValue + ( const T & value ) + + + toBack + toBack + () + + + toFront + toFront + () + + + value + value + () + + + value + value-2 + () + + + operator= + operator-eq + ( QMap<Key, T> & map ) + + + + QMutableVectorIterator + qmutablevectoriterator.html + + QMutableVectorIterator + QMutableVectorIterator + ( QVector<T> & vector ) + + + findNext + findNext + ( const T & value ) + + + findPrevious + findPrevious + ( const T & value ) + + + hasNext + hasNext + () + + + hasPrevious + hasPrevious + () + + + insert + insert + ( const T & value ) + + + next + next + () + + + peekNext + peekNext + () + + + peekPrevious + peekPrevious + () + + + previous + previous + () + + + remove + remove + () + + + setValue + setValue + ( const T & value ) + + + toBack + toBack + () + + + toFront + toFront + () + + + value + value + () + + + value + value-2 + () + + + operator= + operator-eq + ( QVector<T> & vector ) + + + + QMutex + qmutex.html + + RecursionMode + RecursionMode-enum + + + + QMutex + QMutex + ( RecursionMode mode = NonRecursive ) + + + lock + lock + () + + + tryLock + tryLock + () + + + unlock + unlock + () + + + + QMutexLocker + qmutexlocker.html + + QMutexLocker + QMutexLocker + ( QMutex * mutex ) + + + mutex + mutex + () + + + relock + relock + () + + + unlock + unlock + () + + + QMutex + QMutex-2 + ( bool recursive ) + + + locked + locked + () + + + + QNetworkProxy + qnetworkproxy.html + + ProxyType + ProxyType-enum + + + + QNetworkProxy + QNetworkProxy + () + + + QNetworkProxy + QNetworkProxy-2 + ( ProxyType type, const QString & hostName = QString() + + + QNetworkProxy + QNetworkProxy-3 + ( const QNetworkProxy & other ) + + + applicationProxy + applicationProxy + () + + + hostName + hostName + () + + + password + password + () + + + port + port + () + + + setApplicationProxy + setApplicationProxy + ( const QNetworkProxy & networkProxy ) + + + setHostName + setHostName + ( const QString & hostName ) + + + setPassword + setPassword + ( const QString & password ) + + + setPort + setPort + ( quint16 port ) + + + setType + setType + ( QNetworkProxy::ProxyType type ) + + + setUser + setUser + ( const QString & user ) + + + ProxyType + type + QNetworkProxy::type() + + + user + user + () + + + operator= + operator-eq + ( const QNetworkProxy & other ) + + + + QObjectCleanupHandler + qobjectcleanuphandler.html + + QObjectCleanupHandler + QObjectCleanupHandler + () + + + add + add + ( QObject * object ) + + + clear + clear + () + + + isEmpty + isEmpty + () + + + remove + remove + ( QObject * object ) + + + + QObject + qobject.html + + QObject + QObject + ( QObject * parent = 0 ) + + + blockSignals + blockSignals + ( bool block ) + + + childEvent + childEvent + ( QChildEvent * event ) + + + children + children + () + + + connect + connect + ( const QObject * sender, const char * signal, const QObject * receiver, const char * method, Qt::ConnectionType type = Qt::AutoCompatConnection ) + + + connect + connect-2 + ( const QObject * sender, const char * signal, const char * method, Qt::ConnectionType type = Qt::AutoCompatConnection ) + + + connectNotify + connectNotify + ( const char * signal ) + + + customEvent + customEvent + ( QEvent * event ) + + + deleteLater + deleteLater + () + + + destroyed + destroyed + ( QObject * obj = 0 ) + + + disconnect + disconnect + ( const QObject * sender, const char * signal, const QObject * receiver, const char * method ) + + + disconnect + disconnect-2 + ( const char * signal = 0, const QObject * receiver = 0, const char * method = 0 ) + + + disconnect + disconnect-3 + ( const QObject * receiver, const char * method = 0 ) + + + disconnectNotify + disconnectNotify + ( const char * signal ) + + + dumpObjectInfo + dumpObjectInfo + () + + + dumpObjectTree + dumpObjectTree + () + + + event + event + ( QEvent * e ) + + + eventFilter + eventFilter + ( QObject * watched, QEvent * event ) + + + findChild + findChild + ( const QString & name = QString() + + + findChildren + findChildren + ( const QString & name = QString() + + + findChildren + findChildren-2 + ( const QRegExp & regExp ) + + + inherits + inherits + ( const char * className ) + + + installEventFilter + installEventFilter + ( QObject * filterObj ) + + + isWidgetType + isWidgetType + () + + + killTimer + killTimer + ( int id ) + + + metaObject + metaObject + () + + + moveToThread + moveToThread + ( QThread * targetThread ) + + + parent + parent + () + + + property + property + ( const char * name ) + + + receivers + receivers + ( const char * signal ) + + + removeEventFilter + removeEventFilter + ( QObject * obj ) + + + sender + sender + () + + + setParent + setParent + ( QObject * parent ) + + + setProperty + setProperty + ( const char * name, const QVariant & value ) + + + signalsBlocked + signalsBlocked + () + + + startTimer + startTimer + ( int interval ) + + + thread + thread + () + + + timerEvent + timerEvent + ( QTimerEvent * event ) + + + tr + tr + ( const char * sourceText, const char * comment ) + + + trUtf8 + trUtf8 + ( const char * sourceText, const char * comment ) + + + QObject + QObject-3 + ( QObject * parent, const char * name ) + + + checkConnectArgs + checkConnectArgs + ( const char * signal, const QObject * object, const char * method ) + + + child + child + ( const char * objName, const char * inheritsClass = 0, bool recursiveSearch = true ) + + + className + className + () + + + insertChild + insertChild + ( QObject * object ) + + + isA + isA + ( const char * className ) + + + name + name + () + + + name + name-2 + ( const char * defaultName ) + + + normalizeSignalSlot + normalizeSignalSlot + ( const char * signalSlot ) + + + removeChild + removeChild + ( QObject * object ) + + + setName + setName + ( const char * name ) + + + + QPageSetupDialog + qpagesetupdialog.html + + QPageSetupDialog + QPageSetupDialog + ( QPrinter * printer, QWidget * parent = 0 ) + + + printer + printer + () + + + + QPaintDevice + qpaintdevice.html + + PaintDeviceMetric + PaintDeviceMetric-enum + + + + QPaintDevice + QPaintDevice + () + + + depth + depth + () + + + height + height + () + + + heightMM + heightMM + () + + + logicalDpiX + logicalDpiX + () + + + logicalDpiY + logicalDpiY + () + + + metric + metric + ( PaintDeviceMetric metric ) + + + numColors + numColors + () + + + paintEngine + paintEngine + () + + + paintingActive + paintingActive + () + + + physicalDpiX + physicalDpiX + () + + + physicalDpiY + physicalDpiY + () + + + width + width + () + + + widthMM + widthMM + () + + + x11AppCells + x11AppCells + ( int screen = -1 ) + + + HANDLE + x11AppColormap + QPaintDevice::x11AppColormap( int screen = -1 ) + + + x11AppDefaultColormap + x11AppDefaultColormap + ( int screen = -1 ) + + + x11AppDefaultVisual + x11AppDefaultVisual + ( int screen = -1 ) + + + x11AppDepth + x11AppDepth + ( int screen = -1 ) + + + x11AppDisplay + x11AppDisplay + () + + + x11AppDpiX + x11AppDpiX + ( int screen = -1 ) + + + x11AppDpiY + x11AppDpiY + ( int screen = -1 ) + + + HANDLE + x11AppRootWindow + QPaintDevice::x11AppRootWindow( int screen = -1 ) + + + x11AppScreen + x11AppScreen + () + + + x11AppVisual + x11AppVisual + ( int screen = -1 ) + + + x11Cells + x11Cells + () + + + HANDLE + x11Colormap + QPaintDevice::x11Colormap() + + + x11DefaultColormap + x11DefaultColormap + () + + + x11DefaultVisual + x11DefaultVisual + () + + + x11Depth + x11Depth + () + + + x11Display + x11Display + () + + + x11Screen + x11Screen + () + + + x11SetAppDpiX + x11SetAppDpiX + ( int dpi, int screen ) + + + x11SetAppDpiY + x11SetAppDpiY + ( int dpi, int screen ) + + + x11Visual + x11Visual + () + + + + QPaintEngine + qpaintengine.html + + PolygonDrawMode + PolygonDrawMode-enum + + + + Type + Type-enum + + + + QPaintEngine + QPaintEngine + ( PaintEngineFeatures caps = 0 ) + + + begin + begin + ( QPaintDevice * pdev ) + + + drawEllipse + drawEllipse + ( const QRectF & rect ) + + + drawEllipse + drawEllipse-2 + ( const QRect & rect ) + + + drawImage + drawImage + ( const QRectF & rectangle, const QImage & image, const QRectF & sr, Qt::ImageConversionFlags flags = Qt::AutoColor ) + + + drawLines + drawLines + ( const QLineF * lines, int lineCount ) + + + drawLines + drawLines-2 + ( const QLine * lines, int lineCount ) + + + drawPath + drawPath + ( const QPainterPath & path ) + + + drawPixmap + drawPixmap + ( const QRectF & r, const QPixmap & pm, const QRectF & sr ) + + + drawPoints + drawPoints + ( const QPointF * points, int pointCount ) + + + drawPoints + drawPoints-2 + ( const QPoint * points, int pointCount ) + + + drawPolygon + drawPolygon + ( const QPointF * points, int pointCount, PolygonDrawMode mode ) + + + drawPolygon + drawPolygon-2 + ( const QPoint * points, int pointCount, PolygonDrawMode mode ) + + + drawRects + drawRects + ( const QRectF * rects, int rectCount ) + + + drawRects + drawRects-2 + ( const QRect * rects, int rectCount ) + + + drawTextItem + drawTextItem + ( const QPointF & p, const QTextItem & textItem ) + + + drawTiledPixmap + drawTiledPixmap + ( const QRectF & rect, const QPixmap & pixmap, const QPointF & p ) + + + end + end + () + + + hasFeature + hasFeature + ( PaintEngineFeatures feature ) + + + isActive + isActive + () + + + paintDevice + paintDevice + () + + + painter + painter + () + + + setActive + setActive + ( bool state ) + + + type + type + () + + + updateState + updateState + ( const QPaintEngineState & state ) + + + + QPaintEngineState + qpaintenginestate.html + + backgroundBrush + backgroundBrush + () + + + BGMode + backgroundMode + QPaintEngineState::backgroundMode() + + + brush + brush + () + + + brushOrigin + brushOrigin + () + + + ClipOperation + clipOperation + QPaintEngineState::clipOperation() + + + clipPath + clipPath + () + + + clipRegion + clipRegion + () + + + CompositionMode + compositionMode + QPaintEngineState::compositionMode() + + + font + font + () + + + isClipEnabled + isClipEnabled + () + + + matrix + matrix + () + + + painter + painter + () + + + pen + pen + () + + + RenderHints + renderHints + QPaintEngineState::renderHints() + + + DirtyFlags + state + QPaintEngineState::state() + + + + QPainter + qpainter.html + + CompositionMode + CompositionMode-enum + + + + QPainter + QPainter + () + + + QPainter + QPainter-2 + ( QPaintDevice * device ) + + + background + background + () + + + BGMode + backgroundMode + QPainter::backgroundMode() + + + begin + begin + ( QPaintDevice * device ) + + + boundingRect + boundingRect + ( const QRectF & rectangle, int flags, const QString & text ) + + + boundingRect + boundingRect-4 + ( const QRect & rectangle, int flags, const QString & text ) + + + boundingRect + boundingRect-5 + ( int x, int y, int w, int h, int flags, const QString & text ) + + + boundingRect + boundingRect-6 + ( const QRectF & rectangle, const QString & text, const QTextOption & option = QTextOption() + + + brush + brush + () + + + brushOrigin + brushOrigin + () + + + clipPath + clipPath + () + + + clipRegion + clipRegion + () + + + compositionMode + compositionMode + () + + + device + device + () + + + deviceMatrix + deviceMatrix + () + + + drawArc + drawArc + ( const QRectF & rectangle, int startAngle, int spanAngle ) + + + drawArc + drawArc-2 + ( const QRect & rectangle, int startAngle, int spanAngle ) + + + drawArc + drawArc-3 + ( int x, int y, int width, int height, int startAngle, int spanAngle ) + + + drawChord + drawChord + ( const QRectF & rectangle, int startAngle, int spanAngle ) + + + drawChord + drawChord-2 + ( const QRect & rectangle, int startAngle, int spanAngle ) + + + drawChord + drawChord-3 + ( int x, int y, int width, int height, int startAngle, int spanAngle ) + + + drawConvexPolygon + drawConvexPolygon + ( const QPointF * points, int pointCount ) + + + drawConvexPolygon + drawConvexPolygon-2 + ( const QPoint * points, int pointCount ) + + + drawConvexPolygon + drawConvexPolygon-3 + ( const QPolygonF & polygon ) + + + drawConvexPolygon + drawConvexPolygon-4 + ( const QPolygon & polygon ) + + + drawEllipse + drawEllipse + ( const QRectF & rectangle ) + + + drawEllipse + drawEllipse-2 + ( const QRect & rectangle ) + + + drawEllipse + drawEllipse-3 + ( int x, int y, int width, int height ) + + + drawImage + drawImage + ( const QRectF & target, const QImage & image, const QRectF & source, Qt::ImageConversionFlags flags = Qt::AutoColor ) + + + drawImage + drawImage-2 + ( const QRect & target, const QImage & image, const QRect & source, Qt::ImageConversionFlags flags = Qt::AutoColor ) + + + drawImage + drawImage-3 + ( const QPointF & point, const QImage & image ) + + + drawImage + drawImage-4 + ( const QPoint & point, const QImage & image ) + + + drawImage + drawImage-5 + ( const QPointF & point, const QImage & image, const QRectF & source, Qt::ImageConversionFlags flags = Qt::AutoColor ) + + + drawImage + drawImage-6 + ( const QPoint & point, const QImage & image, const QRect & source, Qt::ImageConversionFlags flags = Qt::AutoColor ) + + + drawImage + drawImage-7 + ( const QRectF & rectangle, const QImage & image ) + + + drawImage + drawImage-8 + ( const QRect & rectangle, const QImage & image ) + + + drawImage + drawImage-9 + ( int x, int y, const QImage & image, int sx = 0, int sy = 0, int sw = -1, int sh = -1, Qt::ImageConversionFlags flags = Qt::AutoColor ) + + + drawLine + drawLine + ( const QLineF & line ) + + + drawLine + drawLine-2 + ( const QLine & line ) + + + drawLine + drawLine-3 + ( const QPoint & p1, const QPoint & p2 ) + + + drawLine + drawLine-4 + ( const QPointF & p1, const QPointF & p2 ) + + + drawLine + drawLine-5 + ( int x1, int y1, int x2, int y2 ) + + + drawLines + drawLines + ( const QLineF * lines, int lineCount ) + + + drawLines + drawLines-2 + ( const QLine * lines, int lineCount ) + + + drawLines + drawLines-3 + ( const QPointF * pointPairs, int lineCount ) + + + drawLines + drawLines-4 + ( const QPoint * pointPairs, int lineCount ) + + + drawLines + drawLines-5 + ( const QVector<QPointF> & pointPairs ) + + + drawLines + drawLines-6 + ( const QVector<QPoint> & pointPairs ) + + + drawLines + drawLines-7 + ( const QVector<QLineF> & lines ) + + + drawLines + drawLines-8 + ( const QVector<QLine> & lines ) + + + drawPath + drawPath + ( const QPainterPath & path ) + + + drawPicture + drawPicture + ( const QPointF & point, const QPicture & picture ) + + + drawPicture + drawPicture-2 + ( const QPoint & point, const QPicture & picture ) + + + drawPicture + drawPicture-3 + ( int x, int y, const QPicture & picture ) + + + drawPie + drawPie + ( const QRectF & rectangle, int startAngle, int spanAngle ) + + + drawPie + drawPie-2 + ( const QRect & rectangle, int startAngle, int spanAngle ) + + + drawPie + drawPie-3 + ( int x, int y, int width, int height, int startAngle, int spanAngle ) + + + drawPixmap + drawPixmap + ( const QRectF & target, const QPixmap & pixmap, const QRectF & source ) + + + drawPixmap + drawPixmap-2 + ( const QRect & target, const QPixmap & pixmap, const QRect & source ) + + + drawPixmap + drawPixmap-3 + ( const QPointF & point, const QPixmap & pixmap, const QRectF & source ) + + + drawPixmap + drawPixmap-4 + ( const QPoint & point, const QPixmap & pixmap, const QRect & source ) + + + drawPixmap + drawPixmap-5 + ( const QPointF & point, const QPixmap & pixmap ) + + + drawPixmap + drawPixmap-6 + ( const QPoint & point, const QPixmap & pixmap ) + + + drawPixmap + drawPixmap-7 + ( int x, int y, const QPixmap & pixmap ) + + + drawPixmap + drawPixmap-8 + ( const QRect & rectangle, const QPixmap & pixmap ) + + + drawPixmap + drawPixmap-9 + ( int x, int y, int width, int height, const QPixmap & pixmap ) + + + drawPixmap + drawPixmap-10 + ( int x, int y, int w, int h, const QPixmap & pixmap, int sx, int sy, int sw, int sh ) + + + drawPixmap + drawPixmap-11 + ( int x, int y, const QPixmap & pixmap, int sx, int sy, int sw, int sh ) + + + drawPoint + drawPoint + ( const QPointF & position ) + + + drawPoint + drawPoint-2 + ( const QPoint & position ) + + + drawPoint + drawPoint-3 + ( int x, int y ) + + + drawPoints + drawPoints + ( const QPointF * points, int pointCount ) + + + drawPoints + drawPoints-2 + ( const QPoint * points, int pointCount ) + + + drawPoints + drawPoints-3 + ( const QPolygonF & points ) + + + drawPoints + drawPoints-4 + ( const QPolygon & points ) + + + drawPolygon + drawPolygon + ( const QPointF * points, int pointCount, Qt::FillRule fillRule = Qt::OddEvenFill ) + + + drawPolygon + drawPolygon-2 + ( const QPoint * points, int pointCount, Qt::FillRule fillRule = Qt::OddEvenFill ) + + + drawPolygon + drawPolygon-5 + ( const QPolygonF & points, Qt::FillRule fillRule = Qt::OddEvenFill ) + + + drawPolygon + drawPolygon-6 + ( const QPolygon & points, Qt::FillRule fillRule = Qt::OddEvenFill ) + + + drawPolyline + drawPolyline + ( const QPointF * points, int pointCount ) + + + drawPolyline + drawPolyline-2 + ( const QPoint * points, int pointCount ) + + + drawPolyline + drawPolyline-4 + ( const QPolygonF & points ) + + + drawPolyline + drawPolyline-5 + ( const QPolygon & points ) + + + drawRect + drawRect + ( const QRectF & rectangle ) + + + drawRect + drawRect-2 + ( const QRect & rectangle ) + + + drawRect + drawRect-3 + ( int x, int y, int width, int height ) + + + drawRects + drawRects + ( const QRectF * rectangles, int rectCount ) + + + drawRects + drawRects-2 + ( const QRect * rectangles, int rectCount ) + + + drawRects + drawRects-3 + ( const QVector<QRectF> & rectangles ) + + + drawRects + drawRects-4 + ( const QVector<QRect> & rectangles ) + + + drawRoundRect + drawRoundRect + ( const QRectF & r, int xRnd = 25, int yRnd = 25 ) + + + drawRoundRect + drawRoundRect-2 + ( const QRect & r, int xRnd = 25, int yRnd = 25 ) + + + drawRoundRect + drawRoundRect-3 + ( int x, int y, int w, int h, int xRnd = 25, int yRnd = 25 ) + + + drawText + drawText + ( const QPointF & position, const QString & text ) + + + drawText + drawText-8 + ( const QPoint & position, const QString & text ) + + + drawText + drawText-9 + ( const QRectF & rectangle, int flags, const QString & text, QRectF * boundingRect = 0 ) + + + drawText + drawText-10 + ( const QRect & rectangle, int flags, const QString & text, QRect * boundingRect = 0 ) + + + drawText + drawText-11 + ( int x, int y, const QString & text ) + + + drawText + drawText-12 + ( int x, int y, int width, int height, int flags, const QString & text, QRect * boundingRect = 0 ) + + + drawText + drawText-13 + ( const QRectF & rectangle, const QString & text, const QTextOption & option = QTextOption() + + + drawTiledPixmap + drawTiledPixmap + ( const QRectF & rectangle, const QPixmap & pixmap, const QPointF & position = QPointF() + + + drawTiledPixmap + drawTiledPixmap-2 + ( const QRect & rectangle, const QPixmap & pixmap, const QPoint & position = QPoint() + + + drawTiledPixmap + drawTiledPixmap-3 + ( int x, int y, int width, int height, const QPixmap & pixmap, int sx = 0, int sy = 0 ) + + + end + end + () + + + eraseRect + eraseRect + ( const QRectF & rectangle ) + + + eraseRect + eraseRect-2 + ( const QRect & rectangle ) + + + eraseRect + eraseRect-3 + ( int x, int y, int width, int height ) + + + fillPath + fillPath + ( const QPainterPath & path, const QBrush & brush ) + + + fillRect + fillRect + ( const QRectF & rectangle, const QBrush & brush ) + + + fillRect + fillRect-2 + ( const QRect & rectangle, const QBrush & brush ) + + + fillRect + fillRect-3 + ( int x, int y, int width, int height, const QBrush & brush ) + + + font + font + () + + + fontInfo + fontInfo + () + + + fontMetrics + fontMetrics + () + + + hasClipping + hasClipping + () + + + initFrom + initFrom + ( const QWidget * widget ) + + + isActive + isActive + () + + + LayoutDirection + layoutDirection + QPainter::layoutDirection() + + + matrix + matrix + () + + + matrixEnabled + matrixEnabled + () + + + paintEngine + paintEngine + () + + + pen + pen + () + + + redirected + redirected + ( const QPaintDevice * device, QPoint * offset = 0 ) + + + renderHints + renderHints + () + + + resetMatrix + resetMatrix + () + + + restore + restore + () + + + restoreRedirected + restoreRedirected + ( const QPaintDevice * device ) + + + rotate + rotate + ( qreal angle ) + + + save + save + () + + + scale + scale + ( qreal sx, qreal sy ) + + + setBackground + setBackground + ( const QBrush & brush ) + + + setBackgroundMode + setBackgroundMode + ( Qt::BGMode mode ) + + + setBrush + setBrush + ( const QBrush & brush ) + + + setBrush + setBrush-2 + ( Qt::BrushStyle style ) + + + setBrushOrigin + setBrushOrigin + ( const QPointF & position ) + + + setBrushOrigin + setBrushOrigin-2 + ( const QPoint & position ) + + + setBrushOrigin + setBrushOrigin-3 + ( int x, int y ) + + + setClipPath + setClipPath + ( const QPainterPath & path, Qt::ClipOperation operation = Qt::ReplaceClip ) + + + setClipRect + setClipRect + ( const QRectF & rectangle, Qt::ClipOperation operation = Qt::ReplaceClip ) + + + setClipRect + setClipRect-2 + ( int x, int y, int width, int height, Qt::ClipOperation operation = Qt::ReplaceClip ) + + + setClipRect + setClipRect-3 + ( const QRect & rectangle, Qt::ClipOperation operation = Qt::ReplaceClip ) + + + setClipRegion + setClipRegion + ( const QRegion & region, Qt::ClipOperation operation = Qt::ReplaceClip ) + + + setClipping + setClipping + ( bool enable ) + + + setCompositionMode + setCompositionMode + ( CompositionMode mode ) + + + setFont + setFont + ( const QFont & font ) + + + setLayoutDirection + setLayoutDirection + ( Qt::LayoutDirection direction ) + + + setMatrix + setMatrix + ( const QMatrix & matrix, bool combine = false ) + + + setMatrixEnabled + setMatrixEnabled + ( bool enable ) + + + setPen + setPen + ( const QPen & pen ) + + + setPen + setPen-2 + ( const QColor & color ) + + + setPen + setPen-3 + ( Qt::PenStyle style ) + + + setRedirected + setRedirected + ( const QPaintDevice * device, QPaintDevice * replacement, const QPoint & offset = QPoint() + + + setRenderHint + setRenderHint + ( RenderHint hint, bool on = true ) + + + setViewTransformEnabled + setViewTransformEnabled + ( bool enable ) + + + setViewport + setViewport + ( const QRect & rectangle ) + + + setViewport + setViewport-2 + ( int x, int y, int width, int height ) + + + setWindow + setWindow + ( const QRect & rectangle ) + + + setWindow + setWindow-2 + ( int x, int y, int width, int height ) + + + shear + shear + ( qreal sh, qreal sv ) + + + strokePath + strokePath + ( const QPainterPath & path, const QPen & pen ) + + + translate + translate + ( const QPointF & offset ) + + + translate + translate-2 + ( const QPoint & offset ) + + + translate + translate-3 + ( qreal dx, qreal dy ) + + + viewTransformEnabled + viewTransformEnabled + () + + + viewport + viewport + () + + + window + window + () + + + + QPainterPath::Element + qpainterpath-element.html + + isCurveTo + isCurveTo + () + + + isLineTo + isLineTo + () + + + isMoveTo + isMoveTo + () + + + operator + operator-QPointF + QPointF() + + + type + type-varx + + + + x + x-var + + + + y + y-var + + + + + QPainterPath + qpainterpath.html + + ElementType + ElementType-enum + + + + QPainterPath + QPainterPath + () + + + QPainterPath + QPainterPath-2 + ( const QPointF & startPoint ) + + + QPainterPath + QPainterPath-3 + ( const QPainterPath & path ) + + + addEllipse + addEllipse + ( const QRectF & boundingRectangle ) + + + addEllipse + addEllipse-2 + ( qreal x, qreal y, qreal width, qreal height ) + + + addPath + addPath + ( const QPainterPath & path ) + + + addPolygon + addPolygon + ( const QPolygonF & polygon ) + + + addRect + addRect + ( const QRectF & rectangle ) + + + addRect + addRect-2 + ( qreal x, qreal y, qreal width, qreal height ) + + + addRegion + addRegion + ( const QRegion & region ) + + + addText + addText + ( const QPointF & point, const QFont & font, const QString & text ) + + + addText + addText-2 + ( qreal x, qreal y, const QFont & font, const QString & text ) + + + arcTo + arcTo + ( const QRectF & rectangle, qreal startAngle, qreal sweepLength ) + + + arcTo + arcTo-2 + ( qreal x, qreal y, qreal width, qreal height, qreal startAngle, qreal sweepLength ) + + + boundingRect + boundingRect + () + + + closeSubpath + closeSubpath + () + + + connectPath + connectPath + ( const QPainterPath & path ) + + + contains + contains + ( const QPointF & point ) + + + contains + contains-2 + ( const QRectF & rectangle ) + + + controlPointRect + controlPointRect + () + + + cubicTo + cubicTo + ( const QPointF & c1, const QPointF & c2, const QPointF & endPoint ) + + + cubicTo + cubicTo-2 + ( qreal c1X, qreal c1Y, qreal c2X, qreal c2Y, qreal endPointX, qreal endPointY ) + + + currentPosition + currentPosition + () + + + Element + elementAt + & QPainterPath::elementAt( int index ) + + + elementCount + elementCount + () + + + FillRule + fillRule + QPainterPath::fillRule() + + + intersects + intersects + ( const QRectF & rectangle ) + + + isEmpty + isEmpty + () + + + lineTo + lineTo + ( const QPointF & endPoint ) + + + lineTo + lineTo-2 + ( qreal x, qreal y ) + + + moveTo + moveTo + ( const QPointF & point ) + + + moveTo + moveTo-2 + ( qreal x, qreal y ) + + + quadTo + quadTo + ( const QPointF & c, const QPointF & endPoint ) + + + quadTo + quadTo-2 + ( qreal cx, qreal cy, qreal endPointX, qreal endPointY ) + + + setFillRule + setFillRule + ( Qt::FillRule fillRule ) + + + toFillPolygon + toFillPolygon + ( const QMatrix & matrix = QMatrix() + + + toFillPolygons + toFillPolygons + ( const QMatrix & matrix = QMatrix() + + + toReversed + toReversed + () + + + toSubpathPolygons + toSubpathPolygons + ( const QMatrix & matrix = QMatrix() + + + operator!= + operator-not-eq + ( const QPainterPath & path ) + + + operator= + operator-eq + ( const QPainterPath & path ) + + + operator== + operator-eq-eq + ( const QPainterPath & path ) + + + + QPainterPathStroker + qpainterpathstroker.html + + QPainterPathStroker + QPainterPathStroker + () + + + PenCapStyle + capStyle + QPainterPathStroker::capStyle() + + + createStroke + createStroke + ( const QPainterPath & path ) + + + curveThreshold + curveThreshold + () + + + dashPattern + dashPattern + () + + + PenJoinStyle + joinStyle + QPainterPathStroker::joinStyle() + + + miterLimit + miterLimit + () + + + setCapStyle + setCapStyle + ( Qt::PenCapStyle style ) + + + setCurveThreshold + setCurveThreshold + ( qreal threshold ) + + + setDashPattern + setDashPattern + ( Qt::PenStyle style ) + + + setDashPattern + setDashPattern-2 + ( const QVector<qreal> & dashPattern ) + + + setJoinStyle + setJoinStyle + ( Qt::PenJoinStyle style ) + + + setMiterLimit + setMiterLimit + ( qreal limit ) + + + setWidth + setWidth + ( qreal width ) + + + width + width + () + + + backgroundColor + backgroundColor + () + + + begin + begin-2 + ( QPaintDevice * device, const QWidget * init ) + + + boundingRect + boundingRect-2 + ( const QRect & rectangle, int flags, const QString & text, int length ) + + + boundingRect + boundingRect-3 + ( int x, int y, int width, int height, int flags, const QString & text, int length ) + + + drawConvexPolygon + drawConvexPolygon-5 + ( const QPolygonF & polygon, int index, int count = -1 ) + + + drawConvexPolygon + drawConvexPolygon-6 + ( const QPolygon & polygon, int index, int count = -1 ) + + + drawCubicBezier + drawCubicBezier + ( const QPolygon & controlPoints, int index = 0 ) + + + drawLineSegments + drawLineSegments + ( const QPolygon & polygon, int index = 0, int count = -1 ) + + + drawPoints + drawPoints-5 + ( const QPolygon & polygon, int index, int count = -1 ) + + + drawPolygon + drawPolygon-3 + ( const QPolygonF & polygon, bool winding, int index = 0, int count = -1 ) + + + drawPolygon + drawPolygon-4 + ( const QPolygon & polygon, bool winding, int index = 0, int count = -1 ) + + + drawPolyline + drawPolyline-3 + ( const QPolygon & polygon, int index, int count = -1 ) + + + drawText + drawText-2 + ( int x, int y, const QString & text, int pos, int length ) + + + drawText + drawText-3 + ( const QPoint & point, const QString & text, int pos, int length ) + + + drawText + drawText-4 + ( int x, int y, const QString & text, int length ) + + + drawText + drawText-5 + ( const QPoint & point, const QString & text, int length ) + + + drawText + drawText-6 + ( const QRect & rectangle, int flags, const QString & text, int length, QRect * br = 0 ) + + + drawText + drawText-7 + ( int x, int y, int width, int height, int flags, const QString & text, int length, QRect * br = 0 ) + + + hasViewXForm + hasViewXForm + () + + + hasWorldXForm + hasWorldXForm + () + + + redirect + redirect + ( QPaintDevice * pdev, QPaintDevice * replacement ) + + + redirect + redirect-2 + ( QPaintDevice * pdev ) + + + resetXForm + resetXForm + () + + + setBackgroundColor + setBackgroundColor + ( const QColor & color ) + + + setViewXForm + setViewXForm + ( bool enabled ) + + + setWorldMatrix + setWorldMatrix + ( const QMatrix & wm, bool combine = false ) + + + setWorldXForm + setWorldXForm + ( bool enabled ) + + + translationX + translationX + () + + + translationY + translationY + () + + + worldMatrix + worldMatrix + () + + + xForm + xForm + ( const QPoint & point ) + + + xForm + xForm-2 + ( const QRect & rectangle ) + + + xForm + xForm-3 + ( const QPolygon & polygon ) + + + xForm + xForm-4 + ( const QPolygon & polygon, int index, int count ) + + + xFormDev + xFormDev + ( const QPoint & point ) + + + xFormDev + xFormDev-2 + ( const QRect & rectangle ) + + + xFormDev + xFormDev-3 + ( const QPolygon & polygon ) + + + xFormDev + xFormDev-4 + ( const QPolygon & polygon, int index, int count ) + + + + QPaintEvent + qpaintevent.html + + QPaintEvent + QPaintEvent + ( const QRegion & paintRegion ) + + + QPaintEvent + QPaintEvent-2 + ( const QRect & paintRect ) + + + rect + rect + () + + + region + region + () + + + QPaintEvent + QPaintEvent-3 + ( const QRegion & paintRegion, const QRect & paintRect ) + + + erased + erased + () + + + + QPair + qpair.html + + first_type + first_type-typedef + + + + second_type + second_type-typedef + + + + QPair + QPair + () + + + QPair + QPair-2 + ( const T1 & value1, const T2 & value2 ) + + + operator= + operator-eq + ( const QPair<T1, T2> & other ) + + + first + first-var + + + + second + second-var + + + + + QPalette + qpalette.html + + ColorGroup + ColorGroup-enum + + + + ColorRole + ColorRole-enum + + + + QPalette + QPalette + () + + + QPalette + QPalette-2 + ( const QColor & button ) + + + QPalette + QPalette-3 + ( Qt::GlobalColor button ) + + + QPalette + QPalette-4 + ( const QColor & button, const QColor & window ) + + + QPalette + QPalette-5 + ( const QBrush & windowText, const QBrush & button, const QBrush & light, const QBrush & dark, const QBrush & mid, const QBrush & text, const QBrush & bright_text, const QBrush & base, const QBrush & window ) + + + QPalette + QPalette-8 + ( const QPalette & p ) + + + alternateBase + alternateBase + () + + + base + base + () + + + brightText + brightText + () + + + brush + brush + ( ColorGroup gr, ColorRole cr ) + + + brush + brush-2 + ( ColorRole r ) + + + button + button + () + + + buttonText + buttonText + () + + + color + color + ( ColorGroup gr, ColorRole r ) + + + color + color-2 + ( ColorRole r ) + + + currentColorGroup + currentColorGroup + () + + + dark + dark + () + + + highlight + highlight + () + + + highlightedText + highlightedText + () + + + isCopyOf + isCopyOf + ( const QPalette & p ) + + + isEqual + isEqual + ( ColorGroup cg1, ColorGroup cg2 ) + + + light + light + () + + + link + link + () + + + linkVisited + linkVisited + () + + + mid + mid + () + + + midlight + midlight + () + + + resolve + resolve + ( const QPalette & other ) + + + serialNumber + serialNumber + () + + + setBrush + setBrush + ( ColorRole cr, const QBrush & brush ) + + + setBrush + setBrush-2 + ( ColorGroup cg, ColorRole cr, const QBrush & b ) + + + setColor + setColor + ( ColorGroup gr, ColorRole r, const QColor & c ) + + + setColor + setColor-2 + ( ColorRole r, const QColor & c ) + + + setColorGroup + setColorGroup + ( ColorGroup cg, const QBrush & windowText, const QBrush & button, const QBrush & light, const QBrush & dark, const QBrush & mid, const QBrush & text, const QBrush & bright_text, const QBrush & base, const QBrush & window ) + + + setCurrentColorGroup + setCurrentColorGroup + ( ColorGroup cg ) + + + shadow + shadow + () + + + text + text + () + + + window + window + () + + + windowText + windowText + () + + + operator + operator-QVariant + QVariant() + + + operator!= + operator-not-eq + ( const QPalette & p ) + + + operator= + operator-eq + ( const QPalette & p ) + + + operator== + operator-eq-eq + ( const QPalette & p ) + + + QPalette + QPalette-6 + ( const QColor & windowText, const QColor & window, const QColor & light, const QColor & dark, const QColor & mid, const QColor & text, const QColor & base ) + + + background + background + () + + + foreground + foreground + () + + + QPalette + QPalette-7 + ( const QColorGroup & active, const QColorGroup & disabled, const QColorGroup & inactive ) + + + active + active + () + + + copy + copy + () + + + disabled + disabled + () + + + inactive + inactive + () + + + normal + normal + () + + + setActive + setActive + ( const QColorGroup & colorGroup ) + + + setDisabled + setDisabled + ( const QColorGroup & colorGroup ) + + + setInactive + setInactive + ( const QColorGroup & colorGroup ) + + + setNormal + setNormal + ( const QColorGroup & colorGroup ) + + + + QPen + qpen.html + + QPen + QPen + () + + + QPen + QPen-2 + ( Qt::PenStyle style ) + + + QPen + QPen-3 + ( const QColor & color ) + + + QPen + QPen-4 + ( const QBrush & brush, qreal width, Qt::PenStyle style = Qt::SolidLine, Qt::PenCapStyle cap = Qt::SquareCap, Qt::PenJoinStyle join = Qt::BevelJoin ) + + + QPen + QPen-5 + ( const QPen & pen ) + + + brush + brush + () + + + PenCapStyle + capStyle + QPen::capStyle() + + + color + color + () + + + dashPattern + dashPattern + () + + + isSolid + isSolid + () + + + PenJoinStyle + joinStyle + QPen::joinStyle() + + + miterLimit + miterLimit + () + + + setBrush + setBrush + ( const QBrush & brush ) + + + setCapStyle + setCapStyle + ( Qt::PenCapStyle style ) + + + setColor + setColor + ( const QColor & color ) + + + setDashPattern + setDashPattern + ( const QVector<qreal> & pattern ) + + + setJoinStyle + setJoinStyle + ( Qt::PenJoinStyle style ) + + + setMiterLimit + setMiterLimit + ( qreal limit ) + + + setStyle + setStyle + ( Qt::PenStyle style ) + + + setWidth + setWidth + ( int width ) + + + setWidthF + setWidthF + ( qreal width ) + + + PenStyle + style + QPen::style() + + + width + width + () + + + widthF + widthF + () + + + operator + operator-QVariant + QVariant() + + + operator!= + operator-not-eq + ( const QPen & pen ) + + + operator= + operator-eq + ( const QPen & pen ) + + + operator== + operator-eq-eq + ( const QPen & pen ) + + + + QPersistentModelIndex + qpersistentmodelindex.html + + QPersistentModelIndex + QPersistentModelIndex-2 + ( const QModelIndex & index ) + + + QPersistentModelIndex + QPersistentModelIndex-3 + ( const QPersistentModelIndex & other ) + + + child + child + ( int row, int column ) + + + column + column + () + + + data + data + ( int role = Qt::DisplayRole ) + + + isValid + isValid + () + + + model + model + () + + + parent + parent + () + + + row + row + () + + + sibling + sibling + ( int row, int column ) + + + operator + operator-const-QModelIndex--and + const QModelIndex &() + + + operator!= + operator-not-eq + ( const QModelIndex & other ) + + + operator< + operator-lt + ( const QPersistentModelIndex & other ) + + + operator= + operator-eq + ( const QPersistentModelIndex & other ) + + + operator= + operator-eq-2 + ( const QModelIndex & other ) + + + operator== + operator-eq-eq + ( const QPersistentModelIndex & other ) + + + operator== + operator-eq-eq-2 + ( const QModelIndex & other ) + + + + QPictureFormatPlugin + qpictureformatplugin.html + + QPictureFormatPlugin + QPictureFormatPlugin + ( QObject * parent = 0 ) + + + installIOHandler + installIOHandler + ( const QString & format ) + + + keys + keys + () + + + loadPicture + loadPicture + ( const QString & format, const QString & fileName, QPicture * picture ) + + + savePicture + savePicture + ( const QString & format, const QString & fileName, const QPicture & picture ) + + + + QPicture + qpicture.html + + QPicture + QPicture + ( int formatVersion = -1 ) + + + QPicture + QPicture-2 + ( const QPicture & pic ) + + + boundingRect + boundingRect + () + + + data + data + () + + + inputFormatList + inputFormatList + () + + + inputFormats + inputFormats + () + + + isNull + isNull + () + + + load + load + ( const QString & fileName, const char * format = 0 ) + + + load + load-2 + ( QIODevice * dev, const char * format = 0 ) + + + metric + metric + ( PaintDeviceMetric m ) + + + outputFormatList + outputFormatList + () + + + outputFormats + outputFormats + () + + + pictureFormat + pictureFormat + ( const QString & fileName ) + + + play + play + ( QPainter * painter ) + + + save + save + ( const QString & fileName, const char * format = 0 ) + + + save + save-2 + ( QIODevice * dev, const char * format = 0 ) + + + setBoundingRect + setBoundingRect + ( const QRect & r ) + + + setData + setData + ( const char * data, uint size ) + + + size + size + () + + + operator= + operator-eq + ( const QPicture & p ) + + + + QPictureIO + qpictureio.html + + QPictureIO + QPictureIO + () + + + QPictureIO + QPictureIO-2 + ( QIODevice * ioDevice, const char * format ) + + + QPictureIO + QPictureIO-3 + ( const QString & fileName, const char * format ) + + + defineIOHandler + defineIOHandler + ( const char * format, const char * header, const char * flags, picture_io_handler readPicture, picture_io_handler writePicture ) + + + description + description + () + + + fileName + fileName + () + + + format + format + () + + + gamma + gamma + () + + + inputFormats + inputFormats + () + + + ioDevice + ioDevice + () + + + outputFormats + outputFormats + () + + + parameters + parameters + () + + + picture + picture + () + + + pictureFormat + pictureFormat + ( const QString & fileName ) + + + pictureFormat + pictureFormat-2 + ( QIODevice * d ) + + + quality + quality + () + + + read + read + () + + + setDescription + setDescription + ( const QString & description ) + + + setFileName + setFileName + ( const QString & fileName ) + + + setFormat + setFormat + ( const char * format ) + + + setGamma + setGamma + ( float gamma ) + + + setIODevice + setIODevice + ( QIODevice * ioDevice ) + + + setParameters + setParameters + ( const char * parameters ) + + + setPicture + setPicture + ( const QPicture & picture ) + + + setQuality + setQuality + ( int q ) + + + setStatus + setStatus + ( int status ) + + + status + status + () + + + write + write + () + + + copy + copy + () + + + + QPixmapCache + qpixmapcache.html + + cacheLimit + cacheLimit + () + + + clear + clear + () + + + find + find + ( const QString & key, QPixmap & pm ) + + + insert + insert + ( const QString & key, const QPixmap & pm ) + + + remove + remove + ( const QString & key ) + + + setCacheLimit + setCacheLimit + ( int n ) + + + find + find-2 + ( const QString & key ) + + + + QPixmap + qpixmap.html + + HBitmapFormat + HBitmapFormat-enum + + + + QPixmap + QPixmap + () + + + QPixmap + QPixmap-2 + ( int width, int height ) + + + QPixmap + QPixmap-3 + ( const QString & fileName, const char * format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor ) + + + QPixmap + QPixmap-4 + ( const char * const[] xpm ) + + + QPixmap + QPixmap-5 + ( const QPixmap & pixmap ) + + + QPixmap + QPixmap-9 + ( const QSize & size ) + + + alphaChannel + alphaChannel + () + + + copy + copy + ( const QRect & rectangle = QRect() + + + copy + copy-2 + ( int x, int y, int width, int height ) + + + createHeuristicMask + createHeuristicMask + ( bool clipTight = true ) + + + createMaskFromColor + createMaskFromColor + ( const QColor & maskColor ) + + + defaultDepth + defaultDepth + () + + + depth + depth + () + + + detach + detach + () + + + fill + fill + ( const QColor & fillColor = Qt::white ) + + + fill + fill-2 + ( const QWidget * widget, const QPoint & offset ) + + + fill + fill-3 + ( const QWidget * widget, int x, int y ) + + + fromImage + fromImage + ( const QImage & image, Qt::ImageConversionFlags flags = Qt::AutoColor ) + + + fromWinHBITMAP + fromWinHBITMAP + ( HBITMAP bitmap, HBitmapFormat format = NoAlpha ) + + + grabWidget + grabWidget + ( QWidget * widget, const QRect & rectangle ) + + + grabWidget + grabWidget-2 + ( QWidget * widget, int x = 0, int y = 0, int width = -1, int height = -1 ) + + + grabWindow + grabWindow + ( WId window, int x = 0, int y = 0, int width = -1, int height = -1 ) + + + HANDLE + handle + QPixmap::handle() + + + hasAlpha + hasAlpha + () + + + hasAlphaChannel + hasAlphaChannel + () + + + height + height + () + + + isNull + isNull + () + + + isQBitmap + isQBitmap + () + + + load + load + ( const QString & fileName, const char * format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor ) + + + loadFromData + loadFromData + ( const uchar * data, uint len, const char * format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor ) + + + loadFromData + loadFromData-3 + ( const QByteArray & data, const char * format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor ) + + + mask + mask + () + + + rect + rect + () + + + save + save + ( const QString & fileName, const char * format, int quality = -1 ) + + + save + save-2 + ( QIODevice * device, const char * format, int quality = -1 ) + + + scaled + scaled + ( const QSize & size, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio, Qt::TransformationMode transformMode = Qt::FastTransformation ) + + + scaled + scaled-2 + ( int width, int height, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio, Qt::TransformationMode transformMode = Qt::FastTransformation ) + + + scaledToHeight + scaledToHeight + ( int height, Qt::TransformationMode mode = Qt::FastTransformation ) + + + scaledToWidth + scaledToWidth + ( int width, Qt::TransformationMode mode = Qt::FastTransformation ) + + + serialNumber + serialNumber + () + + + setAlphaChannel + setAlphaChannel + ( const QPixmap & alphaChannel ) + + + setMask + setMask + ( const QBitmap & newmask ) + + + size + size + () + + + toImage + toImage + () + + + toWinHBITMAP + toWinHBITMAP + ( HBitmapFormat format = NoAlpha ) + + + transformed + transformed + ( const QMatrix & matrix, Qt::TransformationMode mode = Qt::FastTransformation ) + + + trueMatrix + trueMatrix + ( const QMatrix & matrix, int width, int height ) + + + width + width + () + + + x11Info + x11Info + () + + + HANDLE + x11PictureHandle + QPixmap::x11PictureHandle() + + + operator + operator-QVariant + QVariant() + + + operator! + operator-not + () + + + operator= + operator-eq + ( const QPixmap & pixmap ) + + + ColorMode + ColorMode-enum + + + + QPixmap + QPixmap-6 + ( const QString & fileName, const char * format, ColorMode mode ) + + + QPixmap + QPixmap-7 + ( const QImage & image ) + + + convertFromImage + convertFromImage + ( const QImage & image, ColorMode mode ) + + + convertFromImage + convertFromImage-2 + ( const QImage & image, Qt::ImageConversionFlags flags = Qt::AutoColor ) + + + convertToImage + convertToImage + () + + + load + load-2 + ( const QString & fileName, const char * format, ColorMode mode ) + + + loadFromData + loadFromData-2 + ( const uchar * buf, uint len, const char * format, ColorMode mode ) + + + resize + resize + ( int width, int height ) + + + resize + resize-2 + ( const QSize & size ) + + + selfMask + selfMask + () + + + xForm + xForm + ( const QMatrix & matrix ) + + + operator + operator-QImage + QImage() + + + operator= + operator-eq-2 + ( const QImage & image ) + + + + QPlastiqueStyle + qplastiquestyle.html + + QPlastiqueStyle + QPlastiqueStyle + () + + + + QPluginLoader + qpluginloader.html + + QPluginLoader + QPluginLoader + ( QObject * parent = 0 ) + + + QPluginLoader + QPluginLoader-2 + ( const QString & fileName, QObject * parent = 0 ) + + + instance + instance + () + + + isLoaded + isLoaded + () + + + load + load + () + + + staticInstances + staticInstances + () + + + unload + unload + () + + + + QPointer + qpointer.html + + QPointer + QPointer + () + + + QPointer + QPointer-2 + ( T * p ) + + + QPointer + QPointer-3 + ( const QPointer<T> & p ) + + + isNull + isNull + () + + + operator + operator-T--2a + T *() + + + operator* + operator-2a + () + + + operator-& + operator--gt + gt;() + + + operator= + operator-eq + ( const QPointer<T> & p ) + + + operator= + operator-eq-2 + ( T * p ) + + + + QPointF + qpointf.html + + QPointF + QPointF + () + + + QPointF + QPointF-2 + ( const QPoint & point ) + + + QPointF + QPointF-3 + ( qreal x, qreal y ) + + + isNull + isNull + () + + + rx + rx + () + + + ry + ry + () + + + setX + setX + ( qreal x ) + + + setY + setY + ( qreal y ) + + + toPoint + toPoint + () + + + x + x + () + + + y + y + () + + + operator*= + operator-2a-eq + ( qreal factor ) + + + operator+= + operator-2b-eq + ( const QPointF & point ) + + + operator-= + operator--eq + ( const QPointF & point ) + + + operator/= + operator-2f-eq + ( qreal divisor ) + + + + QPoint + qpoint.html + + QPoint + QPoint + () + + + QPoint + QPoint-2 + ( int x, int y ) + + + isNull + isNull + () + + + manhattanLength + manhattanLength + () + + + rx + rx + () + + + ry + ry + () + + + setX + setX + ( int x ) + + + setY + setY + ( int y ) + + + x + x + () + + + y + y + () + + + operator*= + operator-2a-eq + ( qreal factor ) + + + operator+= + operator-2b-eq + ( const QPoint & point ) + + + operator-= + operator--eq + ( const QPoint & point ) + + + operator/= + operator-2f-eq + ( qreal divisor ) + + + + QPolygonF + qpolygonf.html + + QPolygonF + QPolygonF + () + + + QPolygonF + QPolygonF-2 + ( int size ) + + + QPolygonF + QPolygonF-3 + ( const QPolygonF & polygon ) + + + QPolygonF + QPolygonF-4 + ( const QVector<QPointF> & points ) + + + QPolygonF + QPolygonF-5 + ( const QRectF & rectangle ) + + + QPolygonF + QPolygonF-6 + ( const QPolygon & polygon ) + + + boundingRect + boundingRect + () + + + isClosed + isClosed + () + + + toPolygon + toPolygon + () + + + translate + translate + ( const QPointF & offset ) + + + translate + translate-2 + ( qreal dx, qreal dy ) + + + + QPolygon + qpolygon.html + + QPolygon + QPolygon + () + + + QPolygon + QPolygon-2 + ( int size ) + + + QPolygon + QPolygon-3 + ( const QPolygon & polygon ) + + + QPolygon + QPolygon-4 + ( const QVector<QPoint> & points ) + + + QPolygon + QPolygon-5 + ( const QRect & rectangle, bool closed = false ) + + + boundingRect + boundingRect + () + + + point + point + ( int index, int * x, int * y ) + + + point + point-2 + ( int index ) + + + putPoints + putPoints + ( int index, int nPoints, int firstx, int firsty, ... ) + + + putPoints + putPoints-3 + ( int index, int nPoints, const QPolygon & fromPolygon, int fromIndex = 0 ) + + + setPoint + setPoint + ( int index, int x, int y ) + + + setPoint + setPoint-2 + ( int index, const QPoint & point ) + + + setPoints + setPoints + ( int nPoints, const int * points ) + + + setPoints + setPoints-2 + ( int nPoints, int firstx, int firsty, ... ) + + + translate + translate + ( int dx, int dy ) + + + translate + translate-2 + ( const QPoint & offset ) + + + operator + operator-QVariant + QVariant() + + + + QPrintDialog + qprintdialog.html + + QPrintDialog + QPrintDialog + ( QPrinter * printer, QWidget * parent = 0 ) + + + + QPrintEngine + qprintengine.html + + PrintEnginePropertyKey + PrintEnginePropertyKey-enum + + + + abort + abort + () + + + metric + metric + ( QPaintDevice::PaintDeviceMetric id ) + + + newPage + newPage + () + + + PrinterState + printerState + QPrintEngine::printerState() + + + property + property + ( PrintEnginePropertyKey key ) + + + setProperty + setProperty + ( PrintEnginePropertyKey key, const QVariant & value ) + + + + QPrinter + qprinter.html + + ColorMode + ColorMode-enum + + + + Orientation + Orientation-enum + + + + OutputFormat + OutputFormat-enum + + + + PageOrder + PageOrder-enum + + + + PageSize + PageSize-enum + + + + PaperSource + PaperSource-enum + + + + PrintRange + PrintRange-enum + + + + PrinterMode + PrinterMode-enum + + + + PrinterState + PrinterState-enum + + + + QPrinter + QPrinter + ( PrinterMode mode = ScreenResolution ) + + + abort + abort + () + + + collateCopies + collateCopies + () + + + colorMode + colorMode + () + + + creator + creator + () + + + docName + docName + () + + + fontEmbeddingEnabled + fontEmbeddingEnabled + () + + + fromPage + fromPage + () + + + fullPage + fullPage + () + + + newPage + newPage + () + + + numCopies + numCopies + () + + + orientation + orientation + () + + + outputFileName + outputFileName + () + + + outputFormat + outputFormat + () + + + pageOrder + pageOrder + () + + + pageRect + pageRect + () + + + pageSize + pageSize + () + + + paintEngine + paintEngine + () + + + paperRect + paperRect + () + + + paperSource + paperSource + () + + + printEngine + printEngine + () + + + printProgram + printProgram + () + + + printRange + printRange + () + + + printerName + printerName + () + + + printerSelectionOption + printerSelectionOption + () + + + printerState + printerState + () + + + resolution + resolution + () + + + setCollateCopies + setCollateCopies + ( bool collate ) + + + setColorMode + setColorMode + ( ColorMode newColorMode ) + + + setCreator + setCreator + ( const QString & creator ) + + + setDocName + setDocName + ( const QString & name ) + + + setEngines + setEngines + ( QPrintEngine * printEngine, QPaintEngine * paintEngine ) + + + setFontEmbeddingEnabled + setFontEmbeddingEnabled + ( bool enable ) + + + setFromTo + setFromTo + ( int from, int to ) + + + setFullPage + setFullPage + ( bool fp ) + + + setNumCopies + setNumCopies + ( int numCopies ) + + + setOrientation + setOrientation + ( Orientation orientation ) + + + setOutputFileName + setOutputFileName + ( const QString & fileName ) + + + setOutputFormat + setOutputFormat + ( OutputFormat format ) + + + setPageOrder + setPageOrder + ( PageOrder pageOrder ) + + + setPageSize + setPageSize + ( PageSize newPageSize ) + + + setPaperSource + setPaperSource + ( PaperSource source ) + + + setPrintProgram + setPrintProgram + ( const QString & printProg ) + + + setPrintRange + setPrintRange + ( PrintRange range ) + + + setPrinterName + setPrinterName + ( const QString & name ) + + + setPrinterSelectionOption + setPrinterSelectionOption + ( const QString & option ) + + + setResolution + setResolution + ( int dpi ) + + + setWinPageSize + setWinPageSize + ( int pageSize ) + + + supportedResolutions + supportedResolutions + () + + + toPage + toPage + () + + + winPageSize + winPageSize + () + + + PrinterOption + PrinterOption-enum + + + + aborted + aborted + () + + + collateCopiesEnabled + collateCopiesEnabled + () + + + isOptionEnabled + isOptionEnabled + ( PrinterOption option ) + + + margins + margins + ( uint * top, uint * left, uint * bottom, uint * right ) + + + margins + margins-2 + () + + + maxPage + maxPage + () + + + minPage + minPage + () + + + outputToFile + outputToFile + () + + + pageSetup + pageSetup + ( QWidget * parent = 0 ) + + + printSetup + printSetup + ( QWidget * parent = 0 ) + + + setCollateCopiesEnabled + setCollateCopiesEnabled + ( bool enable ) + + + setMinMax + setMinMax + ( int minPage, int maxPage ) + + + setOptionEnabled + setOptionEnabled + ( PrinterOption option, bool enable ) + + + setOutputToFile + setOutputToFile + ( bool enable ) + + + setup + setup + ( QWidget * parent = 0 ) + + + + QProcess + qprocess.html + + ExitStatus + ExitStatus-enum + + + + ProcessChannel + ProcessChannel-enum + + + + ProcessChannelMode + ProcessChannelMode-enum + + + + ProcessError + ProcessError-enum + + + + ProcessState + ProcessState-enum + + + + QProcess + QProcess + ( QObject * parent = 0 ) + + + close + close + () + + + closeReadChannel + closeReadChannel + ( ProcessChannel channel ) + + + closeWriteChannel + closeWriteChannel + () + + + environment + environment + () + + + ProcessError + error + QProcess::error() + + + error + error-2 + ( QProcess::ProcessError error ) + + + execute + execute + ( const QString & program, const QStringList & arguments ) + + + execute + execute-2 + ( const QString & program ) + + + exitCode + exitCode + () + + + ExitStatus + exitStatus + QProcess::exitStatus() + + + finished + finished + ( int exitCode, QProcess::ExitStatus exitStatus ) + + + kill + kill + () + + + pid + pid + () + + + readAllStandardError + readAllStandardError + () + + + readAllStandardOutput + readAllStandardOutput + () + + + readChannel + readChannel + () + + + readChannelMode + readChannelMode + () + + + readyReadStandardError + readyReadStandardError + () + + + readyReadStandardOutput + readyReadStandardOutput + () + + + setEnvironment + setEnvironment + ( const QStringList & environment ) + + + setProcessState + setProcessState + ( ProcessState state ) + + + setReadChannel + setReadChannel + ( ProcessChannel channel ) + + + setReadChannelMode + setReadChannelMode + ( ProcessChannelMode mode ) + + + setWorkingDirectory + setWorkingDirectory + ( const QString & dir ) + + + setupChildProcess + setupChildProcess + () + + + start + start + ( const QString & program, const QStringList & arguments, OpenMode mode = ReadWrite ) + + + start + start-2 + ( const QString & program, OpenMode mode = ReadWrite ) + + + startDetached + startDetached + ( const QString & program, const QStringList & arguments ) + + + startDetached + startDetached-2 + ( const QString & program ) + + + started + started + () + + + ProcessState + state + QProcess::state() + + + stateChanged + stateChanged + ( QProcess::ProcessState newState ) + + + systemEnvironment + systemEnvironment + () + + + terminate + terminate + () + + + waitForFinished + waitForFinished + ( int msecs = 30000 ) + + + waitForStarted + waitForStarted + ( int msecs = 30000 ) + + + workingDirectory + workingDirectory + () + + + finished + finished-2 + ( int exitCode ) + + + + QProgressBar + qprogressbar.html + + Direction + Direction-enum + + + + Alignment + alignment-prop + + + + Orientation + orientation-prop + + + + QProgressBar + QProgressBar + ( QWidget * parent = 0 ) + + + reset + reset + () + + + setRange + setRange + ( int minimum, int maximum ) + + + valueChanged + valueChanged + ( int value ) + + + + QProgressDialog + qprogressdialog.html + + QProgressDialog + QProgressDialog + ( QWidget * parent = 0, Qt::WFlags f = 0 ) + + + QProgressDialog + QProgressDialog-2 + ( const QString & labelText, const QString & cancelButtonText, int minimum, int maximum, QWidget * parent = 0, Qt::WFlags f = 0 ) + + + cancel + cancel + () + + + canceled + canceled + () + + + forceShow + forceShow + () + + + reset + reset + () + + + setBar + setBar + ( QProgressBar * bar ) + + + setCancelButton + setCancelButton + ( QPushButton * cancelButton ) + + + setCancelButtonText + setCancelButtonText + ( const QString & cancelButtonText ) + + + setLabel + setLabel + ( QLabel * label ) + + + setRange + setRange + ( int minimum, int maximum ) + + + sizeHint + sizeHint + () + + + + QProxyModel + qproxymodel.html + + QProxyModel + QProxyModel + ( QObject * parent = 0 ) + + + columnCount + columnCount + ( const QModelIndex & parent ) + + + data + data + ( const QModelIndex & index, int role ) + + + dropMimeData + dropMimeData + ( const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent ) + + + fetchMore + fetchMore + ( const QModelIndex & parent ) + + + ItemFlags + flags + QProxyModel::flags( const QModelIndex & index ) + + + hasChildren + hasChildren + ( const QModelIndex & parent ) + + + headerData + headerData + ( int section, Qt::Orientation orientation, int role ) + + + index + index + ( int row, int column, const QModelIndex & parent ) + + + insertColumns + insertColumns + ( int column, int count, const QModelIndex & parent ) + + + insertRows + insertRows + ( int row, int count, const QModelIndex & parent ) + + + match + match + ( const QModelIndex & start, int role, const QVariant & value, int hits, Qt::MatchFlags flags ) + + + mimeData + mimeData + ( const QModelIndexList & indexes ) + + + mimeTypes + mimeTypes + () + + + model + model + () + + + parent + parent + ( const QModelIndex & child ) + + + revert + revert + () + + + rowCount + rowCount + ( const QModelIndex & parent ) + + + setData + setData + ( const QModelIndex & index, const QVariant & value, int role ) + + + setHeaderData + setHeaderData + ( int section, Qt::Orientation orientation, const QVariant & value, int role ) + + + setModel + setModel + ( QAbstractItemModel * model ) + + + sort + sort + ( int column, Qt::SortOrder order ) + + + span + span + ( const QModelIndex & index ) + + + submit + submit + () + + + DropActions + supportedDropActions + QProxyModel::supportedDropActions() + + + + QPushButton + qpushbutton.html + + QPushButton + QPushButton + ( QWidget * parent = 0 ) + + + QPushButton + QPushButton-2 + ( const QString & text, QWidget * parent = 0 ) + + + QPushButton + QPushButton-3 + ( const QIcon & icon, const QString & text, QWidget * parent = 0 ) + + + menu + menu + () + + + setMenu + setMenu + ( QMenu * menu ) + + + showMenu + showMenu + () + + + QPushButton + QPushButton-4 + ( QWidget * parent, const char * name ) + + + QPushButton + QPushButton-5 + ( const QString & text, QWidget * parent, const char * name ) + + + QPushButton + QPushButton-6 + ( const QIcon & icon, const QString & text, QWidget * parent, const char * name ) + + + isMenuButton + isMenuButton + () + + + openPopup + openPopup + () + + + popup + popup + () + + + setPopup + setPopup + ( QMenu * popup ) + + + + QQueue + qqueue.html + + QQueue + QQueue + () + + + dequeue + dequeue + () + + + enqueue + enqueue + ( const T & t ) + + + head + head + () + + + head + head-2 + () + + + + QRadialGradient + qradialgradient.html + + QRadialGradient + QRadialGradient + ( const QPointF & center, qreal radius, const QPointF & focalPoint = QPointF() + + + QRadialGradient + QRadialGradient-2 + ( qreal cx, qreal cy, qreal radius, qreal fx = 0, qreal fy = 0 ) + + + center + center + () + + + focalPoint + focalPoint + () + + + radius + radius + () + + + + QRadioButton + qradiobutton.html + + QRadioButton + QRadioButton + ( QWidget * parent = 0 ) + + + QRadioButton + QRadioButton-2 + ( const QString & text, QWidget * parent = 0 ) + + + QRadioButton + QRadioButton-3 + ( QWidget * parent, const char * name ) + + + QRadioButton + QRadioButton-4 + ( const QString & text, QWidget * parent, const char * name ) + + + + QReadLocker + qreadlocker.html + + QReadLocker + QReadLocker + ( QReadWriteLock * lock ) + + + readWriteLock + readWriteLock + () + + + relock + relock + () + + + unlock + unlock + () + + + + QReadWriteLock + qreadwritelock.html + + QReadWriteLock + QReadWriteLock + () + + + lockForRead + lockForRead + () + + + lockForWrite + lockForWrite + () + + + tryLockForRead + tryLockForRead + () + + + tryLockForWrite + tryLockForWrite + () + + + unlock + unlock + () + + + + QRectF + qrectf.html + + QRectF + QRectF + () + + + QRectF + QRectF-2 + ( const QPointF & topLeft, const QSizeF & size ) + + + QRectF + QRectF-3 + ( qreal x, qreal y, qreal width, qreal height ) + + + QRectF + QRectF-4 + ( const QRect & rectangle ) + + + adjust + adjust + ( qreal dx1, qreal dy1, qreal dx2, qreal dy2 ) + + + adjusted + adjusted + ( qreal dx1, qreal dy1, qreal dx2, qreal dy2 ) + + + bottom + bottom + () + + + bottomLeft + bottomLeft + () + + + bottomRight + bottomRight + () + + + center + center + () + + + contains + contains + ( const QPointF & point ) + + + contains + contains-2 + ( qreal x, qreal y ) + + + contains + contains-3 + ( const QRectF & rectangle ) + + + getCoords + getCoords + ( qreal * x1, qreal * y1, qreal * x2, qreal * y2 ) + + + getRect + getRect + ( qreal * x, qreal * y, qreal * width, qreal * height ) + + + height + height + () + + + intersect + intersect + ( const QRectF & rectangle ) + + + intersects + intersects + ( const QRectF & rectangle ) + + + isEmpty + isEmpty + () + + + isNull + isNull + () + + + isValid + isValid + () + + + left + left + () + + + moveBottom + moveBottom + ( qreal y ) + + + moveBottomLeft + moveBottomLeft + ( const QPointF & position ) + + + moveBottomRight + moveBottomRight + ( const QPointF & position ) + + + moveCenter + moveCenter + ( const QPointF & position ) + + + moveLeft + moveLeft + ( qreal x ) + + + moveRight + moveRight + ( qreal x ) + + + moveTo + moveTo + ( qreal x, qreal y ) + + + moveTo + moveTo-2 + ( const QPointF & position ) + + + moveTop + moveTop + ( qreal y ) + + + moveTopLeft + moveTopLeft + ( const QPointF & position ) + + + moveTopRight + moveTopRight + ( const QPointF & position ) + + + normalized + normalized + () + + + right + right + () + + + setBottom + setBottom + ( qreal y ) + + + setBottomLeft + setBottomLeft + ( const QPointF & position ) + + + setBottomRight + setBottomRight + ( const QPointF & position ) + + + setCoords + setCoords + ( qreal x1, qreal y1, qreal x2, qreal y2 ) + + + setHeight + setHeight + ( qreal height ) + + + setLeft + setLeft + ( qreal x ) + + + setRect + setRect + ( qreal x, qreal y, qreal width, qreal height ) + + + setRight + setRight + ( qreal x ) + + + setSize + setSize + ( const QSizeF & size ) + + + setTop + setTop + ( qreal y ) + + + setTopLeft + setTopLeft + ( const QPointF & position ) + + + setTopRight + setTopRight + ( const QPointF & position ) + + + setWidth + setWidth + ( qreal width ) + + + setX + setX + ( qreal x ) + + + setY + setY + ( qreal y ) + + + size + size + () + + + toRect + toRect + () + + + top + top + () + + + topLeft + topLeft + () + + + topRight + topRight + () + + + translate + translate + ( qreal dx, qreal dy ) + + + translate + translate-2 + ( const QPointF & offset ) + + + translated + translated + ( qreal dx, qreal dy ) + + + translated + translated-2 + ( const QPointF & offset ) + + + unite + unite + ( const QRectF & rectangle ) + + + width + width + () + + + x + x + () + + + y + y + () + + + operator& + operator-and + amp;( const QRectF & rectangle ) + + + operator& + operator-and-eq + amp;=( const QRectF & rectangle ) + + + operator| + operator-7c + ( const QRectF & rectangle ) + + + operator|= + operator-7c-eq + ( const QRectF & rectangle ) + + + + QRect + qrect.html + + QRect + QRect + () + + + QRect + QRect-2 + ( const QPoint & topLeft, const QPoint & bottomRight ) + + + QRect + QRect-3 + ( const QPoint & topLeft, const QSize & size ) + + + QRect + QRect-4 + ( int x, int y, int width, int height ) + + + adjust + adjust + ( int dx1, int dy1, int dx2, int dy2 ) + + + adjusted + adjusted + ( int dx1, int dy1, int dx2, int dy2 ) + + + bottom + bottom + () + + + bottomLeft + bottomLeft + () + + + bottomRight + bottomRight + () + + + center + center + () + + + contains + contains + ( const QPoint & point, bool proper = false ) + + + contains + contains-2 + ( int x, int y, bool proper ) + + + contains + contains-3 + ( int x, int y ) + + + contains + contains-4 + ( const QRect & rectangle, bool proper = false ) + + + getCoords + getCoords + ( int * x1, int * y1, int * x2, int * y2 ) + + + getRect + getRect + ( int * x, int * y, int * width, int * height ) + + + height + height + () + + + intersect + intersect + ( const QRect & rectangle ) + + + intersects + intersects + ( const QRect & rectangle ) + + + isEmpty + isEmpty + () + + + isNull + isNull + () + + + isValid + isValid + () + + + left + left + () + + + moveBottom + moveBottom + ( int y ) + + + moveBottomLeft + moveBottomLeft + ( const QPoint & position ) + + + moveBottomRight + moveBottomRight + ( const QPoint & position ) + + + moveCenter + moveCenter + ( const QPoint & position ) + + + moveLeft + moveLeft + ( int x ) + + + moveRight + moveRight + ( int x ) + + + moveTo + moveTo + ( int x, int y ) + + + moveTo + moveTo-2 + ( const QPoint & position ) + + + moveTop + moveTop + ( int y ) + + + moveTopLeft + moveTopLeft + ( const QPoint & position ) + + + moveTopRight + moveTopRight + ( const QPoint & position ) + + + normalized + normalized + () + + + right + right + () + + + setBottom + setBottom + ( int y ) + + + setBottomLeft + setBottomLeft + ( const QPoint & position ) + + + setBottomRight + setBottomRight + ( const QPoint & position ) + + + setCoords + setCoords + ( int x1, int y1, int x2, int y2 ) + + + setHeight + setHeight + ( int height ) + + + setLeft + setLeft + ( int x ) + + + setRect + setRect + ( int x, int y, int width, int height ) + + + setRight + setRight + ( int x ) + + + setSize + setSize + ( const QSize & size ) + + + setTop + setTop + ( int y ) + + + setTopLeft + setTopLeft + ( const QPoint & position ) + + + setTopRight + setTopRight + ( const QPoint & position ) + + + setWidth + setWidth + ( int width ) + + + setX + setX + ( int x ) + + + setY + setY + ( int y ) + + + size + size + () + + + top + top + () + + + topLeft + topLeft + () + + + topRight + topRight + () + + + translate + translate + ( int dx, int dy ) + + + translate + translate-2 + ( const QPoint & offset ) + + + translated + translated + ( int dx, int dy ) + + + translated + translated-2 + ( const QPoint & offset ) + + + unite + unite + ( const QRect & rectangle ) + + + width + width + () + + + x + x + () + + + y + y + () + + + operator& + operator-and + amp;( const QRect & rectangle ) + + + operator& + operator-and-eq + amp;=( const QRect & rectangle ) + + + operator| + operator-7c + ( const QRect & rectangle ) + + + operator|= + operator-7c-eq + ( const QRect & rectangle ) + + + addCoords + addCoords + ( int dx1, int dy1, int dx2, int dy2 ) + + + coords + coords + ( int * x1, int * y1, int * x2, int * y2 ) + + + moveBy + moveBy + ( int dx, int dy ) + + + moveBy + moveBy-2 + ( const QPoint & p ) + + + normalize + normalize + () + + + rBottom + rBottom + () + + + rLeft + rLeft + () + + + rRight + rRight + () + + + rTop + rTop + () + + + rect + rect + ( int * x, int * y, int * width, int * height ) + + + + QRegExp + qregexp.html + + CaretMode + CaretMode-enum + + + + PatternSyntax + PatternSyntax-enum + + + + QRegExp + QRegExp + () + + + QRegExp + QRegExp-2 + ( const QString & pattern, Qt::CaseSensitivity cs = Qt::CaseSensitive, PatternSyntax syntax = RegExp ) + + + QRegExp + QRegExp-3 + ( const QRegExp & rx ) + + + cap + cap + ( int nth = 0 ) + + + capturedTexts + capturedTexts + () + + + CaseSensitivity + caseSensitivity + QRegExp::caseSensitivity() + + + errorString + errorString + () + + + escape + escape + ( const QString & str ) + + + exactMatch + exactMatch + ( const QString & str ) + + + indexIn + indexIn + ( const QString & str, int offset = 0, CaretMode caretMode = CaretAtZero ) + + + isEmpty + isEmpty + () + + + isMinimal + isMinimal + () + + + isValid + isValid + () + + + lastIndexIn + lastIndexIn + ( const QString & str, int offset = -1, CaretMode caretMode = CaretAtZero ) + + + matchedLength + matchedLength + () + + + numCaptures + numCaptures + () + + + pattern + pattern + () + + + patternSyntax + patternSyntax + () + + + pos + pos + ( int nth = 0 ) + + + setCaseSensitivity + setCaseSensitivity + ( Qt::CaseSensitivity cs ) + + + setMinimal + setMinimal + ( bool minimal ) + + + setPattern + setPattern + ( const QString & pattern ) + + + setPatternSyntax + setPatternSyntax + ( PatternSyntax syntax ) + + + operator!= + operator-not-eq + ( const QRegExp & rx ) + + + operator= + operator-eq + ( const QRegExp & rx ) + + + operator== + operator-eq-eq + ( const QRegExp & rx ) + + + QRegExp + QRegExp-4 + ( const QString & pattern, bool cs, bool wildcard = false ) + + + caseSensitive + caseSensitive + () + + + minimal + minimal + () + + + search + search + ( const QString & str, int from = 0, CaretMode caretMode = CaretAtZero ) + + + searchRev + searchRev + ( const QString & str, int from = -1, CaretMode caretMode = CaretAtZero ) + + + setCaseSensitive + setCaseSensitive + ( bool sensitive ) + + + setWildcard + setWildcard + ( bool wildcard ) + + + wildcard + wildcard + () + + + + QRegExpValidator + qregexpvalidator.html + + QRegExpValidator + QRegExpValidator + ( QObject * parent ) + + + QRegExpValidator + QRegExpValidator-2 + ( const QRegExp & rx, QObject * parent ) + + + State + validate + QRegExpValidator::validate( QString & input, int & pos ) + + + QRegExpValidator + QRegExpValidator-3 + ( QObject * parent, const char * name ) + + + QRegExpValidator + QRegExpValidator-4 + ( const QRegExp & rx, QObject * parent, const char * name ) + + + + QRegion + qregion.html + + RegionType + RegionType-enum + + + + QRegion + QRegion + () + + + QRegion + QRegion-2 + ( int x, int y, int w, int h, RegionType t = Rectangle ) + + + QRegion + QRegion-3 + ( const QPolygon & a, Qt::FillRule fillRule = Qt::OddEvenFill ) + + + QRegion + QRegion-5 + ( const QRegion & r ) + + + QRegion + QRegion-6 + ( const QBitmap & bm ) + + + QRegion + QRegion-7 + ( const QRect & r, RegionType t = Rectangle ) + + + boundingRect + boundingRect + () + + + contains + contains + ( const QPoint & p ) + + + contains + contains-2 + ( const QRect & r ) + + + eor + eor + ( const QRegion & r ) + + + handle + handle + () + + + handle + handle-2 + () + + + handle + handle-3 + () + + + intersect + intersect + ( const QRegion & r ) + + + isEmpty + isEmpty + () + + + rects + rects + () + + + subtract + subtract + ( const QRegion & r ) + + + translate + translate + ( int dx, int dy ) + + + translate + translate-2 + ( const QPoint & point ) + + + translated + translated + ( int dx, int dy ) + + + translated + translated-2 + ( const QPoint & p ) + + + unite + unite + ( const QRegion & r ) + + + operator + operator-QVariant + QVariant() + + + operator!= + operator-not-eq + ( const QRegion & other ) + + + operator& + operator-and + amp;( const QRegion & r ) + + + operator& + operator-and-eq + amp;=( const QRegion & r ) + + + operator+ + operator-2b + ( const QRegion & r ) + + + operator+= + operator-2b-eq + ( const QRegion & r ) + + + operator- + operator- + ( const QRegion & r ) + + + operator-= + operator--eq + ( const QRegion & r ) + + + operator= + operator-eq + ( const QRegion & r ) + + + operator== + operator-eq-eq + ( const QRegion & r ) + + + operator^ + operator-5e + ( const QRegion & r ) + + + operator^= + operator-5e-eq + ( const QRegion & r ) + + + operator| + operator-7c + ( const QRegion & r ) + + + operator|= + operator-7c-eq + ( const QRegion & r ) + + + QRegion + QRegion-4 + ( const QPolygon & pa, bool winding ) + + + isNull + isNull + () + + + + QResizeEvent + qresizeevent.html + + QResizeEvent + QResizeEvent + ( const QSize & size, const QSize & oldSize ) + + + oldSize + oldSize + () + + + size + size + () + + + + QRubberBand + qrubberband.html + + Shape + Shape-enum + + + + QRubberBand + QRubberBand + ( Shape s, QWidget * p = 0 ) + + + move + move + ( int x, int y ) + + + move + move-2 + ( const QPoint & p ) + + + resize + resize + ( int width, int height ) + + + resize + resize-2 + ( const QSize & size ) + + + setGeometry + setGeometry + ( const QRect & rect ) + + + setGeometry + setGeometry-2 + ( int x, int y, int width, int height ) + + + shape + shape + () + + + + QScreenCursor + qscreencursor.html + + + QScreenDriverFactory + qscreendriverfactory.html + + create + create + ( const QString & key, int displayId ) + + + keys + keys + () + + + + QScreenDriverPlugin + qscreendriverplugin.html + + QScreenDriverPlugin + QScreenDriverPlugin + ( QObject * parent = 0 ) + + + create + create + ( const QString & key, int displayId ) + + + keys + keys + () + + + + QScreen + qscreen.html + + PixelType + PixelType-enum + + + + QScreen + QScreen + ( int displayId ) + + + alloc + alloc + ( unsigned int red, unsigned int green, unsigned int blue ) + + + base + base + () + + + blank + blank + ( bool on ) + + + blit + blit + ( const QImage & image, const QPoint & topLeft, const QRegion & region ) + + + clut + clut + () + + + connect + connect + ( const QString & displaySpec ) + + + depth + depth + () + + + deviceHeight + deviceHeight + () + + + deviceWidth + deviceWidth + () + + + disconnect + disconnect + () + + + exposeRegion + exposeRegion + ( QRegion region, int windowIndex ) + + + height + height + () + + + initDevice + initDevice + () + + + isInterlaced + isInterlaced + () + + + isTransformed + isTransformed + () + + + lastOp + lastOp + () + + + linestep + linestep + () + + + mapFromDevice + mapFromDevice + ( const QSize & size ) + + + mapFromDevice + mapFromDevice-2 + ( const QPoint & point, const QSize & screenSize ) + + + mapFromDevice + mapFromDevice-3 + ( const QRect & rectangle, const QSize & screenSize ) + + + mapFromDevice + mapFromDevice-4 + ( const QImage & image ) + + + mapFromDevice + mapFromDevice-5 + ( const QRegion & region, const QSize & screenSize ) + + + mapToDevice + mapToDevice + ( const QSize & size ) + + + mapToDevice + mapToDevice-2 + ( const QPoint & point, const QSize & screenSize ) + + + mapToDevice + mapToDevice-3 + ( const QRect & rectangle, const QSize & screenSize ) + + + mapToDevice + mapToDevice-4 + ( const QImage & image ) + + + mapToDevice + mapToDevice-5 + ( const QRegion & region, const QSize & screenSize ) + + + numCols + numCols + () + + + onCard + onCard + ( const unsigned char * buffer ) + + + onCard + onCard-2 + ( const unsigned char * buffer, ulong & offset ) + + + opType + opType + () + + + pixelType + pixelType + () + + + pixmapDepth + pixmapDepth + () + + + pixmapLinestepAlignment + pixmapLinestepAlignment + () + + + pixmapOffsetAlignment + pixmapOffsetAlignment + () + + + restore + restore + () + + + save + save + () + + + screenSize + screenSize + () + + + setDirty + setDirty + ( const QRect & rectangle ) + + + setMode + setMode + ( int width, int height, int depth ) + + + shutdownDevice + shutdownDevice + () + + + solidFill + solidFill + ( const QColor & color, const QRegion & region ) + + + supportsDepth + supportsDepth + ( int depth ) + + + totalSize + totalSize + () + + + transformOrientation + transformOrientation + () + + + width + width + () + + + + QScrollArea + qscrollarea.html + + QScrollArea + QScrollArea + ( QWidget * parent = 0 ) + + + ensureVisible + ensureVisible + ( int x, int y, int xmargin = 50, int ymargin = 50 ) + + + setWidget + setWidget + ( QWidget * widget ) + + + takeWidget + takeWidget + () + + + widget + widget + () + + + + QScrollBar + qscrollbar.html + + QScrollBar + QScrollBar + ( QWidget * parent = 0 ) + + + QScrollBar + QScrollBar-2 + ( Qt::Orientation orientation, QWidget * parent = 0 ) + + + QScrollBar + QScrollBar-3 + ( QWidget * parent, const char * name ) + + + QScrollBar + QScrollBar-4 + ( Qt::Orientation orientation, QWidget * parent, const char * name ) + + + QScrollBar + QScrollBar-5 + ( int minimum, int maximum, int lineStep, int pageStep, int value, Qt::Orientation orientation, QWidget * parent = 0, const char * name = 0 ) + + + draggingSlider + draggingSlider + () + + + + QSemaphore + qsemaphore.html + + QSemaphore + QSemaphore + ( int n = 0 ) + + + acquire + acquire + ( int n = 1 ) + + + available + available + () + + + release + release + ( int n = 1 ) + + + tryAcquire + tryAcquire + ( int n = 1 ) + + + + QSessionManager + qsessionmanager.html + + RestartHint + RestartHint-enum + + + + allowsErrorInteraction + allowsErrorInteraction + () + + + allowsInteraction + allowsInteraction + () + + + cancel + cancel + () + + + discardCommand + discardCommand + () + + + isPhase2 + isPhase2 + () + + + release + release + () + + + requestPhase2 + requestPhase2 + () + + + restartCommand + restartCommand + () + + + restartHint + restartHint + () + + + sessionId + sessionId + () + + + sessionKey + sessionKey + () + + + setDiscardCommand + setDiscardCommand + ( const QStringList & list ) + + + setManagerProperty + setManagerProperty + ( const QString & name, const QStringList & value ) + + + setManagerProperty + setManagerProperty-2 + ( const QString & name, const QString & value ) + + + setRestartCommand + setRestartCommand + ( const QStringList & command ) + + + setRestartHint + setRestartHint + ( RestartHint hint ) + + + + QSet::const_iterator + qset-const-iterator.html + + const_iterator + const_iterator + () + + + const_iterator + const_iterator-3 + ( const const_iterator & other ) + + + operator!= + operator-not-eq + ( const const_iterator & other ) + + + operator* + operator-2a + () + + + operator+ + operator-2b + ( int j ) + + + operator++ + operator-2b-2b + () + + + operator++ + operator-2b-2b-2 + ( int ) + + + operator+= + operator-2b-eq + ( int j ) + + + operator- + operator- + ( int j ) + + + operator-- + operator-- + () + + + operator-- + operator---2 + ( int ) + + + operator-= + operator--eq + ( int j ) + + + operator-& + operator--gt + gt;() + + + operator= + operator-eq + ( const const_iterator & other ) + + + operator== + operator-eq-eq + ( const const_iterator & other ) + + + + QSet + qset.html + + ConstIterator + ConstIterator-typedef + + + + QSet + QSet + () + + + QSet + QSet-2 + ( const QSet<T> & other ) + + + begin + begin + () + + + capacity + capacity + () + + + clear + clear + () + + + constBegin + constBegin + () + + + constEnd + constEnd + () + + + contains + contains + ( const T & value ) + + + count + count + () + + + empty + empty + () + + + end + end + () + + + fromList + fromList + ( const QList<T> & list ) + + + insert + insert + ( const T & value ) + + + intersect + intersect + ( const QSet<T> & other ) + + + isEmpty + isEmpty + () + + + remove + remove + ( const T & value ) + + + reserve + reserve + ( int size ) + + + size + size + () + + + squeeze + squeeze + () + + + subtract + subtract + ( const QSet<T> & other ) + + + toList + toList + () + + + unite + unite + ( const QSet<T> & other ) + + + values + values + () + + + operator!= + operator-not-eq + ( const QSet<T> & other ) + + + operator& + operator-and + amp;( const QSet<T> & other ) + + + operator& + operator-and-eq + amp;=( const QSet<T> & other ) + + + operator& + operator-and-eq-2 + amp;=( const T & value ) + + + operator+ + operator-2b + ( const QSet<T> & other ) + + + operator+= + operator-2b-eq + ( const QSet<T> & other ) + + + operator+= + operator-2b-eq-2 + ( const T & value ) + + + operator- + operator- + ( const QSet<T> & other ) + + + operator-= + operator--eq + ( const QSet<T> & other ) + + + operator-= + operator--eq-2 + ( const T & value ) + + + operator<< + operator-lt-lt + ( const T & value ) + + + operator= + operator-eq + ( const QSet<T> & other ) + + + operator== + operator-eq-eq + ( const QSet<T> & other ) + + + operator| + operator-7c + ( const QSet<T> & other ) + + + operator|= + operator-7c-eq + ( const QSet<T> & other ) + + + operator|= + operator-7c-eq-2 + ( const T & value ) + + + + QSetIterator + qsetiterator.html + + QSetIterator + QSetIterator + ( const QSet<T> & set ) + + + findNext + findNext + ( const T & value ) + + + findPrevious + findPrevious + ( const T & value ) + + + hasNext + hasNext + () + + + hasPrevious + hasPrevious + () + + + next + next + () + + + peekNext + peekNext + () + + + peekPrevious + peekPrevious + () + + + previous + previous + () + + + toBack + toBack + () + + + toFront + toFront + () + + + operator= + operator-eq + ( const QSet<T> & set ) + + + + QSettings + qsettings.html + + Format + Format-enum + + + + ReadFunc + ReadFunc-typedef + + + + Scope + Scope-enum + + + + SettingsMap + SettingsMap-typedef + + + + Status + Status-enum + + + + WriteFunc + WriteFunc-typedef + + + + QSettings + QSettings + ( const QString & organization, const QString & application = QString() + + + QSettings + QSettings-2 + ( Scope scope, const QString & organization, const QString & application = QString() + + + QSettings + QSettings-3 + ( Format format, Scope scope, const QString & organization, const QString & application = QString() + + + QSettings + QSettings-4 + ( const QString & fileName, Format format, QObject * parent = 0 ) + + + QSettings + QSettings-5 + ( QObject * parent = 0 ) + + + allKeys + allKeys + () + + + beginGroup + beginGroup + ( const QString & prefix ) + + + beginReadArray + beginReadArray + ( const QString & prefix ) + + + beginWriteArray + beginWriteArray + ( const QString & prefix, int size = -1 ) + + + childGroups + childGroups + () + + + childKeys + childKeys + () + + + clear + clear + () + + + contains + contains + ( const QString & key ) + + + endArray + endArray + () + + + endGroup + endGroup + () + + + fallbacksEnabled + fallbacksEnabled + () + + + fileName + fileName + () + + + group + group + () + + + isWritable + isWritable + () + + + registerFormat + registerFormat + ( const QString & extension, ReadFunc readFunc, WriteFunc writeFunc, Qt::CaseSensitivity caseSensitivity = Qt::CaseSensitive ) + + + remove + remove + ( const QString & key ) + + + setArrayIndex + setArrayIndex + ( int i ) + + + setFallbacksEnabled + setFallbacksEnabled + ( bool b ) + + + setPath + setPath + ( Format format, Scope scope, const QString & path ) + + + setValue + setValue + ( const QString & key, const QVariant & value ) + + + status + status + () + + + sync + sync + () + + + value + value + ( const QString & key, const QVariant & defaultValue = QVariant() + + + setSystemIniPath + setSystemIniPath + ( const QString & dir ) + + + setUserIniPath + setUserIniPath + ( const QString & dir ) + + + System + System-enum + + + + entryList + entryList + ( const QString & key ) + + + insertSearchPath + insertSearchPath + ( System system, const QString & path ) + + + readBoolEntry + readBoolEntry + ( const QString & key, bool defaultValue = false, bool * ok = 0 ) + + + readDoubleEntry + readDoubleEntry + ( const QString & key, double defaultValue = 0, bool * ok = 0 ) + + + readEntry + readEntry + ( const QString & key, const QString & defaultValue = QString() + + + readListEntry + readListEntry + ( const QString & key, bool * ok = 0 ) + + + readListEntry + readListEntry-2 + ( const QString & key, QChar separator, bool * ok = 0 ) + + + readNumEntry + readNumEntry + ( const QString & key, int defaultValue = 0, bool * ok = 0 ) + + + removeEntry + removeEntry + ( const QString & key ) + + + removeSearchPath + removeSearchPath + ( System system, const QString & path ) + + + resetGroup + resetGroup + () + + + setPath + setPath-2 + ( const QString & organization, const QString & application, Scope scope = Global ) + + + subkeyList + subkeyList + ( const QString & key ) + + + writeEntry + writeEntry + ( const QString & key, bool value ) + + + writeEntry + writeEntry-2 + ( const QString & key, double value ) + + + writeEntry + writeEntry-3 + ( const QString & key, int value ) + + + writeEntry + writeEntry-4 + ( const QString & key, const char * value ) + + + writeEntry + writeEntry-5 + ( const QString & key, const QString & value ) + + + writeEntry + writeEntry-6 + ( const QString & key, const QStringList & value ) + + + writeEntry + writeEntry-7 + ( const QString & key, const QStringList & value, QChar separator ) + + + + QSharedData + qshareddata.html + + QSharedData + QSharedData + () + + + QSharedData + QSharedData-2 + ( const QSharedData & other ) + + + + QSharedDataPointer + qshareddatapointer.html + + QSharedDataPointer + QSharedDataPointer + () + + + QSharedDataPointer + QSharedDataPointer-2 + ( T * sharedData ) + + + QSharedDataPointer + QSharedDataPointer-3 + ( const QSharedDataPointer<T> & other ) + + + constData + constData + () + + + data + data + () + + + data + data-2 + () + + + detach + detach + () + + + operator + operator-T--2a + T *() + + + operator + operator-const-T--2a + const T *() + + + operator! + operator-not + () + + + operator!= + operator-not-eq + ( const QSharedDataPointer<T> & other ) + + + operator* + operator-2a + () + + + operator* + operator-2a-2 + () + + + operator-& + operator--gt + gt;() + + + operator-& + operator--gt-2 + gt;() + + + operator= + operator-eq + ( const QSharedDataPointer<T> & other ) + + + operator= + operator-eq-2 + ( T * sharedData ) + + + operator== + operator-eq-eq + ( const QSharedDataPointer<T> & other ) + + + + QShortcutEvent + qshortcutevent.html + + QShortcutEvent + QShortcutEvent + ( const QKeySequence & key, int id, bool ambiguous = false ) + + + isAmbiguous + isAmbiguous + () + + + key + key + () + + + shortcutId + shortcutId + () + + + + QShortcut + qshortcut.html + + ShortcutContext + context-prop + + + + QShortcut + QShortcut + ( QWidget * parent ) + + + QShortcut + QShortcut-2 + ( const QKeySequence & key, QWidget * parent, const char * member = 0, const char * ambiguousMember = 0, Qt::ShortcutContext context = Qt::WindowShortcut ) + + + activated + activated + () + + + activatedAmbiguously + activatedAmbiguously + () + + + id + id + () + + + parentWidget + parentWidget + () + + + + QShowEvent + qshowevent.html + + QShowEvent + QShowEvent + () + + + + QSignalMapper + qsignalmapper.html + + QSignalMapper + QSignalMapper + ( QObject * parent = 0 ) + + + map + map + () + + + map + map-2 + ( QObject * sender ) + + + mapped + mapped + ( int i ) + + + mapped + mapped-2 + ( const QString & text ) + + + mapped + mapped-3 + ( QWidget * widget ) + + + mapped + mapped-4 + ( QObject * object ) + + + mapping + mapping + ( int id ) + + + mapping + mapping-2 + ( const QString & id ) + + + mapping + mapping-3 + ( QWidget * widget ) + + + mapping + mapping-4 + ( QObject * object ) + + + removeMappings + removeMappings + ( QObject * sender ) + + + setMapping + setMapping + ( QObject * sender, int id ) + + + setMapping + setMapping-2 + ( QObject * sender, const QString & text ) + + + setMapping + setMapping-3 + ( QObject * sender, QWidget * widget ) + + + setMapping + setMapping-4 + ( QObject * sender, QObject * object ) + + + QSignalMapper + QSignalMapper-2 + ( QObject * parent, const char * name ) + + + + QSignalSpy + qsignalspy.html + + QSignalSpy + QSignalSpy + ( QObject * object, const char * signal ) + + + isValid + isValid + () + + + signal + signal + () + + + + QSizeF + qsizef.html + + QSizeF + QSizeF + () + + + QSizeF + QSizeF-2 + ( const QSize & size ) + + + QSizeF + QSizeF-3 + ( qreal width, qreal height ) + + + boundedTo + boundedTo + ( const QSizeF & otherSize ) + + + expandedTo + expandedTo + ( const QSizeF & otherSize ) + + + height + height + () + + + isEmpty + isEmpty + () + + + isNull + isNull + () + + + isValid + isValid + () + + + rheight + rheight + () + + + rwidth + rwidth + () + + + scale + scale + ( qreal width, qreal height, Qt::AspectRatioMode mode ) + + + scale + scale-2 + ( const QSizeF & size, Qt::AspectRatioMode mode ) + + + setHeight + setHeight + ( qreal height ) + + + setWidth + setWidth + ( qreal width ) + + + toSize + toSize + () + + + transpose + transpose + () + + + width + width + () + + + operator*= + operator-2a-eq + ( qreal factor ) + + + operator+= + operator-2b-eq + ( const QSizeF & size ) + + + operator-= + operator--eq + ( const QSizeF & size ) + + + operator/= + operator-2f-eq + ( qreal divisor ) + + + + QSizeGrip + qsizegrip.html + + QSizeGrip + QSizeGrip + ( QWidget * parent ) + + + mouseMoveEvent + mouseMoveEvent + ( QMouseEvent * event ) + + + mousePressEvent + mousePressEvent + ( QMouseEvent * event ) + + + paintEvent + paintEvent + ( QPaintEvent * event ) + + + QSizeGrip + QSizeGrip-2 + ( QWidget * parent, const char * name ) + + + + QSize + qsize.html + + QSize + QSize + () + + + QSize + QSize-2 + ( int width, int height ) + + + boundedTo + boundedTo + ( const QSize & otherSize ) + + + expandedTo + expandedTo + ( const QSize & otherSize ) + + + height + height + () + + + isEmpty + isEmpty + () + + + isNull + isNull + () + + + isValid + isValid + () + + + rheight + rheight + () + + + rwidth + rwidth + () + + + scale + scale + ( int width, int height, Qt::AspectRatioMode mode ) + + + scale + scale-2 + ( const QSize & size, Qt::AspectRatioMode mode ) + + + setHeight + setHeight + ( int height ) + + + setWidth + setWidth + ( int width ) + + + transpose + transpose + () + + + width + width + () + + + operator*= + operator-2a-eq + ( qreal factor ) + + + operator+= + operator-2b-eq + ( const QSize & size ) + + + operator-= + operator--eq + ( const QSize & size ) + + + operator/= + operator-2f-eq + ( qreal divisor ) + + + + QSizePolicy + qsizepolicy.html + + Policy + Policy-enum + + + + PolicyFlag + PolicyFlag-enum + + + + QSizePolicy + QSizePolicy + () + + + QSizePolicy + QSizePolicy-2 + ( Policy horizontal, Policy vertical ) + + + Orientations + expandingDirections + QSizePolicy::expandingDirections() + + + hasHeightForWidth + hasHeightForWidth + () + + + horizontalPolicy + horizontalPolicy + () + + + horizontalStretch + horizontalStretch + () + + + setHeightForWidth + setHeightForWidth + ( bool dependent ) + + + setHorizontalPolicy + setHorizontalPolicy + ( Policy policy ) + + + setHorizontalStretch + setHorizontalStretch + ( uchar stretchFactor ) + + + setVerticalPolicy + setVerticalPolicy + ( Policy policy ) + + + setVerticalStretch + setVerticalStretch + ( uchar stretchFactor ) + + + transpose + transpose + () + + + verticalPolicy + verticalPolicy + () + + + verticalStretch + verticalStretch + () + + + operator + operator-QVariant + QVariant() + + + operator!= + operator-not-eq + ( const QSizePolicy & other ) + + + operator== + operator-eq-eq + ( const QSizePolicy & other ) + + + ExpandData + ExpandData-enum + + + + SizeType + SizeType-typedef + + + + QSizePolicy + QSizePolicy-3 + ( Policy horizontal, Policy vertical, bool dependent ) + + + QSizePolicy + QSizePolicy-4 + ( Policy horizontal, Policy vertical, uchar horizontalStretch, uchar verticalStretch, bool dependent = false ) + + + Orientations + expanding + QSizePolicy::expanding() + + + horData + horData + () + + + horStretch + horStretch + () + + + mayGrowHorizontally + mayGrowHorizontally + () + + + mayGrowVertically + mayGrowVertically + () + + + mayShrinkHorizontally + mayShrinkHorizontally + () + + + mayShrinkVertically + mayShrinkVertically + () + + + setHorData + setHorData + ( Policy policy ) + + + setHorStretch + setHorStretch + ( uchar stretch ) + + + setVerData + setVerData + ( Policy policy ) + + + setVerStretch + setVerStretch + ( uchar stretch ) + + + verData + verData + () + + + verStretch + verStretch + () + + + + QSlider + qslider.html + + TickPosition + TickPosition-enum + + + + QSlider + QSlider + ( QWidget * parent = 0 ) + + + QSlider + QSlider-2 + ( Qt::Orientation orientation, QWidget * parent = 0 ) + + + QSlider + QSlider-3 + ( QWidget * parent, const char * name ) + + + QSlider + QSlider-4 + ( Qt::Orientation orientation, QWidget * parent, const char * name ) + + + QSlider + QSlider-5 + ( int minValue, int maxValue, int pageStep, int value, Qt::Orientation orientation, QWidget * parent = 0, const char * name = 0 ) + + + addStep + addStep + () + + + setTickmarks + setTickmarks + ( TickPosition position ) + + + subtractStep + subtractStep + () + + + tickmarks + tickmarks + () + + + + QSocketNotifier + qsocketnotifier.html + + Type + Type-enum + + + + QSocketNotifier + QSocketNotifier + ( int socket, Type type, QObject * parent = 0 ) + + + activated + activated + ( int socket ) + + + isEnabled + isEnabled + () + + + setEnabled + setEnabled + ( bool enable ) + + + socket + socket + () + + + type + type + () + + + QSocketNotifier + QSocketNotifier-2 + ( int socket, Type type, QObject * parent, const char * name ) + + + + QSortFilterProxyModel + qsortfilterproxymodel.html + + CaseSensitivity + filterCaseSensitivity-prop + + + + QSortFilterProxyModel + QSortFilterProxyModel + ( QObject * parent = 0 ) + + + clear + clear + () + + + filterAcceptsColumn + filterAcceptsColumn + ( int source_column, const QModelIndex & source_parent ) + + + filterAcceptsRow + filterAcceptsRow + ( int source_row, const QModelIndex & source_parent ) + + + lessThan + lessThan + ( const QModelIndex & left, const QModelIndex & right ) + + + mapFromSource + mapFromSource + ( const QModelIndex & sourceIndex ) + + + mapToSource + mapToSource + ( const QModelIndex & proxyIndex ) + + + setFilterFixedString + setFilterFixedString + ( const QString & pattern ) + + + setFilterWildcard + setFilterWildcard + ( const QString & pattern ) + + + + QSound + qsound.html + + QSound + QSound + ( const QString & filename, QObject * parent = 0 ) + + + fileName + fileName + () + + + isAvailable + isAvailable + () + + + isFinished + isFinished + () + + + loops + loops + () + + + loopsRemaining + loopsRemaining + () + + + play + play + ( const QString & filename ) + + + play + play-2 + () + + + setLoops + setLoops + ( int number ) + + + stop + stop + () + + + QSound + QSound-2 + ( const QString & filename, QObject * parent, const char * name ) + + + available + available + () + + + + QSpacerItem + qspaceritem.html + + QSpacerItem + QSpacerItem + ( int w, int h, QSizePolicy::Policy hPolicy = QSizePolicy::Minimum, QSizePolicy::Policy vPolicy = QSizePolicy::Minimum ) + + + changeSize + changeSize + ( int w, int h, QSizePolicy::Policy hPolicy = QSizePolicy::Minimum, QSizePolicy::Policy vPolicy = QSizePolicy::Minimum ) + + + isEmpty + isEmpty + () + + + spacerItem + spacerItem + () + + + + QSpinBox + qspinbox.html + + QSpinBox + QSpinBox + ( QWidget * parent = 0 ) + + + setRange + setRange + ( int min, int max ) + + + textFromValue + textFromValue + ( int v ) + + + valueChanged + valueChanged + ( int i ) + + + valueChanged + valueChanged-2 + ( const QString & text ) + + + valueFromText + valueFromText + ( const QString & text ) + + + QSpinBox + QSpinBox-2 + ( QWidget * parent, const char * name ) + + + QSpinBox + QSpinBox-3 + ( int min, int max, int step, QWidget * parent, const char * name = 0 ) + + + maxValue + maxValue + () + + + minValue + minValue + () + + + setLineStep + setLineStep + ( int step ) + + + setMaxValue + setMaxValue + ( int val ) + + + setMinValue + setMinValue + ( int val ) + + + + QSplashScreen + qsplashscreen.html + + QSplashScreen + QSplashScreen + ( const QPixmap & pixmap = QPixmap() + + + QSplashScreen + QSplashScreen-2 + ( QWidget * parent, const QPixmap & pixmap = QPixmap() + + + clearMessage + clearMessage + () + + + drawContents + drawContents + ( QPainter * painter ) + + + finish + finish + ( QWidget * mainWin ) + + + messageChanged + messageChanged + ( const QString & message ) + + + pixmap + pixmap + () + + + repaint + repaint + () + + + setPixmap + setPixmap + ( const QPixmap & pixmap ) + + + showMessage + showMessage + ( const QString & message, int alignment = Qt::AlignLeft, const QColor & color = Qt::black ) + + + clear + clear + () + + + message + message + ( const QString & message, int alignment = Qt::AlignLeft, const QColor & color = Qt::black ) + + + + QSplitterHandle + qsplitterhandle.html + + QSplitterHandle + QSplitterHandle + ( Qt::Orientation orientation, QSplitter * parent ) + + + closestLegalPosition + closestLegalPosition + ( int pos ) + + + moveSplitter + moveSplitter + ( int pos ) + + + opaqueResize + opaqueResize + () + + + Orientation + orientation + QSplitterHandle::orientation() + + + setOrientation + setOrientation + ( Qt::Orientation orientation ) + + + splitter + splitter + () + + + + QSplitter + qsplitter.html + + Orientation + orientation-prop + + + + QSplitter + QSplitter + ( QWidget * parent = 0 ) + + + QSplitter + QSplitter-2 + ( Qt::Orientation orientation, QWidget * parent = 0 ) + + + addWidget + addWidget + ( QWidget * widget ) + + + closestLegalPosition + closestLegalPosition + ( int pos, int index ) + + + count + count + () + + + createHandle + createHandle + () + + + getRange + getRange + ( int index, int * min, int * max ) + + + handle + handle + ( int index ) + + + indexOf + indexOf + ( QWidget * widget ) + + + insertWidget + insertWidget + ( int index, QWidget * widget ) + + + isCollapsible + isCollapsible + ( int index ) + + + moveSplitter + moveSplitter + ( int pos, int index ) + + + refresh + refresh + () + + + restoreState + restoreState + ( const QByteArray & state ) + + + saveState + saveState + () + + + setCollapsible + setCollapsible + ( int index, bool collapse ) + + + setRubberBand + setRubberBand + ( int pos ) + + + setSizes + setSizes + ( const QList<int> & list ) + + + setStretchFactor + setStretchFactor + ( int index, int stretch ) + + + sizes + sizes + () + + + splitterMoved + splitterMoved + ( int pos, int index ) + + + widget + widget + ( int index ) + + + ResizeMode + ResizeMode-enum + + + + QSplitter + QSplitter-3 + ( QWidget * parent, const char * name ) + + + QSplitter + QSplitter-4 + ( Qt::Orientation orientation, QWidget * parent, const char * name ) + + + moveToFirst + moveToFirst + ( QWidget * widget ) + + + moveToLast + moveToLast + ( QWidget * widget ) + + + setCollapsible + setCollapsible-2 + ( QWidget * widget, bool collapsible ) + + + setResizeMode + setResizeMode + ( QWidget * widget, ResizeMode mode ) + + + + QSqlDatabase + qsqldatabase.html + + QSqlDatabase + QSqlDatabase + () + + + QSqlDatabase + QSqlDatabase-2 + ( const QSqlDatabase & other ) + + + QSqlDatabase + QSqlDatabase-3 + ( const QString & type ) + + + QSqlDatabase + QSqlDatabase-4 + ( QSqlDriver * driver ) + + + addDatabase + addDatabase + ( const QString & type, const QString & connectionName = QLatin1String( defaultConnection ) + + + addDatabase + addDatabase-2 + ( QSqlDriver * driver, const QString & connectionName = QLatin1String( defaultConnection ) + + + cloneDatabase + cloneDatabase + ( const QSqlDatabase & other, const QString & connectionName ) + + + close + close + () + + + commit + commit + () + + + connectOptions + connectOptions + () + + + connectionNames + connectionNames + () + + + contains + contains + ( const QString & connectionName = QLatin1String( defaultConnection ) + + + database + database + ( const QString & connectionName = QLatin1String( defaultConnection ) + + + databaseName + databaseName + () + + + driver + driver + () + + + driverName + driverName + () + + + drivers + drivers + () + + + exec + exec + ( const QString & query = QString() + + + hostName + hostName + () + + + isDriverAvailable + isDriverAvailable + ( const QString & name ) + + + isOpen + isOpen + () + + + isOpenError + isOpenError + () + + + isValid + isValid + () + + + lastError + lastError + () + + + open + open + () + + + open + open-2 + ( const QString & user, const QString & password ) + + + password + password + () + + + port + port + () + + + primaryIndex + primaryIndex + ( const QString & tablename ) + + + record + record + ( const QString & tablename ) + + + registerSqlDriver + registerSqlDriver + ( const QString & name, QSqlDriverCreatorBase * creator ) + + + removeDatabase + removeDatabase + ( const QString & connectionName ) + + + rollback + rollback + () + + + setConnectOptions + setConnectOptions + ( const QString & options = QString() + + + setDatabaseName + setDatabaseName + ( const QString & name ) + + + setHostName + setHostName + ( const QString & host ) + + + setPassword + setPassword + ( const QString & password ) + + + setPort + setPort + ( int port ) + + + setUserName + setUserName + ( const QString & name ) + + + tables + tables + ( QSql::TableType type = QSql::Tables ) + + + transaction + transaction + () + + + userName + userName + () + + + operator= + operator-eq + ( const QSqlDatabase & other ) + + + record + record-2 + ( const QSqlQuery & query ) + + + recordInfo + recordInfo + ( const QString & tablename ) + + + recordInfo + recordInfo-2 + ( const QSqlQuery & query ) + + + + QSqlDriverCreatorBase + qsqldrivercreatorbase.html + + createObject + createObject + () + + + + QSqlDriverCreator + qsqldrivercreator.html + + + QSqlDriver + qsqldriver.html + + DriverFeature + DriverFeature-enum + + + + IdentifierType + IdentifierType-enum + + + + StatementType + StatementType-enum + + + + QSqlDriver + QSqlDriver + ( QObject * parent = 0 ) + + + beginTransaction + beginTransaction + () + + + close + close + () + + + commitTransaction + commitTransaction + () + + + createResult + createResult + () + + + escapeIdentifier + escapeIdentifier + ( const QString & identifier, IdentifierType type ) + + + formatValue + formatValue-2 + ( const QSqlField & field, bool trimStrings = false ) + + + handle + handle + () + + + hasFeature + hasFeature + ( DriverFeature feature ) + + + isOpen + isOpen + () + + + isOpenError + isOpenError + () + + + lastError + lastError + () + + + open + open + ( const QString & db, const QString & user = QString() + + + primaryIndex + primaryIndex + ( const QString & tableName ) + + + record + record + ( const QString & tableName ) + + + rollbackTransaction + rollbackTransaction + () + + + setLastError + setLastError + ( const QSqlError & error ) + + + setOpen + setOpen + ( bool open ) + + + setOpenError + setOpenError + ( bool error ) + + + sqlStatement + sqlStatement + ( StatementType type, const QString & tableName, const QSqlRecord & rec, bool preparedStatement ) + + + tables + tables + ( QSql::TableType tableType ) + + + + QSqlDriverPlugin + qsqldriverplugin.html + + QSqlDriverPlugin + QSqlDriverPlugin + ( QObject * parent = 0 ) + + + create + create + ( const QString & key ) + + + keys + keys + () + + + formatValue + formatValue + ( const QSqlField * field, bool trimStrings = false ) + + + nullText + nullText + () + + + record + record-2 + ( const QSqlQuery & query ) + + + recordInfo + recordInfo + ( const QString & tablename ) + + + recordInfo + recordInfo-2 + ( const QSqlQuery & query ) + + + + QSqlError + qsqlerror.html + + ErrorType + ErrorType-enum + + + + QSqlError + QSqlError + ( const QString & driverText = QString() + + + QSqlError + QSqlError-2 + ( const QSqlError & other ) + + + databaseText + databaseText + () + + + driverText + driverText + () + + + isValid + isValid + () + + + number + number + () + + + setDatabaseText + setDatabaseText + ( const QString & databaseText ) + + + setDriverText + setDriverText + ( const QString & driverText ) + + + setNumber + setNumber + ( int number ) + + + setType + setType + ( ErrorType type ) + + + text + text + () + + + type + type + () + + + operator= + operator-eq + ( const QSqlError & other ) + + + + QSqlField + qsqlfield.html + + RequiredStatus + RequiredStatus-enum + + + + QSqlField + QSqlField + ( const QString & fieldName = QString() + + + QSqlField + QSqlField-2 + ( const QSqlField & other ) + + + clear + clear + () + + + defaultValue + defaultValue + () + + + isAutoValue + isAutoValue + () + + + isGenerated + isGenerated + () + + + isNull + isNull + () + + + isReadOnly + isReadOnly + () + + + isValid + isValid + () + + + length + length + () + + + name + name + () + + + precision + precision + () + + + requiredStatus + requiredStatus + () + + + setAutoValue + setAutoValue + ( bool autoVal ) + + + setDefaultValue + setDefaultValue + ( const QVariant & value ) + + + setGenerated + setGenerated + ( bool gen ) + + + setLength + setLength + ( int fieldLength ) + + + setName + setName + ( const QString & name ) + + + setPrecision + setPrecision + ( int precision ) + + + setReadOnly + setReadOnly + ( bool readOnly ) + + + setRequired + setRequired + ( bool required ) + + + setRequiredStatus + setRequiredStatus + ( RequiredStatus required ) + + + setType + setType + ( QVariant::Type type ) + + + setValue + setValue + ( const QVariant & value ) + + + Type + type + QSqlField::type() + + + value + value + () + + + operator!= + operator-not-eq + ( const QSqlField & other ) + + + operator= + operator-eq + ( const QSqlField & other ) + + + operator== + operator-eq-eq + ( const QSqlField & other ) + + + setNull + setNull + () + + + Location + Location-enum + + + + TableType + TableType-enum + + + + + QSqlIndex + qsqlindex.html + + QSqlIndex + QSqlIndex + ( const QString & cursorname = QString() + + + QSqlIndex + QSqlIndex-2 + ( const QSqlIndex & other ) + + + append + append + ( const QSqlField & field ) + + + append + append-2 + ( const QSqlField & field, bool desc ) + + + cursorName + cursorName + () + + + isDescending + isDescending + ( int i ) + + + name + name + () + + + setCursorName + setCursorName + ( const QString & cursorName ) + + + setDescending + setDescending + ( int i, bool desc ) + + + setName + setName + ( const QString & name ) + + + operator= + operator-eq + ( const QSqlIndex & other ) + + + toString + toString + ( const QString & prefix = QString() + + + toStringList + toStringList + ( const QString & prefix = QString() + + + Confirm + Confirm-enum + + + + Op + Op-enum + + + + + QSqlQuery + qsqlquery.html + + QSqlQuery + QSqlQuery + ( QSqlResult * result ) + + + QSqlQuery + QSqlQuery-2 + ( const QString & query = QString() + + + QSqlQuery + QSqlQuery-3 + ( QSqlDatabase db ) + + + QSqlQuery + QSqlQuery-4 + ( const QSqlQuery & other ) + + + addBindValue + addBindValue + ( const QVariant & val, QSql::ParamType paramType = QSql::In ) + + + at + at + () + + + bindValue + bindValue + ( const QString & placeholder, const QVariant & val, QSql::ParamType paramType = QSql::In ) + + + bindValue + bindValue-2 + ( int pos, const QVariant & val, QSql::ParamType paramType = QSql::In ) + + + boundValue + boundValue + ( const QString & placeholder ) + + + boundValue + boundValue-2 + ( int pos ) + + + boundValues + boundValues + () + + + clear + clear + () + + + driver + driver + () + + + exec + exec + ( const QString & query ) + + + exec + exec-2 + () + + + executedQuery + executedQuery + () + + + first + first + () + + + isActive + isActive + () + + + isForwardOnly + isForwardOnly + () + + + isNull + isNull + ( int field ) + + + isSelect + isSelect + () + + + isValid + isValid + () + + + last + last + () + + + lastError + lastError + () + + + lastInsertId + lastInsertId + () + + + lastQuery + lastQuery + () + + + next + next + () + + + numRowsAffected + numRowsAffected + () + + + prepare + prepare + ( const QString & query ) + + + previous + previous + () + + + record + record + () + + + result + result + () + + + seek + seek + ( int index, bool relative = false ) + + + setForwardOnly + setForwardOnly + ( bool forward ) + + + size + size + () + + + value + value + ( int index ) + + + operator= + operator-eq + ( const QSqlQuery & other ) + + + + QSqlQueryModel + qsqlquerymodel.html + + QSqlQueryModel + QSqlQueryModel + ( QObject * parent = 0 ) + + + canFetchMore + canFetchMore + ( const QModelIndex & parent = QModelIndex() + + + clear + clear + () + + + data + data + ( const QModelIndex & item, int role = Qt::DisplayRole ) + + + fetchMore + fetchMore + ( const QModelIndex & parent = QModelIndex() + + + headerData + headerData + ( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) + + + indexInQuery + indexInQuery + ( const QModelIndex & item ) + + + insertColumns + insertColumns + ( int column, int count, const QModelIndex & parent = QModelIndex() + + + lastError + lastError + () + + + query + query + () + + + queryChange + queryChange + () + + + record + record + ( int row ) + + + record + record-2 + () + + + removeColumns + removeColumns + ( int column, int count, const QModelIndex & parent = QModelIndex() + + + rowCount + rowCount + ( const QModelIndex & parent = QModelIndex() + + + setHeaderData + setHeaderData + ( int section, Qt::Orientation orientation, const QVariant & value, int role = Qt::EditRole ) + + + setLastError + setLastError + ( const QSqlError & error ) + + + setQuery + setQuery + ( const QSqlQuery & query ) + + + setQuery + setQuery-2 + ( const QString & query, const QSqlDatabase & db = QSqlDatabase() + + + prev + prev + () + + + + QSqlRecord + qsqlrecord.html + + QSqlRecord + QSqlRecord + () + + + QSqlRecord + QSqlRecord-2 + ( const QSqlRecord & other ) + + + append + append + ( const QSqlField & field ) + + + clear + clear + () + + + clearValues + clearValues + () + + + contains + contains + ( const QString & name ) + + + count + count + () + + + field + field + ( int index ) + + + field + field-2 + ( const QString & name ) + + + fieldName + fieldName + ( int index ) + + + indexOf + indexOf + ( const QString & name ) + + + insert + insert + ( int pos, const QSqlField & field ) + + + isEmpty + isEmpty + () + + + isGenerated + isGenerated + ( const QString & name ) + + + isGenerated + isGenerated-2 + ( int index ) + + + isNull + isNull + ( const QString & name ) + + + isNull + isNull-2 + ( int index ) + + + remove + remove + ( int pos ) + + + replace + replace + ( int pos, const QSqlField & field ) + + + setGenerated + setGenerated + ( const QString & name, bool generated ) + + + setGenerated + setGenerated-2 + ( int index, bool generated ) + + + setNull + setNull + ( int index ) + + + setNull + setNull-2 + ( const QString & name ) + + + setValue + setValue + ( int index, const QVariant & val ) + + + setValue + setValue-2 + ( const QString & name, const QVariant & val ) + + + value + value + ( int index ) + + + value + value-2 + ( const QString & name ) + + + operator!= + operator-not-eq + ( const QSqlRecord & other ) + + + operator= + operator-eq + ( const QSqlRecord & other ) + + + operator== + operator-eq-eq + ( const QSqlRecord & other ) + + + fieldPtr + fieldPtr + ( int index ) + + + fieldPtr + fieldPtr-2 + ( const QString & name ) + + + position + position + ( const QString & name ) + + + toString + toString + ( const QString & prefix = QString() + + + toStringList + toStringList + ( const QString & prefix = QString() + + + + QSqlRelationalDelegate + qsqlrelationaldelegate.html + + QSqlRelationalDelegate + QSqlRelationalDelegate + ( QObject * parent = 0 ) + + + + QSqlRelationalTableModel + qsqlrelationaltablemodel.html + + QSqlRelationalTableModel + QSqlRelationalTableModel + ( QObject * parent = 0, QSqlDatabase db = QSqlDatabase() + + + relation + relation + ( int column ) + + + relationModel + relationModel + ( int column ) + + + setData + setData + ( const QModelIndex & index, const QVariant & value, int role = Qt::EditRole ) + + + setRelation + setRelation + ( int column, const QSqlRelation & relation ) + + + + QSqlRelation + qsqlrelation.html + + QSqlRelation + QSqlRelation + () + + + QSqlRelation + QSqlRelation-2 + ( const QString & tableName, const QString & indexColumn, const QString & displayColumn ) + + + displayColumn + displayColumn + () + + + indexColumn + indexColumn + () + + + isValid + isValid + () + + + tableName + tableName + () + + + + QSqlResult + qsqlresult.html + + BindingSyntax + BindingSyntax-enum + + + + QSqlResult + QSqlResult + ( const QSqlDriver * db ) + + + addBindValue + addBindValue + ( const QVariant & val, QSql::ParamType paramType ) + + + at + at + () + + + bindValue + bindValue + ( int index, const QVariant & val, QSql::ParamType paramType ) + + + bindValue + bindValue-2 + ( const QString & placeholder, const QVariant & val, QSql::ParamType paramType ) + + + ParamType + bindValueType + QSqlResult::bindValueType( int index ) + + + ParamType + bindValueType-2 + QSqlResult::bindValueType( const QString & placeholder ) + + + bindingSyntax + bindingSyntax + () + + + boundValue + boundValue + ( int index ) + + + boundValue + boundValue-2 + ( const QString & placeholder ) + + + boundValueCount + boundValueCount + () + + + boundValueName + boundValueName + ( int index ) + + + boundValues + boundValues + () + + + clear + clear + () + + + data + data + ( int index ) + + + driver + driver + () + + + exec + exec + () + + + executedQuery + executedQuery + () + + + fetch + fetch + ( int index ) + + + fetchFirst + fetchFirst + () + + + fetchLast + fetchLast + () + + + fetchNext + fetchNext + () + + + fetchPrevious + fetchPrevious + () + + + handle + handle + () + + + hasOutValues + hasOutValues + () + + + isActive + isActive + () + + + isForwardOnly + isForwardOnly + () + + + isNull + isNull + ( int index ) + + + isSelect + isSelect + () + + + isValid + isValid + () + + + lastError + lastError + () + + + lastInsertId + lastInsertId + () + + + lastQuery + lastQuery + () + + + numRowsAffected + numRowsAffected + () + + + prepare + prepare + ( const QString & query ) + + + record + record + () + + + reset + reset + ( const QString & query ) + + + savePrepare + savePrepare + ( const QString & query ) + + + setActive + setActive + ( bool active ) + + + setAt + setAt + ( int index ) + + + setForwardOnly + setForwardOnly + ( bool forward ) + + + setLastError + setLastError + ( const QSqlError & error ) + + + setQuery + setQuery + ( const QString & query ) + + + setSelect + setSelect + ( bool select ) + + + size + size + () + + + + QSqlTableModel + qsqltablemodel.html + + EditStrategy + EditStrategy-enum + + + + QSqlTableModel + QSqlTableModel + ( QObject * parent = 0, QSqlDatabase db = QSqlDatabase() + + + beforeDelete + beforeDelete + ( int row ) + + + beforeInsert + beforeInsert + ( QSqlRecord & record ) + + + beforeUpdate + beforeUpdate + ( int row, QSqlRecord & record ) + + + database + database + () + + + deleteRowFromTable + deleteRowFromTable + ( int row ) + + + editStrategy + editStrategy + () + + + fieldIndex + fieldIndex + ( const QString & fieldName ) + + + filter + filter + () + + + indexInQuery + indexInQuery + ( const QModelIndex & item ) + + + insertRecord + insertRecord + ( int row, const QSqlRecord & record ) + + + insertRowIntoTable + insertRowIntoTable + ( const QSqlRecord & values ) + + + insertRows + insertRows + ( int row, int count, const QModelIndex & parent = QModelIndex() + + + isDirty + isDirty + ( const QModelIndex & index ) + + + orderByClause + orderByClause + () + + + primaryKey + primaryKey + () + + + primeInsert + primeInsert + ( int row, QSqlRecord & record ) + + + removeColumns + removeColumns + ( int column, int count, const QModelIndex & parent = QModelIndex() + + + removeRows + removeRows + ( int row, int count, const QModelIndex & parent = QModelIndex() + + + revert + revert + () + + + revertAll + revertAll + () + + + revertRow + revertRow + ( int row ) + + + select + select + () + + + selectStatement + selectStatement + () + + + setData + setData + ( const QModelIndex & index, const QVariant & value, int role = Qt::EditRole ) + + + setEditStrategy + setEditStrategy + ( EditStrategy strategy ) + + + setFilter + setFilter + ( const QString & filter ) + + + setPrimaryKey + setPrimaryKey + ( const QSqlIndex & key ) + + + setQuery + setQuery + ( const QSqlQuery & query ) + + + setRecord + setRecord + ( int row, const QSqlRecord & record ) + + + setSort + setSort + ( int column, Qt::SortOrder order ) + + + setTable + setTable + ( const QString & tableName ) + + + sort + sort + ( int column, Qt::SortOrder order ) + + + submit + submit + () + + + submitAll + submitAll + () + + + tableName + tableName + () + + + updateRowInTable + updateRowInTable + ( int row, const QSqlRecord & values ) + + + + QStackedLayout + qstackedlayout.html + + QStackedLayout + QStackedLayout + () + + + QStackedLayout + QStackedLayout-2 + ( QWidget * parent ) + + + QStackedLayout + QStackedLayout-3 + ( QLayout * parentLayout ) + + + addWidget + addWidget + ( QWidget * widget ) + + + currentChanged + currentChanged + ( int index ) + + + currentWidget + currentWidget + () + + + insertWidget + insertWidget + ( int index, QWidget * widget ) + + + setCurrentWidget + setCurrentWidget + ( QWidget * widget ) + + + widget + widget + ( int index ) + + + widgetRemoved + widgetRemoved + ( int index ) + + + + QStackedWidget + qstackedwidget.html + + QStackedWidget + QStackedWidget + ( QWidget * parent = 0 ) + + + addWidget + addWidget + ( QWidget * widget ) + + + currentChanged + currentChanged + ( int index ) + + + currentWidget + currentWidget + () + + + indexOf + indexOf + ( QWidget * widget ) + + + insertWidget + insertWidget + ( int index, QWidget * widget ) + + + removeWidget + removeWidget + ( QWidget * widget ) + + + setCurrentWidget + setCurrentWidget + ( QWidget * widget ) + + + widget + widget + ( int index ) + + + widgetRemoved + widgetRemoved + ( int index ) + + + + QStack + qstack.html + + QStack + QStack + () + + + pop + pop + () + + + push + push + ( const T & t ) + + + top + top + () + + + top + top-2 + () + + + + QStandardItemModel + qstandarditemmodel.html + + QStandardItemModel + QStandardItemModel + ( QObject * parent = 0 ) + + + QStandardItemModel + QStandardItemModel-2 + ( int rows, int columns, QObject * parent = 0 ) + + + clear + clear + () + + + columnCount + columnCount + ( const QModelIndex & parent = QModelIndex() + + + data + data + ( const QModelIndex & index, int role = Qt::DisplayRole ) + + + ItemFlags + flags + QStandardItemModel::flags( const QModelIndex & index ) + + + hasChildren + hasChildren + ( const QModelIndex & parent = QModelIndex() + + + index + index + ( int row, int column, const QModelIndex & parent = QModelIndex() + + + insertColumns + insertColumns + ( int column, int count, const QModelIndex & parent = QModelIndex() + + + insertRows + insertRows + ( int row, int count, const QModelIndex & parent = QModelIndex() + + + parent + parent + ( const QModelIndex & child ) + + + removeColumns + removeColumns + ( int column, int count, const QModelIndex & parent = QModelIndex() + + + removeRows + removeRows + ( int row, int count, const QModelIndex & parent = QModelIndex() + + + rowCount + rowCount + ( const QModelIndex & parent = QModelIndex() + + + setData + setData + ( const QModelIndex & index, const QVariant & value, int role = Qt::EditRole ) + + + + QStatusBar + qstatusbar.html + + QStatusBar + QStatusBar + ( QWidget * parent = 0 ) + + + addPermanentWidget + addPermanentWidget + ( QWidget * widget, int stretch = 0 ) + + + addWidget + addWidget + ( QWidget * widget, int stretch = 0 ) + + + clearMessage + clearMessage + () + + + currentMessage + currentMessage + () + + + hideOrShow + hideOrShow + () + + + messageChanged + messageChanged + ( const QString & message ) + + + reformat + reformat + () + + + removeWidget + removeWidget + ( QWidget * widget ) + + + showMessage + showMessage + ( const QString & message, int timeout = 0 ) + + + QStatusBar + QStatusBar-2 + ( QWidget * parent, const char * name ) + + + addWidget + addWidget-2 + ( QWidget * widget, int stretch, bool permanent ) + + + clear + clear + () + + + message + message + ( const QString & message, int timeout = 0 ) + + + + QStatusTipEvent + qstatustipevent.html + + QStatusTipEvent + QStatusTipEvent + ( const QString & tip ) + + + tip + tip + () + + + + QString + qstring.html + + NormalizationForm + NormalizationForm-enum + + + + SplitBehavior + SplitBehavior-enum + + + + QString + QString + () + + + QString + QString-2 + ( const QChar * unicode, int size ) + + + QString + QString-3 + ( QChar ch ) + + + QString + QString-4 + ( int size, QChar ch ) + + + QString + QString-5 + ( const QLatin1String & str ) + + + QString + QString-6 + ( const QString & other ) + + + QString + QString-7 + ( const char * str ) + + + QString + QString-8 + ( const QByteArray & ba ) + + + append + append + ( const QString & str ) + + + append + append-2 + ( const QLatin1String & str ) + + + append + append-3 + ( const QByteArray & ba ) + + + append + append-4 + ( const char * str ) + + + append + append-5 + ( QChar ch ) + + + arg + arg + ( const QString & a, int fieldWidth = 0, const QChar & fillChar = QLatin1Char( ' ' ) + + + arg + arg-2 + ( const QString & a1, const QString & a2 ) + + + arg + arg-3 + ( const QString & a1, const QString & a2, const QString & a3 ) + + + arg + arg-4 + ( const QString & a1, const QString & a2, const QString & a3, const QString & a4 ) + + + arg + arg-5 + ( int a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) + + + arg + arg-6 + ( uint a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) + + + arg + arg-7 + ( long a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) + + + arg + arg-8 + ( ulong a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) + + + arg + arg-9 + ( qlonglong a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) + + + arg + arg-10 + ( qulonglong a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) + + + arg + arg-11 + ( short a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) + + + arg + arg-12 + ( ushort a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) + + + arg + arg-13 + ( QChar a, int fieldWidth = 0, const QChar & fillChar = QLatin1Char( ' ' ) + + + arg + arg-14 + ( char a, int fieldWidth = 0, const QChar & fillChar = QLatin1Char( ' ' ) + + + arg + arg-15 + ( double a, int fieldWidth = 0, char fmt = 'g', int prec = -1, const QChar & fillChar = QLatin1Char( ' ' ) + + + at + at + ( int i ) + + + capacity + capacity + () + + + chop + chop + ( int n ) + + + clear + clear + () + + + compare + compare + ( const QString & s1, const QString & s2 ) + + + compare + compare-2 + ( const QString & other ) + + + constData + constData + () + + + contains + contains + ( const QString & str, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + contains + contains-4 + ( QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + contains + contains-5 + ( const QRegExp & rx ) + + + count + count + ( const QString & str, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + count + count-2 + ( QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + count + count-3 + ( const QRegExp & rx ) + + + count + count-4 + () + + + data + data + () + + + data + data-2 + () + + + endsWith + endsWith + ( const QString & s, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + endsWith + endsWith-3 + ( const QLatin1String & s, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + endsWith + endsWith-4 + ( const QChar & c, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + fill + fill + ( QChar ch, int size = -1 ) + + + fromAscii + fromAscii + ( const char * str, int size = -1 ) + + + fromLatin1 + fromLatin1 + ( const char * str, int size = -1 ) + + + fromLocal8Bit + fromLocal8Bit + ( const char * str, int size = -1 ) + + + fromRawData + fromRawData + ( const QChar * unicode, int size ) + + + fromStdString + fromStdString + ( const std::string & str ) + + + fromStdWString + fromStdWString + ( const std::wstring & str ) + + + fromUtf8 + fromUtf8 + ( const char * str, int size = -1 ) + + + fromUtf16 + fromUtf16 + ( const ushort * unicode, int size = -1 ) + + + indexOf + indexOf + ( const QString & str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + indexOf + indexOf-2 + ( QChar ch, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + indexOf + indexOf-3 + ( const QRegExp & rx, int from = 0 ) + + + insert + insert + ( int i, const QString & str ) + + + insert + insert-2 + ( int i, const QLatin1String & str ) + + + insert + insert-3 + ( int i, const QChar * unicode, int size ) + + + insert + insert-4 + ( int i, QChar ch ) + + + isEmpty + isEmpty + () + + + isNull + isNull + () + + + lastIndexOf + lastIndexOf + ( const QString & str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + lastIndexOf + lastIndexOf-2 + ( QChar ch, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + lastIndexOf + lastIndexOf-3 + ( const QRegExp & rx, int from = -1 ) + + + left + left + ( int len ) + + + leftJustified + leftJustified + ( int width, QChar fill = QLatin1Char( ' ' ) + + + length + length + () + + + localeAwareCompare + localeAwareCompare + ( const QString & s1, const QString & s2 ) + + + localeAwareCompare + localeAwareCompare-2 + ( const QString & other ) + + + mid + mid + ( int i, int len = -1 ) + + + normalized + normalized + ( NormalizationForm form ) + + + normalized + normalized-2 + ( NormalizationForm form, QChar::UnicodeVersion version ) + + + number + number + ( long n, int base = 10 ) + + + number + number-2 + ( ulong n, int base = 10 ) + + + number + number-3 + ( int n, int base = 10 ) + + + number + number-4 + ( uint n, int base = 10 ) + + + number + number-5 + ( qlonglong n, int base = 10 ) + + + number + number-6 + ( qulonglong n, int base = 10 ) + + + number + number-7 + ( double n, char f = 'g', int prec = 6 ) + + + prepend + prepend + ( const QString & str ) + + + prepend + prepend-2 + ( const QLatin1String & str ) + + + prepend + prepend-3 + ( const QByteArray & ba ) + + + prepend + prepend-4 + ( const char * str ) + + + prepend + prepend-5 + ( QChar ch ) + + + push_back + push_back + ( const QString & other ) + + + push_back + push_back-2 + ( QChar ch ) + + + push_front + push_front + ( const QString & other ) + + + push_front + push_front-2 + ( QChar ch ) + + + remove + remove + ( int pos, int len ) + + + remove + remove-4 + ( const QString & str, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + remove + remove-5 + ( QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + remove + remove-6 + ( const QRegExp & rx ) + + + replace + replace + ( int pos, int len, const QString & after ) + + + replace + replace-6 + ( int pos, int len, const QChar * unicode, int size ) + + + replace + replace-7 + ( int pos, int len, QChar after ) + + + replace + replace-8 + ( const QString & before, const QString & after, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + replace + replace-9 + ( QChar ch, const QString & after, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + replace + replace-10 + ( QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + replace + replace-11 + ( const QRegExp & rx, const QString & after ) + + + reserve + reserve + ( int size ) + + + resize + resize + ( int size ) + + + right + right + ( int len ) + + + rightJustified + rightJustified + ( int width, QChar fill = QLatin1Char( ' ' ) + + + section + section + ( QChar sep, int start, int end = -1, SectionFlags flags = SectionDefault ) + + + section + section-2 + ( const QString & sep, int start, int end = -1, SectionFlags flags = SectionDefault ) + + + section + section-3 + ( const QRegExp & reg, int start, int end = -1, SectionFlags flags = SectionDefault ) + + + setNum + setNum + ( int n, int base = 10 ) + + + setNum + setNum-2 + ( uint n, int base = 10 ) + + + setNum + setNum-3 + ( long n, int base = 10 ) + + + setNum + setNum-4 + ( ulong n, int base = 10 ) + + + setNum + setNum-5 + ( qlonglong n, int base = 10 ) + + + setNum + setNum-6 + ( qulonglong n, int base = 10 ) + + + setNum + setNum-7 + ( short n, int base = 10 ) + + + setNum + setNum-8 + ( ushort n, int base = 10 ) + + + setNum + setNum-9 + ( double n, char f = 'g', int prec = 6 ) + + + setNum + setNum-10 + ( float n, char f = 'g', int prec = 6 ) + + + setUnicode + setUnicode + ( const QChar * unicode, int size ) + + + setUtf16 + setUtf16 + ( const ushort * unicode, int size ) + + + simplified + simplified + () + + + size + size + () + + + split + split + ( const QString & sep, SplitBehavior behavior = KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + split + split-2 + ( const QChar & sep, SplitBehavior behavior = KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + split + split-3 + ( const QRegExp & rx, SplitBehavior behavior = KeepEmptyParts ) + + + sprintf + sprintf + ( const char * cformat, ... ) + + + squeeze + squeeze + () + + + startsWith + startsWith + ( const QString & s, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + startsWith + startsWith-3 + ( const QLatin1String & s, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + startsWith + startsWith-4 + ( const QChar & c, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + toAscii + toAscii + () + + + toDouble + toDouble + ( bool * ok = 0 ) + + + toFloat + toFloat + ( bool * ok = 0 ) + + + toInt + toInt + ( bool * ok = 0, int base = 10 ) + + + toLatin1 + toLatin1 + () + + + toLocal8Bit + toLocal8Bit + () + + + toLong + toLong + ( bool * ok = 0, int base = 10 ) + + + toLongLong + toLongLong + ( bool * ok = 0, int base = 10 ) + + + toLower + toLower + () + + + toShort + toShort + ( bool * ok = 0, int base = 10 ) + + + string + toStdString + QString::toStdString() + + + wstring + toStdWString + QString::toStdWString() + + + toUInt + toUInt + ( bool * ok = 0, int base = 10 ) + + + toULong + toULong + ( bool * ok = 0, int base = 10 ) + + + toULongLong + toULongLong + ( bool * ok = 0, int base = 10 ) + + + toUShort + toUShort + ( bool * ok = 0, int base = 10 ) + + + toUpper + toUpper + () + + + toUtf8 + toUtf8 + () + + + trimmed + trimmed + () + + + truncate + truncate + ( int pos ) + + + unicode + unicode + () + + + utf16 + utf16 + () + + + vsprintf + vsprintf + ( const char * cformat, va_list ap ) + + + operator!= + operator-not-eq + ( const QString & other ) + + + operator!= + operator-not-eq-2 + ( const QLatin1String & other ) + + + operator!= + operator-not-eq-3 + ( const QByteArray & other ) + + + operator!= + operator-not-eq-4 + ( const char * other ) + + + operator+= + operator-2b-eq + ( const QString & other ) + + + operator+= + operator-2b-eq-2 + ( const QLatin1String & str ) + + + operator+= + operator-2b-eq-3 + ( const QByteArray & ba ) + + + operator+= + operator-2b-eq-4 + ( const char * str ) + + + operator+= + operator-2b-eq-5 + ( char ch ) + + + operator+= + operator-2b-eq-6 + ( QChar ch ) + + + operator< + operator-lt + ( const QString & other ) + + + operator< + operator-lt-2 + ( const QLatin1String & other ) + + + operator< + operator-lt-3 + ( const QByteArray & other ) + + + operator< + operator-lt-4 + ( const char * other ) + + + operator<= + operator-lt-eq + ( const QString & other ) + + + operator<= + operator-lt-eq-2 + ( const QLatin1String & other ) + + + operator<= + operator-lt-eq-3 + ( const QByteArray & other ) + + + operator<= + operator-lt-eq-4 + ( const char * other ) + + + operator= + operator-eq + ( const QString & other ) + + + operator= + operator-eq-3 + ( const QLatin1String & str ) + + + operator= + operator-eq-4 + ( const QByteArray & ba ) + + + operator= + operator-eq-5 + ( const char * str ) + + + operator= + operator-eq-6 + ( char ch ) + + + operator= + operator-eq-7 + ( QChar ch ) + + + operator== + operator-eq-eq + ( const QString & other ) + + + operator== + operator-eq-eq-2 + ( const QLatin1String & other ) + + + operator== + operator-eq-eq-3 + ( const QByteArray & other ) + + + operator== + operator-eq-eq-4 + ( const char * other ) + + + operator> + operator-gt + ( const QString & other ) + + + operator> + operator-gt-2 + ( const QLatin1String & other ) + + + operator> + operator-gt-3 + ( const QByteArray & other ) + + + operator> + operator-gt-4 + ( const char * other ) + + + operator>= + operator-gt-eq + ( const QString & other ) + + + operator>= + operator-gt-eq-2 + ( const QLatin1String & other ) + + + operator>= + operator-gt-eq-3 + ( const QByteArray & other ) + + + operator>= + operator-gt-eq-4 + ( const char * other ) + + + operator[] + operator-5b-5d + ( int i ) + + + operator[] + operator-5b-5d-2 + ( int i ) + + + operator[] + operator-5b-5d-3 + ( uint i ) + + + operator[] + operator-5b-5d-4 + ( uint i ) + + + + QStringList + qstringlist.html + + QStringList + QStringList + () + + + QStringList + QStringList-2 + ( const QString & str ) + + + QStringList + QStringList-3 + ( const QStringList & other ) + + + QStringList + QStringList-4 + ( const QList<QString> & other ) + + + contains + contains + ( const QString & str, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + filter + filter + ( const QString & str, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + filter + filter-2 + ( const QRegExp & rx ) + + + indexOf + indexOf + ( const QRegExp & rx, int from = 0 ) + + + join + join + ( const QString & sep ) + + + lastIndexOf + lastIndexOf + ( const QRegExp & rx, int from = -1 ) + + + replaceInStrings + replaceInStrings + ( const QString & before, const QString & after, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + replaceInStrings + replaceInStrings-2 + ( const QRegExp & rx, const QString & after ) + + + sort + sort + () + + + operator+ + operator-2b + ( const QStringList & other ) + + + operator<< + operator-lt-lt + ( const QString & str ) + + + operator<< + operator-lt-lt-2 + ( const QStringList & other ) + + + + QStringListModel + qstringlistmodel.html + + QStringListModel + QStringListModel + ( QObject * parent = 0 ) + + + QStringListModel + QStringListModel-2 + ( const QStringList & strings, QObject * parent = 0 ) + + + data + data + ( const QModelIndex & index, int role ) + + + ItemFlags + flags + QStringListModel::flags( const QModelIndex & index ) + + + insertRows + insertRows + ( int row, int count, const QModelIndex & parent = QModelIndex() + + + removeRows + removeRows + ( int row, int count, const QModelIndex & parent = QModelIndex() + + + rowCount + rowCount + ( const QModelIndex & parent = QModelIndex() + + + setData + setData + ( const QModelIndex & index, const QVariant & value, int role = Qt::EditRole ) + + + setStringList + setStringList + ( const QStringList & strings ) + + + stringList + stringList + () + + + fromLast + fromLast + () + + + fromLast + fromLast-2 + () + + + grep + grep + ( const QString & str, bool cs = true ) + + + grep + grep-2 + ( const QRegExp & rx ) + + + gres + gres + ( const QRegExp & rx, const QString & after ) + + + gres + gres-2 + ( const QString & before, const QString & after, bool cs = true ) + + + split + split + ( const QRegExp & sep, const QString & str, bool allowEmptyEntries = false ) + + + split + split-2 + ( const QChar & sep, const QString & str, bool allowEmptyEntries = false ) + + + split + split-3 + ( const QString & sep, const QString & str, bool allowEmptyEntries = false ) + + + + QStringMatcher + qstringmatcher.html + + QStringMatcher + QStringMatcher + () + + + QStringMatcher + QStringMatcher-2 + ( const QString & pattern, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + QStringMatcher + QStringMatcher-3 + ( const QStringMatcher & other ) + + + CaseSensitivity + caseSensitivity + QStringMatcher::caseSensitivity() + + + indexIn + indexIn + ( const QString & str, int from = 0 ) + + + pattern + pattern + () + + + setCaseSensitivity + setCaseSensitivity + ( Qt::CaseSensitivity cs ) + + + setPattern + setPattern + ( const QString & pattern ) + + + operator= + operator-eq + ( const QStringMatcher & other ) + + + + QString::Null + qstring-null.html + + ascii + ascii + () + + + constref + constref + ( uint i ) + + + contains + contains-2 + ( QChar c, bool cs ) + + + contains + contains-3 + ( const QString & s, bool cs ) + + + copy + copy + () + + + endsWith + endsWith-2 + ( const QString & s, bool cs ) + + + find + find + ( QChar c, int i = 0, bool cs = true ) + + + find + find-2 + ( const QString & s, int i = 0, bool cs = true ) + + + find + find-3 + ( const QRegExp & rx, int i = 0 ) + + + findRev + findRev + ( QChar c, int i = -1, bool cs = true ) + + + findRev + findRev-2 + ( const QString & s, int i = -1, bool cs = true ) + + + findRev + findRev-3 + ( const QRegExp & rx, int i = -1 ) + + + fromUcs2 + fromUcs2 + ( const ushort * unicode, int size = -1 ) + + + latin1 + latin1 + () + + + leftJustify + leftJustify + ( int width, QChar fill = QLatin1Char( ' ' ) + + + local8Bit + local8Bit + () + + + lower + lower + () + + + ref + ref + ( uint i ) + + + remove + remove-2 + ( QChar c, bool cs ) + + + remove + remove-3 + ( const QString & s, bool cs ) + + + replace + replace-2 + ( QChar c, const QString & after, bool cs ) + + + replace + replace-3 + ( const QString & before, const QString & after, bool cs ) + + + replace + replace-4 + ( char c, const QString & after, bool cs ) + + + replace + replace-5 + ( char c, const QString & after, Qt::CaseSensitivity cs ) + + + rightJustify + rightJustify + ( int width, QChar fill = QLatin1Char( ' ' ) + + + setAscii + setAscii + ( const char * str, int len = -1 ) + + + setLatin1 + setLatin1 + ( const char * str, int len = -1 ) + + + setLength + setLength + ( int nl ) + + + setUnicodeCodes + setUnicodeCodes + ( const ushort * unicode_as_ushorts, int size ) + + + simplifyWhiteSpace + simplifyWhiteSpace + () + + + startsWith + startsWith-2 + ( const QString & s, bool cs ) + + + stripWhiteSpace + stripWhiteSpace + () + + + ucs2 + ucs2 + () + + + upper + upper + () + + + utf8 + utf8 + () + + + operator + operator-const-char--2a + const char *() + + + + QStyleFactory + qstylefactory.html + + create + create + ( const QString & key ) + + + keys + keys + () + + + + QStyleHintReturn + qstylehintreturn.html + + HintReturnType + HintReturnType-enum + + + + QStyleHintReturn + QStyleHintReturn + ( int version = QStyleOption::Version, int type = SH_Default ) + + + Type + Type-var + + + + Version + Version-var + + + + type + type-varx + + + + version + version-varx + + + + + QStyleHintReturnMask + qstylehintreturnmask.html + + QStyleHintReturnMask + QStyleHintReturnMask + () + + + Type + Type-var + + + + Version + Version-var + + + + region + region-var + + + + + QStyle + qstyle.html + + ComplexControl + ComplexControl-enum + + + + ContentsType + ContentsType-enum + + + + ControlElement + ControlElement-enum + + + + PixelMetric + PixelMetric-enum + + + + PrimitiveElement + PrimitiveElement-enum + + + + StandardPixmap + StandardPixmap-enum + + + + StyleHint + StyleHint-enum + + + + SubElement + SubElement-enum + + + + QStyle + QStyle-2 + () + + + alignedRect + alignedRect + ( Qt::LayoutDirection direction, Qt::Alignment alignment, const QSize & size, const QRect & rectangle ) + + + drawComplexControl + drawComplexControl + ( ComplexControl control, const QStyleOptionComplex * option, QPainter * painter, const QWidget * widget = 0 ) + + + drawControl + drawControl + ( ControlElement element, const QStyleOption * option, QPainter * painter, const QWidget * widget = 0 ) + + + drawItemPixmap + drawItemPixmap + ( QPainter * painter, const QRect & rect, int alignment, const QPixmap & pixmap ) + + + drawItemText + drawItemText + ( QPainter * painter, const QRect & rect, int alignment, const QPalette & pal, bool enabled, const QString & text, QPalette::ColorRole textRole = QPalette::NoRole ) + + + drawPrimitive + drawPrimitive + ( PrimitiveElement elem, const QStyleOption * option, QPainter * painter, const QWidget * widget = 0 ) + + + generatedIconPixmap + generatedIconPixmap + ( QIcon::Mode iconMode, const QPixmap & pixmap, const QStyleOption * option ) + + + hitTestComplexControl + hitTestComplexControl + ( ComplexControl control, const QStyleOptionComplex * option, const QPoint & pos, const QWidget * widget = 0 ) + + + itemPixmapRect + itemPixmapRect + ( const QRect & rect, int alignment, const QPixmap & pixmap ) + + + itemTextRect + itemTextRect + ( const QFontMetrics & metrics, const QRect & rect, int alignment, bool enabled, const QString & text ) + + + pixelMetric + pixelMetric + ( PixelMetric metric, const QStyleOption * option = 0, const QWidget * widget = 0 ) + + + polish + polish + ( QWidget * widget ) + + + polish + polish-2 + ( QApplication * app ) + + + polish + polish-3 + ( QPalette & pal ) + + + sizeFromContents + sizeFromContents + ( ContentsType type, const QStyleOption * option, const QSize & contentsSize, const QWidget * widget = 0 ) + + + sliderPositionFromValue + sliderPositionFromValue + ( int min, int max, int logicalValue, int span, bool upsideDown = false ) + + + sliderValueFromPosition + sliderValueFromPosition + ( int min, int max, int pos, int span, bool upsideDown = false ) + + + standardIcon + standardIcon + ( StandardPixmap standardIcon, const QStyleOption * option = 0, const QWidget * widget = 0 ) + + + standardIconImplementation + standardIconImplementation + ( StandardPixmap standardIcon, const QStyleOption * option = 0, const QWidget * widget = 0 ) + + + standardPalette + standardPalette + () + + + standardPixmap + standardPixmap + ( StandardPixmap standardPixmap, const QStyleOption * option = 0, const QWidget * widget = 0 ) + + + styleHint + styleHint + ( StyleHint hint, const QStyleOption * option = 0, const QWidget * widget = 0, QStyleHintReturn * returnData = 0 ) + + + subControlRect + subControlRect + ( ComplexControl control, const QStyleOptionComplex * option, SubControl subControl, const QWidget * widget = 0 ) + + + subElementRect + subElementRect + ( SubElement element, const QStyleOption * option, const QWidget * widget = 0 ) + + + unpolish + unpolish + ( QWidget * widget ) + + + unpolish + unpolish-2 + ( QApplication * app ) + + + Alignment + visualAlignment + QStyle::visualAlignment( Qt::LayoutDirection direction, Qt::Alignment alignment ) + + + visualPos + visualPos + ( Qt::LayoutDirection direction, const QRect & boundingRect, const QPoint & logicalPos ) + + + visualRect + visualRect + ( Qt::LayoutDirection direction, const QRect & boundingRect, const QRect & logicalRect ) + + + + QStyleOptionButton + qstyleoptionbutton.html + + QStyleOptionButton + QStyleOptionButton + () + + + QStyleOptionButton + QStyleOptionButton-2 + ( const QStyleOptionButton & other ) + + + Type + Type-var + + + + Version + Version-var + + + + features + features-var + + + + icon + icon-var + + + + iconSize + iconSize-var + + + + text + text-var + + + + + QStyleOptionComboBox + qstyleoptioncombobox.html + + QStyleOptionComboBox + QStyleOptionComboBox + () + + + QStyleOptionComboBox + QStyleOptionComboBox-2 + ( const QStyleOptionComboBox & other ) + + + Type + Type-var + + + + Version + Version-var + + + + currentIcon + currentIcon-var + + + + currentText + currentText-var + + + + editable + editable-var + + + + frame + frame-var + + + + iconSize + iconSize-var + + + + popupRect + popupRect-var + + + + + QStyleOptionComplex + qstyleoptioncomplex.html + + QStyleOptionComplex + QStyleOptionComplex + ( int version = QStyleOptionComplex::Version, int type = SO_Complex ) + + + QStyleOptionComplex + QStyleOptionComplex-2 + ( const QStyleOptionComplex & other ) + + + Type + Type-var + + + + Version + Version-var + + + + SubControls + activeSubControls-var + QStyleOptionComplex::activeSubControls + + + SubControls + subControls-var + QStyleOptionComplex::subControls + + + + QStyleOptionDockWidget + qstyleoptiondockwidget.html + + QStyleOptionDockWidget + QStyleOptionDockWidget + () + + + QStyleOptionDockWidget + QStyleOptionDockWidget-2 + ( const QStyleOptionDockWidget & other ) + + + Type + Type-var + + + + Version + Version-var + + + + closable + closable-var + + + + floatable + floatable-var + + + + movable + movable-var + + + + title + title-var + + + + + QStyleOptionFocusRect + qstyleoptionfocusrect.html + + QStyleOptionFocusRect + QStyleOptionFocusRect + () + + + QStyleOptionFocusRect + QStyleOptionFocusRect-2 + ( const QStyleOptionFocusRect & other ) + + + Type + Type-var + + + + Version + Version-var + + + + backgroundColor + backgroundColor-var + + + + + QStyleOptionFrame + qstyleoptionframe.html + + QStyleOptionFrame + QStyleOptionFrame + () + + + QStyleOptionFrame + QStyleOptionFrame-2 + ( const QStyleOptionFrame & other ) + + + Type + Type-var + + + + Version + Version-var + + + + lineWidth + lineWidth-var + + + + midLineWidth + midLineWidth-var + + + + + QStyleOptionFrameV2 + qstyleoptionframev2.html + + QStyleOptionFrameV2 + QStyleOptionFrameV2 + () + + + QStyleOptionFrameV2 + QStyleOptionFrameV2-2 + ( const QStyleOptionFrameV2 & other ) + + + QStyleOptionFrameV2 + QStyleOptionFrameV2-3 + ( const QStyleOptionFrame & other ) + + + operator= + operator-eq + ( const QStyleOptionFrame & other ) + + + + QStyleOptionGroupBox + qstyleoptiongroupbox.html + + QStyleOptionGroupBox + QStyleOptionGroupBox + () + + + QStyleOptionGroupBox + QStyleOptionGroupBox-2 + ( const QStyleOptionGroupBox & other ) + + + lineWidth + lineWidth-var + + + + midLineWidth + midLineWidth-var + + + + text + text-var + + + + Alignment + textAlignment-var + QStyleOptionGroupBox::textAlignment + + + textColor + textColor-var + + + + + QStyleOptionHeader + qstyleoptionheader.html + + SectionPosition + SectionPosition-enum + + + + SelectedPosition + SelectedPosition-enum + + + + SortIndicator + SortIndicator-enum + + + + QStyleOptionHeader + QStyleOptionHeader + () + + + QStyleOptionHeader + QStyleOptionHeader-2 + ( const QStyleOptionHeader & other ) + + + Type + Type-var + + + + Version + Version-var + + + + icon + icon-var + + + + Alignment + iconAlignment-var + QStyleOptionHeader::iconAlignment + + + Orientation + orientation-var + QStyleOptionHeader::orientation + + + position + position-var + + + + section + section-var + + + + selectedPosition + selectedPosition-var + + + + sortIndicator + sortIndicator-var + + + + text + text-var + + + + Alignment + textAlignment-var + QStyleOptionHeader::textAlignment + + + + QStyleOption + qstyleoption.html + + OptionType + OptionType-enum + + + + QStyleOption + QStyleOption + ( int version = QStyleOption::Version, int type = SO_Default ) + + + QStyleOption + QStyleOption-2 + ( const QStyleOption & other ) + + + initFrom + initFrom + ( const QWidget * widget ) + + + operator= + operator-eq + ( const QStyleOption & other ) + + + Type + Type-var + + + + Version + Version-var + + + + LayoutDirection + direction-var + QStyleOption::direction + + + fontMetrics + fontMetrics-var + + + + palette + palette-var + + + + rect + rect-var + + + + State + state-var + QStyleOption::state + + + type + type-varx + + + + version + version-varx + + + + + QStyleOptionMenuItem + qstyleoptionmenuitem.html + + CheckType + CheckType-enum + + + + MenuItemType + MenuItemType-enum + + + + QStyleOptionMenuItem + QStyleOptionMenuItem + () + + + QStyleOptionMenuItem + QStyleOptionMenuItem-2 + ( const QStyleOptionMenuItem & other ) + + + Type + Type-var + + + + Version + Version-var + + + + checkType + checkType-var + + + + checked + checked-var + + + + font + font-var + + + + icon + icon-var + + + + maxIconWidth + maxIconWidth-var + + + + menuHasCheckableItems + menuHasCheckableItems-var + + + + menuItemType + menuItemType-var + + + + menuRect + menuRect-var + + + + tabWidth + tabWidth-var + + + + text + text-var + + + + init + init + ( const QWidget * widget ) + + + + QStyleOptionProgressBar + qstyleoptionprogressbar.html + + QStyleOptionProgressBar + QStyleOptionProgressBar + () + + + QStyleOptionProgressBar + QStyleOptionProgressBar-2 + ( const QStyleOptionProgressBar & other ) + + + Type + Type-var + + + + Version + Version-var + + + + maximum + maximum-var + + + + minimum + minimum-var + + + + progress + progress-var + + + + text + text-var + + + + Alignment + textAlignment-var + QStyleOptionProgressBar::textAlignment + + + textVisible + textVisible-var + + + + + QStyleOptionProgressBarV2 + qstyleoptionprogressbarv2.html + + QStyleOptionProgressBarV2 + QStyleOptionProgressBarV2 + () + + + QStyleOptionProgressBarV2 + QStyleOptionProgressBarV2-2 + ( const QStyleOptionProgressBar & other ) + + + QStyleOptionProgressBarV2 + QStyleOptionProgressBarV2-3 + ( const QStyleOptionProgressBarV2 & other ) + + + operator= + operator-eq + ( const QStyleOptionProgressBar & other ) + + + bottomToTop + bottomToTop-var + + + + invertedAppearance + invertedAppearance-var + + + + Orientation + orientation-var + QStyleOptionProgressBarV2::orientation + + + + QStyleOptionQ3DockWindow + qstyleoptionq3dockwindow.html + + QStyleOptionQ3DockWindow + QStyleOptionQ3DockWindow + () + + + QStyleOptionQ3DockWindow + QStyleOptionQ3DockWindow-2 + ( const QStyleOptionQ3DockWindow & other ) + + + Type + Type-var + + + + Version + Version-var + + + + closeEnabled + closeEnabled-var + + + + docked + docked-var + + + + + QStyleOptionQ3ListView + qstyleoptionq3listview.html + + QStyleOptionQ3ListView + QStyleOptionQ3ListView + () + + + QStyleOptionQ3ListView + QStyleOptionQ3ListView-2 + ( const QStyleOptionQ3ListView & other ) + + + Type + Type-var + + + + Version + Version-var + + + + itemMargin + itemMargin-var + + + + items + items-var + + + + rootIsDecorated + rootIsDecorated-var + + + + sortColumn + sortColumn-var + + + + treeStepSize + treeStepSize-var + + + + ColorRole + viewportBGRole-var + QStyleOptionQ3ListView::viewportBGRole + + + viewportPalette + viewportPalette-var + + + + + QStyleOptionQ3ListViewItem + qstyleoptionq3listviewitem.html + + QStyleOptionQ3ListViewItem + QStyleOptionQ3ListViewItem + () + + + QStyleOptionQ3ListViewItem + QStyleOptionQ3ListViewItem-2 + ( const QStyleOptionQ3ListViewItem & other ) + + + Type + Type-var + + + + Version + Version-var + + + + childCount + childCount-var + + + + features + features-var + + + + height + height-var + + + + itemY + itemY-var + + + + totalHeight + totalHeight-var + + + + + QStyleOptionRubberBand + qstyleoptionrubberband.html + + QStyleOptionRubberBand + QStyleOptionRubberBand + () + + + QStyleOptionRubberBand + QStyleOptionRubberBand-2 + ( const QStyleOptionRubberBand & other ) + + + Type + Type-var + + + + Version + Version-var + + + + opaque + opaque-var + + + + Shape + shape-var + QStyleOptionRubberBand::shape + + + + QStyleOptionSlider + qstyleoptionslider.html + + QStyleOptionSlider + QStyleOptionSlider + () + + + QStyleOptionSlider + QStyleOptionSlider-2 + ( const QStyleOptionSlider & other ) + + + Type + Type-var + + + + Version + Version-var + + + + dialWrapping + dialWrapping-var + + + + maximum + maximum-var + + + + minimum + minimum-var + + + + notchTarget + notchTarget-var + + + + Orientation + orientation-var + QStyleOptionSlider::orientation + + + pageStep + pageStep-var + + + + singleStep + singleStep-var + + + + sliderPosition + sliderPosition-var + + + + sliderValue + sliderValue-var + + + + tickInterval + tickInterval-var + + + + TickPosition + tickPosition-var + QStyleOptionSlider::tickPosition + + + upsideDown + upsideDown-var + + + + + QStyleOptionSpinBox + qstyleoptionspinbox.html + + QStyleOptionSpinBox + QStyleOptionSpinBox + () + + + QStyleOptionSpinBox + QStyleOptionSpinBox-2 + ( const QStyleOptionSpinBox & other ) + + + Type + Type-var + + + + Version + Version-var + + + + ButtonSymbols + buttonSymbols-var + QStyleOptionSpinBox::buttonSymbols + + + frame + frame-var + + + + StepEnabled + stepEnabled-var + QStyleOptionSpinBox::stepEnabled + + + + QStyleOptionTabBarBase + qstyleoptiontabbarbase.html + + QStyleOptionTabBarBase + QStyleOptionTabBarBase + () + + + QStyleOptionTabBarBase + QStyleOptionTabBarBase-2 + ( const QStyleOptionTabBarBase & other ) + + + Type + Type-var + + + + Version + Version-var + + + + selectedTabRect + selectedTabRect-var + + + + Shape + shape-var + QStyleOptionTabBarBase::shape + + + tabBarRect + tabBarRect-var + + + + + QStyleOptionTab + qstyleoptiontab.html + + SelectedPosition + SelectedPosition-enum + + + + TabPosition + TabPosition-enum + + + + QStyleOptionTab + QStyleOptionTab + () + + + QStyleOptionTab + QStyleOptionTab-2 + ( const QStyleOptionTab & other ) + + + Type + Type-var + + + + Version + Version-var + + + + cornerWidgets + cornerWidgets-var + + + + icon + icon-var + + + + position + position-var + + + + row + row-var + + + + selectedPosition + selectedPosition-var + + + + Shape + shape-var + QStyleOptionTab::shape + + + text + text-var + + + + + QStyleOptionTabV2 + qstyleoptiontabv2.html + + QStyleOptionTabV2 + QStyleOptionTabV2 + () + + + QStyleOptionTabV2 + QStyleOptionTabV2-2 + ( const QStyleOptionTabV2 & other ) + + + QStyleOptionTabV2 + QStyleOptionTabV2-3 + ( const QStyleOptionTab & other ) + + + operator= + operator-eq + ( const QStyleOptionTab & other ) + + + iconSize + iconSize-var + + + + + QStyleOptionTabWidgetFrame + qstyleoptiontabwidgetframe.html + + QStyleOptionTabWidgetFrame + QStyleOptionTabWidgetFrame + () + + + QStyleOptionTabWidgetFrame + QStyleOptionTabWidgetFrame-2 + ( const QStyleOptionTabWidgetFrame & other ) + + + Type + Type-var + + + + Version + Version-var + + + + leftCornerWidgetSize + leftCornerWidgetSize-var + + + + lineWidth + lineWidth-var + + + + midLineWidth + midLineWidth-var + + + + rightCornerWidgetSize + rightCornerWidgetSize-var + + + + Shape + shape-var + QStyleOptionTabWidgetFrame::shape + + + tabBarSize + tabBarSize-var + + + + + QStyleOptionTitleBar + qstyleoptiontitlebar.html + + QStyleOptionTitleBar + QStyleOptionTitleBar + () + + + QStyleOptionTitleBar + QStyleOptionTitleBar-2 + ( const QStyleOptionTitleBar & other ) + + + Type + Type-var + + + + Version + Version-var + + + + icon + icon-var + + + + text + text-var + + + + WFlags + titleBarFlags-var + QStyleOptionTitleBar::titleBarFlags + + + titleBarState + titleBarState-var + + + + + QStyleOptionToolBar + qstyleoptiontoolbar.html + + ToolBarPosition + ToolBarPosition-enum + + + + QStyleOptionToolBar + QStyleOptionToolBar + () + + + QStyleOptionToolBar + QStyleOptionToolBar-2 + ( const QStyleOptionToolBar & other ) + + + features + features-var + + + + lineWidth + lineWidth-var + + + + midLineWidth + midLineWidth-var + + + + positionOfLine + positionOfLine-var + + + + positionWithinLine + positionWithinLine-var + + + + ToolBarArea + toolBarArea-var + QStyleOptionToolBar::toolBarArea + + + + QStyleOptionToolBox + qstyleoptiontoolbox.html + + QStyleOptionToolBox + QStyleOptionToolBox + () + + + QStyleOptionToolBox + QStyleOptionToolBox-2 + ( const QStyleOptionToolBox & other ) + + + Type + Type-var + + + + Version + Version-var + + + + icon + icon-var + + + + text + text-var + + + + + QStyleOptionToolButton + qstyleoptiontoolbutton.html + + QStyleOptionToolButton + QStyleOptionToolButton + () + + + QStyleOptionToolButton + QStyleOptionToolButton-2 + ( const QStyleOptionToolButton & other ) + + + Type + Type-var + + + + Version + Version-var + + + + ArrowType + arrowType-var + QStyleOptionToolButton::arrowType + + + features + features-var + + + + font + font-var + + + + icon + icon-var + + + + iconSize + iconSize-var + + + + pos + pos-var + + + + text + text-var + + + + ToolButtonStyle + toolButtonStyle-var + QStyleOptionToolButton::toolButtonStyle + + + + QStyleOptionViewItem + qstyleoptionviewitem.html + + Position + Position-enum + + + + QStyleOptionViewItem + QStyleOptionViewItem + () + + + QStyleOptionViewItem + QStyleOptionViewItem-2 + ( const QStyleOptionViewItem & other ) + + + Type + Type-var + + + + Version + Version-var + + + + Alignment + decorationAlignment-var + QStyleOptionViewItem::decorationAlignment + + + decorationPosition + decorationPosition-var + + + + decorationSize + decorationSize-var + + + + Alignment + displayAlignment-var + QStyleOptionViewItem::displayAlignment + + + font + font-var + + + + showDecorationSelected + showDecorationSelected-var + + + + TextElideMode + textElideMode-var + QStyleOptionViewItem::textElideMode + + + + QStylePainter + qstylepainter.html + + QStylePainter + QStylePainter + () + + + QStylePainter + QStylePainter-2 + ( QWidget * widget ) + + + QStylePainter + QStylePainter-3 + ( QPaintDevice * pd, QWidget * widget ) + + + begin + begin + ( QWidget * widget ) + + + begin + begin-2 + ( QPaintDevice * pd, QWidget * widget ) + + + drawComplexControl + drawComplexControl + ( QStyle::ComplexControl cc, const QStyleOptionComplex & option ) + + + drawControl + drawControl + ( QStyle::ControlElement ce, const QStyleOption & option ) + + + drawItemPixmap + drawItemPixmap + ( const QRect & rect, int flags, const QPixmap & pixmap ) + + + drawItemText + drawItemText + ( const QRect & rect, int flags, const QPalette & pal, bool enabled, const QString & text, QPalette::ColorRole textRole = QPalette::NoRole ) + + + drawPrimitive + drawPrimitive + ( QStyle::PrimitiveElement pe, const QStyleOption & option ) + + + style + style + () + + + + QStylePlugin + qstyleplugin.html + + QStylePlugin + QStylePlugin + ( QObject * parent = 0 ) + + + create + create + ( const QString & key ) + + + keys + keys + () + + + + QSvgRenderer + qsvgrenderer.html + + QSvgRenderer + QSvgRenderer + ( QObject * parent = 0 ) + + + QSvgRenderer + QSvgRenderer-2 + ( const QString & filename, QObject * parent = 0 ) + + + QSvgRenderer + QSvgRenderer-3 + ( const QByteArray & contents, QObject * parent = 0 ) + + + animated + animated + () + + + currentFrame + currentFrame + () + + + defaultSize + defaultSize + () + + + isValid + isValid + () + + + load + load + ( const QString & filename ) + + + load + load-2 + ( const QByteArray & contents ) + + + render + render + ( QPainter * painter ) + + + repaintNeeded + repaintNeeded + () + + + setCurrentFrame + setCurrentFrame + ( int ) + + + + QSvgWidget + qsvgwidget.html + + QSvgWidget + QSvgWidget + ( QWidget * parent = 0 ) + + + QSvgWidget + QSvgWidget-2 + ( const QString & file, QWidget * parent = 0 ) + + + load + load + ( const QString & file ) + + + load + load-2 + ( const QByteArray & contents ) + + + renderer + renderer + () + + + + QSyntaxHighlighter + qsyntaxhighlighter.html + + QSyntaxHighlighter + QSyntaxHighlighter + ( QObject * parent ) + + + QSyntaxHighlighter + QSyntaxHighlighter-2 + ( QTextDocument * parent ) + + + QSyntaxHighlighter + QSyntaxHighlighter-3 + ( QTextEdit * parent ) + + + currentBlockState + currentBlockState + () + + + currentBlockUserData + currentBlockUserData + () + + + document + document + () + + + format + format + ( int position ) + + + highlightBlock + highlightBlock + ( const QString & text ) + + + previousBlockState + previousBlockState + () + + + setCurrentBlockState + setCurrentBlockState + ( int newState ) + + + setCurrentBlockUserData + setCurrentBlockUserData + ( QTextBlockUserData * data ) + + + setDocument + setDocument + ( QTextDocument * doc ) + + + setFormat + setFormat + ( int start, int count, const QTextCharFormat & format ) + + + setFormat + setFormat-2 + ( int start, int count, const QColor & color ) + + + setFormat + setFormat-3 + ( int start, int count, const QFont & font ) + + + + QSysInfo + qsysinfo.html + + Endian + Endian-enum + + + + MacVersion + MacVersion-enum + + + + WinVersion + WinVersion-enum + + + + MacintoshVersion + MacintoshVersion-var + + + + WindowsVersion + WindowsVersion-var + + + + WordSize + WordSize-var + + + + + QTabBar + qtabbar.html + + Shape + Shape-enum + + + + QTabBar + QTabBar + ( QWidget * parent = 0 ) + + + addTab + addTab + ( const QString & text ) + + + addTab + addTab-2 + ( const QIcon & icon, const QString & text ) + + + currentChanged + currentChanged + ( int index ) + + + insertTab + insertTab + ( int index, const QString & text ) + + + insertTab + insertTab-2 + ( int index, const QIcon & icon, const QString & text ) + + + isTabEnabled + isTabEnabled + ( int index ) + + + removeTab + removeTab + ( int index ) + + + setTabData + setTabData + ( int index, const QVariant & data ) + + + setTabEnabled + setTabEnabled + ( int index, bool enabled ) + + + setTabIcon + setTabIcon + ( int index, const QIcon & icon ) + + + setTabText + setTabText + ( int index, const QString & text ) + + + setTabTextColor + setTabTextColor + ( int index, const QColor & color ) + + + setTabToolTip + setTabToolTip + ( int index, const QString & tip ) + + + setTabWhatsThis + setTabWhatsThis + ( int index, const QString & text ) + + + tabData + tabData + ( int index ) + + + tabIcon + tabIcon + ( int index ) + + + tabInserted + tabInserted + ( int index ) + + + tabLayoutChange + tabLayoutChange + () + + + tabRect + tabRect + ( int index ) + + + tabRemoved + tabRemoved + ( int index ) + + + tabSizeHint + tabSizeHint + ( int index ) + + + tabText + tabText + ( int index ) + + + tabTextColor + tabTextColor + ( int index ) + + + tabToolTip + tabToolTip + ( int index ) + + + tabWhatsThis + tabWhatsThis + ( int index ) + + + selected + selected + ( int index ) + + + setCurrentTab + setCurrentTab + ( int index ) + + + + QTabletEvent + qtabletevent.html + + PointerType + PointerType-enum + + + + TabletDevice + TabletDevice-enum + + + + QTabletEvent + QTabletEvent + ( Type type, const QPoint & pos, const QPoint & globalPos, const QPointF & hiResGlobalPos, int device, int pointerType, qreal pressure, int xTilt, int yTilt, qreal tangentialPressure, qreal rotation, int z, Qt::KeyboardModifiers keyState, qint64 uniqueID ) + + + device + device + () + + + globalPos + globalPos + () + + + globalX + globalX + () + + + globalY + globalY + () + + + hiResGlobalPos + hiResGlobalPos + () + + + hiResGlobalX + hiResGlobalX + () + + + hiResGlobalY + hiResGlobalY + () + + + pointerType + pointerType + () + + + pos + pos + () + + + pressure + pressure + () + + + rotation + rotation + () + + + tangentialPressure + tangentialPressure + () + + + uniqueId + uniqueId + () + + + x + x + () + + + xTilt + xTilt + () + + + y + y + () + + + yTilt + yTilt + () + + + z + z + () + + + + QTableView + qtableview.html + + PenStyle + gridStyle-prop + + + + QTableView + QTableView + ( QWidget * parent = 0 ) + + + columnAt + columnAt + ( int x ) + + + columnCountChanged + columnCountChanged + ( int oldCount, int newCount ) + + + columnMoved + columnMoved + ( int column, int oldIndex, int newIndex ) + + + columnResized + columnResized + ( int column, int oldWidth, int newWidth ) + + + columnViewportPosition + columnViewportPosition + ( int column ) + + + columnWidth + columnWidth + ( int column ) + + + hideColumn + hideColumn + ( int column ) + + + hideRow + hideRow + ( int row ) + + + horizontalHeader + horizontalHeader + () + + + horizontalOffset + horizontalOffset + () + + + indexAt + indexAt + ( const QPoint & pos ) + + + isColumnHidden + isColumnHidden + ( int column ) + + + isRowHidden + isRowHidden + ( int row ) + + + moveCursor + moveCursor + ( CursorAction cursorAction, Qt::KeyboardModifiers modifiers ) + + + paintEvent + paintEvent + ( QPaintEvent * event ) + + + resizeColumnToContents + resizeColumnToContents + ( int column ) + + + resizeColumnsToContents + resizeColumnsToContents + () + + + resizeRowToContents + resizeRowToContents + ( int row ) + + + resizeRowsToContents + resizeRowsToContents + () + + + rowAt + rowAt + ( int y ) + + + rowCountChanged + rowCountChanged + ( int oldCount, int newCount ) + + + rowHeight + rowHeight + ( int row ) + + + rowMoved + rowMoved + ( int row, int oldIndex, int newIndex ) + + + rowResized + rowResized + ( int row, int oldHeight, int newHeight ) + + + rowViewportPosition + rowViewportPosition + ( int row ) + + + selectColumn + selectColumn + ( int column ) + + + selectRow + selectRow + ( int row ) + + + setColumnHidden + setColumnHidden + ( int column, bool hide ) + + + setColumnWidth + setColumnWidth + ( int column, int width ) + + + setHorizontalHeader + setHorizontalHeader + ( QHeaderView * header ) + + + setRowHeight + setRowHeight + ( int row, int height ) + + + setRowHidden + setRowHidden + ( int row, bool hide ) + + + setSelection + setSelection + ( const QRect & rect, QItemSelectionModel::SelectionFlags flags ) + + + setVerticalHeader + setVerticalHeader + ( QHeaderView * header ) + + + showColumn + showColumn + ( int column ) + + + showRow + showRow + ( int row ) + + + sizeHintForColumn + sizeHintForColumn + ( int column ) + + + sizeHintForRow + sizeHintForRow + ( int row ) + + + sortByColumn + sortByColumn + ( int column ) + + + verticalHeader + verticalHeader + () + + + verticalOffset + verticalOffset + () + + + + QTableWidget + qtablewidget.html + + QTableWidget + QTableWidget + ( QWidget * parent = 0 ) + + + QTableWidget + QTableWidget-2 + ( int rows, int columns, QWidget * parent = 0 ) + + + cellActivated + cellActivated + ( int row, int column ) + + + cellChanged + cellChanged + ( int row, int column ) + + + cellClicked + cellClicked + ( int row, int column ) + + + cellDoubleClicked + cellDoubleClicked + ( int row, int column ) + + + cellEntered + cellEntered + ( int row, int column ) + + + cellPressed + cellPressed + ( int row, int column ) + + + cellWidget + cellWidget + ( int row, int column ) + + + clear + clear + () + + + closePersistentEditor + closePersistentEditor + ( QTableWidgetItem * item ) + + + column + column + ( const QTableWidgetItem * item ) + + + currentCellChanged + currentCellChanged + ( int currentRow, int currentColumn, int previousRow, int previousColumn ) + + + currentColumn + currentColumn + () + + + currentItem + currentItem + () + + + currentItemChanged + currentItemChanged + ( QTableWidgetItem * current, QTableWidgetItem * previous ) + + + currentRow + currentRow + () + + + dropMimeData + dropMimeData + ( int row, int column, const QMimeData * data, Qt::DropAction action ) + + + editItem + editItem + ( QTableWidgetItem * item ) + + + event + event + ( QEvent * e ) + + + findItems + findItems + ( const QString & text, Qt::MatchFlags flags ) + + + horizontalHeaderItem + horizontalHeaderItem + ( int column ) + + + indexFromItem + indexFromItem + ( QTableWidgetItem * item ) + + + insertColumn + insertColumn + ( int column ) + + + insertRow + insertRow + ( int row ) + + + isItemSelected + isItemSelected + ( const QTableWidgetItem * item ) + + + item + item + ( int row, int column ) + + + itemActivated + itemActivated + ( QTableWidgetItem * item ) + + + itemAt + itemAt + ( const QPoint & point ) + + + itemAt + itemAt-2 + ( int ax, int ay ) + + + itemChanged + itemChanged + ( QTableWidgetItem * item ) + + + itemClicked + itemClicked + ( QTableWidgetItem * item ) + + + itemDoubleClicked + itemDoubleClicked + ( QTableWidgetItem * item ) + + + itemEntered + itemEntered + ( QTableWidgetItem * item ) + + + itemFromIndex + itemFromIndex + ( const QModelIndex & index ) + + + itemPressed + itemPressed + ( QTableWidgetItem * item ) + + + itemPrototype + itemPrototype + () + + + itemSelectionChanged + itemSelectionChanged + () + + + items + items + ( const QMimeData * data ) + + + mimeData + mimeData + ( const QList<QTableWidgetItem *> items ) + + + mimeTypes + mimeTypes + () + + + openPersistentEditor + openPersistentEditor + ( QTableWidgetItem * item ) + + + removeColumn + removeColumn + ( int column ) + + + removeRow + removeRow + ( int row ) + + + row + row + ( const QTableWidgetItem * item ) + + + scrollToItem + scrollToItem + ( const QTableWidgetItem * item, QAbstractItemView::ScrollHint hint = EnsureVisible ) + + + selectedItems + selectedItems + () + + + selectedRanges + selectedRanges + () + + + setCellWidget + setCellWidget + ( int row, int column, QWidget * widget ) + + + setCurrentCell + setCurrentCell + ( int row, int column ) + + + setCurrentItem + setCurrentItem + ( QTableWidgetItem * item ) + + + setHorizontalHeaderItem + setHorizontalHeaderItem + ( int column, QTableWidgetItem * item ) + + + setHorizontalHeaderLabels + setHorizontalHeaderLabels + ( const QStringList & labels ) + + + setItem + setItem + ( int row, int column, QTableWidgetItem * item ) + + + setItemPrototype + setItemPrototype + ( const QTableWidgetItem * item ) + + + setItemSelected + setItemSelected + ( const QTableWidgetItem * item, bool select ) + + + setRangeSelected + setRangeSelected + ( const QTableWidgetSelectionRange & range, bool select ) + + + setVerticalHeaderItem + setVerticalHeaderItem + ( int row, QTableWidgetItem * item ) + + + setVerticalHeaderLabels + setVerticalHeaderLabels + ( const QStringList & labels ) + + + sortItems + sortItems + ( int column, Qt::SortOrder order = Qt::AscendingOrder ) + + + DropActions + supportedDropActions + QTableWidget::supportedDropActions() + + + takeHorizontalHeaderItem + takeHorizontalHeaderItem + ( int column ) + + + takeItem + takeItem + ( int row, int column ) + + + takeVerticalHeaderItem + takeVerticalHeaderItem + ( int row ) + + + verticalHeaderItem + verticalHeaderItem + ( int row ) + + + visualColumn + visualColumn + ( int logicalColumn ) + + + visualItemRect + visualItemRect + ( const QTableWidgetItem * item ) + + + visualRow + visualRow + ( int logicalRow ) + + + + QTableWidgetItem + qtablewidgetitem.html + + QTableWidgetItem + QTableWidgetItem + ( int type = Type ) + + + QTableWidgetItem + QTableWidgetItem-2 + ( const QString & text, int type = Type ) + + + QTableWidgetItem + QTableWidgetItem-3 + ( const QTableWidgetItem & other ) + + + backgroundColor + backgroundColor + () + + + CheckState + checkState + QTableWidgetItem::checkState() + + + clone + clone + () + + + data + data + ( int role ) + + + ItemFlags + flags + QTableWidgetItem::flags() + + + font + font + () + + + icon + icon + () + + + read + read + ( QDataStream & in ) + + + setBackgroundColor + setBackgroundColor + ( const QColor & color ) + + + setCheckState + setCheckState + ( Qt::CheckState state ) + + + setData + setData + ( int role, const QVariant & value ) + + + setFlags + setFlags + ( Qt::ItemFlags flags ) + + + setFont + setFont + ( const QFont & font ) + + + setIcon + setIcon + ( const QIcon & icon ) + + + setSizeHint + setSizeHint + ( const QSize & size ) + + + setStatusTip + setStatusTip + ( const QString & statusTip ) + + + setText + setText + ( const QString & text ) + + + setTextAlignment + setTextAlignment + ( int alignment ) + + + setTextColor + setTextColor + ( const QColor & color ) + + + setToolTip + setToolTip + ( const QString & toolTip ) + + + setWhatsThis + setWhatsThis + ( const QString & whatsThis ) + + + sizeHint + sizeHint + () + + + statusTip + statusTip + () + + + tableWidget + tableWidget + () + + + text + text + () + + + textAlignment + textAlignment + () + + + textColor + textColor + () + + + toolTip + toolTip + () + + + type + type + () + + + whatsThis + whatsThis + () + + + write + write + ( QDataStream & out ) + + + operator< + operator-lt + ( const QTableWidgetItem & other ) + + + operator= + operator-eq + ( const QTableWidgetItem & other ) + + + Type + Type-var + + + + UserType + UserType-var + + + + + QTableWidgetSelectionRange + qtablewidgetselectionrange.html + + QTableWidgetSelectionRange + QTableWidgetSelectionRange + () + + + QTableWidgetSelectionRange + QTableWidgetSelectionRange-2 + ( int top, int left, int bottom, int right ) + + + QTableWidgetSelectionRange + QTableWidgetSelectionRange-3 + ( const QTableWidgetSelectionRange & other ) + + + bottomRow + bottomRow + () + + + columnCount + columnCount + () + + + leftColumn + leftColumn + () + + + rightColumn + rightColumn + () + + + rowCount + rowCount + () + + + topRow + topRow + () + + + + QTabWidget + qtabwidget.html + + TabPosition + TabPosition-enum + + + + TabShape + TabShape-enum + + + + QTabWidget + QTabWidget + ( QWidget * parent = 0 ) + + + addTab + addTab + ( QWidget * child, const QString & label ) + + + addTab + addTab-2 + ( QWidget * child, const QIcon & icon, const QString & label ) + + + cornerWidget + cornerWidget + ( Qt::Corner corner = Qt::TopRightCorner ) + + + currentChanged + currentChanged + ( int index ) + + + currentWidget + currentWidget + () + + + indexOf + indexOf + ( QWidget * w ) + + + insertTab + insertTab + ( int index, QWidget * w, const QString & label ) + + + insertTab + insertTab-4 + ( int index, QWidget * w, const QIcon & icon, const QString & label ) + + + isTabEnabled + isTabEnabled + ( int index ) + + + paintEvent + paintEvent + ( QPaintEvent * event ) + + + removeTab + removeTab + ( int index ) + + + setCornerWidget + setCornerWidget + ( QWidget * widget, Qt::Corner corner = Qt::TopRightCorner ) + + + setCurrentWidget + setCurrentWidget + ( QWidget * widget ) + + + setTabBar + setTabBar + ( QTabBar * tb ) + + + setTabEnabled + setTabEnabled + ( int index, bool enable ) + + + setTabIcon + setTabIcon + ( int index, const QIcon & icon ) + + + setTabText + setTabText + ( int index, const QString & label ) + + + setTabToolTip + setTabToolTip + ( int index, const QString & tip ) + + + setTabWhatsThis + setTabWhatsThis + ( int index, const QString & text ) + + + tabBar + tabBar + () + + + tabIcon + tabIcon + ( int index ) + + + tabInserted + tabInserted + ( int index ) + + + tabRemoved + tabRemoved + ( int index ) + + + tabText + tabText + ( int index ) + + + tabToolTip + tabToolTip + ( int index ) + + + tabWhatsThis + tabWhatsThis + ( int index ) + + + widget + widget + ( int index ) + + + QTabWidget + QTabWidget-2 + ( QWidget * parent, const char * name, Qt::WFlags f = 0 ) + + + changeTab + changeTab + ( QWidget * widget, const QString & label ) + + + changeTab + changeTab-2 + ( QWidget * widget, const QIcon & icon, const QString & label ) + + + currentChanged + currentChanged-2 + ( QWidget * widget ) + + + currentPage + currentPage + () + + + currentPageIndex + currentPageIndex + () + + + insertTab + insertTab-2 + ( QWidget * widget, const QString & label, int index = -1 ) + + + insertTab + insertTab-3 + ( QWidget * widget, const QIcon & icon, const QString & label, int index = -1 ) + + + isTabEnabled + isTabEnabled-2 + ( QWidget * widget ) + + + label + label + ( int index ) + + + margin + margin + () + + + page + page + ( int index ) + + + removePage + removePage + ( QWidget * widget ) + + + removeTabToolTip + removeTabToolTip + ( QWidget * widget ) + + + setCurrentPage + setCurrentPage + ( int index ) + + + setMargin + setMargin + ( int margin ) + + + setTabEnabled + setTabEnabled-2 + ( QWidget * widget, bool b ) + + + setTabIconSet + setTabIconSet + ( QWidget * widget, const QIcon & icon ) + + + setTabLabel + setTabLabel + ( QWidget * widget, const QString & label ) + + + setTabToolTip + setTabToolTip-2 + ( QWidget * widget, const QString & tip ) + + + showPage + showPage + ( QWidget * widget ) + + + tabIconSet + tabIconSet + ( QWidget * widget ) + + + tabLabel + tabLabel + ( QWidget * widget ) + + + tabToolTip + tabToolTip-2 + ( QWidget * widget ) + + + + QTcpServer + qtcpserver.html + + QTcpServer + QTcpServer + ( QObject * parent = 0 ) + + + close + close + () + + + errorString + errorString + () + + + hasPendingConnections + hasPendingConnections + () + + + incomingConnection + incomingConnection + ( int socketDescriptor ) + + + isListening + isListening + () + + + listen + listen + ( const QHostAddress & address = QHostAddress::Any, quint16 port = 0 ) + + + maxPendingConnections + maxPendingConnections + () + + + newConnection + newConnection + () + + + nextPendingConnection + nextPendingConnection + () + + + proxy + proxy + () + + + serverAddress + serverAddress + () + + + SocketError + serverError + QTcpServer::serverError() + + + serverPort + serverPort + () + + + setMaxPendingConnections + setMaxPendingConnections + ( int numConnections ) + + + setProxy + setProxy + ( const QNetworkProxy & networkProxy ) + + + setSocketDescriptor + setSocketDescriptor + ( int socketDescriptor ) + + + socketDescriptor + socketDescriptor + () + + + waitForNewConnection + waitForNewConnection + ( int msec = 0, bool * timedOut = 0 ) + + + + QTcpSocket + qtcpsocket.html + + QTcpSocket + QTcpSocket + ( QObject * parent = 0 ) + + + + QTemporaryFile + qtemporaryfile.html + + QTemporaryFile + QTemporaryFile + () + + + QTemporaryFile + QTemporaryFile-2 + ( const QString & templateName ) + + + QTemporaryFile + QTemporaryFile-3 + ( QObject * parent ) + + + QTemporaryFile + QTemporaryFile-4 + ( const QString & templateName, QObject * parent ) + + + autoRemove + autoRemove + () + + + createLocalFile + createLocalFile + ( QFile & file ) + + + createLocalFile + createLocalFile-2 + ( const QString & fileName ) + + + fileName + fileName + () + + + fileTemplate + fileTemplate + () + + + open + open + () + + + setAutoRemove + setAutoRemove + ( bool b ) + + + setFileTemplate + setFileTemplate + ( const QString & name ) + + + + QTestEventList + qtesteventlist.html + + QTestEventList + QTestEventList + () + + + QTestEventList + QTestEventList-2 + ( const QTestEventList & other ) + + + addDelay + addDelay + ( int msecs ) + + + addKeyClick + addKeyClick + ( Qt::Key qtKey, Qt::KeyboardModifiers modifiers = Qt::NoModifier, int msecs = -1 ) + + + addKeyClick + addKeyClick-2 + ( char ascii, Qt::KeyboardModifiers modifiers = Qt::NoModifier, int msecs = -1 ) + + + addKeyClicks + addKeyClicks + ( const QString & keys, Qt::KeyboardModifiers modifiers = Qt::NoModifier, int msecs = -1 ) + + + addKeyPress + addKeyPress + ( Qt::Key qtKey, Qt::KeyboardModifiers modifiers = Qt::NoModifier, int msecs = -1 ) + + + addKeyPress + addKeyPress-2 + ( char ascii, Qt::KeyboardModifiers modifiers = Qt::NoModifier, int msecs = -1 ) + + + addKeyRelease + addKeyRelease + ( Qt::Key qtKey, Qt::KeyboardModifiers modifiers = Qt::NoModifier, int msecs = -1 ) + + + addKeyRelease + addKeyRelease-2 + ( char ascii, Qt::KeyboardModifiers modifiers = Qt::NoModifier, int msecs = -1 ) + + + addMouseClick + addMouseClick + ( Qt::MouseButton button, Qt::KeyboardModifiers modifiers = 0, QPoint pos = QPoint() + + + addMouseDClick + addMouseDClick + ( Qt::MouseButton button, Qt::KeyboardModifiers modifiers = 0, QPoint pos = QPoint() + + + addMouseMove + addMouseMove + ( QPoint pos = QPoint() + + + addMousePress + addMousePress + ( Qt::MouseButton button, Qt::KeyboardModifiers modifiers = 0, QPoint pos = QPoint() + + + addMouseRelease + addMouseRelease + ( Qt::MouseButton button, Qt::KeyboardModifiers modifiers = 0, QPoint pos = QPoint() + + + clear + clear + () + + + simulate + simulate + ( QWidget * w ) + + + KeyAction + KeyAction-enum + + + + MouseAction + MouseAction-enum + + + + SkipMode + SkipMode-enum + + + + TestFailMode + TestFailMode-enum + + + + addColumn + addColumn + ( const char * name, T * dummy = 0 ) + + + currentDataTag + currentDataTag + () + + + currentTestFailed + currentTestFailed + () + + + currentTestFunction + currentTestFunction + () + + + ignoreMessage + ignoreMessage + ( QtMsgType type, const char * message ) + + + keyClick + keyClick + ( QWidget * widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1 ) + + + keyClick + keyClick-2 + ( QWidget * widget, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1 ) + + + keyClicks + keyClicks + ( QWidget * widget, const QString & sequence, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1 ) + + + keyEvent + keyEvent + ( KeyAction action, QWidget * widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1 ) + + + keyEvent + keyEvent-2 + ( KeyAction action, QWidget * widget, char ascii, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1 ) + + + keyPress + keyPress + ( QWidget * widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1 ) + + + keyPress + keyPress-2 + ( QWidget * widget, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1 ) + + + keyRelease + keyRelease + ( QWidget * widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1 ) + + + keyRelease + keyRelease-2 + ( QWidget * widget, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1 ) + + + mouseClick + mouseClick + ( QWidget * widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = 0, QPoint pos = QPoint() + + + mouseDClick + mouseDClick + ( QWidget * widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = 0, QPoint pos = QPoint() + + + mouseMove + mouseMove + ( QWidget * widget, QPoint pos = QPoint() + + + mousePress + mousePress + ( QWidget * widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = 0, QPoint pos = QPoint() + + + mouseRelease + mouseRelease + ( QWidget * widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = 0, QPoint pos = QPoint() + + + newRow + newRow + ( const char * dataTag ) + + + qExec + qExec + ( QObject * testObject, int argc = 0, char ** argv = 0 ) + + + qSleep + qSleep + ( int ms ) + + + qWait + qWait + ( int ms ) + + + toString + toString + ( const T & value ) + + + toString + toString-4 + ( const QLatin1String & string ) + + + toString + toString-5 + ( const QString & string ) + + + toString + toString-6 + ( const QTime & time ) + + + toString + toString-7 + ( const QDate & date ) + + + toString + toString-8 + ( const QDateTime & dateTime ) + + + toString + toString-9 + ( const QChar & character ) + + + + QTextBlockFormat + qtextblockformat.html + + QTextBlockFormat + QTextBlockFormat + () + + + Alignment + alignment + QTextBlockFormat::alignment() + + + bottomMargin + bottomMargin + () + + + indent + indent + () + + + isValid + isValid + () + + + leftMargin + leftMargin + () + + + nonBreakableLines + nonBreakableLines + () + + + rightMargin + rightMargin + () + + + setAlignment + setAlignment + ( Qt::Alignment alignment ) + + + setBottomMargin + setBottomMargin + ( qreal margin ) + + + setIndent + setIndent + ( int indentation ) + + + setLeftMargin + setLeftMargin + ( qreal margin ) + + + setNonBreakableLines + setNonBreakableLines + ( bool b ) + + + setRightMargin + setRightMargin + ( qreal margin ) + + + setTextIndent + setTextIndent + ( qreal indent ) + + + setTopMargin + setTopMargin + ( qreal margin ) + + + textIndent + textIndent + () + + + topMargin + topMargin + () + + + + QTextBlockGroup + qtextblockgroup.html + + QTextBlockGroup + QTextBlockGroup + ( QTextDocument * document ) + + + blockFormatChanged + blockFormatChanged + ( const QTextBlock & block ) + + + blockInserted + blockInserted + ( const QTextBlock & block ) + + + blockList + blockList + () + + + blockRemoved + blockRemoved + ( const QTextBlock & block ) + + + + QTextBlock + qtextblock.html + + Iterator + Iterator-typedef + + + + QTextBlock + QTextBlock-3 + ( const QTextBlock & other ) + + + begin + begin + () + + + blockFormat + blockFormat + () + + + blockFormatIndex + blockFormatIndex + () + + + charFormat + charFormat + () + + + charFormatIndex + charFormatIndex + () + + + contains + contains + ( int position ) + + + document + document + () + + + end + end + () + + + isValid + isValid + () + + + layout + layout + () + + + length + length + () + + + next + next + () + + + position + position + () + + + previous + previous + () + + + setUserData + setUserData + ( QTextBlockUserData * data ) + + + setUserState + setUserState + ( int state ) + + + text + text + () + + + textList + textList + () + + + userData + userData + () + + + userState + userState + () + + + operator!= + operator-not-eq + ( const QTextBlock & other ) + + + operator< + operator-lt + ( const QTextBlock & other ) + + + operator= + operator-eq + ( const QTextBlock & other ) + + + operator== + operator-eq-eq + ( const QTextBlock & other ) + + + + QTextBlock::iterator + qtextblock-iterator.html + + iterator + iterator-2 + () + + + iterator + iterator-3 + ( const iterator & other ) + + + atEnd + atEnd + () + + + fragment + fragment + () + + + operator!= + operator-not-eq + ( const iterator & other ) + + + operator++ + operator-2b-2b + () + + + operator++ + operator-2b-2b-2 + ( int ) + + + operator-- + operator-- + () + + + operator-- + operator---2 + ( int ) + + + operator== + operator-eq-eq + ( const iterator & other ) + + + + QTextBlockUserData + qtextblockuserdata.html + + + QTextBrowser + qtextbrowser.html + + QTextBrowser + QTextBrowser + ( QWidget * parent = 0 ) + + + anchorClicked + anchorClicked + ( const QUrl & link ) + + + backward + backward + () + + + backwardAvailable + backwardAvailable + ( bool available ) + + + forward + forward + () + + + forwardAvailable + forwardAvailable + ( bool available ) + + + highlighted + highlighted + ( const QUrl & link ) + + + highlighted + highlighted-2 + ( const QString & link ) + + + home + home + () + + + keyPressEvent + keyPressEvent + ( QKeyEvent * ev ) + + + loadResource + loadResource + ( int type, const QUrl & name ) + + + reload + reload + () + + + sourceChanged + sourceChanged + ( const QUrl & src ) + + + QTextBrowser + QTextBrowser-2 + ( QWidget * parent, const char * name ) + + + + QTextCharFormat + qtextcharformat.html + + VerticalAlignment + VerticalAlignment-enum + + + + QTextCharFormat + QTextCharFormat + () + + + anchorHref + anchorHref + () + + + anchorName + anchorName + () + + + font + font + () + + + fontFamily + fontFamily + () + + + fontFixedPitch + fontFixedPitch + () + + + fontItalic + fontItalic + () + + + fontOverline + fontOverline + () + + + fontPointSize + fontPointSize + () + + + fontStrikeOut + fontStrikeOut + () + + + fontUnderline + fontUnderline + () + + + fontWeight + fontWeight + () + + + isAnchor + isAnchor + () + + + isValid + isValid + () + + + setAnchor + setAnchor + ( bool anchor ) + + + setAnchorHref + setAnchorHref + ( const QString & value ) + + + setAnchorName + setAnchorName + ( const QString & name ) + + + setFont + setFont + ( const QFont & font ) + + + setFontFamily + setFontFamily + ( const QString & family ) + + + setFontFixedPitch + setFontFixedPitch + ( bool fixedPitch ) + + + setFontItalic + setFontItalic + ( bool italic ) + + + setFontOverline + setFontOverline + ( bool overline ) + + + setFontPointSize + setFontPointSize + ( qreal size ) + + + setFontStrikeOut + setFontStrikeOut + ( bool strikeOut ) + + + setFontUnderline + setFontUnderline + ( bool underline ) + + + setFontWeight + setFontWeight + ( int weight ) + + + setTableCellColumnSpan + setTableCellColumnSpan + ( int tableCellColumnSpan ) + + + setTableCellRowSpan + setTableCellRowSpan + ( int tableCellRowSpan ) + + + setTextOutline + setTextOutline + ( const QPen & pen ) + + + setUnderlineColor + setUnderlineColor + ( const QColor & color ) + + + setVerticalAlignment + setVerticalAlignment + ( VerticalAlignment alignment ) + + + tableCellColumnSpan + tableCellColumnSpan + () + + + tableCellRowSpan + tableCellRowSpan + () + + + textOutline + textOutline + () + + + underlineColor + underlineColor + () + + + verticalAlignment + verticalAlignment + () + + + + QTextCodec::ConverterState + qtextcodec-converterstate.html + + ConverterState + ConverterState + ( ConversionFlags flags = DefaultConversion ) + + + + QTextCodec + qtextcodec.html + + QTextCodec + QTextCodec + () + + + aliases + aliases + () + + + availableCodecs + availableCodecs + () + + + availableMibs + availableMibs + () + + + canEncode + canEncode + ( QChar ch ) + + + canEncode + canEncode-2 + ( const QString & s ) + + + codecForCStrings + codecForCStrings + () + + + codecForLocale + codecForLocale + () + + + codecForMib + codecForMib + ( int mib ) + + + codecForName + codecForName + ( const QByteArray & name ) + + + codecForName + codecForName-2 + ( const char * name ) + + + codecForTr + codecForTr + () + + + convertFromUnicode + convertFromUnicode + ( const QChar * input, int number, ConverterState * state ) + + + convertToUnicode + convertToUnicode + ( const char * chars, int len, ConverterState * state ) + + + fromUnicode + fromUnicode + ( const QString & str ) + + + fromUnicode + fromUnicode-2 + ( const QChar * input, int number, ConverterState * state = 0 ) + + + makeDecoder + makeDecoder + () + + + makeEncoder + makeEncoder + () + + + mibEnum + mibEnum + () + + + name + name + () + + + setCodecForCStrings + setCodecForCStrings + ( QTextCodec * c ) + + + setCodecForLocale + setCodecForLocale + ( QTextCodec * c ) + + + setCodecForTr + setCodecForTr + ( QTextCodec * c ) + + + toUnicode + toUnicode + ( const QByteArray & a ) + + + toUnicode + toUnicode-2 + ( const char * input, int size, ConverterState * state = 0 ) + + + toUnicode + toUnicode-4 + ( const char * chars ) + + + + QTextCodecPlugin + qtextcodecplugin.html + + QTextCodecPlugin + QTextCodecPlugin + ( QObject * parent = 0 ) + + + aliases + aliases + () + + + createForMib + createForMib + ( int mib ) + + + createForName + createForName + ( const QByteArray & name ) + + + mibEnums + mibEnums + () + + + names + names + () + + + codecForContent + codecForContent + ( const char * str, int size ) + + + codecForIndex + codecForIndex + ( int i ) + + + codecForName + codecForName-3 + ( const char * hint, int accuracy ) + + + fromUnicode + fromUnicode-3 + ( const QString & uc, int & lenInOut ) + + + locale + locale + () + + + mimeName + mimeName + () + + + toUnicode + toUnicode-3 + ( const QByteArray & a, int len ) + + + + QTextCursor + qtextcursor.html + + MoveMode + MoveMode-enum + + + + MoveOperation + MoveOperation-enum + + + + SelectionType + SelectionType-enum + + + + QTextCursor + QTextCursor + () + + + QTextCursor + QTextCursor-2 + ( QTextDocument * document ) + + + QTextCursor + QTextCursor-4 + ( QTextFrame * frame ) + + + QTextCursor + QTextCursor-5 + ( const QTextBlock & block ) + + + QTextCursor + QTextCursor-7 + ( const QTextCursor & cursor ) + + + anchor + anchor + () + + + atBlockEnd + atBlockEnd + () + + + atBlockStart + atBlockStart + () + + + atEnd + atEnd + () + + + atStart + atStart + () + + + beginEditBlock + beginEditBlock + () + + + block + block + () + + + blockCharFormat + blockCharFormat + () + + + blockFormat + blockFormat + () + + + charFormat + charFormat + () + + + clearSelection + clearSelection + () + + + createList + createList + ( const QTextListFormat & format ) + + + createList + createList-2 + ( QTextListFormat::Style style ) + + + currentFrame + currentFrame + () + + + currentList + currentList + () + + + currentTable + currentTable + () + + + deleteChar + deleteChar + () + + + deletePreviousChar + deletePreviousChar + () + + + endEditBlock + endEditBlock + () + + + hasComplexSelection + hasComplexSelection + () + + + hasSelection + hasSelection + () + + + insertBlock + insertBlock + () + + + insertBlock + insertBlock-2 + ( const QTextBlockFormat & format ) + + + insertBlock + insertBlock-3 + ( const QTextBlockFormat & format, const QTextCharFormat & charFormat ) + + + insertFragment + insertFragment + ( const QTextDocumentFragment & fragment ) + + + insertFrame + insertFrame + ( const QTextFrameFormat & format ) + + + insertImage + insertImage + ( const QTextImageFormat & format ) + + + insertImage + insertImage-2 + ( const QString & name ) + + + insertList + insertList + ( const QTextListFormat & format ) + + + insertList + insertList-2 + ( QTextListFormat::Style style ) + + + insertTable + insertTable + ( int rows, int columns, const QTextTableFormat & format ) + + + insertTable + insertTable-2 + ( int rows, int columns ) + + + insertText + insertText + ( const QString & text ) + + + insertText + insertText-2 + ( const QString & text, const QTextCharFormat & format ) + + + isCopyOf + isCopyOf + ( const QTextCursor & other ) + + + isNull + isNull + () + + + joinPreviousEditBlock + joinPreviousEditBlock + () + + + mergeBlockCharFormat + mergeBlockCharFormat + ( const QTextCharFormat & modifier ) + + + mergeBlockFormat + mergeBlockFormat + ( const QTextBlockFormat & modifier ) + + + mergeCharFormat + mergeCharFormat + ( const QTextCharFormat & modifier ) + + + movePosition + movePosition + ( MoveOperation operation, MoveMode mode = MoveAnchor, int n = 1 ) + + + position + position + () + + + removeSelectedText + removeSelectedText + () + + + select + select + ( SelectionType selection ) + + + selectedTableCells + selectedTableCells + ( int * firstRow, int * numRows, int * firstColumn, int * numColumns ) + + + selectedText + selectedText + () + + + selection + selection + () + + + selectionEnd + selectionEnd + () + + + selectionStart + selectionStart + () + + + setBlockCharFormat + setBlockCharFormat + ( const QTextCharFormat & format ) + + + setBlockFormat + setBlockFormat + ( const QTextBlockFormat & format ) + + + setCharFormat + setCharFormat + ( const QTextCharFormat & format ) + + + setPosition + setPosition + ( int pos, MoveMode m = MoveAnchor ) + + + operator!= + operator-not-eq + ( const QTextCursor & other ) + + + operator< + operator-lt + ( const QTextCursor & other ) + + + operator<= + operator-lt-eq + ( const QTextCursor & other ) + + + operator= + operator-eq + ( const QTextCursor & cursor ) + + + operator== + operator-eq-eq + ( const QTextCursor & other ) + + + operator> + operator-gt + ( const QTextCursor & other ) + + + operator>= + operator-gt-eq + ( const QTextCursor & other ) + + + + QTextDecoder + qtextdecoder.html + + QTextDecoder + QTextDecoder + ( const QTextCodec * codec ) + + + toUnicode + toUnicode + ( const char * chars, int len ) + + + toUnicode + toUnicode-2 + ( const QByteArray & ba ) + + + + QTextDocumentFragment + qtextdocumentfragment.html + + QTextDocumentFragment + QTextDocumentFragment + () + + + QTextDocumentFragment + QTextDocumentFragment-2 + ( const QTextDocument * document ) + + + QTextDocumentFragment + QTextDocumentFragment-3 + ( const QTextCursor & cursor ) + + + QTextDocumentFragment + QTextDocumentFragment-4 + ( const QTextDocumentFragment & other ) + + + fromHtml + fromHtml + ( const QString & text ) + + + fromPlainText + fromPlainText + ( const QString & plainText ) + + + isEmpty + isEmpty + () + + + toHtml + toHtml + () + + + toPlainText + toPlainText + () + + + operator= + operator-eq + ( const QTextDocumentFragment & other ) + + + + QTextDocument + qtextdocument.html + + MetaInformation + MetaInformation-enum + + + + ResourceType + ResourceType-enum + + + + QTextDocument + QTextDocument + ( QObject * parent = 0 ) + + + QTextDocument + QTextDocument-2 + ( const QString & text, QObject * parent = 0 ) + + + addResource + addResource + ( int type, const QUrl & name, const QVariant & resource ) + + + allFormats + allFormats + () + + + begin + begin + () + + + clear + clear + () + + + clone + clone + ( QObject * parent = 0 ) + + + contentsChange + contentsChange + ( int position, int charsRemoved, int charsAdded ) + + + contentsChanged + contentsChanged + () + + + createObject + createObject + ( const QTextFormat & format ) + + + cursorPositionChanged + cursorPositionChanged + ( const QTextCursor & cursor ) + + + documentLayout + documentLayout + () + + + end + end + () + + + find + find + ( const QString & expr, const QTextCursor & cursor, FindFlags options = 0 ) + + + find + find-2 + ( const QString & expr, int position = 0, FindFlags options = 0 ) + + + findBlock + findBlock + ( int pos ) + + + isEmpty + isEmpty + () + + + isRedoAvailable + isRedoAvailable + () + + + isUndoAvailable + isUndoAvailable + () + + + loadResource + loadResource + ( int type, const QUrl & name ) + + + markContentsDirty + markContentsDirty + ( int position, int length ) + + + metaInformation + metaInformation + ( MetaInformation info ) + + + modificationChanged + modificationChanged + ( bool changed ) + + + object + object + ( int objectIndex ) + + + objectForFormat + objectForFormat + ( const QTextFormat & f ) + + + pageCount + pageCount + () + + + print + print + ( QPrinter * printer ) + + + redo + redo + () + + + redoAvailable + redoAvailable + ( bool available ) + + + resource + resource + ( int type, const QUrl & name ) + + + rootFrame + rootFrame + () + + + setDocumentLayout + setDocumentLayout + ( QAbstractTextDocumentLayout * layout ) + + + setHtml + setHtml + ( const QString & html ) + + + setMetaInformation + setMetaInformation + ( MetaInformation info, const QString & string ) + + + setPlainText + setPlainText + ( const QString & text ) + + + toHtml + toHtml + ( const QByteArray & encoding = QByteArray() + + + toPlainText + toPlainText + () + + + undo + undo + () + + + undoAvailable + undoAvailable + ( bool available ) + + + + QTextEdit + qtextedit.html + + CursorAction + CursorAction-enum + + + + LineWrapMode + LineWrapMode-enum + + + + WrapMode + wordWrapMode-prop + + + + QTextEdit + QTextEdit + ( QWidget * parent = 0 ) + + + QTextEdit + QTextEdit-2 + ( const QString & text, QWidget * parent = 0 ) + + + Alignment + alignment + QTextEdit::alignment() + + + anchorAt + anchorAt + ( const QPoint & pos ) + + + append + append + ( const QString & text ) + + + canInsertFromMimeData + canInsertFromMimeData + ( const QMimeData * source ) + + + clear + clear + () + + + contextMenuEvent + contextMenuEvent + ( QContextMenuEvent * e ) + + + copy + copy + () + + + copyAvailable + copyAvailable + ( bool yes ) + + + createMimeDataFromSelection + createMimeDataFromSelection + () + + + createStandardContextMenu + createStandardContextMenu + () + + + currentCharFormat + currentCharFormat + () + + + currentCharFormatChanged + currentCharFormatChanged + ( const QTextCharFormat & f ) + + + currentFont + currentFont + () + + + cursorForPosition + cursorForPosition + ( const QPoint & pos ) + + + cursorPositionChanged + cursorPositionChanged + () + + + cursorRect + cursorRect + ( const QTextCursor & cursor ) + + + cursorRect + cursorRect-2 + () + + + cut + cut + () + + + document + document + () + + + ensureCursorVisible + ensureCursorVisible + () + + + find + find + ( const QString & exp, QTextDocument::FindFlags options = 0 ) + + + fontFamily + fontFamily + () + + + fontItalic + fontItalic + () + + + fontPointSize + fontPointSize + () + + + fontUnderline + fontUnderline + () + + + fontWeight + fontWeight + () + + + insertFromMimeData + insertFromMimeData + ( const QMimeData * source ) + + + insertHtml + insertHtml + ( const QString & text ) + + + insertPlainText + insertPlainText + ( const QString & text ) + + + loadResource + loadResource + ( int type, const QUrl & name ) + + + mergeCurrentCharFormat + mergeCurrentCharFormat + ( const QTextCharFormat & modifier ) + + + paste + paste + () + + + redoAvailable + redoAvailable + ( bool available ) + + + scrollToAnchor + scrollToAnchor + ( const QString & name ) + + + selectAll + selectAll + () + + + selectionChanged + selectionChanged + () + + + setAlignment + setAlignment + ( Qt::Alignment a ) + + + setCurrentCharFormat + setCurrentCharFormat + ( const QTextCharFormat & format ) + + + setCurrentFont + setCurrentFont + ( const QFont & f ) + + + setDocument + setDocument + ( QTextDocument * document ) + + + setFontFamily + setFontFamily + ( const QString & fontFamily ) + + + setFontItalic + setFontItalic + ( bool italic ) + + + setFontPointSize + setFontPointSize + ( qreal s ) + + + setFontUnderline + setFontUnderline + ( bool underline ) + + + setFontWeight + setFontWeight + ( int w ) + + + setPlainText + setPlainText + ( const QString & text ) + + + setTextColor + setTextColor + ( const QColor & c ) + + + setTextCursor + setTextCursor + ( const QTextCursor & cursor ) + + + textChanged + textChanged + () + + + textColor + textColor + () + + + textCursor + textCursor + () + + + toPlainText + toPlainText + () + + + undoAvailable + undoAvailable + ( bool available ) + + + zoomIn + zoomIn + ( int range = 1 ) + + + zoomOut + zoomOut + ( int range = 1 ) + + + KeyboardAction + KeyboardAction-enum + + + + QTextEdit + QTextEdit-4 + ( QWidget * parent, const char * name ) + + + bold + bold + () + + + color + color + () + + + currentColorChanged + currentColorChanged + ( const QColor & color ) + + + currentFontChanged + currentFontChanged + ( const QFont & font ) + + + doKeyboardAction + doKeyboardAction + ( KeyboardAction action ) + + + family + family + () + + + find + find-2 + ( const QString & exp, bool cs, bool wo ) + + + hasSelectedText + hasSelectedText + () + + + insert + insert + ( const QString & text ) + + + isModified + isModified + () + + + isRedoAvailable + isRedoAvailable + () + + + isUndoAvailable + isUndoAvailable + () + + + italic + italic + () + + + moveCursor + moveCursor + ( CursorAction action, QTextCursor::MoveMode mode = QTextCursor::MoveAnchor ) + + + moveCursor + moveCursor-2 + ( CursorAction action, bool select ) + + + pointSize + pointSize + () + + + redo + redo + () + + + selectedText + selectedText + () + + + setBold + setBold + ( bool b ) + + + setColor + setColor + ( const QColor & color ) + + + setFamily + setFamily + ( const QString & family ) + + + setItalic + setItalic + ( bool i ) + + + setModified + setModified + ( bool m = true ) + + + setPointSize + setPointSize + ( int size ) + + + setText + setText + ( const QString & text ) + + + setTextFormat + setTextFormat + ( Qt::TextFormat f ) + + + setUnderline + setUnderline + ( bool b ) + + + sync + sync + () + + + text + text + () + + + TextFormat + textFormat + QTextEdit::textFormat() + + + underline + underline + () + + + undo + undo + () + + + + QTextEncoder + qtextencoder.html + + QTextEncoder + QTextEncoder + ( const QTextCodec * codec ) + + + fromUnicode + fromUnicode + ( const QString & str ) + + + fromUnicode + fromUnicode-2 + ( const QChar * uc, int len ) + + + fromUnicode + fromUnicode-3 + ( const QString & uc, int & lenInOut ) + + + + QTextFormat + qtextformat.html + + FormatType + FormatType-enum + + + + ObjectTypes + ObjectTypes-enum + + + + Property + Property-enum + + + + QTextFormat + QTextFormat + () + + + QTextFormat + QTextFormat-2 + ( int type ) + + + QTextFormat + QTextFormat-3 + ( const QTextFormat & other ) + + + background + background + () + + + boolProperty + boolProperty + ( int propertyId ) + + + brushProperty + brushProperty + ( int propertyId ) + + + clearBackground + clearBackground + () + + + clearForeground + clearForeground + () + + + clearProperty + clearProperty + ( int propertyId ) + + + colorProperty + colorProperty + ( int propertyId ) + + + doubleProperty + doubleProperty + ( int propertyId ) + + + foreground + foreground + () + + + hasProperty + hasProperty + ( int propertyId ) + + + intProperty + intProperty + ( int propertyId ) + + + isBlockFormat + isBlockFormat + () + + + isCharFormat + isCharFormat + () + + + isFrameFormat + isFrameFormat + () + + + isImageFormat + isImageFormat + () + + + isListFormat + isListFormat + () + + + isTableFormat + isTableFormat + () + + + isValid + isValid + () + + + LayoutDirection + layoutDirection + QTextFormat::layoutDirection() + + + lengthProperty + lengthProperty + ( int propertyId ) + + + lengthVectorProperty + lengthVectorProperty + ( int propertyId ) + + + merge + merge + ( const QTextFormat & other ) + + + objectIndex + objectIndex + () + + + objectType + objectType + () + + + penProperty + penProperty + ( int propertyId ) + + + properties + properties + () + + + property + property + ( int propertyId ) + + + setBackground + setBackground + ( const QBrush & brush ) + + + setForeground + setForeground + ( const QBrush & brush ) + + + setLayoutDirection + setLayoutDirection + ( Qt::LayoutDirection direction ) + + + setObjectIndex + setObjectIndex + ( int index ) + + + setObjectType + setObjectType + ( int type ) + + + setProperty + setProperty + ( int propertyId, const QVariant & value ) + + + setProperty + setProperty-2 + ( int propertyId, const QVector<QTextLength> & value ) + + + stringProperty + stringProperty + ( int propertyId ) + + + toBlockFormat + toBlockFormat + () + + + toCharFormat + toCharFormat + () + + + toFrameFormat + toFrameFormat + () + + + toImageFormat + toImageFormat + () + + + toListFormat + toListFormat + () + + + toTableFormat + toTableFormat + () + + + type + type + () + + + operator + operator-QVariant + QVariant() + + + operator!= + operator-not-eq + ( const QTextFormat & other ) + + + operator= + operator-eq + ( const QTextFormat & other ) + + + operator== + operator-eq-eq + ( const QTextFormat & other ) + + + + QTextFragment + qtextfragment.html + + QTextFragment + QTextFragment-2 + () + + + QTextFragment + QTextFragment-3 + ( const QTextFragment & other ) + + + charFormat + charFormat + () + + + charFormatIndex + charFormatIndex + () + + + contains + contains + ( int position ) + + + isValid + isValid + () + + + length + length + () + + + position + position + () + + + text + text + () + + + operator!= + operator-not-eq + ( const QTextFragment & other ) + + + operator< + operator-lt + ( const QTextFragment & other ) + + + operator= + operator-eq + ( const QTextFragment & other ) + + + operator== + operator-eq-eq + ( const QTextFragment & other ) + + + + QTextFrameFormat + qtextframeformat.html + + Position + Position-enum + + + + QTextFrameFormat + QTextFrameFormat + () + + + border + border + () + + + height + height + () + + + isValid + isValid + () + + + margin + margin + () + + + padding + padding + () + + + position + position + () + + + setBorder + setBorder + ( qreal width ) + + + setHeight + setHeight + ( const QTextLength & height ) + + + setHeight + setHeight-2 + ( qreal height ) + + + setMargin + setMargin + ( qreal margin ) + + + setPadding + setPadding + ( qreal width ) + + + setPosition + setPosition + ( Position policy ) + + + setWidth + setWidth + ( const QTextLength & width ) + + + setWidth + setWidth-2 + ( qreal width ) + + + width + width + () + + + + QTextFrame + qtextframe.html + + Iterator + Iterator-typedef + + + + QTextFrame + QTextFrame + ( QTextDocument * document ) + + + begin + begin + () + + + childFrames + childFrames + () + + + end + end + () + + + firstCursorPosition + firstCursorPosition + () + + + firstPosition + firstPosition + () + + + frameFormat + frameFormat + () + + + lastCursorPosition + lastCursorPosition + () + + + lastPosition + lastPosition + () + + + parentFrame + parentFrame + () + + + setFrameFormat + setFrameFormat + ( const QTextFrameFormat & format ) + + + + QTextFrame::iterator + qtextframe-iterator.html + + iterator + iterator-2 + () + + + iterator + iterator-3 + ( const iterator & other ) + + + atEnd + atEnd + () + + + currentBlock + currentBlock + () + + + currentFrame + currentFrame + () + + + parentFrame + parentFrame + () + + + operator!= + operator-not-eq + ( const iterator & other ) + + + operator++ + operator-2b-2b + () + + + operator++ + operator-2b-2b-2 + ( int ) + + + operator-- + operator-- + () + + + operator-- + operator---2 + ( int ) + + + operator= + operator-eq + ( const iterator & other ) + + + operator== + operator-eq-eq + ( const iterator & other ) + + + + QTextImageFormat + qtextimageformat.html + + QTextImageFormat + QTextImageFormat + () + + + height + height + () + + + isValid + isValid + () + + + name + name + () + + + setHeight + setHeight + ( qreal height ) + + + setName + setName + ( const QString & name ) + + + setWidth + setWidth + ( qreal width ) + + + width + width + () + + + + QTextInlineObject + qtextinlineobject.html + + QTextInlineObject + QTextInlineObject + ( int i, QTextEngine * e ) + + + ascent + ascent + () + + + descent + descent + () + + + format + format + () + + + formatIndex + formatIndex + () + + + height + height + () + + + isValid + isValid + () + + + rect + rect + () + + + setAscent + setAscent + ( qreal a ) + + + setDescent + setDescent + ( qreal d ) + + + setWidth + setWidth + ( qreal w ) + + + LayoutDirection + textDirection + QTextInlineObject::textDirection() + + + textPosition + textPosition + () + + + width + width + () + + + + QTextIStream + qtextistream.html + + QTextIStream + QTextIStream + ( const QString * string ) + + + QTextIStream + QTextIStream-2 + ( QByteArray * byteArray ) + + + QTextIStream + QTextIStream-3 + ( FILE * file ) + + + + QTextLayout::FormatRange + qtextlayout-formatrange.html + + + QTextLayout + qtextlayout.html + + CursorMode + CursorMode-enum + + + + QTextLayout + QTextLayout + () + + + QTextLayout + QTextLayout-2 + ( const QString & text ) + + + QTextLayout + QTextLayout-3 + ( const QString & text, const QFont & font, QPaintDevice * paintdevice = 0 ) + + + additionalFormats + additionalFormats + () + + + beginLayout + beginLayout + () + + + boundingRect + boundingRect + () + + + cacheEnabled + cacheEnabled + () + + + clearAdditionalFormats + clearAdditionalFormats + () + + + createLine + createLine + () + + + draw + draw + ( QPainter * p, const QPointF & pos, const QVector<FormatRange> & selections = QVector<FormatRange>() + + + drawCursor + drawCursor + ( QPainter * painter, const QPointF & position, int cursorPosition ) + + + endLayout + endLayout + () + + + font + font + () + + + isValidCursorPosition + isValidCursorPosition + ( int pos ) + + + lineAt + lineAt + ( int i ) + + + lineCount + lineCount + () + + + lineForTextPosition + lineForTextPosition + ( int pos ) + + + maximumWidth + maximumWidth + () + + + minimumWidth + minimumWidth + () + + + nextCursorPosition + nextCursorPosition + ( int oldPos, CursorMode mode = SkipCharacters ) + + + position + position + () + + + preeditAreaPosition + preeditAreaPosition + () + + + preeditAreaText + preeditAreaText + () + + + previousCursorPosition + previousCursorPosition + ( int oldPos, CursorMode mode = SkipCharacters ) + + + setAdditionalFormats + setAdditionalFormats + ( const QList<FormatRange> & formatList ) + + + setCacheEnabled + setCacheEnabled + ( bool enable ) + + + setFont + setFont + ( const QFont & font ) + + + setPosition + setPosition + ( const QPointF & p ) + + + setPreeditArea + setPreeditArea + ( int position, const QString & text ) + + + setText + setText + ( const QString & string ) + + + setTextOption + setTextOption + ( const QTextOption & option ) + + + text + text + () + + + textOption + textOption + () + + + + QTextLength + qtextlength.html + + Type + Type-enum + + + + QTextLength + QTextLength + () + + + QTextLength + QTextLength-2 + ( Type type, qreal value ) + + + rawValue + rawValue + () + + + type + type + () + + + value + value + ( qreal maximumLength ) + + + operator + operator-QVariant + QVariant() + + + operator!= + operator-not-eq + ( const QTextLength & other ) + + + operator== + operator-eq-eq + ( const QTextLength & other ) + + + + QTextLine + qtextline.html + + CursorPosition + CursorPosition-enum + + + + Edge + Edge-enum + + + + QTextLine + QTextLine + () + + + ascent + ascent + () + + + cursorToX + cursorToX + ( int * cursorPos, Edge edge = Leading ) + + + cursorToX + cursorToX-2 + ( int cursorPos, Edge edge = Leading ) + + + descent + descent + () + + + draw + draw + ( QPainter * painter, const QPointF & position, const QTextLayout::FormatRange * selection = 0 ) + + + height + height + () + + + isValid + isValid + () + + + lineNumber + lineNumber + () + + + naturalTextRect + naturalTextRect + () + + + naturalTextWidth + naturalTextWidth + () + + + rect + rect + () + + + setLineWidth + setLineWidth + ( qreal width ) + + + setNumColumns + setNumColumns + ( int numColumns ) + + + setPosition + setPosition + ( const QPointF & pos ) + + + textLength + textLength + () + + + textStart + textStart + () + + + width + width + () + + + x + x + () + + + xToCursor + xToCursor + ( qreal x, CursorPosition cpos = CursorBetweenCharacters ) + + + y + y + () + + + + QTextListFormat + qtextlistformat.html + + Style + Style-enum + + + + QTextListFormat + QTextListFormat + () + + + indent + indent + () + + + isValid + isValid + () + + + setIndent + setIndent + ( int indentation ) + + + setStyle + setStyle + ( Style style ) + + + style + style + () + + + + QTextList + qtextlist.html + + add + add + ( const QTextBlock & block ) + + + count + count + () + + + format + format + () + + + item + item + ( int i ) + + + itemNumber + itemNumber + ( const QTextBlock & block ) + + + itemText + itemText + ( const QTextBlock & block ) + + + remove + remove + ( const QTextBlock & block ) + + + removeItem + removeItem + ( int i ) + + + setFormat + setFormat + ( const QTextListFormat & format ) + + + isEmpty + isEmpty + () + + + + QTextObject + qtextobject.html + + QTextObject + QTextObject + ( QTextDocument * document ) + + + document + document + () + + + format + format + () + + + formatIndex + formatIndex + () + + + objectIndex + objectIndex + () + + + setFormat + setFormat + ( const QTextFormat & format ) + + + + QTextOption + qtextoption.html + + WrapMode + WrapMode-enum + + + + QTextOption + QTextOption + () + + + QTextOption + QTextOption-2 + ( Qt::Alignment alignment ) + + + QTextOption + QTextOption-3 + ( const QTextOption & other ) + + + Alignment + alignment + QTextOption::alignment() + + + flags + flags + () + + + setAlignment + setAlignment + ( Qt::Alignment alignment ) + + + setFlags + setFlags + ( Flags flags ) + + + setTabArray + setTabArray + ( QList<qreal> tabStops ) + + + setTabStop + setTabStop + ( qreal tabStop ) + + + setTextDirection + setTextDirection + ( Qt::LayoutDirection direction ) + + + setUseDesignMetrics + setUseDesignMetrics + ( bool enable ) + + + setWrapMode + setWrapMode + ( WrapMode mode ) + + + tabArray + tabArray + () + + + tabStop + tabStop + () + + + LayoutDirection + textDirection + QTextOption::textDirection() + + + useDesignMetrics + useDesignMetrics + () + + + wrapMode + wrapMode + () + + + operator= + operator-eq + ( const QTextOption & other ) + + + + QTextOStream + qtextostream.html + + QTextOStream + QTextOStream + ( QString * string ) + + + QTextOStream + QTextOStream-2 + ( QByteArray * byteArray ) + + + QTextOStream + QTextOStream-3 + ( FILE * file ) + + + + QTextStream + qtextstream.html + + FieldAlignment + FieldAlignment-enum + + + + RealNumberNotation + RealNumberNotation-enum + + + + Status + Status-enum + + + + QTextStream + QTextStream + () + + + QTextStream + QTextStream-2 + ( QIODevice * device ) + + + QTextStream + QTextStream-3 + ( FILE * fileHandle, QIODevice::OpenMode openMode = QIODevice::ReadWrite ) + + + QTextStream + QTextStream-4 + ( QString * string, QIODevice::OpenMode openMode = QIODevice::ReadWrite ) + + + QTextStream + QTextStream-5 + ( QByteArray * array, QIODevice::OpenMode openMode = QIODevice::ReadWrite ) + + + QTextStream + QTextStream-6 + ( const QByteArray & array, QIODevice::OpenMode openMode = QIODevice::ReadOnly ) + + + atEnd + atEnd + () + + + autoDetectUnicode + autoDetectUnicode + () + + + codec + codec + () + + + device + device + () + + + fieldAlignment + fieldAlignment + () + + + fieldWidth + fieldWidth + () + + + flush + flush + () + + + generateByteOrderMark + generateByteOrderMark + () + + + integerBase + integerBase + () + + + numberFlags + numberFlags + () + + + padChar + padChar + () + + + read + read + ( qint64 maxlen ) + + + readAll + readAll + () + + + readLine + readLine + ( qint64 maxlen = 0 ) + + + realNumberNotation + realNumberNotation + () + + + realNumberPrecision + realNumberPrecision + () + + + reset + reset + () + + + resetStatus + resetStatus + () + + + seek + seek + ( qint64 pos ) + + + setAutoDetectUnicode + setAutoDetectUnicode + ( bool enabled ) + + + setCodec + setCodec + ( QTextCodec * codec ) + + + setCodec + setCodec-2 + ( const char * codecName ) + + + setDevice + setDevice + ( QIODevice * device ) + + + setFieldAlignment + setFieldAlignment + ( FieldAlignment mode ) + + + setFieldWidth + setFieldWidth + ( int width ) + + + setGenerateByteOrderMark + setGenerateByteOrderMark + ( bool generate ) + + + setIntegerBase + setIntegerBase + ( int base ) + + + setNumberFlags + setNumberFlags + ( NumberFlags flags ) + + + setPadChar + setPadChar + ( QChar ch ) + + + setRealNumberNotation + setRealNumberNotation + ( RealNumberNotation notation ) + + + setRealNumberPrecision + setRealNumberPrecision + ( int precision ) + + + setStatus + setStatus + ( Status status ) + + + setString + setString + ( QString * string, QIODevice::OpenMode openMode = QIODevice::ReadWrite ) + + + skipWhiteSpace + skipWhiteSpace + () + + + status + status + () + + + string + string + () + + + operator<< + operator-lt-lt + ( QChar c ) + + + operator<< + operator-lt-lt-2 + ( signed short i ) + + + operator<< + operator-lt-lt-3 + ( float f ) + + + operator<< + operator-lt-lt-4 + ( const QString & string ) + + + operator<< + operator-lt-lt-6 + ( char c ) + + + operator<< + operator-lt-lt-7 + ( unsigned short i ) + + + operator<< + operator-lt-lt-8 + ( signed int i ) + + + operator<< + operator-lt-lt-9 + ( unsigned int i ) + + + operator<< + operator-lt-lt-10 + ( signed long i ) + + + operator<< + operator-lt-lt-11 + ( unsigned long i ) + + + operator<< + operator-lt-lt-12 + ( qlonglong i ) + + + operator<< + operator-lt-lt-13 + ( qulonglong i ) + + + operator<< + operator-lt-lt-14 + ( double f ) + + + operator<< + operator-lt-lt-15 + ( const QByteArray & array ) + + + operator<< + operator-lt-lt-16 + ( const char * string ) + + + operator<< + operator-lt-lt-17 + ( const void * ptr ) + + + operator>> + operator-gt-gt + ( QChar & c ) + + + operator>> + operator-gt-gt-2 + ( signed short & i ) + + + operator>> + operator-gt-gt-3 + ( float & f ) + + + operator>> + operator-gt-gt-4 + ( QString & str ) + + + operator>> + operator-gt-gt-5 + ( char & c ) + + + operator>> + operator-gt-gt-6 + ( unsigned short & i ) + + + operator>> + operator-gt-gt-7 + ( signed int & i ) + + + operator>> + operator-gt-gt-8 + ( unsigned int & i ) + + + operator>> + operator-gt-gt-9 + ( signed long & i ) + + + operator>> + operator-gt-gt-10 + ( unsigned long & i ) + + + operator>> + operator-gt-gt-11 + ( qlonglong & i ) + + + operator>> + operator-gt-gt-12 + ( qulonglong & i ) + + + operator>> + operator-gt-gt-13 + ( double & f ) + + + operator>> + operator-gt-gt-14 + ( QByteArray & array ) + + + operator>> + operator-gt-gt-15 + ( char * c ) + + + Encoding + Encoding-enum + + + + fill + fill + ( int f ) + + + flags + flags + () + + + flags + flags-2 + ( int f ) + + + precision + precision + ( int p ) + + + read + read-2 + () + + + setEncoding + setEncoding + ( Encoding encoding ) + + + setf + setf + ( int bits ) + + + setf + setf-2 + ( int bits, int mask ) + + + unsetDevice + unsetDevice + () + + + unsetf + unsetf + ( int bits ) + + + width + width + ( int w ) + + + adjustfield + adjustfield-var + + + + basefield + basefield-var + + + + bin + bin-var + + + + dec + dec-var + + + + fixed + fixed-var + + + + floatfield + floatfield-var + + + + hex + hex-var + + + + internal + internal-var + + + + left + left-var + + + + oct + oct-var + + + + right + right-var + + + + scientific + scientific-var + + + + showbase + showbase-var + + + + showpoint + showpoint-var + + + + showpos + showpos-var + + + + skipws + skipws-var + + + + uppercase + uppercase-var + + + + + QTextTableCell + qtexttablecell.html + + QTextTableCell + QTextTableCell + () + + + QTextTableCell + QTextTableCell-2 + ( const QTextTableCell & other ) + + + iterator + begin + QTextTableCell::begin() + + + column + column + () + + + columnSpan + columnSpan + () + + + iterator + end + QTextTableCell::end() + + + firstCursorPosition + firstCursorPosition + () + + + format + format + () + + + isValid + isValid + () + + + lastCursorPosition + lastCursorPosition + () + + + row + row + () + + + rowSpan + rowSpan + () + + + operator!= + operator-not-eq + ( const QTextTableCell & other ) + + + operator= + operator-eq + ( const QTextTableCell & other ) + + + operator== + operator-eq-eq + ( const QTextTableCell & other ) + + + + QTextTableFormat + qtexttableformat.html + + QTextTableFormat + QTextTableFormat + () + + + Alignment + alignment + QTextTableFormat::alignment() + + + cellPadding + cellPadding + () + + + cellSpacing + cellSpacing + () + + + clearColumnWidthConstraints + clearColumnWidthConstraints + () + + + columnWidthConstraints + columnWidthConstraints + () + + + columns + columns + () + + + isValid + isValid + () + + + setAlignment + setAlignment + ( Qt::Alignment alignment ) + + + setCellPadding + setCellPadding + ( qreal padding ) + + + setCellSpacing + setCellSpacing + ( qreal spacing ) + + + setColumnWidthConstraints + setColumnWidthConstraints + ( const QVector<QTextLength> & constraints ) + + + setColumns + setColumns + ( int columns ) + + + + QTextTable + qtexttable.html + + cellAt + cellAt + ( int row, int column ) + + + cellAt + cellAt-2 + ( int position ) + + + cellAt + cellAt-3 + ( const QTextCursor & cursor ) + + + columns + columns + () + + + format + format + () + + + insertColumns + insertColumns + ( int index, int columns ) + + + insertRows + insertRows + ( int index, int rows ) + + + mergeCells + mergeCells + ( int row, int column, int numRows, int numCols ) + + + mergeCells + mergeCells-2 + ( const QTextCursor & cursor ) + + + removeColumns + removeColumns + ( int index, int columns ) + + + removeRows + removeRows + ( int index, int rows ) + + + resize + resize + ( int rows, int columns ) + + + rowEnd + rowEnd + ( const QTextCursor & cursor ) + + + rowStart + rowStart + ( const QTextCursor & cursor ) + + + rows + rows + () + + + setFormat + setFormat + ( const QTextTableFormat & format ) + + + splitCell + splitCell + ( int row, int column, int numRows, int numCols ) + + + + QThread + qthread.html + + Priority + Priority-enum + + + + QThread + QThread + ( QObject * parent = 0 ) + + + currentThread + currentThread + () + + + HANDLE + currentThreadId + QThread::currentThreadId() + + + exec + exec + () + + + exit + exit + ( int returnCode = 0 ) + + + finished + finished + () + + + isFinished + isFinished + () + + + isRunning + isRunning + () + + + msleep + msleep + ( unsigned long msecs ) + + + priority + priority + () + + + quit + quit + () + + + run + run + () + + + setPriority + setPriority + ( Priority priority ) + + + setStackSize + setStackSize + ( uint stackSize ) + + + setTerminationEnabled + setTerminationEnabled + ( bool enabled = true ) + + + sleep + sleep + ( unsigned long secs ) + + + stackSize + stackSize + () + + + start + start + ( QThread::Priority = InheritPriority ) + + + started + started + () + + + terminate + terminate + () + + + terminated + terminated + () + + + usleep + usleep + ( unsigned long usecs ) + + + wait + wait + ( unsigned long time = ULONG_MAX ) + + + finished + finished-2 + () + + + running + running + () + + + + QThreadStorage + qthreadstorage.html + + QThreadStorage + QThreadStorage + () + + + hasLocalData + hasLocalData + () + + + localData + localData + () + + + localData + localData-2 + () + + + setLocalData + setLocalData + ( T data ) + + + AnchorAttribute + AnchorAttribute-enum + + + + ArrowType + ArrowType-enum + + + + AspectRatioMode + AspectRatioMode-enum + + + + BGMode + BGMode-enum + + + + BrushStyle + BrushStyle-enum + + + + CaseSensitivity + CaseSensitivity-enum + + + + CheckState + CheckState-enum + + + + ClipOperation + ClipOperation-enum + + + + ConnectionType + ConnectionType-enum + + + + ContextMenuPolicy + ContextMenuPolicy-enum + + + + Corner + Corner-enum + + + + CursorShape + CursorShape-enum + + + + DayOfWeek + DayOfWeek-enum + + + + Dock + Dock-enum + + + + FillRule + FillRule-enum + + + + FocusPolicy + FocusPolicy-enum + + + + FocusReason + FocusReason-enum + + + + GlobalColor + GlobalColor-enum + + + + HANDLE + HANDLE-typedef + + + + HitTestAccuracy + HitTestAccuracy-enum + + + + InputMethodQuery + InputMethodQuery-enum + + + + ItemDataRole + ItemDataRole-enum + + + + Key + Key-enum + + + + LayoutDirection + LayoutDirection-enum + + + + Modifier + Modifier-enum + + + + PenCapStyle + PenCapStyle-enum + + + + PenJoinStyle + PenJoinStyle-enum + + + + PenStyle + PenStyle-enum + + + + ScrollBarPolicy + ScrollBarPolicy-enum + + + + ShortcutContext + ShortcutContext-enum + + + + SortOrder + SortOrder-enum + + + + TextElideMode + TextElideMode-enum + + + + TextFlag + TextFlag-enum + + + + TextFormat + TextFormat-enum + + + + TimeSpec + TimeSpec-enum + + + + ToolButtonStyle + ToolButtonStyle-enum + + + + TransformationMode + TransformationMode-enum + + + + UIEffect + UIEffect-enum + + + + WFlags + WFlags-typedef + + + + WhiteSpaceMode + WhiteSpaceMode-enum + + + + WidgetAttribute + WidgetAttribute-enum + + + + WindowModality + WindowModality-enum + + + + convertFromPlainText + convertFromPlainText + ( const QString & plain, WhiteSpaceMode mode = WhiteSpacePre ) + + + escape + escape + ( const QString & plain ) + + + mightBeRichText + mightBeRichText + ( const QString & text ) + + + + QTimeEdit + qtimeedit.html + + QTimeEdit + QTimeEdit + ( QWidget * parent = 0 ) + + + QTimeEdit + QTimeEdit-2 + ( const QTime & time, QWidget * parent = 0 ) + + + + QTime + qtime.html + + QTime + QTime + () + + + QTime + QTime-2 + ( int h, int m, int s = 0, int ms = 0 ) + + + addMSecs + addMSecs + ( int ms ) + + + addSecs + addSecs + ( int nsecs ) + + + currentTime + currentTime-2 + () + + + elapsed + elapsed + () + + + fromString + fromString + ( const QString & string, Qt::DateFormat format = Qt::TextDate ) + + + fromString + fromString-2 + ( const QString & string, const QString & format ) + + + hour + hour + () + + + isNull + isNull + () + + + isValid + isValid + () + + + isValid + isValid-2 + ( int h, int m, int s, int ms = 0 ) + + + minute + minute + () + + + msec + msec + () + + + msecsTo + msecsTo + ( const QTime & t ) + + + restart + restart + () + + + second + second + () + + + secsTo + secsTo + ( const QTime & t ) + + + setHMS + setHMS + ( int h, int m, int s, int ms = 0 ) + + + start + start + () + + + toString + toString + ( const QString & format ) + + + toString + toString-2 + ( Qt::DateFormat f = Qt::TextDate ) + + + operator!= + operator-not-eq + ( const QTime & t ) + + + operator< + operator-lt + ( const QTime & t ) + + + operator<= + operator-lt-eq + ( const QTime & t ) + + + operator== + operator-eq-eq + ( const QTime & t ) + + + operator> + operator-gt + ( const QTime & t ) + + + operator>= + operator-gt-eq + ( const QTime & t ) + + + currentTime + currentTime + ( Qt::TimeSpec spec ) + + + + QTimerEvent + qtimerevent.html + + QTimerEvent + QTimerEvent + ( int timerId ) + + + timerId + timerId + () + + + + QTimer + qtimer.html + + QTimer + QTimer + ( QObject * parent = 0 ) + + + isActive + isActive + () + + + singleShot + singleShot + ( int msec, QObject * receiver, const char * member ) + + + start + start + ( int msec ) + + + start + start-2 + () + + + stop + stop + () + + + timeout + timeout + () + + + timerId + timerId + () + + + QTimer + QTimer-2 + ( QObject * parent, const char * name ) + + + changeInterval + changeInterval + ( int msec ) + + + start + start-3 + ( int msec, bool sshot ) + + + + QToolBar + qtoolbar.html + + ToolBarAreas + allowedAreas-prop + + + + Orientation + orientation-prop + + + + ToolButtonStyle + toolButtonStyle-prop + + + + QToolBar + QToolBar + ( const QString & title, QWidget * parent = 0 ) + + + QToolBar + QToolBar-2 + ( QWidget * parent = 0 ) + + + actionAt + actionAt + ( const QPoint & p ) + + + actionAt + actionAt-2 + ( int x, int y ) + + + actionTriggered + actionTriggered + ( QAction * action ) + + + addAction + addAction + ( const QString & text ) + + + addAction + addAction-2 + ( const QIcon & icon, const QString & text ) + + + addAction + addAction-3 + ( const QString & text, const QObject * receiver, const char * member ) + + + addAction + addAction-4 + ( const QIcon & icon, const QString & text, const QObject * receiver, const char * member ) + + + addSeparator + addSeparator + () + + + addWidget + addWidget + ( QWidget * widget ) + + + allowedAreasChanged + allowedAreasChanged + ( Qt::ToolBarAreas allowedAreas ) + + + clear + clear + () + + + iconSizeChanged + iconSizeChanged + ( const QSize & iconSize ) + + + insertSeparator + insertSeparator + ( QAction * before ) + + + insertWidget + insertWidget + ( QAction * before, QWidget * widget ) + + + isAreaAllowed + isAreaAllowed + ( Qt::ToolBarArea area ) + + + movableChanged + movableChanged + ( bool movable ) + + + orientationChanged + orientationChanged + ( Qt::Orientation orientation ) + + + toggleViewAction + toggleViewAction + () + + + toolButtonStyleChanged + toolButtonStyleChanged + ( Qt::ToolButtonStyle toolButtonStyle ) + + + QToolBar + QToolBar-3 + ( QWidget * parent, const char * name ) + + + label + label + () + + + setLabel + setLabel + ( const QString & label ) + + + + QToolBox + qtoolbox.html + + QToolBox + QToolBox + ( QWidget * parent = 0, Qt::WFlags f = 0 ) + + + addItem + addItem + ( QWidget * widget, const QIcon & iconSet, const QString & text ) + + + addItem + addItem-2 + ( QWidget * w, const QString & text ) + + + currentChanged + currentChanged + ( int index ) + + + currentWidget + currentWidget + () + + + indexOf + indexOf + ( QWidget * widget ) + + + insertItem + insertItem + ( int index, QWidget * widget, const QIcon & icon, const QString & text ) + + + insertItem + insertItem-2 + ( int index, QWidget * widget, const QString & text ) + + + isItemEnabled + isItemEnabled + ( int index ) + + + itemIcon + itemIcon + ( int index ) + + + itemInserted + itemInserted + ( int index ) + + + itemRemoved + itemRemoved + ( int index ) + + + itemText + itemText + ( int index ) + + + itemToolTip + itemToolTip + ( int index ) + + + removeItem + removeItem + ( int index ) + + + setCurrentWidget + setCurrentWidget + ( QWidget * widget ) + + + setItemEnabled + setItemEnabled + ( int index, bool enabled ) + + + setItemIcon + setItemIcon + ( int index, const QIcon & icon ) + + + setItemText + setItemText + ( int index, const QString & text ) + + + setItemToolTip + setItemToolTip + ( int index, const QString & toolTip ) + + + widget + widget + ( int index ) + + + QToolBox + QToolBox-2 + ( QWidget * parent, const char * name, Qt::WFlags f = 0 ) + + + currentItem + currentItem + () + + + item + item + ( int index ) + + + itemIconSet + itemIconSet + ( int index ) + + + itemLabel + itemLabel + ( int index ) + + + removeItem + removeItem-2 + ( QWidget * widget ) + + + setCurrentItem + setCurrentItem + ( QWidget * widget ) + + + setItemIconSet + setItemIconSet + ( int index, const QIcon & icon ) + + + setItemLabel + setItemLabel + ( int index, const QString & text ) + + + + QToolButton + qtoolbutton.html + + ToolButtonPopupMode + ToolButtonPopupMode-enum + + + + ArrowType + arrowType-prop + + + + ToolButtonStyle + toolButtonStyle-prop + + + + QToolButton + QToolButton + ( QWidget * parent = 0 ) + + + defaultAction + defaultAction + () + + + menu + menu + () + + + paintEvent + paintEvent + ( QPaintEvent * event ) + + + setDefaultAction + setDefaultAction + ( QAction * action ) + + + setMenu + setMenu + ( QMenu * menu ) + + + showMenu + showMenu + () + + + triggered + triggered + ( QAction * action ) + + + TextPosition + TextPosition-enum + + + + QToolButton + QToolButton-3 + ( QWidget * parent, const char * name ) + + + QToolButton + QToolButton-4 + ( Qt::ArrowType type, QWidget * parent, const char * name ) + + + QToolButton + QToolButton-5 + ( const QIcon & icon, const QString & textLabel, const QString & statusTip, QObject * receiver, const char * slot, QWidget * parent, const char * name = 0 ) + + + iconSet + iconSet + () + + + iconSet + iconSet-2 + ( bool on ) + + + offIconSet + offIconSet + () + + + onIconSet + onIconSet + () + + + openPopup + openPopup + () + + + popup + popup + () + + + popupDelay + popupDelay + () + + + setIconSet + setIconSet + ( const QIcon & icon ) + + + setIconSet + setIconSet-2 + ( const QIcon & set, bool on ) + + + setOffIconSet + setOffIconSet + ( const QIcon & set ) + + + setOnIconSet + setOnIconSet + ( const QIcon & set ) + + + setPixmap + setPixmap + ( const QPixmap & pixmap ) + + + setPopup + setPopup + ( QMenu * popup ) + + + setPopupDelay + setPopupDelay + ( int delay ) + + + setTextLabel + setTextLabel + ( const QString & text, bool tooltip = true ) + + + setTextPosition + setTextPosition + ( QToolButton::TextPosition pos ) + + + setUsesBigPixmap + setUsesBigPixmap + ( bool enable ) + + + setUsesTextLabel + setUsesTextLabel + ( bool enable ) + + + textLabel + textLabel + () + + + textPosition + textPosition + () + + + usesBigPixmap + usesBigPixmap + () + + + usesTextLabel + usesTextLabel + () + + + + QToolTip + qtooltip.html + + palette + palette + () + + + showText + showText + ( const QPoint & pos, const QString & text, QWidget * w = 0 ) + + + add + add + ( QWidget * widget, const QString & text ) + + + add + add-2 + ( QWidget * widget, const QRect & rect, const QString & text ) + + + remove + remove + ( QWidget * widget ) + + + BackgroundMode + BackgroundMode-enum + + + + ButtonState + ButtonState-typedef + + + + ButtonState_enum + ButtonState_enum-enum + + + + GUIStyle + GUIStyle-enum + + + + MacintoshVersion + MacintoshVersion-enum + + + + PaintUnit + PaintUnit-enum + + + + ScaleMode + ScaleMode-typedef + + + + TextFlags + TextFlags-typedef + + + + ToolBarDock + ToolBarDock-typedef + + + + WindowsVersion + WindowsVersion-enum + + + + + QTransformedScreen + qtransformedscreen.html + + Transformation + Transformation-enum + + + + QTransformedScreen + QTransformedScreen + ( int displayId ) + + + setTransformation + setTransformation + ( Transformation transformation ) + + + transformation + transformation + () + + + + QTranslator + qtranslator.html + + QTranslator + QTranslator + ( QObject * parent = 0 ) + + + isEmpty + isEmpty + () + + + load + load + ( const QString & filename, const QString & directory = QString() + + + load + load-2 + ( const uchar * data, int len ) + + + translate + translate + ( const char * context, const char * sourceText, const char * comment = 0 ) + + + QTranslator + QTranslator-2 + ( QObject * parent, const char * name ) + + + find + find + ( const char * context, const char * sourceText, const char * comment = 0 ) + + + + QTreeView + qtreeview.html + + QTreeView + QTreeView + ( QWidget * parent = 0 ) + + + collapse + collapse + ( const QModelIndex & index ) + + + collapsed + collapsed + ( const QModelIndex & index ) + + + columnAt + columnAt + ( int x ) + + + columnCountChanged + columnCountChanged + ( int oldCount, int newCount ) + + + columnMoved + columnMoved + () + + + columnResized + columnResized + ( int column, int oldSize, int newSize ) + + + columnViewportPosition + columnViewportPosition + ( int column ) + + + columnWidth + columnWidth + ( int column ) + + + doItemsLayout + doItemsLayout + () + + + drawBranches + drawBranches + ( QPainter * painter, const QRect & rect, const QModelIndex & index ) + + + drawRow + drawRow + ( QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index ) + + + expand + expand + ( const QModelIndex & index ) + + + expanded + expanded + ( const QModelIndex & index ) + + + header + header + () + + + hideColumn + hideColumn + ( int column ) + + + horizontalOffset + horizontalOffset + () + + + indexAbove + indexAbove + ( const QModelIndex & index ) + + + indexBelow + indexBelow + ( const QModelIndex & index ) + + + indexRowSizeHint + indexRowSizeHint + ( const QModelIndex & index ) + + + isColumnHidden + isColumnHidden + ( int column ) + + + isExpanded + isExpanded + ( const QModelIndex & index ) + + + isRowHidden + isRowHidden + ( int row, const QModelIndex & parent ) + + + moveCursor + moveCursor + ( CursorAction cursorAction, Qt::KeyboardModifiers modifiers ) + + + resizeColumnToContents + resizeColumnToContents + ( int column ) + + + rowsAboutToBeRemoved + rowsAboutToBeRemoved + ( const QModelIndex & parent, int start, int end ) + + + rowsInserted + rowsInserted + ( const QModelIndex & parent, int start, int end ) + + + rowsRemoved + rowsRemoved + ( const QModelIndex & parent, int start, int end ) + + + scrollContentsBy + scrollContentsBy + ( int dx, int dy ) + + + scrollTo + scrollTo + ( const QModelIndex & index, ScrollHint hint = EnsureVisible ) + + + selectAll + selectAll + () + + + setColumnHidden + setColumnHidden + ( int column, bool hide ) + + + setExpanded + setExpanded + ( const QModelIndex & index, bool expanded ) + + + setHeader + setHeader + ( QHeaderView * header ) + + + setRowHidden + setRowHidden + ( int row, const QModelIndex & parent, bool hide ) + + + setSelection + setSelection + ( const QRect & rect, QItemSelectionModel::SelectionFlags command ) + + + showColumn + showColumn + ( int column ) + + + sizeHintForColumn + sizeHintForColumn + ( int column ) + + + sortByColumn + sortByColumn + ( int column ) + + + verticalOffset + verticalOffset + () + + + visualRect + visualRect + ( const QModelIndex & index ) + + + visualRegionForSelection + visualRegionForSelection + ( const QItemSelection & selection ) + + + + QTreeWidget + qtreewidget.html + + QTreeWidget + QTreeWidget + ( QWidget * parent = 0 ) + + + addTopLevelItem + addTopLevelItem + ( QTreeWidgetItem * item ) + + + addTopLevelItems + addTopLevelItems + ( const QList<QTreeWidgetItem *> & items ) + + + clear + clear + () + + + closePersistentEditor + closePersistentEditor + ( QTreeWidgetItem * item, int column = 0 ) + + + collapseItem + collapseItem + ( const QTreeWidgetItem * item ) + + + currentColumn + currentColumn + () + + + currentItem + currentItem + () + + + currentItemChanged + currentItemChanged + ( QTreeWidgetItem * current, QTreeWidgetItem * previous ) + + + dropMimeData + dropMimeData + ( QTreeWidgetItem * parent, int index, const QMimeData * data, Qt::DropAction action ) + + + editItem + editItem + ( QTreeWidgetItem * item, int column = 0 ) + + + event + event + ( QEvent * e ) + + + expandItem + expandItem + ( const QTreeWidgetItem * item ) + + + findItems + findItems + ( const QString & text, Qt::MatchFlags flags, int column = 0 ) + + + headerItem + headerItem + () + + + indexFromItem + indexFromItem + ( QTreeWidgetItem * item, int column = 0 ) + + + indexOfTopLevelItem + indexOfTopLevelItem + ( QTreeWidgetItem * item ) + + + insertTopLevelItem + insertTopLevelItem + ( int index, QTreeWidgetItem * item ) + + + insertTopLevelItems + insertTopLevelItems + ( int index, const QList<QTreeWidgetItem *> & items ) + + + isItemExpanded + isItemExpanded + ( const QTreeWidgetItem * item ) + + + isItemHidden + isItemHidden + ( const QTreeWidgetItem * item ) + + + isItemSelected + isItemSelected + ( const QTreeWidgetItem * item ) + + + itemActivated + itemActivated + ( QTreeWidgetItem * item, int column ) + + + itemAt + itemAt + ( const QPoint & p ) + + + itemAt + itemAt-2 + ( int x, int y ) + + + itemChanged + itemChanged + ( QTreeWidgetItem * item, int column ) + + + itemClicked + itemClicked + ( QTreeWidgetItem * item, int column ) + + + itemCollapsed + itemCollapsed + ( QTreeWidgetItem * item ) + + + itemDoubleClicked + itemDoubleClicked + ( QTreeWidgetItem * item, int column ) + + + itemEntered + itemEntered + ( QTreeWidgetItem * item, int column ) + + + itemExpanded + itemExpanded + ( QTreeWidgetItem * item ) + + + itemFromIndex + itemFromIndex + ( const QModelIndex & index ) + + + itemPressed + itemPressed + ( QTreeWidgetItem * item, int column ) + + + itemSelectionChanged + itemSelectionChanged + () + + + itemWidget + itemWidget + ( QTreeWidgetItem * item, int column ) + + + items + items + ( const QMimeData * data ) + + + mimeData + mimeData + ( const QList<QTreeWidgetItem *> items ) + + + mimeTypes + mimeTypes + () + + + openPersistentEditor + openPersistentEditor + ( QTreeWidgetItem * item, int column = 0 ) + + + scrollToItem + scrollToItem + ( const QTreeWidgetItem * item, QAbstractItemView::ScrollHint hint = EnsureVisible ) + + + selectedItems + selectedItems + () + + + setCurrentItem + setCurrentItem + ( QTreeWidgetItem * item ) + + + setCurrentItem + setCurrentItem-2 + ( QTreeWidgetItem * item, int column ) + + + setHeaderItem + setHeaderItem + ( QTreeWidgetItem * item ) + + + setHeaderLabels + setHeaderLabels + ( const QStringList & labels ) + + + setItemExpanded + setItemExpanded + ( const QTreeWidgetItem * item, bool expand ) + + + setItemHidden + setItemHidden + ( const QTreeWidgetItem * item, bool hide ) + + + setItemSelected + setItemSelected + ( const QTreeWidgetItem * item, bool select ) + + + setItemWidget + setItemWidget + ( QTreeWidgetItem * item, int column, QWidget * widget ) + + + sortColumn + sortColumn + () + + + sortItems + sortItems + ( int column, Qt::SortOrder order ) + + + DropActions + supportedDropActions + QTreeWidget::supportedDropActions() + + + takeTopLevelItem + takeTopLevelItem + ( int index ) + + + topLevelItem + topLevelItem + ( int index ) + + + visualItemRect + visualItemRect + ( const QTreeWidgetItem * item ) + + + + QTreeWidgetItem + qtreewidgetitem.html + + QTreeWidgetItem + QTreeWidgetItem + ( int type = Type ) + + + QTreeWidgetItem + QTreeWidgetItem-2 + ( const QStringList & strings, int type = Type ) + + + QTreeWidgetItem + QTreeWidgetItem-3 + ( QTreeWidget * parent, int type = Type ) + + + QTreeWidgetItem + QTreeWidgetItem-4 + ( QTreeWidget * parent, const QStringList & strings, int type = Type ) + + + QTreeWidgetItem + QTreeWidgetItem-5 + ( QTreeWidget * parent, QTreeWidgetItem * preceding, int type = Type ) + + + QTreeWidgetItem + QTreeWidgetItem-6 + ( QTreeWidgetItem * parent, int type = Type ) + + + QTreeWidgetItem + QTreeWidgetItem-7 + ( QTreeWidgetItem * parent, const QStringList & strings, int type = Type ) + + + QTreeWidgetItem + QTreeWidgetItem-8 + ( QTreeWidgetItem * parent, QTreeWidgetItem * preceding, int type = Type ) + + + QTreeWidgetItem + QTreeWidgetItem-9 + ( const QTreeWidgetItem & other ) + + + addChild + addChild + ( QTreeWidgetItem * child ) + + + addChildren + addChildren + ( const QList<QTreeWidgetItem *> & children ) + + + backgroundColor + backgroundColor + ( int column ) + + + CheckState + checkState + QTreeWidgetItem::checkState( int column ) + + + child + child + ( int index ) + + + childCount + childCount + () + + + clone + clone + () + + + columnCount + columnCount + () + + + data + data + ( int column, int role ) + + + ItemFlags + flags + QTreeWidgetItem::flags() + + + font + font + ( int column ) + + + icon + icon + ( int column ) + + + indexOfChild + indexOfChild + ( QTreeWidgetItem * child ) + + + insertChild + insertChild + ( int index, QTreeWidgetItem * child ) + + + insertChildren + insertChildren + ( int index, const QList<QTreeWidgetItem *> & children ) + + + parent + parent + () + + + read + read + ( QDataStream & in ) + + + setBackgroundColor + setBackgroundColor + ( int column, const QColor & color ) + + + setCheckState + setCheckState + ( int column, Qt::CheckState state ) + + + setData + setData + ( int column, int role, const QVariant & value ) + + + setFlags + setFlags + ( Qt::ItemFlags flags ) + + + setFont + setFont + ( int column, const QFont & font ) + + + setIcon + setIcon + ( int column, const QIcon & icon ) + + + setSizeHint + setSizeHint + ( int column, const QSize & size ) + + + setStatusTip + setStatusTip + ( int column, const QString & statusTip ) + + + setText + setText + ( int column, const QString & text ) + + + setTextAlignment + setTextAlignment + ( int column, int alignment ) + + + setTextColor + setTextColor + ( int column, const QColor & color ) + + + setToolTip + setToolTip + ( int column, const QString & toolTip ) + + + setWhatsThis + setWhatsThis + ( int column, const QString & whatsThis ) + + + sizeHint + sizeHint + ( int column ) + + + statusTip + statusTip + ( int column ) + + + takeChild + takeChild + ( int index ) + + + takeChildren + takeChildren + () + + + text + text + ( int column ) + + + textAlignment + textAlignment + ( int column ) + + + textColor + textColor + ( int column ) + + + toolTip + toolTip + ( int column ) + + + treeWidget + treeWidget + () + + + type + type + () + + + whatsThis + whatsThis + ( int column ) + + + write + write + ( QDataStream & out ) + + + operator< + operator-lt + ( const QTreeWidgetItem & other ) + + + operator= + operator-eq + ( const QTreeWidgetItem & other ) + + + Type + Type-var + + + + UserType + UserType-var + + + + + QTreeWidgetItemIterator + qtreewidgetitemiterator.html + + QTreeWidgetItemIterator + QTreeWidgetItemIterator + ( const QTreeWidgetItemIterator & it ) + + + QTreeWidgetItemIterator + QTreeWidgetItemIterator-2 + ( QTreeWidget * widget, IteratorFlags flags = All ) + + + QTreeWidgetItemIterator + QTreeWidgetItemIterator-3 + ( QTreeWidgetItem * item, IteratorFlags flags = All ) + + + operator* + operator-2a + () + + + operator++ + operator-2b-2b + () + + + operator++ + operator-2b-2b-2 + ( int ) + + + operator+= + operator-2b-eq + ( int n ) + + + operator-- + operator-- + () + + + operator-- + operator---2 + ( int ) + + + operator-= + operator--eq + ( int n ) + + + operator= + operator-eq + ( const QTreeWidgetItemIterator & it ) + + + + QUdpSocket + qudpsocket.html + + QUdpSocket + QUdpSocket + ( QObject * parent = 0 ) + + + bind + bind + ( const QHostAddress & address, quint16 port ) + + + bind + bind-2 + ( const QHostAddress & address, quint16 port, BindMode mode ) + + + bind + bind-3 + ( quint16 port = 0 ) + + + bind + bind-4 + ( quint16 port, BindMode mode ) + + + hasPendingDatagrams + hasPendingDatagrams + () + + + pendingDatagramSize + pendingDatagramSize + () + + + readDatagram + readDatagram + ( char * data, qint64 maxSize, QHostAddress * address = 0, quint16 * port = 0 ) + + + writeDatagram + writeDatagram + ( const char * data, qint64 size, const QHostAddress & address, quint16 port ) + + + writeDatagram + writeDatagram-2 + ( const QByteArray & datagram, const QHostAddress & host, quint16 port ) + + + + QUiLoader + quiloader.html + + QUiLoader + QUiLoader + ( QObject * parent = 0 ) + + + addPluginPath + addPluginPath + ( const QString & path ) + + + availableWidgets + availableWidgets + () + + + clearPluginPaths + clearPluginPaths + () + + + createAction + createAction + ( QObject * parent = 0, const QString & name = QString() + + + createActionGroup + createActionGroup + ( QObject * parent = 0, const QString & name = QString() + + + createLayout + createLayout + ( const QString & className, QObject * parent = 0, const QString & name = QString() + + + createWidget + createWidget + ( const QString & className, QWidget * parent = 0, const QString & name = QString() + + + load + load + ( QIODevice * device, QWidget * parentWidget = 0 ) + + + pluginPaths + pluginPaths + () + + + + QUrl + qurl.html + + ParsingMode + ParsingMode-enum + + + + QUrl + QUrl + () + + + QUrl + QUrl-2 + ( const QString & url ) + + + QUrl + QUrl-3 + ( const QUrl & other ) + + + QUrl + QUrl-4 + ( const QString & url, ParsingMode parsingMode ) + + + addQueryItem + addQueryItem + ( const QString & key, const QString & value ) + + + allQueryItemValues + allQueryItemValues + ( const QString & key ) + + + authority + authority + () + + + clear + clear + () + + + encodedQuery + encodedQuery + () + + + fragment + fragment + () + + + fromEncoded + fromEncoded + ( const QByteArray & input ) + + + fromEncoded + fromEncoded-2 + ( const QByteArray & input, ParsingMode parsingMode ) + + + fromLocalFile + fromLocalFile + ( const QString & localFile ) + + + fromPercentEncoding + fromPercentEncoding + ( const QByteArray & input ) + + + fromPunycode + fromPunycode + ( const QByteArray & pc ) + + + hasQueryItem + hasQueryItem + ( const QString & key ) + + + host + host + () + + + isEmpty + isEmpty + () + + + isParentOf + isParentOf + ( const QUrl & childUrl ) + + + isRelative + isRelative + () + + + isValid + isValid + () + + + password + password + () + + + path + path + () + + + port + port + () + + + port + port-2 + ( int defaultPort ) + + + queryItemValue + queryItemValue + ( const QString & key ) + + + queryItems + queryItems + () + + + queryPairDelimiter + queryPairDelimiter + () + + + queryValueDelimiter + queryValueDelimiter + () + + + removeAllQueryItems + removeAllQueryItems + ( const QString & key ) + + + removeQueryItem + removeQueryItem + ( const QString & key ) + + + resolved + resolved + ( const QUrl & relative ) + + + scheme + scheme + () + + + setAuthority + setAuthority + ( const QString & authority ) + + + setEncodedQuery + setEncodedQuery + ( const QByteArray & query ) + + + setEncodedUrl + setEncodedUrl + ( const QByteArray & encodedUrl ) + + + setEncodedUrl + setEncodedUrl-2 + ( const QByteArray & encodedUrl, ParsingMode parsingMode ) + + + setFragment + setFragment + ( const QString & fragment ) + + + setHost + setHost + ( const QString & host ) + + + setPassword + setPassword + ( const QString & password ) + + + setPath + setPath + ( const QString & path ) + + + setPort + setPort + ( int port ) + + + setQueryDelimiters + setQueryDelimiters + ( char valueDelimiter, char pairDelimiter ) + + + setQueryItems + setQueryItems + ( const QList<QPair<QString, QString> > & query ) + + + setScheme + setScheme + ( const QString & scheme ) + + + setUrl + setUrl + ( const QString & url ) + + + setUrl + setUrl-2 + ( const QString & url, ParsingMode parsingMode ) + + + setUserInfo + setUserInfo + ( const QString & userInfo ) + + + setUserName + setUserName + ( const QString & userName ) + + + toEncoded + toEncoded + ( FormattingOptions options = None ) + + + toLocalFile + toLocalFile + () + + + toPercentEncoding + toPercentEncoding + ( const QString & input, const QByteArray & exclude = QByteArray() + + + toPunycode + toPunycode + ( const QString & uc ) + + + toString + toString + ( FormattingOptions options = None ) + + + userInfo + userInfo + () + + + userName + userName + () + + + operator!= + operator-not-eq + ( const QUrl & url ) + + + operator= + operator-eq + ( const QUrl & url ) + + + operator= + operator-eq-2 + ( const QString & url ) + + + operator== + operator-eq-eq + ( const QUrl & url ) + + + + QUrlInfo + qurlinfo.html + + PermissionSpec + PermissionSpec-enum + + + + QUrlInfo + QUrlInfo + () + + + QUrlInfo + QUrlInfo-2 + ( const QUrlInfo & ui ) + + + QUrlInfo + QUrlInfo-3 + ( const QString & name, int permissions, const QString & owner, const QString & group, qint64 size, const QDateTime & lastModified, const QDateTime & lastRead, bool isDir, bool isFile, bool isSymLink, bool isWritable, bool isReadable, bool isExecutable ) + + + QUrlInfo + QUrlInfo-4 + ( const QUrl & url, int permissions, const QString & owner, const QString & group, qint64 size, const QDateTime & lastModified, const QDateTime & lastRead, bool isDir, bool isFile, bool isSymLink, bool isWritable, bool isReadable, bool isExecutable ) + + + equal + equal + ( const QUrlInfo & i1, const QUrlInfo & i2, int sortBy ) + + + greaterThan + greaterThan + ( const QUrlInfo & i1, const QUrlInfo & i2, int sortBy ) + + + group + group + () + + + isDir + isDir + () + + + isExecutable + isExecutable + () + + + isFile + isFile + () + + + isReadable + isReadable + () + + + isSymLink + isSymLink + () + + + isValid + isValid + () + + + isWritable + isWritable + () + + + lastModified + lastModified + () + + + lastRead + lastRead + () + + + lessThan + lessThan + ( const QUrlInfo & i1, const QUrlInfo & i2, int sortBy ) + + + name + name + () + + + owner + owner + () + + + permissions + permissions + () + + + setDir + setDir + ( bool b ) + + + setFile + setFile + ( bool b ) + + + setGroup + setGroup + ( const QString & s ) + + + setLastModified + setLastModified + ( const QDateTime & dt ) + + + setName + setName + ( const QString & name ) + + + setOwner + setOwner + ( const QString & s ) + + + setPermissions + setPermissions + ( int p ) + + + setReadable + setReadable + ( bool b ) + + + setSize + setSize + ( qint64 size ) + + + setSymLink + setSymLink + ( bool b ) + + + setWritable + setWritable + ( bool b ) + + + size + size + () + + + operator= + operator-eq + ( const QUrlInfo & ui ) + + + operator== + operator-eq-eq + ( const QUrlInfo & i ) + + + addPath + addPath + ( const QString & p ) + + + cdUp + cdUp + () + + + decode + decode + ( QString & url ) + + + dirPath + dirPath + () + + + encode + encode + ( QString & url ) + + + fileName + fileName + () + + + hasHost + hasHost + () + + + hasPassword + hasPassword + () + + + hasPath + hasPath + () + + + hasPort + hasPort + () + + + hasRef + hasRef + () + + + hasUser + hasUser + () + + + isRelativeUrl + isRelativeUrl + ( const QString & url ) + + + protocol + protocol + () + + + query + query + () + + + ref + ref + () + + + reset + reset + () + + + setFileName + setFileName + ( const QString & txt ) + + + setProtocol + setProtocol + ( const QString & s ) + + + setQuery + setQuery + ( const QString & txt ) + + + setRef + setRef + ( const QString & txt ) + + + setUser + setUser + ( const QString & s ) + + + user + user + () + + + operator + operator-QString + QString() + + + + QUuid + quuid.html + + Variant + Variant-enum + + + + Version + Version-enum + + + + QUuid + QUuid + () + + + QUuid + QUuid-2 + ( uint l, ushort w1, ushort w2, uchar b1, uchar b2, uchar b3, uchar b4, uchar b5, uchar b6, uchar b7, uchar b8 ) + + + QUuid + QUuid-3 + ( const QString & text ) + + + QUuid + QUuid-5 + ( const GUID & guid ) + + + createUuid + createUuid + () + + + isNull + isNull + () + + + toString + toString + () + + + Variant + variant + QUuid::variant() + + + Version + version + QUuid::version() + + + operator + operator-GUID + GUID() + + + operator + operator-QString + QString() + + + operator!= + operator-not-eq + ( const QUuid & other ) + + + operator!= + operator-not-eq-2 + ( const GUID & guid ) + + + operator< + operator-lt + ( const QUuid & other ) + + + operator= + operator-eq + ( const GUID & guid ) + + + operator== + operator-eq-eq + ( const QUuid & other ) + + + operator== + operator-eq-eq-2 + ( const GUID & guid ) + + + operator> + operator-gt + ( const QUuid & other ) + + + + QValidator + qvalidator.html + + State + State-enum + + + + QValidator + QValidator + ( QObject * parent ) + + + fixup + fixup + ( QString & input ) + + + validate + validate + ( QString & input, int & pos ) + + + QValidator + QValidator-2 + ( QObject * parent, const char * name ) + + + + QVariant + qvariant.html + + Type + Type-enum + + + + QVariant + QVariant + () + + + QVariant + QVariant-2 + ( Type type ) + + + QVariant + QVariant-3 + ( int typeOrUserType, const void * copy ) + + + QVariant + QVariant-4 + ( const QVariant & p ) + + + QVariant + QVariant-5 + ( QDataStream & s ) + + + QVariant + QVariant-6 + ( int val ) + + + QVariant + QVariant-7 + ( uint val ) + + + QVariant + QVariant-8 + ( qlonglong val ) + + + QVariant + QVariant-9 + ( qulonglong val ) + + + QVariant + QVariant-10 + ( bool val ) + + + QVariant + QVariant-11 + ( double val ) + + + QVariant + QVariant-12 + ( const char * val ) + + + QVariant + QVariant-13 + ( const QByteArray & val ) + + + QVariant + QVariant-14 + ( const QBitArray & val ) + + + QVariant + QVariant-15 + ( const QString & val ) + + + QVariant + QVariant-16 + ( const QLatin1String & val ) + + + QVariant + QVariant-17 + ( const QStringList & val ) + + + QVariant + QVariant-18 + ( const QChar & c ) + + + QVariant + QVariant-19 + ( const QDate & val ) + + + QVariant + QVariant-20 + ( const QTime & val ) + + + QVariant + QVariant-21 + ( const QDateTime & val ) + + + QVariant + QVariant-22 + ( const QList<QVariant> & val ) + + + QVariant + QVariant-23 + ( const QMap<QString, QVariant> & val ) + + + QVariant + QVariant-24 + ( const QSize & val ) + + + QVariant + QVariant-25 + ( const QSizeF & val ) + + + QVariant + QVariant-26 + ( const QPoint & val ) + + + QVariant + QVariant-27 + ( const QPointF & val ) + + + QVariant + QVariant-28 + ( const QLine & val ) + + + QVariant + QVariant-29 + ( const QLineF & val ) + + + QVariant + QVariant-30 + ( const QRect & val ) + + + QVariant + QVariant-31 + ( const QRectF & val ) + + + QVariant + QVariant-32 + ( const QUrl & val ) + + + QVariant + QVariant-33 + ( const QLocale & l ) + + + QVariant + QVariant-34 + ( const QRegExp & regExp ) + + + canConvert + canConvert + ( Type t ) + + + canConvert + canConvert-2 + () + + + clear + clear + () + + + convert + convert + ( Type t ) + + + fromValue + fromValue + ( const T & value ) + + + isNull + isNull + () + + + isValid + isValid + () + + + nameToType + nameToType + ( const char * name ) + + + setValue + setValue + ( const T & value ) + + + toBitArray + toBitArray + () + + + toBool + toBool + () + + + toByteArray + toByteArray + () + + + toChar + toChar + () + + + toDate + toDate + () + + + toDateTime + toDateTime + () + + + toDouble + toDouble + ( bool * ok = 0 ) + + + toInt + toInt + ( bool * ok = 0 ) + + + toLine + toLine + () + + + toLineF + toLineF + () + + + toList + toList + () + + + toLocale + toLocale + () + + + toLongLong + toLongLong + ( bool * ok = 0 ) + + + toMap + toMap + () + + + toPoint + toPoint + () + + + toPointF + toPointF + () + + + toRect + toRect + () + + + toRectF + toRectF + () + + + toRegExp + toRegExp + () + + + toSize + toSize + () + + + toSizeF + toSizeF + () + + + toString + toString + () + + + toStringList + toStringList + () + + + toTime + toTime + () + + + toUInt + toUInt + ( bool * ok = 0 ) + + + toULongLong + toULongLong + ( bool * ok = 0 ) + + + toUrl + toUrl + () + + + type + type + () + + + typeName + typeName + () + + + typeToName + typeToName + ( Type typ ) + + + userType + userType + () + + + value + value + () + + + operator!= + operator-not-eq + ( const QVariant & v ) + + + operator= + operator-eq + ( const QVariant & variant ) + + + operator== + operator-eq-eq + ( const QVariant & v ) + + + QVariant + QVariant-35 + ( bool b, int dummy ) + + + asBitArray + asBitArray + () + + + asBool + asBool + () + + + asByteArray + asByteArray + () + + + asCString + asCString + () + + + asDate + asDate + () + + + asDateTime + asDateTime + () + + + asDouble + asDouble + () + + + asInt + asInt + () + + + asList + asList + () + + + asLongLong + asLongLong + () + + + asMap + asMap + () + + + asPoint + asPoint + () + + + asRect + asRect + () + + + asSize + asSize + () + + + asString + asString + () + + + asStringList + asStringList + () + + + asTime + asTime + () + + + asUInt + asUInt + () + + + asULongLong + asULongLong + () + + + canCast + canCast + ( Type t ) + + + cast + cast + ( Type t ) + + + toCString + toCString + () + + + + QVarLengthArray + qvarlengtharray.html + + QVarLengthArray + QVarLengthArray + ( int size = 0 ) + + + QVarLengthArray + QVarLengthArray-2 + ( const QVarLengthArray<T, Prealloc> & other ) + + + append + append + ( const T & t ) + + + append + append-2 + ( const T * buf, int size ) + + + capacity + capacity + () + + + clear + clear + () + + + constData + constData + () + + + count + count + () + + + data + data + () + + + data + data-2 + () + + + isEmpty + isEmpty + () + + + reserve + reserve + ( int size ) + + + resize + resize + ( int size ) + + + size + size + () + + + operator= + operator-eq + ( const QVarLengthArray<T, Prealloc> & other ) + + + operator[] + operator-5b-5d + ( int i ) + + + operator[] + operator-5b-5d-2 + ( int i ) + + + + QVBoxLayout + qvboxlayout.html + + QVBoxLayout + QVBoxLayout + () + + + QVBoxLayout + QVBoxLayout-2 + ( QWidget * parent ) + + + QVBoxLayout + QVBoxLayout-3 + ( QWidget * parent, int margin, int spacing = -1, const char * name = 0 ) + + + QVBoxLayout + QVBoxLayout-4 + ( QLayout * parentLayout, int spacing = -1, const char * name = 0 ) + + + QVBoxLayout + QVBoxLayout-5 + ( int spacing, const char * name = 0 ) + + + + QVector + qvector.html + + ConstIterator + ConstIterator-typedef + + + + Iterator + Iterator-typedef + + + + const_iterator + const_iterator-typedef + + + + iterator + iterator-typedefx + + + + QVector + QVector + () + + + QVector + QVector-2 + ( int size ) + + + QVector + QVector-3 + ( int size, const T & value ) + + + QVector + QVector-4 + ( const QVector<T> & other ) + + + append + append + ( const T & value ) + + + at + at + ( int i ) + + + back + back + () + + + back + back-2 + () + + + begin + begin + () + + + begin + begin-2 + () + + + capacity + capacity + () + + + clear + clear + () + + + constBegin + constBegin + () + + + constData + constData + () + + + constEnd + constEnd + () + + + contains + contains + ( const T & value ) + + + count + count + ( const T & value ) + + + count + count-2 + () + + + data + data + () + + + data + data-2 + () + + + empty + empty + () + + + end + end + () + + + end + end-2 + () + + + erase + erase + ( iterator pos ) + + + erase + erase-2 + ( iterator begin, iterator end ) + + + fill + fill + ( const T & value, int size = -1 ) + + + first + first + () + + + first + first-2 + () + + + fromList + fromList + ( const QList<T> & list ) + + + fromStdVector + fromStdVector + ( const std::vector<T> & vector ) + + + front + front + () + + + front + front-2 + () + + + indexOf + indexOf + ( const T & value, int from = 0 ) + + + insert + insert + ( int i, const T & value ) + + + insert + insert-2 + ( iterator before, int count, const T & value ) + + + insert + insert-3 + ( int i, int count, const T & value ) + + + insert + insert-4 + ( iterator before, const T & value ) + + + isEmpty + isEmpty + () + + + last + last + () + + + last + last-2 + () + + + lastIndexOf + lastIndexOf + ( const T & value, int from = -1 ) + + + mid + mid + ( int pos, int length = -1 ) + + + pop_back + pop_back + () + + + pop_front + pop_front + () + + + prepend + prepend + ( const T & value ) + + + push_back + push_back + ( const T & value ) + + + push_front + push_front + ( const T & value ) + + + remove + remove + ( int i ) + + + remove + remove-2 + ( int i, int count ) + + + replace + replace + ( int i, const T & value ) + + + reserve + reserve + ( int size ) + + + resize + resize + ( int size ) + + + size + size + () + + + squeeze + squeeze + () + + + toList + toList + () + + + vector + toStdVector + <T> QVector::toStdVector() + + + value + value + ( int i ) + + + value + value-2 + ( int i, const T & defaultValue ) + + + operator!= + operator-not-eq + ( const QVector<T> & other ) + + + operator+ + operator-2b + ( const QVector<T> & other ) + + + operator+= + operator-2b-eq + ( const QVector<T> & other ) + + + operator+= + operator-2b-eq-2 + ( const T & value ) + + + operator<< + operator-lt-lt + ( const T & value ) + + + operator<< + operator-lt-lt-2 + ( const QVector<T> & other ) + + + operator= + operator-eq + ( const QVector<T> & other ) + + + operator== + operator-eq-eq + ( const QVector<T> & other ) + + + operator[] + operator-5b-5d + ( int i ) + + + operator[] + operator-5b-5d-2 + ( int i ) + + + + QVectorIterator + qvectoriterator.html + + QVectorIterator + QVectorIterator + ( const QVector<T> & vector ) + + + findNext + findNext + ( const T & value ) + + + findPrevious + findPrevious + ( const T & value ) + + + hasNext + hasNext + () + + + hasPrevious + hasPrevious + () + + + next + next + () + + + peekNext + peekNext + () + + + peekPrevious + peekPrevious + () + + + previous + previous + () + + + toBack + toBack + () + + + toFront + toFront + () + + + operator= + operator-eq + ( const QVector<T> & vector ) + + + + QVFbScreen + qvfbscreen.html + + QVFbScreen + QVFbScreen + ( int displayId ) + + + + QVNCScreen + qvncscreen.html + + QVNCScreen + QVNCScreen + ( int displayId ) + + + + QWaitCondition + qwaitcondition.html + + QWaitCondition + QWaitCondition + () + + + wait + wait + ( QMutex * mutex, unsigned long time = ULONG_MAX ) + + + wakeAll + wakeAll + () + + + wakeOne + wakeOne + () + + + + QWhatsThisClickedEvent + qwhatsthisclickedevent.html + + QWhatsThisClickedEvent + QWhatsThisClickedEvent + ( const QString & href ) + + + href + href + () + + + + QWhatsThis + qwhatsthis.html + + createAction + createAction + ( QObject * parent = 0 ) + + + enterWhatsThisMode + enterWhatsThisMode + () + + + hideText + hideText + () + + + inWhatsThisMode + inWhatsThisMode + () + + + leaveWhatsThisMode + leaveWhatsThisMode + () + + + showText + showText + ( const QPoint & pos, const QString & text, QWidget * w = 0 ) + + + add + add + ( QWidget * w, const QString & s ) + + + remove + remove + ( QWidget * w ) + + + whatsThisButton + whatsThisButton + ( QWidget * parent ) + + + + QWheelEvent + qwheelevent.html + + QWheelEvent + QWheelEvent + ( const QPoint & pos, int delta, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Qt::Orientation orient = Qt::Vertical ) + + + QWheelEvent + QWheelEvent-2 + ( const QPoint & pos, const QPoint & globalPos, int delta, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Qt::Orientation orient = Qt::Vertical ) + + + MouseButtons + buttons + QWheelEvent::buttons() + + + delta + delta + () + + + globalPos + globalPos + () + + + globalX + globalX + () + + + globalY + globalY + () + + + Orientation + orientation + QWheelEvent::orientation() + + + pos + pos + () + + + x + x + () + + + y + y + () + + + QWheelEvent + QWheelEvent-3 + ( const QPoint & pos, int delta, int state, Qt::Orientation orient = Qt::Vertical ) + + + QWheelEvent + QWheelEvent-4 + ( const QPoint & pos, const QPoint & globalPos, int delta, int state, Qt::Orientation orient = Qt::Vertical ) + + + ButtonState + state + QWheelEvent::state() + + + + QWidget + qwidget.html + + ContextMenuPolicy + contextMenuPolicy-prop + + + + FocusPolicy + focusPolicy-prop + + + + LayoutDirection + layoutDirection-prop + + + + WindowFlags + windowFlags-prop + + + + WindowModality + windowModality-prop + + + + QWidget + QWidget + ( QWidget * parent = 0, Qt::WFlags f = 0 ) + + + actionEvent + actionEvent + ( QActionEvent * event ) + + + actions + actions + () + + + activateWindow + activateWindow + () + + + addAction + addAction + ( QAction * action ) + + + addActions + addActions + ( QList<QAction *> actions ) + + + adjustSize + adjustSize + () + + + ColorRole + backgroundRole + QWidget::backgroundRole() + + + changeEvent + changeEvent + ( QEvent * event ) + + + childAt + childAt + ( int x, int y ) + + + childAt + childAt-4 + ( const QPoint & p ) + + + clearFocus + clearFocus + () + + + clearMask + clearMask + () + + + close + close + () + + + closeEvent + closeEvent + ( QCloseEvent * event ) + + + contentsRect + contentsRect + () + + + contextMenuEvent + contextMenuEvent + ( QContextMenuEvent * event ) + + + create + create + ( WId window = 0, bool initializeWindow = true, bool destroyOldWindow = true ) + + + customContextMenuRequested + customContextMenuRequested + ( const QPoint & pos ) + + + destroy + destroy + ( bool destroyWindow = true, bool destroySubWindows = true ) + + + dragEnterEvent + dragEnterEvent + ( QDragEnterEvent * event ) + + + dragLeaveEvent + dragLeaveEvent + ( QDragLeaveEvent * event ) + + + dragMoveEvent + dragMoveEvent + ( QDragMoveEvent * event ) + + + dropEvent + dropEvent + ( QDropEvent * event ) + + + ensurePolished + ensurePolished + () + + + enterEvent + enterEvent + ( QEvent * event ) + + + event + event + ( QEvent * event ) + + + find + find + ( WId id ) + + + focusInEvent + focusInEvent + ( QFocusEvent * event ) + + + focusNextChild + focusNextChild + () + + + focusNextPrevChild + focusNextPrevChild + ( bool next ) + + + focusOutEvent + focusOutEvent + ( QFocusEvent * event ) + + + focusPreviousChild + focusPreviousChild + () + + + focusProxy + focusProxy + () + + + focusWidget + focusWidget + () + + + fontInfo + fontInfo + () + + + fontMetrics + fontMetrics + () + + + ColorRole + foregroundRole + QWidget::foregroundRole() + + + getContentsMargins + getContentsMargins + ( int * left, int * top, int * right, int * bottom ) + + + getDC + getDC + () + + + grabKeyboard + grabKeyboard + () + + + grabMouse + grabMouse + () + + + grabMouse + grabMouse-2 + ( const QCursor & cursor ) + + + grabShortcut + grabShortcut + ( const QKeySequence & key, Qt::ShortcutContext context = Qt::WindowShortcut ) + + + hasEditFocus + hasEditFocus + () + + + heightForWidth + heightForWidth + ( int w ) + + + hide + hide + () + + + hideEvent + hideEvent + ( QHideEvent * event ) + + + inputContext + inputContext + () + + + inputMethodEvent + inputMethodEvent + ( QInputMethodEvent * event ) + + + inputMethodQuery + inputMethodQuery + ( Qt::InputMethodQuery query ) + + + insertAction + insertAction + ( QAction * before, QAction * action ) + + + insertActions + insertActions + ( QAction * before, QList<QAction *> actions ) + + + isAncestorOf + isAncestorOf + ( const QWidget * child ) + + + isEnabledTo + isEnabledTo + ( QWidget * ancestor ) + + + isHidden + isHidden + () + + + isVisibleTo + isVisibleTo + ( QWidget * ancestor ) + + + isWindow + isWindow + () + + + keyPressEvent + keyPressEvent + ( QKeyEvent * event ) + + + keyReleaseEvent + keyReleaseEvent + ( QKeyEvent * event ) + + + keyboardGrabber + keyboardGrabber + () + + + layout + layout + () + + + leaveEvent + leaveEvent + ( QEvent * event ) + + + lower + lower + () + + + macEvent + macEvent + ( EventHandlerCallRef caller, EventRef event ) + + + mapFrom + mapFrom + ( QWidget * parent, const QPoint & pos ) + + + mapFromGlobal + mapFromGlobal + ( const QPoint & pos ) + + + mapFromParent + mapFromParent + ( const QPoint & pos ) + + + mapTo + mapTo + ( QWidget * parent, const QPoint & pos ) + + + mapToGlobal + mapToGlobal + ( const QPoint & pos ) + + + mapToParent + mapToParent + ( const QPoint & pos ) + + + mask + mask + () + + + metric + metric + ( PaintDeviceMetric m ) + + + mouseDoubleClickEvent + mouseDoubleClickEvent + ( QMouseEvent * event ) + + + mouseGrabber + mouseGrabber + () + + + mouseMoveEvent + mouseMoveEvent + ( QMouseEvent * event ) + + + mousePressEvent + mousePressEvent + ( QMouseEvent * event ) + + + mouseReleaseEvent + mouseReleaseEvent + ( QMouseEvent * event ) + + + moveEvent + moveEvent + ( QMoveEvent * event ) + + + nextInFocusChain + nextInFocusChain + () + + + overrideWindowFlags + overrideWindowFlags + ( Qt::WindowFlags flags ) + + + paintEngine + paintEngine + () + + + paintEvent + paintEvent + ( QPaintEvent * event ) + + + parentWidget + parentWidget + () + + + qwsEvent + qwsEvent + ( QWSEvent * event ) + + + raise + raise + () + + + releaseDC + releaseDC + ( HDC hdc ) + + + releaseKeyboard + releaseKeyboard + () + + + releaseMouse + releaseMouse + () + + + releaseShortcut + releaseShortcut + ( int id ) + + + removeAction + removeAction + ( QAction * action ) + + + repaint + repaint + () + + + repaint + repaint-6 + ( int x, int y, int w, int h ) + + + repaint + repaint-7 + ( const QRect & r ) + + + repaint + repaint-8 + ( const QRegion & rgn ) + + + resetInputContext + resetInputContext + () + + + resizeEvent + resizeEvent + ( QResizeEvent * event ) + + + scroll + scroll + ( int dx, int dy ) + + + scroll + scroll-2 + ( int dx, int dy, const QRect & r ) + + + setAttribute + setAttribute + ( Qt::WidgetAttribute attribute, bool on = true ) + + + setBackgroundRole + setBackgroundRole + ( QPalette::ColorRole role ) + + + setContentsMargins + setContentsMargins + ( int left, int top, int right, int bottom ) + + + setDisabled + setDisabled + ( bool disable ) + + + setEditFocus + setEditFocus + ( bool on ) + + + setFixedHeight + setFixedHeight + ( int h ) + + + setFixedSize + setFixedSize + ( const QSize & s ) + + + setFixedSize + setFixedSize-2 + ( int w, int h ) + + + setFixedWidth + setFixedWidth + ( int w ) + + + setFocus + setFocus + ( Qt::FocusReason reason ) + + + setFocus + setFocus-2 + () + + + setFocusProxy + setFocusProxy + ( QWidget * w ) + + + setForegroundRole + setForegroundRole + ( QPalette::ColorRole role ) + + + setHidden + setHidden + ( bool hidden ) + + + setInputContext + setInputContext + ( QInputContext * context ) + + + setLayout + setLayout + ( QLayout * layout ) + + + setMask + setMask + ( const QBitmap & bitmap ) + + + setMask + setMask-2 + ( const QRegion & region ) + + + setParent + setParent + ( QWidget * parent ) + + + setParent + setParent-2 + ( QWidget * parent, Qt::WFlags f ) + + + setShortcutEnabled + setShortcutEnabled + ( int id, bool enable = true ) + + + setStyle + setStyle + ( QStyle * style ) + + + setTabOrder + setTabOrder + ( QWidget * first, QWidget * second ) + + + setWindowRole + setWindowRole + ( const QString & role ) + + + setWindowState + setWindowState + ( Qt::WindowStates windowState ) + + + show + show + () + + + showEvent + showEvent + ( QShowEvent * event ) + + + showFullScreen + showFullScreen + () + + + showMaximized + showMaximized + () + + + showMinimized + showMinimized + () + + + showNormal + showNormal + () + + + stackUnder + stackUnder + ( QWidget * w ) + + + style + style + () + + + tabletEvent + tabletEvent + ( QTabletEvent * event ) + + + testAttribute + testAttribute + ( Qt::WidgetAttribute attribute ) + + + underMouse + underMouse + () + + + update + update + () + + + update + update-2 + ( int x, int y, int w, int h ) + + + update + update-3 + ( const QRect & r ) + + + update + update-4 + ( const QRegion & rgn ) + + + updateGeometry + updateGeometry + () + + + updateMicroFocus + updateMicroFocus + () + + + visibleRegion + visibleRegion + () + + + wheelEvent + wheelEvent + ( QWheelEvent * event ) + + + winEvent + winEvent + ( MSG * message, long * result ) + + + winId + winId + () + + + window + window + () + + + windowRole + windowRole + () + + + WindowStates + windowState + QWidget::windowState() + + + WindowType + windowType + QWidget::windowType() + + + x11Event + x11Event + ( XEvent * event ) + + + x11Info + x11Info + () + + + HANDLE + x11PictureHandle + QWidget::x11PictureHandle() + + + + QWidgetItem + qwidgetitem.html + + QWidgetItem + QWidgetItem + ( QWidget * widget ) + + + isEmpty + isEmpty + () + + + widget + widget + () + + + isEnabledToTLW + isEnabledToTLW + () + + + isTopLevel + isTopLevel + () + + + languageChange + languageChange + () + + + topLevelWidget + topLevelWidget + () + + + BackgroundOrigin + BackgroundOrigin-enum + + + + QWidget + QWidget-3 + ( QWidget * parent, const char * name, Qt::WFlags f = 0 ) + + + BackgroundMode + backgroundMode + QWidget::backgroundMode() + + + backgroundOffset + backgroundOffset + () + + + backgroundOrigin + backgroundOrigin + () + + + caption + caption + () + + + childAt + childAt-2 + ( int x, int y, bool includeThis ) + + + childAt + childAt-3 + ( const QPoint & p, bool includeThis ) + + + close + close-2 + ( bool alsoDelete ) + + + colorGroup + colorGroup + () + + + constPolish + constPolish + () + + + drawText + drawText + ( const QPoint & p, const QString & s ) + + + drawText + drawText-2 + ( int x, int y, const QString & s ) + + + erase + erase + () + + + erase + erase-2 + ( int x, int y, int w, int h ) + + + erase + erase-3 + ( const QRect & rect ) + + + erase + erase-4 + ( const QRegion & rgn ) + + + hasMouse + hasMouse + () + + + icon + icon + () + + + iconText + iconText + () + + + iconify + iconify + () + + + isDesktop + isDesktop + () + + + isDialog + isDialog + () + + + isInputMethodEnabled + isInputMethodEnabled + () + + + isPopup + isPopup + () + + + isShown + isShown + () + + + isUpdatesEnabled + isUpdatesEnabled + () + + + isVisibleToTLW + isVisibleToTLW + () + + + ownCursor + ownCursor + () + + + ownFont + ownFont + () + + + ownPalette + ownPalette + () + + + parentWidget + parentWidget-2 + ( bool sameWindow ) + + + polish + polish + () + + + recreate + recreate + ( QWidget * parent, Qt::WFlags f, const QPoint & p, bool showIt = false ) + + + repaint + repaint-2 + ( bool b ) + + + repaint + repaint-3 + ( int x, int y, int w, int h, bool b ) + + + repaint + repaint-4 + ( const QRect & r, bool b ) + + + repaint + repaint-5 + ( const QRegion & rgn, bool b ) + + + reparent + reparent + ( QWidget * parent, Qt::WFlags f, const QPoint & p, bool showIt = false ) + + + reparent + reparent-2 + ( QWidget * parent, const QPoint & p, bool showIt = false ) + + + setActiveWindow + setActiveWindow + () + + + setBackgroundColor + setBackgroundColor + ( const QColor & color ) + + + setBackgroundMode + setBackgroundMode + ( Qt::BackgroundMode widgetBackground, Qt::BackgroundMode paletteBackground = Qt::PaletteBackground ) + + + setBackgroundOrigin + setBackgroundOrigin + ( BackgroundOrigin background ) + + + setBackgroundPixmap + setBackgroundPixmap + ( const QPixmap & pixmap ) + + + setCaption + setCaption + ( const QString & c ) + + + setEraseColor + setEraseColor + ( const QColor & color ) + + + setErasePixmap + setErasePixmap + ( const QPixmap & pixmap ) + + + setFont + setFont-2 + ( const QFont & f, bool b ) + + + setIcon + setIcon + ( const QPixmap & i ) + + + setIconText + setIconText + ( const QString & it ) + + + setInputMethodEnabled + setInputMethodEnabled + ( bool enabled ) + + + setKeyCompression + setKeyCompression + ( bool b ) + + + setPalette + setPalette-2 + ( const QPalette & p, bool b ) + + + setPaletteBackgroundColor + setPaletteBackgroundColor + ( const QColor & color ) + + + setPaletteBackgroundPixmap + setPaletteBackgroundPixmap + ( const QPixmap & pixmap ) + + + setPaletteForegroundColor + setPaletteForegroundColor + ( const QColor & color ) + + + setShown + setShown + ( bool shown ) + + + setSizePolicy + setSizePolicy-2 + ( QSizePolicy::Policy hor, QSizePolicy::Policy ver, bool hfw ) + + + setStyle + setStyle-2 + ( const QString & style ) + + + unsetFont + unsetFont + () + + + unsetPalette + unsetPalette + () + + + visibleRect + visibleRect + () + + + wmapper + wmapper + () + + + + QWindowsMime + qwindowsmime.html + + QWindowsMime + QWindowsMime + () + + + canConvertFromMime + canConvertFromMime + ( const FORMATETC & formatetc, const QMimeData * mimeData ) + + + canConvertToMime + canConvertToMime + ( const QString & mimeType, IDataObject * pDataObj ) + + + convertFromMime + convertFromMime + ( const FORMATETC & formatetc, const QMimeData * mimeData, STGMEDIUM * pmedium ) + + + convertToMime + convertToMime + ( const QString & mimeType, IDataObject * pDataObj, QVariant::Type preferredType ) + + + formatsForMime + formatsForMime + ( const QString & mimeType, const QMimeData * mimeData ) + + + mimeForFormat + mimeForFormat + ( const FORMATETC & formatetc ) + + + registerMimeType + registerMimeType + ( const QString & mime ) + + + + QWindowsStyle + qwindowsstyle.html + + QWindowsStyle + QWindowsStyle + () + + + + QWindowStateChangeEvent + qwindowstatechangeevent.html + + WindowStates + oldState + QWindowStateChangeEvent::oldState() + + + + QWindowsXPStyle + qwindowsxpstyle.html + + QWindowsXPStyle + QWindowsXPStyle + () + + + + QWorkspace + qworkspace.html + + WindowOrder + WindowOrder-enum + + + + QWorkspace + QWorkspace + ( QWidget * parent = 0 ) + + + activateNextWindow + activateNextWindow + () + + + activatePreviousWindow + activatePreviousWindow + () + + + activeWindow + activeWindow + () + + + addWindow + addWindow + ( QWidget * w, Qt::WFlags flags = 0 ) + + + arrangeIcons + arrangeIcons + () + + + cascade + cascade + () + + + closeActiveWindow + closeActiveWindow + () + + + closeAllWindows + closeAllWindows + () + + + setActiveWindow + setActiveWindow + ( QWidget * w ) + + + tile + tile + () + + + windowActivated + windowActivated + ( QWidget * w ) + + + windowList + windowList + ( WindowOrder order = CreationOrder ) + + + QWorkspace + QWorkspace-2 + ( QWidget * parent, const char * name ) + + + setPaletteBackgroundColor + setPaletteBackgroundColor + ( const QColor & c ) + + + setPaletteBackgroundPixmap + setPaletteBackgroundPixmap + ( const QPixmap & pm ) + + + + QWriteLocker + qwritelocker.html + + QWriteLocker + QWriteLocker + ( QReadWriteLock * lock ) + + + readWriteLock + readWriteLock + () + + + relock + relock + () + + + unlock + unlock + () + + + + QWSCalibratedMouseHandler + qwscalibratedmousehandler.html + + calibrate + calibrate + ( const QWSPointerCalibrationData * data ) + + + clearCalibration + clearCalibration + () + + + readCalibration + readCalibration + () + + + sendFiltered + sendFiltered + ( const QPoint & position, int state ) + + + setFilterSize + setFilterSize + ( int size ) + + + transform + transform + ( const QPoint & position ) + + + writeCalibration + writeCalibration + () + + + + QWSClient + qwsclient.html + + clientId + clientId + () + + + identity + identity + () + + + + QWSEvent + qwsevent.html + + Type + Type-enum + + + + + QWSInputMethod + qwsinputmethod.html + + UpdateType + UpdateType-enum + + + + QWSInputMethod + QWSInputMethod + () + + + filter + filter + ( int unicode, int keycode, int modifiers, bool isPress, bool autoRepeat ) + + + filter + filter-2 + ( const QPoint & position, int state, int wheel ) + + + inputResolutionShift + inputResolutionShift + () + + + mouseHandler + mouseHandler + ( int offset, int state ) + + + queryResponse + queryResponse + ( int property, const QVariant & result ) + + + reset + reset + () + + + sendCommitString + sendCommitString + ( const QString & commitString, int replaceFromPosition = 0, int replaceLength = 0 ) + + + sendEvent + sendEvent + ( const QInputMethodEvent * ) + + + sendMouseEvent + sendMouseEvent + ( const QPoint & position, int state, int wheel ) + + + sendPreeditString + sendPreeditString + ( const QString & preeditString, int cursorPosition, int selectionLength = 0 ) + + + sendQuery + sendQuery + ( int property ) + + + setInputResolution + setInputResolution + ( bool isHigh ) + + + updateHandler + updateHandler + ( int type ) + + + sendIMEvent + sendIMEvent + ( QWSServer::IMState state, const QString & text, int cursorPosition, int selectionLength = 0 ) + + + + QWSKeyboardHandler + qwskeyboardhandler.html + + QWSKeyboardHandler + QWSKeyboardHandler + () + + + beginAutoRepeat + beginAutoRepeat + ( int unicode, int keycode, Qt::KeyboardModifiers modifier ) + + + endAutoRepeat + endAutoRepeat + () + + + processKeyEvent + processKeyEvent + ( int unicode, int keycode, Qt::KeyboardModifiers modifiers, bool isPress, bool autoRepeat ) + + + transformDirKey + transformDirKey + ( int keycode ) + + + + QWSMouseHandler + qwsmousehandler.html + + QWSMouseHandler + QWSMouseHandler + ( const QString & driver = QString() + + + calibrate + calibrate + ( const QWSPointerCalibrationData * data ) + + + clearCalibration + clearCalibration + () + + + limitToScreen + limitToScreen + ( QPoint & position ) + + + mouseChanged + mouseChanged + ( const QPoint & position, int state, int wheel = 0 ) + + + pos + pos + () + + + resume + resume + () + + + suspend + suspend + () + + + + QWSPointerCalibrationData + qwspointercalibrationdata.html + + Location + Location-enum + + + + + QWSScreenSaver + qwsscreensaver.html + + restore + restore + () + + + save + save + ( int level ) + + + + QWSServer + qwsserver.html + + IMMouse + IMMouse-enum + + + + WindowEvent + WindowEvent-enum + + + + addKeyboardFilter + addKeyboardFilter + ( KeyboardFilter * filter ) + + + backgroundBrush + backgroundBrush + () + + + clientWindows + clientWindows + () + + + closeKeyboard + closeKeyboard + () + + + closeMouse + closeMouse + () + + + enablePainting + enablePainting + ( bool enable ) + + + isCursorVisible + isCursorVisible + () + + + keyMap + keyMap + () + + + keyboardHandler + keyboardHandler + () + + + markedText + markedText + ( const QString & selection ) + + + mouseHandler + mouseHandler + () + + + newChannel + newChannel + ( const QString & channel ) + + + openKeyboard + openKeyboard + () + + + openMouse + openMouse + () + + + processKeyEvent + processKeyEvent + ( int unicode, int keycode, Qt::KeyboardModifiers modifiers, bool isPress, bool autoRepeat ) + + + refresh + refresh + () + + + refresh + refresh-2 + ( QRegion & region ) + + + removeKeyboardFilter + removeKeyboardFilter + () + + + removedChannel + removedChannel + ( const QString & channel ) + + + resumeMouse + resumeMouse + () + + + screenSaverActivate + screenSaverActivate + ( bool activate ) + + + screenSaverActive + screenSaverActive + () + + + sendIMEvent + sendIMEvent + ( const QInputMethodEvent * event ) + + + sendIMQuery + sendIMQuery + ( int property ) + + + sendKeyEvent + sendKeyEvent + ( int unicode, int keycode, Qt::KeyboardModifiers modifiers, bool isPress, bool autoRepeat ) + + + setBackground + setBackground + ( const QBrush & brush ) + + + setCurrentInputMethod + setCurrentInputMethod + ( QWSInputMethod * method ) + + + setCursorVisible + setCursorVisible + ( bool visible ) + + + setDefaultKeyboard + setDefaultKeyboard + ( const char * keyboardDriver ) + + + setDefaultMouse + setDefaultMouse + ( const char * mouseDriver ) + + + setKeyboardHandler + setKeyboardHandler + ( QWSKeyboardHandler * handler ) + + + setMaxWindowRect + setMaxWindowRect + ( const QRect & rectangle ) + + + setMouseHandler + setMouseHandler + ( QWSMouseHandler * handler ) + + + setScreenSaver + setScreenSaver + ( QWSScreenSaver * screenSaver ) + + + setScreenSaverInterval + setScreenSaverInterval + ( int milliseconds ) + + + setScreenSaverIntervals + setScreenSaverIntervals + ( int * intervals ) + + + suspendMouse + suspendMouse + () + + + windowAt + windowAt + ( const QPoint & position ) + + + windowEvent + windowEvent + ( QWSWindow * window, QWSServer::WindowEvent eventType ) + + + + QWSServer::KeyboardFilter + qwsserver-keyboardfilter.html + + filter + filter + ( int unicode, int keycode, int modifiers, bool isPress, bool autoRepeat ) + + + + QWSServer::KeyMap + qwsserver-keymap.html + + ctrl_unicode + ctrl_unicode-var + + + + key_code + key_code-var + + + + shift_unicode + shift_unicode-var + + + + unicode + unicode-var + + + + IMState + IMState-enum + + + + QWSServer + QWSServer-2 + ( int flags, QObject * parent, const char * name ) + + + setDesktopBackground + setDesktopBackground + ( const QImage & img ) + + + setDesktopBackground + setDesktopBackground-2 + ( const QColor & c ) + + + + QWSTslibMouseHandler + qwstslibmousehandler.html + + + QWSWindow + qwswindow.html + + caption + caption + () + + + client + client + () + + + isFullyObscured + isFullyObscured + () + + + isOpaque + isOpaque + () + + + isVisible + isVisible + () + + + name + name + () + + + opacity + opacity + () + + + requestedRegion + requestedRegion + () + + + winId + winId + () + + + + QX11EmbedContainer + qx11embedcontainer.html + + Error + Error-enum + + + + QX11EmbedContainer + QX11EmbedContainer + ( QWidget * parent = 0 ) + + + clientClosed + clientClosed + () + + + clientIsEmbedded + clientIsEmbedded + () + + + clientWinId + clientWinId + () + + + discardClient + discardClient + () + + + embedClient + embedClient + ( WId id ) + + + error + error + () + + + error + error-2 + ( QX11EmbedContainer::Error error ) + + + + QX11EmbedWidget + qx11embedwidget.html + + Error + Error-enum + + + + QX11EmbedWidget + QX11EmbedWidget + ( QWidget * parent = 0 ) + + + containerClosed + containerClosed + () + + + containerWinId + containerWinId + () + + + embedInto + embedInto + ( WId id ) + + + embedded + embedded + () + + + error + error + () + + + error + error-2 + ( QX11EmbedWidget::Error error ) + + + + QX11Info + qx11info.html + + QX11Info + QX11Info + () + + + QX11Info + QX11Info-2 + ( const QX11Info & other ) + + + appCells + appCells + ( int screen = -1 ) + + + appClass + appClass + () + + + HANDLE + appColormap + QX11Info::appColormap( int screen = -1 ) + + + appDefaultColormap + appDefaultColormap + ( int screen = -1 ) + + + appDefaultVisual + appDefaultVisual + ( int screen = -1 ) + + + appDepth + appDepth + ( int screen = -1 ) + + + appDpiX + appDpiX + ( int screen = -1 ) + + + appDpiY + appDpiY + ( int screen = -1 ) + + + HANDLE + appRootWindow + QX11Info::appRootWindow( int screen = -1 ) + + + appScreen + appScreen + () + + + appTime + appTime + () + + + appUserTime + appUserTime + () + + + appVisual + appVisual + ( int screen = -1 ) + + + cells + cells + () + + + HANDLE + colormap + QX11Info::colormap() + + + defaultColormap + defaultColormap + () + + + defaultVisual + defaultVisual + () + + + depth + depth + () + + + display + display + () + + + screen + screen + () + + + setAppDpiX + setAppDpiX + ( int screen, int xdpi ) + + + setAppDpiY + setAppDpiY + ( int screen, int ydpi ) + + + setAppTime + setAppTime + ( unsigned long time ) + + + setAppUserTime + setAppUserTime + ( unsigned long time ) + + + visual + visual + () + + + operator= + operator-eq + ( const QX11Info & other ) + + + + QXmlAttributes + qxmlattributes.html + + QXmlAttributes + QXmlAttributes + () + + + append + append + ( const QString & qName, const QString & uri, const QString & localPart, const QString & value ) + + + clear + clear + () + + + count + count + () + + + index + index + ( const QString & qName ) + + + index + index-2 + ( const QString & uri, const QString & localPart ) + + + length + length + () + + + localName + localName + ( int index ) + + + qName + qName + ( int index ) + + + type + type + ( int index ) + + + type + type-2 + ( const QString & qName ) + + + type + type-3 + ( const QString & uri, const QString & localName ) + + + uri + uri + ( int index ) + + + value + value + ( int index ) + + + value + value-2 + ( const QString & qName ) + + + value + value-3 + ( const QString & uri, const QString & localName ) + + + + QXmlContentHandler + qxmlcontenthandler.html + + characters + characters + ( const QString & ch ) + + + endDocument + endDocument + () + + + endElement + endElement + ( const QString & namespaceURI, const QString & localName, const QString & qName ) + + + endPrefixMapping + endPrefixMapping + ( const QString & prefix ) + + + errorString + errorString + () + + + ignorableWhitespace + ignorableWhitespace + ( const QString & ch ) + + + processingInstruction + processingInstruction + ( const QString & target, const QString & data ) + + + setDocumentLocator + setDocumentLocator + ( QXmlLocator * locator ) + + + skippedEntity + skippedEntity + ( const QString & name ) + + + startDocument + startDocument + () + + + startElement + startElement + ( const QString & namespaceURI, const QString & localName, const QString & qName, const QXmlAttributes & atts ) + + + startPrefixMapping + startPrefixMapping + ( const QString & prefix, const QString & uri ) + + + + QXmlDeclHandler + qxmldeclhandler.html + + attributeDecl + attributeDecl + ( const QString & eName, const QString & aName, const QString & type, const QString & valueDefault, const QString & value ) + + + errorString + errorString + () + + + externalEntityDecl + externalEntityDecl + ( const QString & name, const QString & publicId, const QString & systemId ) + + + internalEntityDecl + internalEntityDecl + ( const QString & name, const QString & value ) + + + + QXmlDefaultHandler + qxmldefaulthandler.html + + QXmlDefaultHandler + QXmlDefaultHandler + () + + + + QXmlDTDHandler + qxmldtdhandler.html + + errorString + errorString + () + + + notationDecl + notationDecl + ( const QString & name, const QString & publicId, const QString & systemId ) + + + unparsedEntityDecl + unparsedEntityDecl + ( const QString & name, const QString & publicId, const QString & systemId, const QString & notationName ) + + + + QXmlEntityResolver + qxmlentityresolver.html + + errorString + errorString + () + + + resolveEntity + resolveEntity + ( const QString & publicId, const QString & systemId, QXmlInputSource *& ret ) + + + + QXmlErrorHandler + qxmlerrorhandler.html + + error + error + ( const QXmlParseException & exception ) + + + errorString + errorString + () + + + fatalError + fatalError + ( const QXmlParseException & exception ) + + + warning + warning + ( const QXmlParseException & exception ) + + + + QXmlInputSource + qxmlinputsource.html + + QXmlInputSource + QXmlInputSource + () + + + QXmlInputSource + QXmlInputSource-2 + ( QIODevice * dev ) + + + data + data + () + + + fetchData + fetchData + () + + + fromRawData + fromRawData + ( const QByteArray & data, bool beginning = false ) + + + next + next + () + + + reset + reset + () + + + setData + setData + ( const QString & dat ) + + + setData + setData-2 + ( const QByteArray & dat ) + + + QXmlInputSource + QXmlInputSource-3 + ( QFile & file ) + + + QXmlInputSource + QXmlInputSource-4 + ( QTextStream & stream ) + + + + QXmlLexicalHandler + qxmllexicalhandler.html + + comment + comment + ( const QString & ch ) + + + endCDATA + endCDATA + () + + + endDTD + endDTD + () + + + endEntity + endEntity + ( const QString & name ) + + + errorString + errorString + () + + + startCDATA + startCDATA + () + + + startDTD + startDTD + ( const QString & name, const QString & publicId, const QString & systemId ) + + + startEntity + startEntity + ( const QString & name ) + + + + QXmlLocator + qxmllocator.html + + QXmlLocator + QXmlLocator + () + + + columnNumber + columnNumber + () + + + lineNumber + lineNumber + () + + + + QXmlNamespaceSupport + qxmlnamespacesupport.html + + QXmlNamespaceSupport + QXmlNamespaceSupport + () + + + popContext + popContext + () + + + prefix + prefix + ( const QString & uri ) + + + prefixes + prefixes + () + + + prefixes + prefixes-2 + ( const QString & uri ) + + + processName + processName + ( const QString & qname, bool isAttribute, QString & nsuri, QString & localname ) + + + pushContext + pushContext + () + + + reset + reset + () + + + setPrefix + setPrefix + ( const QString & pre, const QString & uri ) + + + splitName + splitName + ( const QString & qname, QString & prefix, QString & localname ) + + + uri + uri + ( const QString & prefix ) + + + + QXmlParseException + qxmlparseexception.html + + QXmlParseException + QXmlParseException + ( const QString & name = QString() + + + columnNumber + columnNumber + () + + + lineNumber + lineNumber + () + + + message + message + () + + + publicId + publicId + () + + + systemId + systemId + () + + + + QXmlReader + qxmlreader.html + + DTDHandler + DTDHandler + () + + + contentHandler + contentHandler + () + + + declHandler + declHandler + () + + + entityResolver + entityResolver + () + + + errorHandler + errorHandler + () + + + feature + feature + ( const QString & name, bool * ok = 0 ) + + + hasFeature + hasFeature + ( const QString & name ) + + + hasProperty + hasProperty + ( const QString & name ) + + + lexicalHandler + lexicalHandler + () + + + parse + parse-2 + ( const QXmlInputSource * input ) + + + property + property + ( const QString & name, bool * ok = 0 ) + + + setContentHandler + setContentHandler + ( QXmlContentHandler * handler ) + + + setDTDHandler + setDTDHandler + ( QXmlDTDHandler * handler ) + + + setDeclHandler + setDeclHandler + ( QXmlDeclHandler * handler ) + + + setEntityResolver + setEntityResolver + ( QXmlEntityResolver * handler ) + + + setErrorHandler + setErrorHandler + ( QXmlErrorHandler * handler ) + + + setFeature + setFeature + ( const QString & name, bool value ) + + + setLexicalHandler + setLexicalHandler + ( QXmlLexicalHandler * handler ) + + + setProperty + setProperty + ( const QString & name, void * value ) + + + parse + parse + ( const QXmlInputSource & input ) + + + + QXmlSimpleReader + qxmlsimplereader.html + + QXmlSimpleReader + QXmlSimpleReader + () + + + parse + parse-3 + ( const QXmlInputSource * input, bool incremental ) + + + parseContinue + parseContinue + () + + + setFeature + setFeature + ( const QString & name, bool enable ) + + + diff --git a/qt/src/.cvsignore b/qt/src/.cvsignore new file mode 100644 index 0000000..f6454f2 --- /dev/null +++ b/qt/src/.cvsignore @@ -0,0 +1,11 @@ +.deps +.libs +Makefile +Makefile.in +*.lo +*.la +*.bb +*.bbg +*.da +*.gcov +*.moc diff --git a/qt/src/Makefile.am b/qt/src/Makefile.am new file mode 100644 index 0000000..41e3c5e --- /dev/null +++ b/qt/src/Makefile.am @@ -0,0 +1,70 @@ +INCLUDES=-I$(top_srcdir) $(DBUS_CLIENT_CFLAGS) $(DBUS_QT_CFLAGS) -DDBUS_COMPILATION + +lib_LTLIBRARIES=libdbus-qt4-1.la + +dbusincludedir=$(includedir)/dbus-1.0/dbus +dbusinclude_HEADERS= \ + qdbusbus.h \ + qdbusmacros.h \ + qdbuserror.h \ + qdbusmessage.h \ + qdbusserver.h \ + qdbusconnection.h \ + qdbusabstractinterface.h \ + qdbusinterface.h \ + qdbusutil.h \ + qdbusabstractadaptor.h \ + qdbusreply.h \ + qdbustypehelper_p.h + +noinst_HEADERS= \ + qdbusabstractadaptor_p.h \ + qdbusabstractinterface_p.h \ + qdbusconnection_p.h \ + qdbusinterface_p.h \ + qdbusintrospection_p.h \ + qdbusmarshall_p.h \ + qdbusmessage_p.h \ + qdbusmetaobject_p.h \ + qdbustype_p.h \ + qdbusxmlparser_p.h + +MOCS = qdbusabstractadaptor.moc qdbusserver.moc qdbusconnection_p.moc qdbusconnection_p.moc qdbusabstractadaptor_p.moc qdbusbus.moc qdbusabstractinterface.moc +CLEANFILES = $(MOCS) +BUILT_SOURCES = $(MOCS) + +libdbus_qt4_1_la_SOURCES = \ + qdbusbus.cpp \ + qdbusconnection.cpp \ + qdbuserror.cpp \ + qdbusintegrator.cpp \ + qdbusmarshall.cpp \ + qdbusmessage.cpp \ + qdbusserver.cpp \ + qdbustype.cpp \ + qdbusabstractinterface.cpp \ + qdbusinterface.cpp \ + qdbusxmlparser.cpp \ + qdbusutil.cpp \ + qdbusintrospection.cpp \ + qdbusabstractadaptor.cpp \ + qdbusthread.cpp \ + qdbusinternalfilters.cpp \ + qdbusmetaobject.cpp \ + qdbusmisc.cpp \ + qdbusxmlgenerator.cpp + +qdbusabstractadaptor.lo: qdbusabstractadaptor.moc qdbusabstractadaptor_p.moc +qdbusabstractinterface.lo: qdbusabstractinterface.moc +qdbusbus.lo: qdbusbus.moc +qdbusserver.lo: qdbusserver.moc +qdbusintegrator.lo: qdbusconnection_p.moc + +libdbus_qt4_1_la_LIBADD= $(DBUS_QT_LIBS) $(top_builddir)/dbus/libdbus-1.la +libdbus_qt4_1_la_LDFLAGS= -version-info 1:0 -no-undefined +libdbus_qt4_1_la_CPPFLAGS= -DQDBUS_MAKEDLL + +EXTRA_DIST = qt-dbus.qdocconf + +%.moc: %.h + $(QT_MOC) $< > $@ diff --git a/qt/src/qdbus.h b/qt/src/qdbus.h new file mode 100644 index 0000000..60c3582 --- /dev/null +++ b/qt/src/qdbus.h @@ -0,0 +1,52 @@ +/* qdbus.h precompiled header + * + * Copyright (C) 2005 Harald Fernengel + * + * Licensed under the Academic Free License version 2.1 + * + * This program 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 of the License, or + * (at your option) any later version. + * + * This program is distributed 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 this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#ifndef QDBUS_H +#define QDBUS_H + +#include + +#if !defined(DBUS_COMPILATION) +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +#else +# include "qdbusabstractadaptor.h" +# include "qdbusabstractinterface.h" +# include "qdbusbus.h" +# include "qdbusconnection.h" +# include "qdbuserror.h" +# include "qdbusinterface.h" +# include "qdbusmessage.h" +# include "qdbusreply.h" +# include "qdbusserver.h" +# include "qdbusutil.h" +#endif + +#endif diff --git a/qt/qdbusabstractadaptor.cpp b/qt/src/qdbusabstractadaptor.cpp similarity index 100% rename from qt/qdbusabstractadaptor.cpp rename to qt/src/qdbusabstractadaptor.cpp diff --git a/qt/qdbusabstractadaptor.h b/qt/src/qdbusabstractadaptor.h similarity index 100% rename from qt/qdbusabstractadaptor.h rename to qt/src/qdbusabstractadaptor.h diff --git a/qt/qdbusabstractadaptor_p.h b/qt/src/qdbusabstractadaptor_p.h similarity index 100% rename from qt/qdbusabstractadaptor_p.h rename to qt/src/qdbusabstractadaptor_p.h diff --git a/qt/qdbusabstractinterface.cpp b/qt/src/qdbusabstractinterface.cpp similarity index 100% rename from qt/qdbusabstractinterface.cpp rename to qt/src/qdbusabstractinterface.cpp diff --git a/qt/qdbusabstractinterface.h b/qt/src/qdbusabstractinterface.h similarity index 100% rename from qt/qdbusabstractinterface.h rename to qt/src/qdbusabstractinterface.h diff --git a/qt/qdbusabstractinterface_p.h b/qt/src/qdbusabstractinterface_p.h similarity index 100% rename from qt/qdbusabstractinterface_p.h rename to qt/src/qdbusabstractinterface_p.h diff --git a/qt/qdbusbus.cpp b/qt/src/qdbusbus.cpp similarity index 100% rename from qt/qdbusbus.cpp rename to qt/src/qdbusbus.cpp diff --git a/qt/qdbusbus.h b/qt/src/qdbusbus.h similarity index 99% rename from qt/qdbusbus.h rename to qt/src/qdbusbus.h index 6f0bbb1..2260685 100644 --- a/qt/qdbusbus.h +++ b/qt/src/qdbusbus.h @@ -153,6 +153,6 @@ signals: void nameOwnerChanged(const QString &name, const QString &oldOwner, const QString &newOwner); }; -Q_DECLARE_OPERATORS_FOR_FLAGS(QDBusBusService::RequestNameOptions); +Q_DECLARE_OPERATORS_FOR_FLAGS(QDBusBusService::RequestNameOptions) #endif diff --git a/qt/qdbusconnection.cpp b/qt/src/qdbusconnection.cpp similarity index 98% rename from qt/qdbusconnection.cpp rename to qt/src/qdbusconnection.cpp index 7bbde9a..6cd733c 100644 --- a/qt/qdbusconnection.cpp +++ b/qt/src/qdbusconnection.cpp @@ -49,7 +49,7 @@ private: QHash connectionHash; }; -Q_GLOBAL_STATIC(QDBusConnectionManager, manager); +Q_GLOBAL_STATIC(QDBusConnectionManager, manager) QDBusConnectionPrivate *QDBusConnectionManager::connection(const QString &name) const { @@ -275,13 +275,13 @@ QDBusConnection QDBusConnection::addConnection(BusType type, const QString &name DBusConnection *c = 0; switch (type) { case SystemBus: - c = dbus_bus_get(DBUS_BUS_SYSTEM, &d->error); + c = dbus_bus_get_private(DBUS_BUS_SYSTEM, &d->error); break; case SessionBus: - c = dbus_bus_get(DBUS_BUS_SESSION, &d->error); + c = dbus_bus_get_private(DBUS_BUS_SESSION, &d->error); break; case ActivationBus: - c = dbus_bus_get(DBUS_BUS_STARTER, &d->error); + c = dbus_bus_get_private(DBUS_BUS_STARTER, &d->error); break; } d->setConnection(c); //setConnection does the error handling for us @@ -632,7 +632,7 @@ QDBusBusService *QDBusConnection::busService() const if (!d) return 0; return d->busService; -}; +} QDBusAbstractInterfacePrivate * QDBusConnection::findInterface_helper(const QString &service, const QString &path, @@ -699,7 +699,7 @@ QString QDBusConnection::baseService() const : QString(); } -Q_GLOBAL_STATIC(QMutex, defaultBussesMutex); +Q_GLOBAL_STATIC(QMutex, defaultBussesMutex) static const char sessionBusName[] = "qt_default_session_bus"; static const char systemBusName[] = "qt_default_system_bus"; static QDBusConnection *sessionBus = 0; diff --git a/qt/qdbusconnection.h b/qt/src/qdbusconnection.h similarity index 98% rename from qt/qdbusconnection.h rename to qt/src/qdbusconnection.h index e107242..c1c420a 100644 --- a/qt/qdbusconnection.h +++ b/qt/src/qdbusconnection.h @@ -61,7 +61,7 @@ public: UnregisterTree }; - Q_DECLARE_FLAGS(RegisterOptions, RegisterOption); + Q_DECLARE_FLAGS(RegisterOptions, RegisterOption) QDBusConnection(const QString &name); QDBusConnection(const QDBusConnection &other); diff --git a/qt/qdbusconnection_p.h b/qt/src/qdbusconnection_p.h similarity index 98% rename from qt/qdbusconnection_p.h rename to qt/src/qdbusconnection_p.h index a903449..bab0b65 100644 --- a/qt/qdbusconnection_p.h +++ b/qt/src/qdbusconnection_p.h @@ -60,13 +60,10 @@ class QDBusObjectPrivate; class CallDeliveryEvent; class QMetaMethod; class QDBusInterfacePrivate; -class QDBusMetaObject; +struct QDBusMetaObject; class QDBusAbstractInterface; class QDBusBusService; -typedef struct DBusConnection; -typedef struct DBusServer; - class QDBusConnectionPrivate: public QObject { Q_OBJECT diff --git a/qt/qdbuserror.cpp b/qt/src/qdbuserror.cpp similarity index 100% rename from qt/qdbuserror.cpp rename to qt/src/qdbuserror.cpp diff --git a/qt/qdbuserror.h b/qt/src/qdbuserror.h similarity index 100% rename from qt/qdbuserror.h rename to qt/src/qdbuserror.h diff --git a/qt/qdbusintegrator.cpp b/qt/src/qdbusintegrator.cpp similarity index 99% rename from qt/qdbusintegrator.cpp rename to qt/src/qdbusintegrator.cpp index 190c468..07921cf 100644 --- a/qt/qdbusintegrator.cpp +++ b/qt/src/qdbusintegrator.cpp @@ -46,8 +46,9 @@ int QDBusConnectionPrivate::messageMetaType = 0; -typedef void (*qDBusSpyHook)(const QDBusMessage&); -static qDBusSpyHook messageSpyHook; +typedef void (*QDBusSpyHook)(const QDBusMessage&); +typedef QVarLengthArray QDBusSpyHookList; +Q_GLOBAL_STATIC(QDBusSpyHookList, qDBusSpyHookList) struct QDBusPendingCall { @@ -220,10 +221,10 @@ static void qDBusNewConnection(DBusServer *server, DBusConnection *c, void *data qDebug("SERVER: GOT A NEW CONNECTION"); // TODO } -extern QDBUS_EXPORT void qDBusSetSpyHook(qDBusSpyHook); -void qDBusSetSpyHook(qDBusSpyHook hook) +extern QDBUS_EXPORT void qDBusAddSpyHook(QDBusSpyHook); +void qDBusAddSpyHook(QDBusSpyHook hook) { - messageSpyHook = hook; + qDBusSpyHookList()->append(hook); } #if USE_OUTSIDE_DISPATCH @@ -271,9 +272,10 @@ DBusHandlerResult QDBusConnectionPrivate::messageFilter(DBusConnection *connecti QDBusMessage amsg = QDBusMessage::fromDBusMessage(message, QDBusConnection(d->name)); qDebug() << "got message:" << amsg; - if (messageSpyHook) { + const QDBusSpyHookList *list = qDBusSpyHookList(); + for (int i = 0; i < list->size(); ++i) { qDebug() << "calling the message spy hook"; - (*messageSpyHook)(amsg); + (*(*list)[i])(amsg); } bool handled = false; diff --git a/qt/qdbusinterface.cpp b/qt/src/qdbusinterface.cpp similarity index 100% rename from qt/qdbusinterface.cpp rename to qt/src/qdbusinterface.cpp diff --git a/qt/qdbusinterface.h b/qt/src/qdbusinterface.h similarity index 98% rename from qt/qdbusinterface.h rename to qt/src/qdbusinterface.h index 716ca8a..0b4d187 100644 --- a/qt/qdbusinterface.h +++ b/qt/src/qdbusinterface.h @@ -41,7 +41,7 @@ public: virtual int qt_metacall(QMetaObject::Call, int, void **); private: - Q_DECLARE_PRIVATE(QDBusInterface); + Q_DECLARE_PRIVATE(QDBusInterface) Q_DISABLE_COPY(QDBusInterface) }; diff --git a/qt/qdbusinterface_p.h b/qt/src/qdbusinterface_p.h similarity index 100% rename from qt/qdbusinterface_p.h rename to qt/src/qdbusinterface_p.h diff --git a/qt/qdbusinternalfilters.cpp b/qt/src/qdbusinternalfilters.cpp similarity index 100% rename from qt/qdbusinternalfilters.cpp rename to qt/src/qdbusinternalfilters.cpp diff --git a/qt/qdbusintrospection.cpp b/qt/src/qdbusintrospection.cpp similarity index 100% rename from qt/qdbusintrospection.cpp rename to qt/src/qdbusintrospection.cpp diff --git a/qt/qdbusintrospection_p.h b/qt/src/qdbusintrospection_p.h similarity index 100% rename from qt/qdbusintrospection_p.h rename to qt/src/qdbusintrospection_p.h diff --git a/qt/qdbusmacros.h b/qt/src/qdbusmacros.h similarity index 84% rename from qt/qdbusmacros.h rename to qt/src/qdbusmacros.h index 5b3c7d3..0af5b5b 100644 --- a/qt/qdbusmacros.h +++ b/qt/src/qdbusmacros.h @@ -47,4 +47,14 @@ # define Q_ASYNC #endif +#ifdef Q_CC_MSVC +#include +#include +#include +#include +class QDBusType; +inline uint qHash(const QVariant&) { Q_ASSERT(0); return 0; } +inline uint qHash(const QDBusType&) { Q_ASSERT(0); return 0; } +#endif + #endif diff --git a/qt/qdbusmarshall.cpp b/qt/src/qdbusmarshall.cpp similarity index 99% rename from qt/qdbusmarshall.cpp rename to qt/src/qdbusmarshall.cpp index 8d80152..6209ffb 100644 --- a/qt/qdbusmarshall.cpp +++ b/qt/src/qdbusmarshall.cpp @@ -331,7 +331,7 @@ static void qVariantToIteratorInternal(DBusMessageIter *it, const QVariant &var, const QDBusType &type); static void qListToIterator(DBusMessageIter *it, const QList &list, - const QDBusTypeList &list); + const QDBusTypeList &typelist); template static void qIterAppend(DBusMessageIter *it, const QDBusType &type, T arg) diff --git a/qt/qdbusmarshall_p.h b/qt/src/qdbusmarshall_p.h similarity index 100% rename from qt/qdbusmarshall_p.h rename to qt/src/qdbusmarshall_p.h diff --git a/qt/qdbusmessage.cpp b/qt/src/qdbusmessage.cpp similarity index 100% rename from qt/qdbusmessage.cpp rename to qt/src/qdbusmessage.cpp diff --git a/qt/qdbusmessage.h b/qt/src/qdbusmessage.h similarity index 100% rename from qt/qdbusmessage.h rename to qt/src/qdbusmessage.h diff --git a/qt/qdbusmessage_p.h b/qt/src/qdbusmessage_p.h similarity index 100% rename from qt/qdbusmessage_p.h rename to qt/src/qdbusmessage_p.h diff --git a/qt/qdbusmetaobject.cpp b/qt/src/qdbusmetaobject.cpp similarity index 100% rename from qt/qdbusmetaobject.cpp rename to qt/src/qdbusmetaobject.cpp diff --git a/qt/qdbusmetaobject_p.h b/qt/src/qdbusmetaobject_p.h similarity index 98% rename from qt/qdbusmetaobject_p.h rename to qt/src/qdbusmetaobject_p.h index 7d6c5ca..746240d 100644 --- a/qt/qdbusmetaobject_p.h +++ b/qt/src/qdbusmetaobject_p.h @@ -41,7 +41,7 @@ class QDBusError; -class QDBusMetaObjectPrivate; +struct QDBusMetaObjectPrivate; struct QDBUS_EXPORT QDBusMetaObject: public QMetaObject { bool cached; diff --git a/qt/qdbusmisc.cpp b/qt/src/qdbusmisc.cpp similarity index 100% rename from qt/qdbusmisc.cpp rename to qt/src/qdbusmisc.cpp diff --git a/qt/qdbusreply.h b/qt/src/qdbusreply.h similarity index 99% rename from qt/qdbusreply.h rename to qt/src/qdbusreply.h index ff0d5d5..0b5c12d 100644 --- a/qt/qdbusreply.h +++ b/qt/src/qdbusreply.h @@ -34,7 +34,7 @@ #include "qdbustypehelper_p.h" template -class QDBUS_EXPORT QDBusReply +class QDBusReply { typedef T Type; public: diff --git a/qt/qdbusserver.cpp b/qt/src/qdbusserver.cpp similarity index 100% rename from qt/qdbusserver.cpp rename to qt/src/qdbusserver.cpp diff --git a/qt/qdbusserver.h b/qt/src/qdbusserver.h similarity index 100% rename from qt/qdbusserver.h rename to qt/src/qdbusserver.h diff --git a/qt/qdbusthread.cpp b/qt/src/qdbusthread.cpp similarity index 100% rename from qt/qdbusthread.cpp rename to qt/src/qdbusthread.cpp diff --git a/qt/qdbustype.cpp b/qt/src/qdbustype.cpp similarity index 100% rename from qt/qdbustype.cpp rename to qt/src/qdbustype.cpp diff --git a/qt/qdbustype_p.h b/qt/src/qdbustype_p.h similarity index 100% rename from qt/qdbustype_p.h rename to qt/src/qdbustype_p.h diff --git a/qt/qdbustypehelper_p.h b/qt/src/qdbustypehelper_p.h similarity index 100% rename from qt/qdbustypehelper_p.h rename to qt/src/qdbustypehelper_p.h diff --git a/qt/qdbusutil.cpp b/qt/src/qdbusutil.cpp similarity index 100% rename from qt/qdbusutil.cpp rename to qt/src/qdbusutil.cpp diff --git a/qt/qdbusutil.h b/qt/src/qdbusutil.h similarity index 100% rename from qt/qdbusutil.h rename to qt/src/qdbusutil.h diff --git a/qt/qdbusxmlgenerator.cpp b/qt/src/qdbusxmlgenerator.cpp similarity index 98% rename from qt/qdbusxmlgenerator.cpp rename to qt/src/qdbusxmlgenerator.cpp index 561985a..cbd5388 100644 --- a/qt/qdbusxmlgenerator.cpp +++ b/qt/src/qdbusxmlgenerator.cpp @@ -187,6 +187,8 @@ QString qDBusGenerateMetaObjectXml(QString interface, const QMetaObject *mo, con else xml = generateInterfaceXml(mo, flags, base->methodCount(), base->propertyCount()); + if (xml.isEmpty()) + return QString(); // don't add an empty interface return QString(QLatin1String(" \n%2 \n")) .arg(interface, xml); } diff --git a/qt/qdbusxmlparser.cpp b/qt/src/qdbusxmlparser.cpp similarity index 100% rename from qt/qdbusxmlparser.cpp rename to qt/src/qdbusxmlparser.cpp diff --git a/qt/qdbusxmlparser_p.h b/qt/src/qdbusxmlparser_p.h similarity index 100% rename from qt/qdbusxmlparser_p.h rename to qt/src/qdbusxmlparser_p.h diff --git a/qt/tools/.cvsignore b/qt/tools/.cvsignore new file mode 100644 index 0000000..f6454f2 --- /dev/null +++ b/qt/tools/.cvsignore @@ -0,0 +1,11 @@ +.deps +.libs +Makefile +Makefile.in +*.lo +*.la +*.bb +*.bbg +*.da +*.gcov +*.moc diff --git a/qt/tools/Makefile.am b/qt/tools/Makefile.am new file mode 100644 index 0000000..a79aafd --- /dev/null +++ b/qt/tools/Makefile.am @@ -0,0 +1,10 @@ +INCLUDES=-I$(top_srcdir)/qt $(DBUS_CLIENT_CFLAGS) $(DBUS_QT_CFLAGS) -DDBUS_COMPILATION +bin_PROGRAMS = dbusidl2cpp dbuscpp2xml + +dbusidl2cpp_SOURCES = dbusidl2cpp.cpp +dbusidl2cpp_LDFLAGS = -no-undefined +dbusidl2cpp_LDADD = $(DBUS_QT_LIBS) ../src/libdbus-qt4-1.la + +dbuscpp2xml_SOURCES = dbuscpp2xml.cpp +dbuscpp2xml_LDFLAGS = -no-undefined +dbuscpp2xml_LDADD = $(DBUS_QT_LIBS) ../src/libdbus-qt4-1.la diff --git a/qt/dbuscpp2xml.cpp b/qt/tools/dbuscpp2xml.cpp similarity index 96% rename from qt/dbuscpp2xml.cpp rename to qt/tools/dbuscpp2xml.cpp index e111f11..dd08b5f 100644 --- a/qt/dbuscpp2xml.cpp +++ b/qt/tools/dbuscpp2xml.cpp @@ -31,9 +31,14 @@ #include #include #include +#include -#include "qdbusconnection.h" // for the Export* flags -#include // for the XML DOCTYPE declaration +#include "../src/qdbusconnection.h" // for the Export* flags + +// copied from dbus-protocol.h: +static const char docTypeHeader[] = + "\n"; // in qdbusxmlgenerator.cpp extern QDBUS_EXPORT QString qDBusGenerateMetaObjectXml(QString interface, const QMetaObject *mo, @@ -43,7 +48,7 @@ extern QDBUS_EXPORT QString qDBusGenerateMetaObjectXml(QString interface, const #define PROGRAMVERSION "0.1" #define PROGRAMCOPYRIGHT "Copyright (C) 2006 Trolltech AS. All rights reserved." -static const char cmdlineOptions[] = "psmaPSMAo:"; +static const char cmdlineOptions[] = "psmaPSMAo:hV"; static const char *outputFile; static int flags; @@ -336,7 +341,7 @@ int main(int argc, char **argv) MocParser parser; parseCmdLine(argc, argv); - for (int i = 1; i < argc; ++i) { + for (int i = optind; i < argc; ++i) { FILE *in = fopen(argv[i], "r"); if (in == 0) { fprintf(stderr, PROGRAMNAME ": could not open '%s': %s\n", @@ -390,7 +395,7 @@ int main(int argc, char **argv) } } - fprintf(output, "%s\n", DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE); + fprintf(output, "%s\n", docTypeHeader); foreach (QMetaObject mo, parser.objects) { QString xml = qDBusGenerateMetaObjectXml(QString(), &mo, &QObject::staticMetaObject, flags); diff --git a/qt/dbusidl2cpp.cpp b/qt/tools/dbusidl2cpp.cpp similarity index 99% rename from qt/dbusidl2cpp.cpp rename to qt/tools/dbusidl2cpp.cpp index d329c18..091685b 100644 --- a/qt/dbusidl2cpp.cpp +++ b/qt/tools/dbusidl2cpp.cpp @@ -33,8 +33,8 @@ #include #include -#include "qdbusmetaobject_p.h" -#include "qdbusintrospection_p.h" +#include "../src/qdbusmetaobject_p.h" +#include "../src/qdbusintrospection_p.h" #define PROGRAMNAME "dbusidl2cpp" #define PROGRAMVERSION "0.4"