X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcontrib%2Flibqxt-2007-10-24%2Fdoctemplate%2Fqt.tag;fp=src%2Fcontrib%2Flibqxt-2007-10-24%2Fdoctemplate%2Fqt.tag;h=8d5c8d84d939eeca8862e7211e37012010df2206;hp=0000000000000000000000000000000000000000;hb=a634acadbcf6017474f68a3eaf7cb632660e9e49;hpb=cd122ca8e0d2c0ffc5397e0a813c75d791a7e6e3 diff --git a/src/contrib/libqxt-2007-10-24/doctemplate/qt.tag b/src/contrib/libqxt-2007-10-24/doctemplate/qt.tag new file mode 100644 index 00000000..8d5c8d84 --- /dev/null +++ b/src/contrib/libqxt-2007-10-24/doctemplate/qt.tag @@ -0,0 +1,85448 @@ + + + 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 ) + + + + 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 ) + + + + 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 ) + + + + Q3AsciiCache + q3asciicache.html + + Q3AsciiCache + Q3AsciiCache + ( 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 ) + + + + Q3Button + q3button.html + + Q3Button + Q3Button + ( QWidget * parent = 0, const char * name = 0, Qt::WindowFlags f = 0 ) + + + drawButton + drawButton + ( QPainter * painter ) + + + drawButtonLabel + drawButtonLabel + ( QPainter * painter ) + + + paintEvent + paintEvent + ( QPaintEvent * event ) + + + + 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 + () + + + + Q3Cache + q3cache.html + + Q3Cache + Q3Cache + ( 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 ) + + + + 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 + () + + + + 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 + () + + + active + active + () + + + enabled + enabled + () + + + selected + selected + () + + + visible + visible + () + + + + 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 ) + + + + Q3CanvasLine + q3canvasline.html + + Q3CanvasLine + Q3CanvasLine + ( Q3Canvas * canvas ) + + + endPoint + endPoint + () + + + rtti + rtti + () + + + setPoints + setPoints + ( int xa, int ya, int xb, int yb ) + + + startPoint + startPoint + () + + + + 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 ) + + + Q3CanvasPixmapArray + Q3CanvasPixmapArray-3 + ( Q3PtrList<QPixmap> list, Q3PtrList<QPoint> hotspots ) + + + operator! + operator-not + () + + + + 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 ) + + + + Q3CanvasPolygon + q3canvaspolygon.html + + Q3CanvasPolygon + Q3CanvasPolygon + ( Q3Canvas * canvas ) + + + areaPoints + areaPoints + () + + + drawShape + drawShape + ( QPainter & p ) + + + points + points + () + + + rtti + rtti + () + + + setPoints + setPoints + ( Q3PointArray pa ) + + + + 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 + () + + + + 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::WindowFlags f = 0 ) + + + Q3CanvasView + Q3CanvasView-2 + ( Q3Canvas * canvas, QWidget * parent = 0, const char * name = 0, Qt::WindowFlags 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 enable ) + + + 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::WindowFlags 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::WindowFlags 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 ) + + + + 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 ) + + + + Q3DateTimeEditBase + q3datetimeeditbase.html + + + 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::WindowFlags f = 0 ) + + + Q3DockWindow + Q3DockWindow-2 + ( QWidget * parent, const char * name = 0, Qt::WindowFlags 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::WindowFlags 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::WindowFlags f = 0 ) + + + Q3Grid + Q3Grid-2 + ( int n, Qt::Orientation orient, QWidget * parent = 0, const char * name = 0, Qt::WindowFlags f = 0 ) + + + setSpacing + setSpacing + ( int space ) + + + + Q3GridView + q3gridview.html + + Q3GridView + Q3GridView + ( QWidget * parent = 0, const char * name = 0, Qt::WindowFlags 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 ) + + + frameStyle + frameStyle + () + + + insideMargin + insideMargin + () + + + insideSpacing + insideSpacing + () + + + setColumnLayout + setColumnLayout + ( int strips, Qt::Orientation direction ) + + + setFrameStyle + setFrameStyle + ( int style ) + + + setInsideMargin + setInsideMargin + ( int m ) + + + setInsideSpacing + setInsideSpacing + ( int s ) + + + + Q3HBox + q3hbox.html + + Q3HBox + Q3HBox + ( QWidget * parent = 0, const char * name = 0, Qt::WindowFlags f = 0 ) + + + Q3HBox + Q3HBox-2 + ( bool horizontal, QWidget * parent, const char * name, Qt::WindowFlags 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 + () + + + + Q3HGroupBox + q3hgroupbox.html + + Q3HGroupBox + Q3HGroupBox + ( QWidget * parent = 0, const char * name = 0 ) + + + Q3HGroupBox + Q3HGroupBox-2 + ( const QString & title, QWidget * parent = 0, const char * name = 0 ) + + + + 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 ) + + + + 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 ) + + + + 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 + () + + + 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::WindowFlags 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 + ( 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::WindowFlags 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::WindowFlags 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::WindowFlags 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 + ( 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 + ( 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 ) + + + margin + margin + () + + + setMargin + setMargin + ( int margin ) + + + + 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-2 + ( int totalSteps, QWidget * parent, const char * name, Qt::WindowFlags f = 0 ) + + + Q3ProgressBar + Q3ProgressBar-3 + ( QWidget * parent, const char * name, Qt::WindowFlags f = 0 ) + + + + Q3ProgressBar + q3progressbar.html + + Q3ProgressBar + Q3ProgressBar + ( QWidget * parent = 0, Qt::WindowFlags f = 0 ) + + + Q3ProgressBar + Q3ProgressBar-4 + ( int totalSteps, QWidget * parent = 0, Qt::WindowFlags f = 0 ) + + + margin + margin + () + + + reset + reset + () + + + setIndicator + setIndicator + ( QString & indicator, int progress, int totalSteps ) + + + setMargin + setMargin + ( int margin ) + + + + Q3ProgressDialog + q3progressdialog.html + + Q3ProgressDialog + Q3ProgressDialog + ( QWidget * creator, const char * name, bool modal = false, Qt::WindowFlags f = 0 ) + + + Q3ProgressDialog + Q3ProgressDialog-2 + ( const QString & labelText, const QString & cancelButtonText, int totalSteps, QWidget * creator = 0, const char * name = 0, bool modal = false, Qt::WindowFlags f = 0 ) + + + Q3ProgressDialog + Q3ProgressDialog-3 + ( QWidget * creator = 0, Qt::WindowFlags f = 0 ) + + + Q3ProgressDialog + Q3ProgressDialog-4 + ( const QString & labelText, const QString & cancelButtonText, int totalSteps, QWidget * creator = 0, Qt::WindowFlags f = 0 ) + + + cancel + cancel + () + + + canceled + canceled + () + + + cancelled + cancelled + () + + + forceShow + forceShow + () + + + reset + reset + () + + + setBar + setBar + ( Q3ProgressBar * bar ) + + + setCancelButton + setCancelButton + ( QPushButton * cancelButton ) + + + setCancelButtonText + setCancelButtonText + ( const QString & cancelButtonText ) + + + setLabel + setLabel + ( QLabel * label ) + + + sizeHint + sizeHint + () + + + + 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 ) + + + childIsVisible + childIsVisible + ( QWidget * child ) + + + showChild + showChild + ( QWidget * child, bool y = true ) + + + + Q3ScrollView + q3scrollview.html + + ResizePolicy + ResizePolicy-enum + + + + ScrollBarMode + ScrollBarMode-enum + + + + Q3ScrollView + Q3ScrollView + ( QWidget * parent = 0, const char * name = 0, Qt::WindowFlags 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 ) + + + + 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 + () + + + block + block + ( bool b ) + + + isBlocked + isBlocked + () + + + parameter + parameter + () + + + setParameter + setParameter + ( int value ) + + + + 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 + () + + + + 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 + () + + + + 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 + ( OpenMode m ) + + + open + open-2 + ( 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 ) + + + + 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 + ( OpenMode mode ) + + + open + open-2 + ( 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 ) + + + + 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 + ( const QString & name, const QVariant & val ) + + + sort + sort + () + + + toString + toString + ( 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 + () + + + isTabEnabled + isTabEnabled-2 + ( const char * name ) + + + setTabEnabled + setTabEnabled-2 + ( const char * name, bool enable ) + + + + Q3TabDialog + q3tabdialog.html + + Q3TabDialog + Q3TabDialog + ( QWidget * parent = 0, const char * name = 0, bool modal = false, Qt::WindowFlags 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 ) + + + + 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 + ( 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 + ( 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 ) + + + Q3TextStream + Q3TextStream-4 + ( QString & str, int filemode ) + + + eof + eof + () + + + + Q3TextStream + q3textstream.html + + Encoding + Encoding-enum + + + + Q3TextStream + Q3TextStream + () + + + Q3TextStream + Q3TextStream-2 + ( QIODevice * iod ) + + + Q3TextStream + Q3TextStream-3 + ( QString * str, int filemode ) + + + Q3TextStream + Q3TextStream-5 + ( QByteArray & a, int mode ) + + + Q3TextStream + Q3TextStream-6 + ( FILE * fh, int mode ) + + + atEnd + atEnd + () + + + codec + codec + () + + + device + device + () + + + fill + fill + () + + + fill + fill-2 + ( int f ) + + + flags + flags + () + + + flags + flags-2 + ( int f ) + + + precision + precision + () + + + precision + precision-2 + ( int p ) + + + read + read + () + + + readLine + readLine + () + + + readRawBytes + readRawBytes + ( char * s, uint len ) + + + reset + reset + () + + + setCodec + setCodec + ( QTextCodec * codec ) + + + setDevice + setDevice + ( QIODevice * iod ) + + + setEncoding + setEncoding + ( Encoding e ) + + + setf + setf + ( int bits ) + + + setf + setf-2 + ( int bits, int mask ) + + + skipWhiteSpace + skipWhiteSpace + () + + + unsetDevice + unsetDevice + () + + + unsetf + unsetf + ( int bits ) + + + width + width + () + + + width + width-2 + ( int w ) + + + writeRawBytes + writeRawBytes + ( const char * s, uint len ) + + + operator<< + operator-lt-lt + ( QChar c ) + + + operator<< + operator-lt-lt-2 + ( char c ) + + + operator<< + operator-lt-lt-3 + ( signed short i ) + + + operator<< + operator-lt-lt-4 + ( unsigned short i ) + + + operator<< + operator-lt-lt-5 + ( signed int i ) + + + operator<< + operator-lt-lt-6 + ( unsigned int i ) + + + operator<< + operator-lt-lt-7 + ( signed long i ) + + + operator<< + operator-lt-lt-8 + ( unsigned long i ) + + + operator<< + operator-lt-lt-9 + ( float f ) + + + operator<< + operator-lt-lt-10 + ( double f ) + + + operator<< + operator-lt-lt-11 + ( const char * s ) + + + operator<< + operator-lt-lt-12 + ( const Q3CString & s ) + + + operator<< + operator-lt-lt-13 + ( const QString & s ) + + + operator<< + operator-lt-lt-14 + ( void * ptr ) + + + operator>> + operator-gt-gt + ( QChar & c ) + + + operator>> + operator-gt-gt-2 + ( char & c ) + + + operator>> + operator-gt-gt-3 + ( signed short & i ) + + + operator>> + operator-gt-gt-4 + ( unsigned short & i ) + + + operator>> + operator-gt-gt-5 + ( signed int & i ) + + + operator>> + operator-gt-gt-6 + ( unsigned int & i ) + + + operator>> + operator-gt-gt-7 + ( signed long & i ) + + + operator>> + operator-gt-gt-8 + ( unsigned long & i ) + + + operator>> + operator-gt-gt-9 + ( float & f ) + + + operator>> + operator-gt-gt-10 + ( double & f ) + + + operator>> + operator-gt-gt-11 + ( char * s ) + + + operator>> + operator-gt-gt-12 + ( QString & str ) + + + operator>> + operator-gt-gt-13 + ( Q3CString & str ) + + + + 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::WindowFlags f = 0 ) + + + Q3ToolBar + Q3ToolBar-3 + ( Q3MainWindow * parent = 0, const char * name = 0 ) + + + addSeparator + addSeparator + () + + + clear + clear + () + + + mainWindow + mainWindow + () + + + setStretchableWidget + setStretchableWidget + ( QWidget * w ) + + + setFilenames + setFilenames-2x + ( const QStringList & list ) + + + + 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 + setFilenamesx + ( 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 ) + + + + 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 ) + + + + 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 ) + + + + 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 ) + + + + 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::WindowFlags 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 ) + + + + Q3VGroupBox + q3vgroupbox.html + + Q3VGroupBox + Q3VGroupBox + ( QWidget * parent = 0, const char * name = 0 ) + + + Q3VGroupBox + Q3VGroupBox-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::WindowFlags 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 ) + + + setFinish + setFinish + ( QWidget * widget, bool finish ) + + + + Q3Wizard + q3wizard.html + + Q3Wizard + Q3Wizard + ( QWidget * parent = 0, const char * name = 0, bool modal = false, Qt::WindowFlags 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 ) + + + QAbstractButton + QAbstractButton-2 + ( QWidget * parent, const char * name, Qt::WindowFlags 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 ) + + + + 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::WindowFlags 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 ) + + + + QAbstractFileEngine::ExtensionOption + qabstractfileengine-extensionoption.html + + + QAbstractFileEngine::ExtensionReturn + qabstractfileengine-extensionreturn.html + + + QAbstractFileEngine + qabstractfileengine.html + + Extension + Extension-enum + + + + FileName + FileName-enum + + + + FileOwner + FileOwner-enum + + + + FileTime + FileTime-enum + + + + Iterator + Iterator-typedef + + + + QAbstractFileEngine + QAbstractFileEngine + () + + + atEnd + atEnd + () + + + beginEntryList + beginEntryList + ( QDir::Filters filters, const QStringList & filterNames ) + + + 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 + () + + + extension + extension + ( Extension extension, const ExtensionOption * option = 0, ExtensionReturn * output = 0 ) + + + 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 + () + + + supportsExtension + supportsExtension + ( Extension extension ) + + + write + write + ( const char * data, qint64 len ) + + + Iterator + Iterator-typedef + + + + + QAbstractFileEngineHandler + qabstractfileenginehandler.html + + QAbstractFileEngineHandler + QAbstractFileEngineHandler + () + + + create + create + ( const QString & fileName ) + + + + QAbstractFileEngineIterator + qabstractfileengineiterator.html + + QAbstractFileEngineIterator + QAbstractFileEngineIterator + ( QDir::Filters filters, const QStringList & nameFilters ) + + + currentFileInfo + currentFileInfo + () + + + currentFileName + currentFileName + () + + + currentFilePath + currentFilePath + () + + + Filters + filters + QAbstractFileEngineIterator::filters() + + + hasNext + hasNext + () + + + nameFilters + nameFilters + () + + + next + next + () + + + path + path + () + + + + QAbstractFontEngine::FixedPoint + qabstractfontengine-fixedpoint.html + + x + x-var + + + + y + y-var + + + + + QAbstractFontEngine::GlyphMetrics + qabstractfontengine-glyphmetrics.html + + GlyphMetrics + GlyphMetricsx + () + + + advance + advance-var + + + + height + height-var + + + + width + width-var + + + + x + x-var + + + + y + y-var + + + + + QAbstractFontEngine + qabstractfontengine.html + + Fixed + Fixed-typedef + + + + FontProperty + FontProperty-enum + + + + QAbstractFontEngine + QAbstractFontEngine + ( QObject * parent = 0 ) + + + addGlyphOutlinesToPath + addGlyphOutlinesToPath + ( uint * glyphs, int numGlyphs, FixedPoint * positions, QPainterPath * path ) + + + capabilities + capabilities + () + + + convertStringToGlyphIndices + convertStringToGlyphIndices + ( const QChar * string, int length, uint * glyphs, int * numGlyphs, TextShapingFlags flags ) + + + fontProperty + fontProperty + ( FontProperty property ) + + + getGlyphAdvances + getGlyphAdvances + ( const uint * glyphs, int numGlyphs, Fixed * advances, TextShapingFlags flags ) + + + glyphMetrics + glyphMetrics + ( uint glyph ) + + + renderGlyph + renderGlyph + ( uint glyph, int depth, int bytesPerLine, int height, uchar * buffer ) + + + + 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 + () + + + + QAbstractGraphicsShapeItem + qabstractgraphicsshapeitem.html + + QAbstractGraphicsShapeItem + QAbstractGraphicsShapeItem + ( QGraphicsItem * parent = 0 ) + + + brush + brush + () + + + pen + pen + () + + + setBrush + setBrush + ( const QBrush & brush ) + + + setPen + setPen + ( const QPen & pen ) + + + elidedText + elidedText + ( const QFontMetrics & fontMetrics, int width, Qt::TextElideMode mode, const QString & text ) + + + + 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 ) + + + helpEvent + helpEvent + ( QHelpEvent * event, QAbstractItemView * view, const QStyleOptionViewItem & option, const QModelIndex & index ) + + + 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 ) + + + createIndex + createIndex-2 + ( int row, int column, int id ) + + + + 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-3 + ( int row, int column, quint32 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 ) + + + layoutAboutToBeChanged + layoutAboutToBeChanged + () + + + 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 + () + + + modelAboutToBeReset + modelAboutToBeReset + () + + + modelReset + modelReset + () + + + parent + parent + ( const QModelIndex & index ) + + + persistentIndexList + persistentIndexList + () + + + 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 ) + + + setSupportedDragActions + setSupportedDragActions + ( Qt::DropActions actions ) + + + 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 + supportedDragActions + QAbstractItemModel::supportedDragActions() + + + DropActions + supportedDropActions + QAbstractItemModel::supportedDropActions() + + + horizontalStepsPerItem + horizontalStepsPerItem + () + + + setHorizontalStepsPerItem + setHorizontalStepsPerItem + ( int steps ) + + + setVerticalStepsPerItem + setVerticalStepsPerItem + ( int steps ) + + + verticalStepsPerItem + verticalStepsPerItem + () + + + + QAbstractItemView + qabstractitemview.html + + CursorAction + CursorAction-enum + + + + DragDropMode + DragDropMode-enum + + + + DropIndicatorPosition + DropIndicatorPosition-enum + + + + ScrollHint + ScrollHint-enum + + + + ScrollMode + ScrollMode-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 + () + + + indexAt + indexAt + ( const QPoint & point ) + + + indexWidget + indexWidget + ( const QModelIndex & index ) + + + isIndexHidden + isIndexHidden + ( const QModelIndex & index ) + + + itemDelegate + itemDelegate + () + + + itemDelegate + itemDelegate-2 + ( const QModelIndex & index ) + + + itemDelegateForColumn + itemDelegateForColumn + ( int column ) + + + itemDelegateForRow + itemDelegateForRow + ( int row ) + + + 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 ) + + + setIndexWidget + setIndexWidget + ( const QModelIndex & index, QWidget * widget ) + + + setItemDelegate + setItemDelegate + ( QAbstractItemDelegate * delegate ) + + + setItemDelegateForColumn + setItemDelegateForColumn + ( int column, QAbstractItemDelegate * delegate ) + + + setItemDelegateForRow + setItemDelegateForRow + ( int row, 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 ) + + + sizeHintForColumn + sizeHintForColumn + ( int column ) + + + sizeHintForIndex + sizeHintForIndex + ( const QModelIndex & index ) + + + sizeHintForRow + sizeHintForRow + ( int row ) + + + startDrag + startDrag + ( Qt::DropActions supportedActions ) + + + state + state + () + + + timerEvent + timerEvent + ( QTimerEvent * event ) + + + update + update + ( const QModelIndex & index ) + + + verticalOffset + verticalOffset + () + + + 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 ) + + + addScrollBarWidget + addScrollBarWidget + ( QWidget * widget, Qt::Alignment alignment ) + + + contextMenuEvent + contextMenuEvent + ( QContextMenuEvent * e ) + + + cornerWidget + cornerWidget + () + + + dragEnterEvent + dragEnterEvent + ( QDragEnterEvent * event ) + + + dragLeaveEvent + dragLeaveEvent + ( QDragLeaveEvent * event ) + + + dragMoveEvent + dragMoveEvent + ( QDragMoveEvent * event ) + + + dropEvent + dropEvent + ( QDropEvent * event ) + + + 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 ) + + + scrollBarWidgets + scrollBarWidgets + ( Qt::Alignment alignment ) + + + scrollContentsBy + scrollContentsBy + ( int dx, int dy ) + + + setCornerWidget + setCornerWidget + ( QWidget * widget ) + + + setHorizontalScrollBar + setHorizontalScrollBar + ( QScrollBar * scrollBar ) + + + setVerticalScrollBar + setVerticalScrollBar + ( QScrollBar * scrollBar ) + + + setViewport + setViewport + ( QWidget * widget ) + + + setViewportMargins + setViewportMargins + ( int left, int top, int right, int bottom ) + + + setupViewport + setupViewport + ( QWidget * viewport ) + + + verticalScrollBar + verticalScrollBar + () + + + viewport + viewport + () + + + viewportEvent + viewportEvent + ( QEvent * event ) + + + wheelEvent + wheelEvent + ( QWheelEvent * e ) + + + 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 + () + + + + 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 + () + + + Error + Error-enum + + + + State + State-typedef + + + + connectionClosed + connectionClosed + () + + + delayedCloseFinished + delayedCloseFinished + () + + + setSocket + setSocket + ( int socket ) + + + socket + socket + () + + + waitForMore + waitForMore + ( int msecs, bool * timeout = 0 ) + + + + 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 + () + + + proxyAuthenticationRequired + proxyAuthenticationRequired + ( const QNetworkProxy & proxy, QAuthenticator * authenticator ) + + + 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 ) + + + waitForReadyRead + waitForReadyRead + ( 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 + + + + CorrectionMode + CorrectionMode-enum + + + + Alignment + alignment-prop + + + + QAbstractSpinBox + QAbstractSpinBox + ( QWidget * parent = 0 ) + + + clear + clear + () + + + editingFinished + editingFinished + () + + + fixup + fixup + ( QString & input ) + + + initStyleOption + initStyleOption + ( QStyleOptionSpinBox * option ) + + + 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::PaintContext + qabstracttextdocumentlayout-paintcontext.html + + clip + clip-var + + + + cursorPosition + cursorPosition-var + + + + palette + palette-var + + + + selections + selections-var + + + + + QAbstractTextDocumentLayout::Selection + qabstracttextdocumentlayout-selection.html + + cursor + cursor-var + + + + format + format-var + + + + + 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. ) + + + + QAccessible + qaccessible.html + + Action + Action-enum + + + + Event + Event-enum + + + + InterfaceFactory + InterfaceFactory-typedef + + + + Method + Method-enum + + + + Role + Role-enum + + + + Text + Text-enum + + + + installFactory + installFactory + ( InterfaceFactory factory ) + + + installRootObjectHandler + installRootObjectHandler + ( RootObjectHandler handler ) + + + isActive + isActive + () + + + queryAccessibleInterface + queryAccessibleInterface + ( QObject * object ) + + + removeFactory + removeFactory + ( InterfaceFactory factory ) + + + updateAccessibility + updateAccessibility + ( QObject * object, int child, Event reason ) + + + + 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 + () + + + + 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 ) + + + invokeMethod + invokeMethod + ( Method method, int child = 0, const QVariantList & params = QVariantList() + + + 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 ) + + + supportedMethods + supportedMethods + () + + + 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 + () + + + 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 ) + + + + QAction + qaction.html + + ActionEvent + ActionEvent-enum + + + + MenuRole + MenuRole-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 ) + + + associatedWidgets + associatedWidgets + () + + + changed + changed + () + + + data + data + () + + + hover + hover + () + + + hovered + hovered + () + + + isSeparator + isSeparator + () + + + menu + menu + () + + + parentWidget + parentWidget + () + + + setActionGroup + setActionGroup + ( QActionGroup * group ) + + + setData + setData + ( const QVariant & userData ) + + + setDisabled + setDisabled + ( bool b ) + + + setMenu + setMenu + ( QMenu * menu ) + + + setSeparator + setSeparator + ( bool b ) + + + setShortcuts + setShortcuts + ( const QList<QKeySequence> & shortcuts ) + + + setShortcuts + setShortcuts-2 + ( QKeySequence::StandardKey key ) + + + shortcuts + shortcuts + () + + + 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 ) + + + + QActionEvent + qactionevent.html + + QActionEvent + QActionEvent + ( int type, QAction * action, QAction * before = 0 ) + + + action + action + () + + + before + before + () + + + add + add + ( QAction * a ) + + + addSeparator + addSeparator + () + + + addTo + addTo + ( QWidget * widget ) + + + selected + selected + ( QAction * action ) + + + + 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 ) + + + 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 + + + + + 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 + () + + + alert + alert + ( QWidget * widget, int msec = 0 ) + + + allWidgets + allWidgets + () + + + beep + beep + () + + + changeOverrideCursor + changeOverrideCursor + ( const QCursor & cursor ) + + + clipboard + clipboard + () + + + closeAllWindows + closeAllWindows + () + + + colorSpec + colorSpec + () + + + commitData + commitData + ( QSessionManager & manager ) + + + commitDataRequest + commitDataRequest + ( QSessionManager & manager ) + + + desktop + desktop + () + + + desktopSettingsAware + desktopSettingsAware + () + + + exec + exec + () + + + focusChanged + focusChanged + ( QWidget * old, QWidget * now ) + + + focusWidget + focusWidget + () + + + font + font + () + + + font + font-2 + ( const QWidget * widget ) + + + font + font-3 + ( const char * className ) + + + fontMetrics + fontMetrics + () + + + inputContext + inputContext + () + + + isEffectEnabled + isEffectEnabled + ( Qt::UIEffect effect ) + + + isLeftToRight + isLeftToRight + () + + + isRightToLeft + isRightToLeft + () + + + isSessionRestored + isSessionRestored + () + + + LayoutDirection + keyboardInputDirection + QApplication::keyboardInputDirection() + + + keyboardInputLocale + keyboardInputLocale + () + + + 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 ) + + + saveStateRequest + saveStateRequest + ( 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 ) + + + + QAuthenticator + qauthenticator.html + + QAuthenticator + QAuthenticator + () + + + QAuthenticator + QAuthenticator-2 + ( const QAuthenticator & other ) + + + isNull + isNull + () + + + password + password + () + + + realm + realm + () + + + setPassword + setPassword + ( const QString & password ) + + + setUser + setUser + ( const QString & user ) + + + user + user + () + + + operator!= + operator-not-eq + ( const QAuthenticator & other ) + + + operator= + operator-eq + ( const QAuthenticator & other ) + + + operator== + operator-eq-eq + ( const QAuthenticator & other ) + + + + 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 ) + + + + 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 ) + + + + 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 + () + + + + 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::WindowFlags f = 0 ) + + + QAxWidget + QAxWidget-2 + ( const QString & c, QWidget * parent = 0, Qt::WindowFlags f = 0 ) + + + QAxWidget + QAxWidget-3 + ( IUnknown * iface, QWidget * parent = 0, Qt::WindowFlags f = 0 ) + + + createAggregate + createAggregate + () + + + createHostWindow + createHostWindow + ( bool initialized ) + + + doVerb + doVerb + ( const QString & verb ) + + + initialize + initialize + ( IUnknown ** ptr ) + + + 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 + + DataPtr + DataPtr-typedef + + + + 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 ) + + + data_ptr + data_ptr + () + + + 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-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 ) + + + + 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 ) + + + transformed + transformed-2 + ( const QTransform & 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-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 ) + + + + 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 ) + + + setSpacing + setSpacing + ( int spacing ) + + + setStretchFactor + setStretchFactor + ( QWidget * widget, int stretch ) + + + setStretchFactor + setStretchFactor-2 + ( QLayout * layout, int stretch ) + + + spacing + spacing + () + + + 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 ) + + + pixmap + pixmap + () + + + setPixmap + setPixmap + ( const QPixmap & pixmap ) + + + operator + operator-const-QColor--and + const QColor &() + + + + QBrush + qbrush.html + + DataPtr + DataPtr-typedef + + + + 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 QImage & image ) + + + QBrush + QBrush-9 + ( const QBrush & other ) + + + QBrush + QBrush-10 + ( const QGradient & gradient ) + + + color + color + () + + + data_ptr + data_ptr + () + + + gradient + gradient + () + + + isDetached + isDetached + () + + + isOpaque + isOpaque + () + + + matrix + matrix + () + + + setColor + setColor + ( const QColor & color ) + + + setColor + setColor-2 + ( Qt::GlobalColor color ) + + + setMatrix + setMatrix + ( const QMatrix & matrix ) + + + setStyle + setStyle + ( Qt::BrushStyle style ) + + + setTexture + setTexture + ( const QPixmap & pixmap ) + + + setTextureImage + setTextureImage + ( const QImage & image ) + + + setTransform + setTransform + ( const QTransform & ) + + + BrushStyle + style + QBrush::style() + + + texture + texture + () + + + textureImage + textureImage + () + + + transform + transform + () + + + 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 ) + + + insert + insert + ( QAbstractButton * b ) + + + remove + remove + ( QAbstractButton * b ) + + + + 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 ) + + + buttonPressed + buttonPressed + ( QAbstractButton * button ) + + + buttonPressed + buttonPressed-2 + ( int id ) + + + buttonReleased + buttonReleased + ( QAbstractButton * button ) + + + buttonReleased + buttonReleased-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-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 + () + + + + QByteArray + qbytearray.html + + DataPtr + DataPtr-typedef + + + + 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 + () + + + data_ptr + data_ptr + () + + + 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 ) + + + fromHex + fromHex + ( const QByteArray & hexEncoded ) + + + 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 ) + + + toHex + toHex + () + + + 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 ) + + + 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 + () + + + + 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 ) + + + QCache + QCache-2 + ( int maxCost, int dummy ) + + + + 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 ) + + + + QCalendarWidget + qcalendarwidget.html + + HorizontalHeaderFormat + HorizontalHeaderFormat-enum + + + + SelectionMode + SelectionMode-enum + + + + VerticalHeaderFormat + VerticalHeaderFormat-enum + + + + DayOfWeek + firstDayOfWeek-prop + + + + QCalendarWidget + QCalendarWidget + ( QWidget * parent = 0 ) + + + activated + activated + ( const QDate & date ) + + + clicked + clicked + ( const QDate & date ) + + + currentPageChanged + currentPageChanged + ( int year, int month ) + + + dateTextFormat + dateTextFormat + () + + + dateTextFormat + dateTextFormat-2 + ( const QDate & date ) + + + headerTextFormat + headerTextFormat + () + + + monthShown + monthShown + () + + + paintCell + paintCell + ( QPainter * painter, const QRect & rect, const QDate & date ) + + + selectionChanged + selectionChanged + () + + + setCurrentPage + setCurrentPage + ( int year, int month ) + + + setDateRange + setDateRange + ( const QDate & min, const QDate & max ) + + + setDateTextFormat + setDateTextFormat + ( const QDate & date, const QTextCharFormat & format ) + + + setHeaderTextFormat + setHeaderTextFormat + ( const QTextCharFormat & format ) + + + setWeekdayTextFormat + setWeekdayTextFormat + ( Qt::DayOfWeek dayOfWeek, const QTextCharFormat & format ) + + + showNextMonth + showNextMonth + () + + + showNextYear + showNextYear + () + + + showPreviousMonth + showPreviousMonth + () + + + showPreviousYear + showPreviousYear + () + + + showSelectedDate + showSelectedDate + () + + + showToday + showToday + () + + + weekdayTextFormat + weekdayTextFormat + ( Qt::DayOfWeek dayOfWeek ) + + + yearShown + yearShown + () + + + + QCDEStyle + qcdestyle.html + + QCDEStyle + QCDEStyle + ( bool useHighlightCols = false ) + + + ascii + ascii + () + + + latin1 + latin1 + () + + + lower + lower + () + + + mirrored + mirrored + () + + + networkOrdered + networkOrdered + () + + + upper + upper + () + + + + 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 + () + + + category + category-2 + ( uint ucs4 ) + + + category + category-3 + ( ushort ucs2 ) + + + cell + cell + () + + + combiningClass + combiningClass + () + + + combiningClass + combiningClass-2 + ( uint ucs4 ) + + + combiningClass + combiningClass-3 + ( ushort ucs2 ) + + + decomposition + decomposition + () + + + decomposition + decomposition-2 + ( uint ucs4 ) + + + decompositionTag + decompositionTag + () + + + decompositionTag + decompositionTag-2 + ( uint ucs4 ) + + + digitValue + digitValue + () + + + digitValue + digitValue-2 + ( ushort ucs2 ) + + + digitValue + digitValue-3 + ( uint ucs4 ) + + + direction + direction + () + + + direction + direction-2 + ( uint ucs4 ) + + + direction + direction-3 + ( ushort ucs2 ) + + + fromAscii + fromAscii + ( char c ) + + + fromLatin1 + fromLatin1 + ( char c ) + + + hasMirrored + hasMirrored + () + + + highSurrogate + highSurrogate + ( uint ucs4 ) + + + isDigit + isDigit + () + + + isHighSurrogate + isHighSurrogate + () + + + isLetter + isLetter + () + + + isLetterOrNumber + isLetterOrNumber + () + + + isLowSurrogate + isLowSurrogate + () + + + isLower + isLower + () + + + isMark + isMark + () + + + isNull + isNull + () + + + isNumber + isNumber + () + + + isPrint + isPrint + () + + + isPunct + isPunct + () + + + isSpace + isSpace + () + + + isSymbol + isSymbol + () + + + isTitleCase + isTitleCase + () + + + isUpper + isUpper + () + + + joining + joining + () + + + joining + joining-2 + ( uint ucs4 ) + + + joining + joining-3 + ( ushort ucs2 ) + + + lowSurrogate + lowSurrogate + ( uint ucs4 ) + + + mirroredChar + mirroredChar + () + + + mirroredChar + mirroredChar-2 + ( uint ucs4 ) + + + mirroredChar + mirroredChar-3 + ( ushort ucs2 ) + + + row + row + () + + + surrogateToUcs4 + surrogateToUcs4 + ( ushort high, ushort low ) + + + surrogateToUcs4 + surrogateToUcs4-2 + ( QChar high, QChar low ) + + + toAscii + toAscii + () + + + toCaseFolded + toCaseFolded + () + + + toCaseFolded + toCaseFolded-2 + ( uint ucs4 ) + + + toCaseFolded + toCaseFolded-3 + ( ushort ucs2 ) + + + toLatin1 + toLatin1 + () + + + toLower + toLower + () + + + toLower + toLower-2 + ( uint ucs4 ) + + + toLower + toLower-3 + ( ushort ucs2 ) + + + toTitleCase + toTitleCase + () + + + toTitleCase + toTitleCase-2 + ( uint ucs4 ) + + + toTitleCase + toTitleCase-3 + ( ushort ucs2 ) + + + toUpper + toUpper + () + + + toUpper + toUpper-2 + ( uint ucs4 ) + + + toUpper + toUpper-3 + ( ushort ucs2 ) + + + unicode + unicode + () + + + unicode + unicode-2 + () + + + unicodeVersion + unicodeVersion + () + + + unicodeVersion + unicodeVersion-2 + ( uint ucs4 ) + + + unicodeVersion + unicodeVersion-3 + ( ushort ucs2 ) + + + ascii + ascii + () + + + latin1 + latin1 + () + + + lower + lower + () + + + mirrored + mirrored + () + + + networkOrdered + networkOrdered + () + + + upper + upper + () + + + 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 + () + + + + QCheckBox + qcheckbox.html + + QCheckBox + QCheckBox + ( QWidget * parent = 0 ) + + + QCheckBox + QCheckBox-2 + ( const QString & text, QWidget * parent = 0 ) + + + CheckState + checkState + QCheckBox::checkState() + + + initStyleOption + initStyleOption + ( QStyleOptionButton * option ) + + + 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 + () + + + inserted + inserted + () + + + + QChildEvent + qchildevent.html + + QChildEvent + QChildEvent + ( Type type, QObject * child ) + + + added + added + () + + + child + child + () + + + polished + polished + () + + + removed + removed + () + + + inserted + inserted + () + + + + QCleanlooksStyle + qcleanlooksstyle.html + + QCleanlooksStyle + QCleanlooksStyle + () + + + drawItemText + drawItemText + ( QPainter * painter, const QRect & rectangle, int alignment, const QPalette & palette, bool enabled, const QString & text, QPalette::ColorRole textRole = QPalette::NoRole ) + + + data + data + ( Mode mode = Clipboard ) + + + setData + setData + ( QMimeSource * src, Mode mode = Clipboard ) + + + + QClipboard + qclipboard.html + + Mode + Mode-enum + + + + changed + changed + ( QClipboard::Mode mode ) + + + clear + clear + ( Mode mode = Clipboard ) + + + dataChanged + dataChanged + () + + + findBufferChanged + findBufferChanged + () + + + image + image + ( Mode mode = Clipboard ) + + + mimeData + mimeData + ( Mode mode = Clipboard ) + + + ownsClipboard + ownsClipboard + () + + + ownsFindBuffer + ownsFindBuffer + () + + + 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 ) + + + supportsFindBuffer + supportsFindBuffer + () + + + 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 + () + + + dark + dark + ( int factor = 200 ) + + + light + light + ( int factor = 150 ) + + + QColor + QColor-8 + ( 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 ) + + + + 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-9 + ( Qt::GlobalColor color ) + + + allowX11ColorNames + allowX11ColorNames + () + + + alpha + alpha + () + + + alphaF + alphaF + () + + + black + black + () + + + blackF + blackF + () + + + blue + blue + () + + + blueF + blueF + () + + + colorNames + colorNames + () + + + convertTo + convertTo + ( Spec colorSpec ) + + + cyan + cyan + () + + + cyanF + cyanF + () + + + darker + darker + ( 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 + () + + + lighter + lighter + ( int factor = 150 ) + + + magenta + magenta + () + + + magentaF + magentaF + () + + + name + name + () + + + red + red + () + + + redF + redF + () + + + rgb + rgb + () + + + rgba + rgba + () + + + saturation + saturation + () + + + saturationF + saturationF + () + + + setAllowX11ColorNames + setAllowX11ColorNames + ( bool enabled ) + + + 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 ) + + + QColor + QColor-8 + ( 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 ) + + + getColor + getColor-2 + ( const QColor & init, QWidget * parent, const char * name ) + + + getRgba + getRgba-2 + ( QRgb rgba, bool * ok, QWidget * parent, const char * name ) + + + + QColorDialog + qcolordialog.html + + changeEvent + changeEvent + ( QEvent * e ) + + + customColor + customColor + ( int i ) + + + customCount + customCount + () + + + getColor + getColor + ( const QColor & initial = Qt::white, QWidget * parent = 0 ) + + + getRgba + getRgba + ( QRgb initial = 0xffffffff, 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 ) + + + 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 + () + + + + 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 + () + + + + 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 + () + + + operator= + operator-eq + ( const QColormap & colormap ) + + + + QColumnView + qcolumnview.html + + QColumnView + QColumnView + ( QWidget * parent = 0 ) + + + columnWidths + columnWidths + () + + + createColumn + createColumn + ( const QModelIndex & index ) + + + previewWidget + previewWidget + () + + + setColumnWidths + setColumnWidths + ( const QList<int> & list ) + + + setPreviewWidget + setPreviewWidget + ( QWidget * widget ) + + + updatePreviewWidget + updatePreviewWidget + ( const QModelIndex & index ) + + + CaseSensitivity + autoCompletionCaseSensitivity-prop + + + + 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 ) + + + + QComboBox + qcombobox.html + + InsertPolicy + InsertPolicy-enum + + + + SizeAdjustPolicy + SizeAdjustPolicy-enum + + + + 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 + () + + + completer + completer + () + + + 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 ) + + + initStyleOption + initStyleOption + ( QStyleOptionComboBox * option ) + + + 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 + () + + + setCompleter + setCompleter + ( QCompleter * completer ) + + + 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 + () + + + + QCompleter + qcompleter.html + + CompletionMode + CompletionMode-enum + + + + ModelSorting + ModelSorting-enum + + + + CaseSensitivity + caseSensitivity-prop + + + + QCompleter + QCompleter + ( QObject * parent = 0 ) + + + QCompleter + QCompleter-2 + ( QAbstractItemModel * model, QObject * parent = 0 ) + + + QCompleter + QCompleter-3 + ( const QStringList & list, QObject * parent = 0 ) + + + activated + activated + ( const QString & text ) + + + activated + activated-2 + ( const QModelIndex & index ) + + + complete + complete + ( const QRect & rect = QRect() + + + completionCount + completionCount + () + + + completionModel + completionModel + () + + + currentCompletion + currentCompletion + () + + + currentIndex + currentIndex + () + + + currentRow + currentRow + () + + + highlighted + highlighted + ( const QString & text ) + + + highlighted + highlighted-2 + ( const QModelIndex & index ) + + + model + model + () + + + pathFromIndex + pathFromIndex + ( const QModelIndex & index ) + + + popup + popup + () + + + setCurrentRow + setCurrentRow + ( int row ) + + + setModel + setModel + ( QAbstractItemModel * model ) + + + setPopup + setPopup + ( QAbstractItemView * popup ) + + + setWidget + setWidget + ( QWidget * widget ) + + + splitPath + splitPath + ( const QString & path ) + + + widget + widget + () + + + + QConicalGradient + qconicalgradient.html + + QConicalGradient + QConicalGradient + () + + + QConicalGradient + QConicalGradient-2 + ( const QPointF & center, qreal angle ) + + + QConicalGradient + QConicalGradient-3 + ( qreal cx, qreal cy, qreal angle ) + + + angle + angle + () + + + center + center + () + + + setAngle + setAngle + ( qreal angle ) + + + setCenter + setCenter + ( const QPointF & center ) + + + setCenter + setCenter-2 + ( qreal x, qreal y ) + + + QConstString + QConstString + ( const QChar * unicode, int size ) + + + string + string + () + + + + QConstString + qconststring.html + + QConstString + QConstString + ( const QChar * unicode, int size ) + + + string + string + () + + + 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() + + + + 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-2 + ( const QString & channel, QObject * parent, const char * name ) + + + + QCopChannel + qcopchannel.html + + QCopChannel + QCopChannel + ( const QString & channel, QObject * parent = 0 ) + + + channel + channel + () + + + flush + flush + () + + + 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 ) + + + enter_loop + enter_loop + () + + + exit_loop + exit_loop + () + + + lock + lock + () + + + locked + locked + () + + + loopLevel + loopLevel + () + + + processOneEvent + processOneEvent + () + + + tryLock + tryLock + () + + + unlock + unlock + ( bool wakeUpGui = true ) + + + + 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 * translationFile ) + + + instance + instance + () + + + libraryPaths + libraryPaths + () + + + notify + notify + ( QObject * receiver, QEvent * event ) + + + postEvent + postEvent + ( QObject * receiver, QEvent * event ) + + + postEvent + postEvent-2 + ( QObject * receiver, QEvent * event, int priority ) + + + 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 ) + + + removePostedEvents + removePostedEvents-2 + ( QObject * receiver, int eventType ) + + + removeTranslator + removeTranslator + ( QTranslator * translationFile ) + + + sendEvent + sendEvent + ( QObject * receiver, QEvent * event ) + + + sendPostedEvents + sendPostedEvents + ( QObject * receiver, int event_type ) + + + sendPostedEvents + sendPostedEvents-2 + () + + + setAttribute + setAttribute + ( Qt::ApplicationAttribute attribute, bool on = true ) + + + setEventFilter + setEventFilter + ( EventFilter filter ) + + + setLibraryPaths + setLibraryPaths + ( const QStringList & paths ) + + + startingUp + startingUp + () + + + testAttribute + testAttribute + ( Qt::ApplicationAttribute attribute ) + + + translate + translate + ( const char * context, const char * sourceText, const char * comment, Encoding encoding, int n ) + + + translate + translate-2 + ( const char * context, const char * sourceText, const char * comment = 0, Encoding encoding = CodecForTr ) + + + winEventFilter + winEventFilter + ( MSG * msg, long * result ) + + + enter_loop + enter_loop + () + + + exit_loop + exit_loop + () + + + lock + lock + () + + + locked + locked + () + + + loopLevel + loopLevel + () + + + processOneEvent + processOneEvent + () + + + tryLock + tryLock + () + + + unlock + unlock + ( bool wakeUpGui = true ) + + + + QCryptographicHash + qcryptographichash.html + + Algorithm + Algorithm-enum + + + + QCryptographicHash + QCryptographicHash + ( Algorithm method ) + + + addData + addData + ( const char * data, int length ) + + + addData + addData-2 + ( const QByteArray & data ) + + + hash + hash + ( const QByteArray & data, Algorithm method ) + + + reset + reset + () + + + result + result + () + + + + 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 ) + + + bitmap + bitmap + () + + + handle + handle + () + + + 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 + ( int type, void * data = 0 ) + + + data + data + () + + + setData + setData + ( void * data ) + + + + QCustomEvent + qcustomevent.html + + QCustomEvent + QCustomEvent + ( int type, void * data = 0 ) + + + data + data + () + + + setData + setData + ( void * data ) + + + + QCustomRasterPaintDevice + qcustomrasterpaintdevice.html + + QCustomRasterPaintDevice + QCustomRasterPaintDevice + ( QWidget * widget ) + + + bytesPerLine + bytesPerLine + () + + + Format + format + QCustomRasterPaintDevice::format() + + + memory + memory + () + + + 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 ) + + + + 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 ) + + + + QDataWidgetMapper + qdatawidgetmapper.html + + SubmitPolicy + SubmitPolicy-enum + + + + Orientation + orientation-prop + + + + QDataWidgetMapper + QDataWidgetMapper + ( QObject * parent = 0 ) + + + addMapping + addMapping + ( QWidget * widget, int section ) + + + addMapping + addMapping-2 + ( QWidget * widget, int section, const QByteArray & propertyName ) + + + clearMapping + clearMapping + () + + + currentIndexChanged + currentIndexChanged + ( int index ) + + + itemDelegate + itemDelegate + () + + + mappedPropertyName + mappedPropertyName + ( QWidget * widget ) + + + mappedSection + mappedSection + ( QWidget * widget ) + + + mappedWidgetAt + mappedWidgetAt + ( int section ) + + + model + model + () + + + removeMapping + removeMapping + ( QWidget * widget ) + + + revert + revert + () + + + rootIndex + rootIndex + () + + + setCurrentModelIndex + setCurrentModelIndex + ( const QModelIndex & index ) + + + setItemDelegate + setItemDelegate + ( QAbstractItemDelegate * delegate ) + + + setModel + setModel + ( QAbstractItemModel * model ) + + + setRootIndex + setRootIndex + ( const QModelIndex & index ) + + + submit + submit + () + + + toFirst + toFirst + () + + + toLast + toLast + () + + + toNext + toNext + () + + + toPrevious + toPrevious + () + + + setYMD + setYMD + ( int y, int m, int d ) + + + currentDate + currentDate-2 + ( Qt::TimeSpec spec ) + + + dayName + dayName + ( int weekday ) + + + leapYear + leapYear + ( int year ) + + + monthName + monthName + ( int month ) + + + + 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 + () + + + 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 year, int month, int day ) + + + longDayName + longDayName + ( int weekday ) + + + longMonthName + longMonthName + ( int month ) + + + month + month + () + + + setDate + setDate + ( int year, int month, int day ) + + + 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-2 + ( Qt::TimeSpec spec ) + + + dayName + dayName + ( int weekday ) + + + leapYear + leapYear + ( int year ) + + + monthName + monthName + ( int month ) + + + + QDateEdit + qdateedit.html + + QDateEdit + QDateEdit + ( QWidget * parent = 0 ) + + + QDateEdit + QDateEdit-2 + ( const QDate & date, QWidget * parent = 0 ) + + + currentDateTime + currentDateTime-2 + ( Qt::TimeSpec spec ) + + + setTime_t + setTime_t-2 + ( uint secsSince1Jan1970UTC, Qt::TimeSpec spec ) + + + + 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 s ) + + + 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 ) + + + fromTime_t + fromTime_t + ( uint seconds ) + + + 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 ) + + + + 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 ) + + + initStyleOption + initStyleOption + ( QStyleOptionSpinBox * option ) + + + sectionAt + sectionAt + ( int index ) + + + sectionText + sectionText + ( Section section ) + + + setDateRange + setDateRange + ( const QDate & min, const QDate & max ) + + + setSelectedSection + setSelectedSection + ( Section section ) + + + setTimeRange + setTimeRange + ( const QTime & min, const QTime & max ) + + + textFromDateTime + textFromDateTime + ( const QDateTime & dateTime ) + + + timeChanged + timeChanged + ( const QTime & time ) + + + CallMode + CallMode-enum + + + + + QDBusAbstractAdaptor + qdbusabstractadaptor.html + + QDBusAbstractAdaptor + QDBusAbstractAdaptor + ( QObject * obj ) + + + autoRelaySignals + autoRelaySignals + () + + + setAutoRelaySignals + setAutoRelaySignals + ( bool enable ) + + + + QDBusAbstractInterface + qdbusabstractinterface.html + + call + call + ( const QString & method, const QVariant & arg1 = QVariant() + + + call + call-2 + ( QDBus::CallMode mode, const QString & method, const QVariant & arg1 = QVariant() + + + callWithArgumentList + callWithArgumentList + ( QDBus::CallMode mode, const QString & method, const QList<QVariant> & args ) + + + callWithCallback + callWithCallback + ( const QString & method, const QList<QVariant> & args, QObject * receiver, const char * returnMethod, const char * errorMethod ) + + + callWithCallback + callWithCallback-2 + ( const QString & method, const QList<QVariant> & args, QObject * receiver, const char * slot ) + + + connection + connection + () + + + interface + interface + () + + + isValid + isValid + () + + + lastError + lastError + () + + + path + path + () + + + service + service + () + + + + QDBusArgument + qdbusargument.html + + QDBusArgument + QDBusArgument + () + + + QDBusArgument + QDBusArgument-2 + ( const QDBusArgument & other ) + + + atEnd + atEnd + () + + + beginArray + beginArray + ( int id ) + + + beginArray + beginArray-2 + () + + + beginMap + beginMap + ( int kid, int vid ) + + + beginMap + beginMap-2 + () + + + beginMapEntry + beginMapEntry + () + + + beginMapEntry + beginMapEntry-2 + () + + + beginStructure + beginStructure + () + + + beginStructure + beginStructure-2 + () + + + endArray + endArray + () + + + endArray + endArray-2 + () + + + endMap + endMap + () + + + endMap + endMap-2 + () + + + endMapEntry + endMapEntry + () + + + endMapEntry + endMapEntry-2 + () + + + endStructure + endStructure + () + + + endStructure + endStructure-2 + () + + + operator<< + operator-lt-lt + ( uchar arg ) + + + operator<< + operator-lt-lt-2 + ( bool arg ) + + + operator<< + operator-lt-lt-3 + ( short arg ) + + + operator<< + operator-lt-lt-4 + ( ushort arg ) + + + operator<< + operator-lt-lt-5 + ( int arg ) + + + operator<< + operator-lt-lt-6 + ( uint arg ) + + + operator<< + operator-lt-lt-7 + ( qlonglong arg ) + + + operator<< + operator-lt-lt-8 + ( qulonglong arg ) + + + operator<< + operator-lt-lt-9 + ( double arg ) + + + operator<< + operator-lt-lt-10 + ( const QString & arg ) + + + operator<< + operator-lt-lt-13 + ( const QDBusVariant & arg ) + + + operator<< + operator-lt-lt-14 + ( const QStringList & arg ) + + + operator<< + operator-lt-lt-15 + ( const QByteArray & arg ) + + + operator= + operator-eq + ( const QDBusArgument & other ) + + + operator>> + operator-gt-gt + ( uchar & arg ) + + + operator>> + operator-gt-gt-2 + ( bool & arg ) + + + operator>> + operator-gt-gt-3 + ( ushort & arg ) + + + operator>> + operator-gt-gt-4 + ( short & arg ) + + + operator>> + operator-gt-gt-5 + ( int & arg ) + + + operator>> + operator-gt-gt-6 + ( uint & arg ) + + + operator>> + operator-gt-gt-7 + ( qlonglong & arg ) + + + operator>> + operator-gt-gt-8 + ( qulonglong & arg ) + + + operator>> + operator-gt-gt-9 + ( double & arg ) + + + operator>> + operator-gt-gt-10 + ( QString & arg ) + + + operator>> + operator-gt-gt-13 + ( QDBusVariant & arg ) + + + operator>> + operator-gt-gt-14 + ( QStringList & arg ) + + + operator>> + operator-gt-gt-15 + ( QByteArray & arg ) + + + + QDBusConnection + qdbusconnection.html + + BusType + BusType-enum + + + + UnregisterMode + UnregisterMode-enum + + + + QDBusConnection + QDBusConnection + ( const QString & name ) + + + QDBusConnection + QDBusConnection-2 + ( const QDBusConnection & other ) + + + baseService + baseService + () + + + call + call + ( const QDBusMessage & message, QDBus::CallMode mode = QDBus::Block, int timeout = -1 ) + + + callWithCallback + callWithCallback + ( const QDBusMessage & message, QObject * receiver, const char * returnMethod, const char * errorMethod, int timeout = -1 ) + + + callWithCallback + callWithCallback-2 + ( const QDBusMessage & message, QObject * receiver, const char * returnMethod, int timeout = -1 ) + + + connect + connect + ( const QString & service, const QString & path, const QString & interface, const QString & name, QObject * receiver, const char * slot ) + + + connect + connect-2 + ( const QString & service, const QString & path, const QString & interface, const QString & name, const QString & signature, QObject * receiver, const char * slot ) + + + connectToBus + connectToBus + ( BusType type, const QString & name ) + + + connectToBus + connectToBus-2 + ( const QString & address, const QString & name ) + + + disconnect + disconnect + ( const QString & service, const QString & path, const QString & interface, const QString & name, QObject * receiver, const char * slot ) + + + disconnect + disconnect-2 + ( const QString & service, const QString & path, const QString & interface, const QString & name, const QString & signature, QObject * receiver, const char * slot ) + + + disconnectFromBus + disconnectFromBus + ( const QString & name ) + + + interface + interface + () + + + isConnected + isConnected + () + + + lastError + lastError + () + + + objectRegisteredAt + objectRegisteredAt + ( const QString & path ) + + + registerObject + registerObject + ( const QString & path, QObject * object, RegisterOptions options = ExportAdaptors ) + + + registerService + registerService + ( const QString & serviceName ) + + + send + send + ( const QDBusMessage & message ) + + + sender + sender + () + + + sessionBus + sessionBus + () + + + systemBus + systemBus + () + + + unregisterObject + unregisterObject + ( const QString & path, UnregisterMode mode = UnregisterNode ) + + + unregisterService + unregisterService + ( const QString & serviceName ) + + + operator= + operator-eq + ( const QDBusConnection & other ) + + + sessionBus + sessionBus + () + + + systemBus + systemBus + () + + + + QDBusConnectionInterface + qdbusconnectioninterface.html + + RegisterServiceReply + RegisterServiceReply-enum + + + + ServiceQueueOptions + ServiceQueueOptions-enum + + + + ServiceReplacementOptions + ServiceReplacementOptions-enum + + + + callWithCallbackFailed + callWithCallbackFailed + ( const QDBusError & error, const QDBusMessage & call ) + + + isServiceRegistered + isServiceRegistered + ( const QString & serviceName ) + + + RegisterServiceReply + registerService + > QDBusConnectionInterface::registerService( const QString & serviceName, ServiceQueueOptions qoption = DontQueueService, ServiceReplacementOptions roption = DontAllowReplacement ) + + + serviceOwner + serviceOwner + ( const QString & name ) + + + serviceOwnerChanged + serviceOwnerChanged + ( const QString & name, const QString & oldOwner, const QString & newOwner ) + + + servicePid + servicePid + ( const QString & serviceName ) + + + serviceRegistered + serviceRegistered + ( const QString & serviceName ) + + + serviceUid + serviceUid + ( const QString & serviceName ) + + + serviceUnregistered + serviceUnregistered + ( const QString & serviceName ) + + + startService + startService + ( const QString & name ) + + + unregisterService + unregisterService + ( const QString & serviceName ) + + + + QDBusContext + qdbuscontext.html + + QDBusContext + QDBusContext + () + + + calledFromDBus + calledFromDBus + () + + + connection + connection + () + + + isDelayedReply + isDelayedReply + () + + + message + message + () + + + sendErrorReply + sendErrorReply + ( const QString & name, const QString & msg = QString() + + + sendErrorReply + sendErrorReply-2 + ( QDBusError::ErrorType type, const QString & msg = QString() + + + setDelayedReply + setDelayedReply + ( bool enable ) + + + + QDBusError + qdbuserror.html + + ErrorType + ErrorType-enum + + + + errorString + errorString + ( ErrorType error ) + + + isValid + isValid + () + + + message + message + () + + + name + name + () + + + type + type + () + + + + QDBusInterface + qdbusinterface.html + + QDBusInterface + QDBusInterface + ( const QString & service, const QString & path, const QString & interface = QString() + + + + QDBusMessage + qdbusmessage.html + + MessageType + MessageType-enum + + + + QDBusMessage + QDBusMessage + () + + + QDBusMessage + QDBusMessage-2 + ( const QDBusMessage & other ) + + + arguments + arguments + () + + + createError + createError + ( const QString & name, const QString & msg ) + + + createError + createError-2 + ( const QDBusError & error ) + + + createError + createError-3 + ( QDBusError::ErrorType type, const QString & msg ) + + + createErrorReply + createErrorReply + ( const QString name, const QString & msg ) + + + createErrorReply + createErrorReply-2 + ( const QDBusError & error ) + + + createErrorReply + createErrorReply-3 + ( QDBusError::ErrorType type, const QString & msg ) + + + createMethodCall + createMethodCall + ( const QString & service, const QString & path, const QString & interface, const QString & method ) + + + createReply + createReply + ( const QList<QVariant> & arguments = QList<QVariant>() + + + createReply + createReply-2 + ( const QVariant & argument ) + + + createSignal + createSignal + ( const QString & path, const QString & interface, const QString & name ) + + + errorMessage + errorMessage + () + + + errorName + errorName + () + + + interface + interface + () + + + isDelayedReply + isDelayedReply + () + + + isReplyRequired + isReplyRequired + () + + + member + member + () + + + path + path + () + + + service + service + () + + + setArguments + setArguments + ( const QList<QVariant> & arguments ) + + + setDelayedReply + setDelayedReply + ( bool enable ) + + + signature + signature + () + + + type + type + () + + + operator<< + operator-lt-lt + ( const QVariant & arg ) + + + operator= + operator-eq + ( const QDBusMessage & other ) + + + + QDBusObjectPath + qdbusobjectpath.html + + QDBusObjectPath + QDBusObjectPath + () + + + QDBusObjectPath + QDBusObjectPath-2 + ( const char * path ) + + + QDBusObjectPath + QDBusObjectPath-3 + ( const QLatin1String & path ) + + + QDBusObjectPath + QDBusObjectPath-4 + ( const QString & path ) + + + path + path + () + + + setPath + setPath + ( const QString & path ) + + + + QDBusReply + qdbusreply.html + + QDBusReply + QDBusReply + ( const QDBusMessage & reply ) + + + QDBusReply + QDBusReply-2 + ( const QDBusError & error = QDBusError() + + + error + error + () + + + isValid + isValid + () + + + value + value + () + + + operator + operator-Type + Type() + + + operator= + operator-eq + ( const QDBusMessage & message ) + + + operator= + operator-eq-2 + ( const QDBusError & error ) + + + operator= + operator-eq-3 + ( const QDBusReply & other ) + + + + QDBusServer + qdbusserver.html + + QDBusServer + QDBusServer + ( const QString & address, QObject * parent = 0 ) + + + address + address + () + + + isConnected + isConnected + () + + + lastError + lastError + () + + + newConnection + newConnection + ( const QDBusConnection & connection ) + + + + QDBusSignature + qdbussignature.html + + QDBusSignature + QDBusSignature + () + + + QDBusSignature + QDBusSignature-2 + ( const char * signature ) + + + QDBusSignature + QDBusSignature-3 + ( const QLatin1String & signature ) + + + QDBusSignature + QDBusSignature-4 + ( const QString & signature ) + + + setSignature + setSignature + ( const QString & signature ) + + + signature + signature + () + + + + QDBusVariant + qdbusvariant.html + + QDBusVariant + QDBusVariant + () + + + QDBusVariant + QDBusVariant-2 + ( const QVariant & variant ) + + + setVariant + setVariant + ( const QVariant & variant ) + + + variant + variant + () + + + + 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 ) + + + + QDecorationFactory + qdecorationfactory.html + + create + create + ( const QString & key ) + + + keys + keys + () + + + + 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 + () + + + + QDesignerDynamicPropertySheetExtension + qdesignerdynamicpropertysheetextension.html + + addDynamicProperty + addDynamicProperty + ( const QString & propertyName, const QVariant & value ) + + + canAddDynamicProperty + canAddDynamicProperty + ( const QString & propertyName ) + + + dynamicPropertiesAllowed + dynamicPropertiesAllowed + () + + + isDynamicProperty + isDynamicProperty + ( int index ) + + + removeDynamicProperty + removeDynamicProperty + ( int index ) + + + + 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 ) + + + + QDesktopServices + qdesktopservices.html + + openUrl + openUrl + ( const QUrl & url ) + + + setUrlHandler + setUrlHandler + ( const QString & scheme, QObject * receiver, const char * method ) + + + unsetUrlHandler + unsetUrlHandler + ( const QString & scheme ) + + + + 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-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 + () + + + + QDial + qdial.html + + QDial + QDial + ( QWidget * parent = 0 ) + + + initStyleOption + initStyleOption + ( QStyleOptionSlider * option ) + + + 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 + () + + + extension + extension + () + + + Orientation + orientation + QDialog::orientation() + + + setExtension + setExtension + ( QWidget * extension ) + + + setOrientation + setOrientation + ( Qt::Orientation orientation ) + + + showExtension + showExtension + ( bool showIt ) + + + QDialog + QDialog-2 + ( QWidget * parent, const char * name, bool modal = false, Qt::WindowFlags f = 0 ) + + + + QDialog + qdialog.html + + DialogCode + DialogCode-enum + + + + QDialog + QDialog + ( QWidget * parent = 0, Qt::WindowFlags f = 0 ) + + + accept + accept + () + + + accepted + accepted + () + + + done + done + ( int r ) + + + exec + exec + () + + + finished + finished + ( int result ) + + + reject + reject + () + + + rejected + rejected + () + + + result + result + () + + + setResult + setResult + ( int i ) + + + QDialog + QDialog-2 + ( QWidget * parent, const char * name, bool modal = false, Qt::WindowFlags f = 0 ) + + + + QDialogButtonBox + qdialogbuttonbox.html + + ButtonLayout + ButtonLayout-enum + + + + ButtonRole + ButtonRole-enum + + + + Orientation + orientation-prop + + + + QDialogButtonBox + QDialogButtonBox + ( QWidget * parent = 0 ) + + + QDialogButtonBox + QDialogButtonBox-2 + ( Qt::Orientation orientation, QWidget * parent = 0 ) + + + QDialogButtonBox + QDialogButtonBox-3 + ( StandardButtons buttons, Qt::Orientation orientation = Qt::Horizontal, QWidget * parent = 0 ) + + + accepted + accepted + () + + + addButton + addButton + ( QAbstractButton * button, ButtonRole role ) + + + addButton + addButton-2 + ( const QString & text, ButtonRole role ) + + + addButton + addButton-3 + ( StandardButton button ) + + + button + button + ( StandardButton which ) + + + buttonRole + buttonRole + ( QAbstractButton * button ) + + + buttons + buttons + () + + + clear + clear + () + + + clicked + clicked + ( QAbstractButton * button ) + + + helpRequested + helpRequested + () + + + rejected + rejected + () + + + removeButton + removeButton + ( QAbstractButton * button ) + + + standardButton + standardButton + ( QAbstractButton * button ) + + + addResourceSearchPath + addResourceSearchPath + ( const QString & path ) + + + 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-3 + ( const QString & nameFilter, Filters filters = NoFilter, SortFlags sort = NoSort ) + + + entryList + entryList-3 + ( 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 ) + + + + 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 + () + + + addSearchPath + addSearchPath + ( const QString & prefix, const QString & path ) + + + canonicalPath + canonicalPath + () + + + cd + cd + ( const QString & dirName ) + + + cdUp + cdUp + () + + + cleanPath + cleanPath + ( const QString & path ) + + + count + count + () + + + current + current + () + + + currentPath + currentPath + () + + + dirName + dirName + () + + + drives + drives + () + + + entryInfoList + entryInfoList + ( const QStringList & nameFilters, Filters filters = NoFilter, SortFlags sort = NoSort ) + + + entryInfoList + entryInfoList-2 + ( Filters filters = NoFilter, SortFlags sort = NoSort ) + + + entryList + entryList + ( const QStringList & nameFilters, Filters filters = NoFilter, SortFlags sort = NoSort ) + + + entryList + entryList-2 + ( Filters filters = NoFilter, SortFlags sort = NoSort ) + + + exists + exists + ( const QString & name ) + + + exists + exists-2 + () + + + filePath + filePath + ( const QString & fileName ) + + + filter + filter + () + + + fromNativeSeparators + fromNativeSeparators + ( const QString & pathName ) + + + 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 + () + + + searchPaths + searchPaths + ( const QString & prefix ) + + + separator + separator + () + + + setCurrent + setCurrent + ( const QString & path ) + + + setFilter + setFilter + ( Filters filters ) + + + setNameFilters + setNameFilters + ( const QStringList & nameFilters ) + + + setPath + setPath + ( const QString & path ) + + + setSearchPaths + setSearchPaths + ( const QString & prefix, const QStringList & searchPaths ) + + + setSorting + setSorting + ( SortFlags sort ) + + + sorting + sorting + () + + + temp + temp + () + + + tempPath + tempPath + () + + + toNativeSeparators + toNativeSeparators + ( const QString & pathName ) + + + 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 ) + + + absFilePath + absFilePath + ( const QString & fileName, bool acceptAbsPath = true ) + + + absPath + absPath + () + + + cleanDirPath + cleanDirPath + ( const QString & name ) + + + convertToAbs + convertToAbs + () + + + currentDirPath + currentDirPath + () + + + entryInfoList + entryInfoList-3 + ( const QString & nameFilter, Filters filters = NoFilter, SortFlags sort = NoSort ) + + + entryList + entryList-3 + ( 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 ) + + + region + region + () + + + reserveRegion + reserveRegion + ( const QRegion & region ) + + + reservedRegion + reservedRegion + () + + + + QDirectPainter + qdirectpainter.html + + SurfaceFlag + SurfaceFlag-enum + + + + QDirectPainter + QDirectPainter + ( QObject * parent = 0, SurfaceFlag flag = NonReserved ) + + + allocatedRegion + allocatedRegion + () + + + endPainting + endPainting + () + + + endPainting + endPainting-2 + ( const QRegion & region ) + + + flush + flush + ( const QRegion & region ) + + + frameBuffer + frameBuffer + () + + + geometry + geometry + () + + + linestep + linestep + () + + + lock + lock + () + + + lower + lower + () + + + raise + raise + () + + + regionChanged + regionChanged + ( const QRegion & newRegion ) + + + requestedRegion + requestedRegion + () + + + screenDepth + screenDepth + () + + + screenHeight + screenHeight + () + + + screenWidth + screenWidth + () + + + setGeometry + setGeometry + ( const QRect & rectangle ) + + + setRegion + setRegion + ( const QRegion & region ) + + + startPainting + startPainting + ( bool lockDisplay = false ) + + + unlock + unlock + () + + + winId + winId + () + + + + QDirIterator + qdiriterator.html + + QDirIterator + QDirIterator + ( const QDir & dir, IteratorFlags flags = NoIteratorFlags ) + + + QDirIterator + QDirIterator-2 + ( const QString & path, IteratorFlags flags = NoIteratorFlags ) + + + QDirIterator + QDirIterator-3 + ( const QString & path, QDir::Filters filters, IteratorFlags flags = NoIteratorFlags ) + + + QDirIterator + QDirIterator-4 + ( const QString & path, const QStringList & nameFilters, QDir::Filters filters = QDir::NoFilter, IteratorFlags flags = NoIteratorFlags ) + + + fileInfo + fileInfo + () + + + fileName + fileName + () + + + filePath + filePath + () + + + hasNext + hasNext + () + + + next + next + () + + + path + path + () + + + + 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 = QModelIndex() + + + 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 = QModelIndex() + + + headerData + headerData + ( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) + + + 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 = QModelIndex() + + + setData + setData + ( const QModelIndex & index, const QVariant & value, int role = Qt::EditRole ) + + + 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 = Qt::AscendingOrder ) + + + SortFlags + sorting + QDirModel::sorting() + + + DropActions + supportedDropActions + QDirModel::supportedDropActions() + + + + QDockWidget + qdockwidget.html + + DockWidgetAreas + allowedAreas-prop + + + + QDockWidget + QDockWidget + ( const QString & title, QWidget * parent = 0, Qt::WindowFlags flags = 0 ) + + + QDockWidget + QDockWidget-2 + ( QWidget * parent = 0, Qt::WindowFlags flags = 0 ) + + + allowedAreasChanged + allowedAreasChanged + ( Qt::DockWidgetAreas allowedAreas ) + + + dockLocationChanged + dockLocationChanged + ( Qt::DockWidgetArea area ) + + + featuresChanged + featuresChanged + ( QDockWidget::DockWidgetFeatures features ) + + + initStyleOption + initStyleOption + ( QStyleOptionDockWidget * option ) + + + isAreaAllowed + isAreaAllowed + ( Qt::DockWidgetArea area ) + + + setTitleBarWidget + setTitleBarWidget + ( QWidget * widget ) + + + setWidget + setWidget + ( QWidget * widget ) + + + titleBarWidget + titleBarWidget + () + + + toggleViewAction + toggleViewAction + () + + + topLevelChanged + topLevelChanged + ( bool topLevel ) + + + visibilityChanged + visibilityChanged + ( bool visible ) + + + 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 ) + + + + 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 ) + + + + QDomDocumentFragment + qdomdocumentfragment.html + + QDomDocumentFragment + QDomDocumentFragment + () + + + QDomDocumentFragment + QDomDocumentFragment-2 + ( const QDomDocumentFragment & x ) + + + NodeType + nodeType + QDomDocumentFragment::nodeType() + + + operator= + operator-eq + ( const QDomDocumentFragment & 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 + + EncodingPolicy + EncodingPolicy-enum + + + + 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 ) + + + save + save-2 + ( QTextStream & str, int indent, EncodingPolicy encodingPolicy ) + + + 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 minimum, double maximum ) + + + textFromValue + textFromValue + ( double value ) + + + valueChanged + valueChanged + ( double d ) + + + valueChanged + valueChanged-2 + ( const QString & text ) + + + valueFromText + valueFromText + ( const QString & text ) + + + QDoubleValidator + QDoubleValidator-3 + ( QObject * parent, const char * name ) + + + QDoubleValidator + QDoubleValidator-4 + ( double bottom, double top, int decimals, QObject * parent, const char * name ) + + + + QDoubleValidator + qdoublevalidator.html + + Notation + Notation-enum + + + + 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 ) + + + DropAction + start + QDrag::start( Qt::DropActions request = Qt::CopyAction ) + + + + QDrag + qdrag.html + + QDrag + QDrag + ( QWidget * dragSource ) + + + actionChanged + actionChanged + ( Qt::DropAction action ) + + + DropAction + exec + QDrag::exec( Qt::DropActions supportedActions = Qt::MoveAction ) + + + DropAction + exec-2 + QDrag::exec( Qt::DropActions supportedActions, Qt::DropAction defaultDropAction ) + + + 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 + () + + + target + target + () + + + targetChanged + targetChanged + ( QWidget * newTarget ) + + + + QDragEnterEvent + qdragenterevent.html + + QDragEnterEvent + QDragEnterEvent + ( const QPoint & point, Qt::DropActions actions, const QMimeData * data, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers ) + + + + QDragLeaveEvent + qdragleaveevent.html + + QDragLeaveEvent + QDragLeaveEvent + () + + + accept + accept-2 + ( bool y ) + + + + 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 ) + + + 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 ) + + + + 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 ) + + + + QDynamicPropertyChangeEvent + qdynamicpropertychangeevent.html + + QDynamicPropertyChangeEvent + QDynamicPropertyChangeEvent + ( const QByteArray & name ) + + + propertyName + propertyName + () + + + message + message + ( const QString & message ) + + + + QErrorMessage + qerrormessage.html + + QErrorMessage + QErrorMessage + ( QWidget * parent = 0 ) + + + changeEvent + changeEvent + ( QEvent * e ) + + + 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() + + + readLink + readLink + () + + + readLink + readLink-2 + ( const QString & fileName ) + + + name + name + () + + + open + open-2 + ( OpenMode flags, FILE * f ) + + + open + open-3 + ( OpenMode flags, int fd ) + + + setName + setName + ( const QString & name ) + + + + QFile + qfile.html + + DecoderFn + DecoderFn-typedef + + + + EncoderFn + EncoderFn-typedef + + + + FileError + FileError-enum + + + + PermissionSpec + PermissionSpec-typedef + + + + QFile + QFile + ( 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 ) + + + 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 + () + + + symLinkTarget + symLinkTarget + ( const QString & fileName ) + + + symLinkTarget + symLinkTarget-2 + () + + + unsetError + unsetError + () + + + name + name + () + + + open + open-2 + ( OpenMode flags, FILE * f ) + + + open + open-3 + ( OpenMode flags, int fd ) + + + setName + setName + ( const QString & name ) + + + 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 ) + + + + QFileDialog + qfiledialog.html + + AcceptMode + AcceptMode-enum + + + + DialogLabel + DialogLabel-enum + + + + FileMode + FileMode-enum + + + + Mode + Mode-typedef + + + + ViewMode + ViewMode-enum + + + + QFileDialog + QFileDialog + ( QWidget * parent, Qt::WindowFlags flags ) + + + QFileDialog + QFileDialog-2 + ( QWidget * parent = 0, const QString & caption = QString() + + + currentChanged + currentChanged + ( const QString & path ) + + + directory + directory + () + + + directoryEntered + directoryEntered + ( const QString & directory ) + + + filesSelected + filesSelected + ( const QStringList & selected ) + + + filterSelected + filterSelected + ( const QString & filter ) + + + 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 ) + + + proxyModel + proxyModel + () + + + restoreState + restoreState + ( const QByteArray & state ) + + + saveState + saveState + () + + + 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 ) + + + setProxyModel + setProxyModel + ( QAbstractProxyModel * proxyModel ) + + + setSidebarUrls + setSidebarUrls + ( const QList<QUrl> & urls ) + + + sidebarUrls + sidebarUrls + () + + + 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 ) + + + + QFileIconProvider + qfileiconprovider.html + + IconType + IconType-enum + + + + QFileIconProvider + QFileIconProvider + () + + + icon + icon + ( IconType type ) + + + icon + icon-2 + ( const QFileInfo & info ) + + + type + type + ( const QFileInfo & info ) + + + readLink + readLink + () + + + 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 ) + + + + 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 + () + + + bundleName + bundleName + () + + + 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 + () + + + isBundle + isBundle + () + + + 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() + + + 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 + () + + + symLinkTarget + symLinkTarget + () + + + 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 + () + + + + QFileSystemWatcher + qfilesystemwatcher.html + + QFileSystemWatcher + QFileSystemWatcher + ( QObject * parent = 0 ) + + + QFileSystemWatcher + QFileSystemWatcher-2 + ( const QStringList & paths, QObject * parent = 0 ) + + + addPath + addPath + ( const QString & path ) + + + addPaths + addPaths + ( const QStringList & paths ) + + + directories + directories + () + + + directoryChanged + directoryChanged + ( const QString & path ) + + + fileChanged + fileChanged + ( const QString & path ) + + + files + files + () + + + removePath + removePath + ( const QString & path ) + + + removePaths + removePaths + ( const QStringList & paths ) + + + + 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 ) + + + testFlag + testFlag + ( Enum flag ) + + + 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 + () + + + Reason + Reason-enum + + + + + 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 ) + + + initStyleOption + initStyleOption + ( QStyleOption * option ) + + + setWidget + setWidget + ( QWidget * widget ) + + + widget + widget + () + + + defaultFont + defaultFont + () + + + pointSizeFloat + pointSizeFloat + () + + + setDefaultFont + setDefaultFont + ( const QFont & f ) + + + setPixelSizeFloat + setPixelSizeFloat + ( qreal pixelSize ) + + + setPointSizeFloat + setPointSizeFloat + ( qreal size ) + + + + 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 + () + + + freetypeFace + freetypeFace + () + + + 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 + () + + + macFontID + macFontID + () + + + 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 ) + + + defaultFont + defaultFont + () + + + pointSizeFloat + pointSizeFloat + () + + + setDefaultFont + setDefaultFont + ( const QFont & f ) + + + setPixelSizeFloat + setPixelSizeFloat + ( qreal pixelSize ) + + + setPointSizeFloat + setPointSizeFloat + ( qreal size ) + + + + QFontComboBox + qfontcombobox.html + + WritingSystem + writingSystem-prop + + + + QFontComboBox + QFontComboBox + ( QWidget * parent = 0 ) + + + currentFontChanged + currentFontChanged + ( const QFont & font ) + + + + QFontDatabase + qfontdatabase.html + + WritingSystem + WritingSystem-enum + + + + QFontDatabase + QFontDatabase + () + + + addApplicationFont + addApplicationFont + ( const QString & fileName ) + + + addApplicationFontFromData + addApplicationFontFromData + ( const QByteArray & fontData ) + + + applicationFontFamilies + applicationFontFamilies + ( int id ) + + + 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() + + + removeAllApplicationFonts + removeAllApplicationFonts + () + + + removeApplicationFont + removeApplicationFont + ( int id ) + + + 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 + () + + + writingSystems + writingSystems-2 + ( const QString & family ) + + + + QFontDialog + qfontdialog.html + + changeEvent + changeEvent + ( QEvent * e ) + + + getFont + getFont + ( bool * ok, const QFont & initial, QWidget * parent, const QString & caption ) + + + 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, const QFont & initial, QWidget * parent = 0 ) + + + getFont + getFont-6 + ( bool * ok, QWidget * parent = 0 ) + + + + QFontEngineInfo + qfontengineinfo.html + + Style + style-prop + + + + WritingSystem + writingSystems-prop + > + + + QFontEngineInfo + QFontEngineInfo + () + + + QFontEngineInfo + QFontEngineInfo-2 + ( const QString & family ) + + + QFontEngineInfo + QFontEngineInfo-3 + ( const QFontEngineInfo & other ) + + + operator= + operator-eq + ( const QFontEngineInfo & other ) + + + + QFontEnginePlugin + qfontengineplugin.html + + QFontEnginePlugin + QFontEnginePlugin + ( const QString & foundry, QObject * parent = 0 ) + + + availableFontEngines + availableFontEngines + () + + + create + create + ( const QFontEngineInfo & info ) + + + keys + keys + () + + + + 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 ) + + + boundingRect + boundingRect-3 + ( const QString & text, int len ) + + + boundingRect + boundingRect-4 + ( int x, int y, int w, int h, int flags, const QString & text, int len, int tabStops = 0, int * tabArray = 0 ) + + + size + size-2 + ( int flags, const QString & text, int len, int tabStops = 0, int * tabArray = 0 ) + + + + QFontMetrics + qfontmetrics.html + + QFontMetrics + QFontMetrics + ( const QFont & font ) + + + QFontMetrics + QFontMetrics-2 + ( const QFont & font, QPaintDevice * paintdevice ) + + + QFontMetrics + QFontMetrics-3 + ( const QFontMetrics & fm ) + + + ascent + ascent + () + + + averageCharWidth + averageCharWidth + () + + + boundingRect + boundingRect + ( QChar ch ) + + + boundingRect + boundingRect-2 + ( const QString & text ) + + + 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 & rect, int flags, const QString & text, int tabStops = 0, int * tabArray = 0 ) + + + charWidth + charWidth + ( const QString & text, int pos ) + + + descent + descent + () + + + elidedText + elidedText + ( const QString & text, Qt::TextElideMode mode, int width, int flags = 0 ) + + + 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 + () + + + tightBoundingRect + tightBoundingRect + ( const QString & text ) + + + underlinePos + underlinePos + () + + + width + width + ( const QString & text, int len = -1 ) + + + width + width-2 + ( QChar ch ) + + + xHeight + xHeight + () + + + operator!= + operator-not-eq + ( const QFontMetrics & other ) + + + operator!= + operator-not-eq-2 + ( 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 & text, int len, int tabStops = 0, int * tabArray = 0 ) + + + size + size-2 + ( int flags, const QString & text, int len, int tabStops = 0, int * tabArray = 0 ) + + + + QFontMetricsF + qfontmetricsf.html + + QFontMetricsF + QFontMetricsF + ( const QFont & font ) + + + QFontMetricsF + QFontMetricsF-2 + ( const QFont & font, QPaintDevice * paintdevice ) + + + QFontMetricsF + QFontMetricsF-3 + ( const QFontMetrics & fontMetrics ) + + + QFontMetricsF + QFontMetricsF-4 + ( const QFontMetricsF & fm ) + + + ascent + ascent + () + + + averageCharWidth + averageCharWidth + () + + + 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 + () + + + elidedText + elidedText + ( const QString & text, Qt::TextElideMode mode, qreal width, int flags = 0 ) + + + 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 + () + + + tightBoundingRect + tightBoundingRect + ( const QString & text ) + + + 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-2 + ( const QFontMetrics & other ) + + + operator== + operator-eq-eq + ( const QFontMetricsF & other ) + + + operator== + operator-eq-eq-2 + ( const QFontMetricsF & other ) + + + + QFormBuilder + qformbuilder.html + + QFormBuilder + QFormBuilder + () + + + addPluginPath + addPluginPath + ( const QString & pluginPath ) + + + clearPluginPaths + clearPluginPaths + () + + + customWidgets + customWidgets + () + + + pluginPaths + pluginPaths + () + + + setPluginPath + setPluginPath + ( const QStringList & pluginPaths ) + + + QFrame + QFrame-2 + ( QWidget * parent, const char * name, Qt::WindowFlags f = 0 ) + + + + QFrame + qframe.html + + Shadow + Shadow-enum + + + + Shape + Shape-enum + + + + StyleMask + StyleMask-enum + + + + QFrame + QFrame + ( QWidget * parent = 0, Qt::WindowFlags f = 0 ) + + + frameStyle + frameStyle + () + + + setFrameStyle + setFrameStyle + ( int style ) + + + QFrame + QFrame-2 + ( QWidget * parent, const char * name, Qt::WindowFlags f = 0 ) + + + + QFSFileEngine + qfsfileengine.html + + QFSFileEngine + QFSFileEngine + () + + + QFSFileEngine + QFSFileEngine-2 + ( const QString & file ) + + + currentPath + currentPath + ( const QString & fileName = QString() + + + drives + drives + () + + + homePath + homePath + () + + + open + open + ( QIODevice::OpenMode openMode, FILE * fh ) + + + open + open-3 + ( QIODevice::OpenMode openMode, int fd ) + + + rootPath + rootPath + () + + + setCurrentPath + setCurrentPath + ( const QString & path ) + + + tempPath + tempPath + () + + + QFtp + QFtp-2 + ( QObject * parent, const char * name ) + + + readBlock + readBlock + ( char * data, quint64 maxlen ) + + + + 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-2 + ( const QGLFormat & format, QPaintDevice * device ) + + + generateFontDisplayLists + generateFontDisplayLists + ( const QFont & font, int listBase ) + + + + QGLContext + qglcontext.html + + QGLContext + QGLContext + ( const QGLFormat & format ) + + + bindTexture + bindTexture + ( const QImage & image, GLenum target = GL_TEXTURE_2D, GLint format = GL_RGBA ) + + + bindTexture + bindTexture-2 + ( const QString & fileName ) + + + bindTexture + bindTexture-3 + ( const QPixmap & pixmap, GLenum target = GL_TEXTURE_2D, GLint format = GL_RGBA ) + + + chooseContext + chooseContext + ( const QGLContext * shareContext = 0 ) + + + chooseMacVisual + chooseMacVisual + ( GDHandle handle ) + + + 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 + () + + + 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 + () + + + blueBufferSize + blueBufferSize + () + + + defaultFormat + defaultFormat + () + + + defaultOverlayFormat + defaultOverlayFormat + () + + + depth + depth + () + + + depthBufferSize + depthBufferSize + () + + + directRendering + directRendering + () + + + doubleBuffer + doubleBuffer + () + + + greenBufferSize + greenBufferSize + () + + + hasOpenGL + hasOpenGL + () + + + hasOpenGLOverlays + hasOpenGLOverlays + () + + + hasOverlay + hasOverlay + () + + + openGLVersionFlags + openGLVersionFlags + () + + + plane + plane + () + + + redBufferSize + redBufferSize + () + + + rgba + rgba + () + + + sampleBuffers + sampleBuffers + () + + + samples + samples + () + + + setAccum + setAccum + ( bool enable ) + + + setAccumBufferSize + setAccumBufferSize + ( int size ) + + + setAlpha + setAlpha + ( bool enable ) + + + setAlphaBufferSize + setAlphaBufferSize + ( int size ) + + + setBlueBufferSize + setBlueBufferSize + ( 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 ) + + + setGreenBufferSize + setGreenBufferSize + ( int size ) + + + setOption + setOption + ( QGL::FormatOptions opt ) + + + setOverlay + setOverlay + ( bool enable ) + + + setPlane + setPlane + ( int plane ) + + + setRedBufferSize + setRedBufferSize + ( int size ) + + + setRgba + setRgba + ( bool enable ) + + + setSampleBuffers + setSampleBuffers + ( bool enable ) + + + setSamples + setSamples + ( int numSamples ) + + + setStencil + setStencil + ( bool enable ) + + + setStencilBufferSize + setStencilBufferSize + ( int size ) + + + setStereo + setStereo + ( bool enable ) + + + setSwapInterval + setSwapInterval + ( int interval ) + + + stencil + stencil + () + + + stencilBufferSize + stencilBufferSize + () + + + stereo + stereo + () + + + swapInterval + swapInterval + () + + + testOption + testOption + ( QGL::FormatOptions opt ) + + + operator= + operator-eq + ( const QGLFormat & other ) + + + + QGLFramebufferObject + qglframebufferobject.html + + Attachment + Attachment-enum + + + + QGLFramebufferObject + QGLFramebufferObject + ( const QSize & size, GLenum target = GL_TEXTURE_2D ) + + + QGLFramebufferObject + QGLFramebufferObject-2 + ( int width, int height, GLenum target = GL_TEXTURE_2D ) + + + QGLFramebufferObject + QGLFramebufferObject-3 + ( int width, int height, Attachment attachment, GLenum target = GL_TEXTURE_2D, GLenum internal_format = GL_RGBA8 ) + + + QGLFramebufferObject + QGLFramebufferObject-4 + ( const QSize & size, Attachment attachment, GLenum target = GL_TEXTURE_2D, GLenum internal_format = GL_RGBA8 ) + + + attachment + attachment + () + + + bind + bind + () + + + handle + handle + () + + + hasOpenGLFramebufferObjects + hasOpenGLFramebufferObjects + () + + + isValid + isValid + () + + + release + release + () + + + size + size + () + + + texture + texture + () + + + toImage + toImage + () + + + + QGLPixelBuffer + qglpixelbuffer.html + + QGLPixelBuffer + QGLPixelBuffer + ( const QSize & size, const QGLFormat & format = QGLFormat::defaultFormat() + + + QGLPixelBuffer + QGLPixelBuffer-2 + ( int width, int height, 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 ) + + + fontDisplayListBase + fontDisplayListBase + ( const QFont & font, int listBase = 2000 ) + + + setFormat + setFormat + ( const QGLFormat & format ) + + + QGLWidget + QGLWidget-4 + ( QWidget * parent, const char * name, const QGLWidget * shareWidget = 0, Qt::WindowFlags f = 0 ) + + + QGLWidget + QGLWidget-5 + ( const QGLFormat & format, QWidget * parent, const char * name, const QGLWidget * shareWidget = 0, Qt::WindowFlags f = 0 ) + + + QGLWidget + QGLWidget-6 + ( QGLContext * context, QWidget * parent, const char * name, const QGLWidget * shareWidget = 0, Qt::WindowFlags f = 0 ) + + + + QGLWidget + qglwidget.html + + QGLWidget + QGLWidget + ( QWidget * parent = 0, const QGLWidget * shareWidget = 0, Qt::WindowFlags f = 0 ) + + + QGLWidget + QGLWidget-2 + ( QGLContext * context, QWidget * parent = 0, const QGLWidget * shareWidget = 0, Qt::WindowFlags f = 0 ) + + + QGLWidget + QGLWidget-3 + ( const QGLFormat & format, QWidget * parent = 0, const QGLWidget * shareWidget = 0, Qt::WindowFlags f = 0 ) + + + autoBufferSwap + autoBufferSwap + () + + + bindTexture + bindTexture + ( const QImage & image, GLenum target = GL_TEXTURE_2D, GLint format = GL_RGBA ) + + + bindTexture + bindTexture-2 + ( const QPixmap & pixmap, GLenum target = GL_TEXTURE_2D, GLint format = GL_RGBA ) + + + bindTexture + bindTexture-3 + ( const QString & fileName ) + + + colormap + colormap + () + + + context + context + () + + + convertToGLFormat + convertToGLFormat + ( const QImage & img ) + + + deleteTexture + deleteTexture + ( GLuint id ) + + + doneCurrent + doneCurrent + () + + + doubleBuffer + doubleBuffer + () + + + 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 & font = QFont() + + + renderText + renderText-2 + ( double x, double y, double z, const QString & str, const QFont & font = 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 + () + + + QGLWidget + QGLWidget-4 + ( QWidget * parent, const char * name, const QGLWidget * shareWidget = 0, Qt::WindowFlags f = 0 ) + + + QGLWidget + QGLWidget-5 + ( const QGLFormat & format, QWidget * parent, const char * name, const QGLWidget * shareWidget = 0, Qt::WindowFlags f = 0 ) + + + QGLWidget + QGLWidget-6 + ( QGLContext * context, QWidget * parent, const char * name, const QGLWidget * shareWidget = 0, Qt::WindowFlags 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-not-eq + ( const QGradient & gradient ) + + + operator== + operator-eq-eq + ( const QGradient & gradient ) + + + + QGraphicsEllipseItem + qgraphicsellipseitem.html + + QGraphicsEllipseItem + QGraphicsEllipseItem + ( QGraphicsItem * parent = 0 ) + + + QGraphicsEllipseItem + QGraphicsEllipseItem-2 + ( const QRectF & rect, QGraphicsItem * parent = 0 ) + + + QGraphicsEllipseItem + QGraphicsEllipseItem-3 + ( qreal x, qreal y, qreal width, qreal height, QGraphicsItem * parent = 0 ) + + + rect + rect + () + + + setRect + setRect + ( const QRectF & rect ) + + + setRect + setRect-2 + ( qreal x, qreal y, qreal width, qreal height ) + + + setSpanAngle + setSpanAngle + ( int angle ) + + + setStartAngle + setStartAngle + ( int angle ) + + + spanAngle + spanAngle + () + + + startAngle + startAngle + () + + + matrix + matrix + () + + + resetMatrix + resetMatrix + () + + + sceneMatrix + sceneMatrix + () + + + setMatrix + setMatrix + ( const QMatrix & matrix, bool combine = false ) + + + + QGraphicsItem + qgraphicsitem.html + + GraphicsItemChange + GraphicsItemChange-enum + + + + QGraphicsItem + QGraphicsItem + ( QGraphicsItem * parent = 0 ) + + + acceptDrops + acceptDrops + () + + + MouseButtons + acceptedMouseButtons + QGraphicsItem::acceptedMouseButtons() + + + acceptsHoverEvents + acceptsHoverEvents + () + + + advance + advance + ( int phase ) + + + boundingRect + boundingRect + () + + + children + children + () + + + childrenBoundingRect + childrenBoundingRect + () + + + clearFocus + clearFocus + () + + + collidesWithItem + collidesWithItem + ( const QGraphicsItem * other, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape ) + + + collidesWithPath + collidesWithPath + ( const QPainterPath & path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape ) + + + collidingItems + collidingItems + ( Qt::ItemSelectionMode mode = Qt::IntersectsItemShape ) + + + contains + contains + ( const QPointF & point ) + + + contextMenuEvent + contextMenuEvent + ( QGraphicsSceneContextMenuEvent * event ) + + + cursor + cursor + () + + + data + data + ( int key ) + + + deviceTransform + deviceTransform + ( const QTransform & viewportTransform ) + + + dragEnterEvent + dragEnterEvent + ( QGraphicsSceneDragDropEvent * event ) + + + dragLeaveEvent + dragLeaveEvent + ( QGraphicsSceneDragDropEvent * event ) + + + dragMoveEvent + dragMoveEvent + ( QGraphicsSceneDragDropEvent * event ) + + + dropEvent + dropEvent + ( QGraphicsSceneDragDropEvent * event ) + + + ensureVisible + ensureVisible + ( const QRectF & rect = QRectF() + + + ensureVisible + ensureVisible-2 + ( qreal x, qreal y, qreal w, qreal h, int xmargin = 50, int ymargin = 50 ) + + + flags + flags + () + + + focusInEvent + focusInEvent + ( QFocusEvent * event ) + + + focusOutEvent + focusOutEvent + ( QFocusEvent * event ) + + + group + group + () + + + handlesChildEvents + handlesChildEvents + () + + + hasCursor + hasCursor + () + + + hasFocus + hasFocus + () + + + hide + hide + () + + + hoverEnterEvent + hoverEnterEvent + ( QGraphicsSceneHoverEvent * event ) + + + hoverLeaveEvent + hoverLeaveEvent + ( QGraphicsSceneHoverEvent * event ) + + + hoverMoveEvent + hoverMoveEvent + ( QGraphicsSceneHoverEvent * event ) + + + inputMethodEvent + inputMethodEvent + ( QInputMethodEvent * event ) + + + inputMethodQuery + inputMethodQuery + ( Qt::InputMethodQuery query ) + + + installSceneEventFilter + installSceneEventFilter + ( QGraphicsItem * filterItem ) + + + isAncestorOf + isAncestorOf + ( const QGraphicsItem * child ) + + + isEnabled + isEnabled + () + + + isObscured + isObscured + () + + + isObscured + isObscured-2 + ( qreal x, qreal y, qreal w, qreal h ) + + + isObscured + isObscured-3 + ( const QRectF & rect ) + + + isObscuredBy + isObscuredBy + ( const QGraphicsItem * item ) + + + isSelected + isSelected + () + + + isVisible + isVisible + () + + + itemChange + itemChange + ( GraphicsItemChange change, const QVariant & value ) + + + keyPressEvent + keyPressEvent + ( QKeyEvent * event ) + + + keyReleaseEvent + keyReleaseEvent + ( QKeyEvent * event ) + + + mapFromItem + mapFromItem + ( const QGraphicsItem * item, const QPointF & point ) + + + mapFromItem + mapFromItem-2 + ( const QGraphicsItem * item, const QRectF & rect ) + + + mapFromItem + mapFromItem-3 + ( const QGraphicsItem * item, const QPolygonF & polygon ) + + + mapFromItem + mapFromItem-4 + ( const QGraphicsItem * item, const QPainterPath & path ) + + + mapFromItem + mapFromItem-5 + ( const QGraphicsItem * item, qreal x, qreal y, qreal w, qreal h ) + + + mapFromItem + mapFromItem-6 + ( const QGraphicsItem * item, qreal x, qreal y ) + + + mapFromParent + mapFromParent + ( const QPointF & point ) + + + mapFromParent + mapFromParent-2 + ( const QRectF & rect ) + + + mapFromParent + mapFromParent-3 + ( const QPolygonF & polygon ) + + + mapFromParent + mapFromParent-4 + ( const QPainterPath & path ) + + + mapFromParent + mapFromParent-5 + ( qreal x, qreal y, qreal w, qreal h ) + + + mapFromParent + mapFromParent-6 + ( qreal x, qreal y ) + + + mapFromScene + mapFromScene + ( const QPointF & point ) + + + mapFromScene + mapFromScene-2 + ( const QRectF & rect ) + + + mapFromScene + mapFromScene-3 + ( const QPolygonF & polygon ) + + + mapFromScene + mapFromScene-4 + ( const QPainterPath & path ) + + + mapFromScene + mapFromScene-5 + ( qreal x, qreal y, qreal w, qreal h ) + + + mapFromScene + mapFromScene-6 + ( qreal x, qreal y ) + + + mapToItem + mapToItem + ( const QGraphicsItem * item, const QPointF & point ) + + + mapToItem + mapToItem-2 + ( const QGraphicsItem * item, const QRectF & rect ) + + + mapToItem + mapToItem-3 + ( const QGraphicsItem * item, const QPolygonF & polygon ) + + + mapToItem + mapToItem-4 + ( const QGraphicsItem * item, const QPainterPath & path ) + + + mapToItem + mapToItem-5 + ( const QGraphicsItem * item, qreal x, qreal y, qreal w, qreal h ) + + + mapToItem + mapToItem-6 + ( const QGraphicsItem * item, qreal x, qreal y ) + + + mapToParent + mapToParent + ( const QPointF & point ) + + + mapToParent + mapToParent-2 + ( const QRectF & rect ) + + + mapToParent + mapToParent-3 + ( const QPolygonF & polygon ) + + + mapToParent + mapToParent-4 + ( const QPainterPath & path ) + + + mapToParent + mapToParent-5 + ( qreal x, qreal y, qreal w, qreal h ) + + + mapToParent + mapToParent-6 + ( qreal x, qreal y ) + + + mapToScene + mapToScene + ( const QPointF & point ) + + + mapToScene + mapToScene-2 + ( const QRectF & rect ) + + + mapToScene + mapToScene-3 + ( const QPolygonF & polygon ) + + + mapToScene + mapToScene-4 + ( const QPainterPath & path ) + + + mapToScene + mapToScene-5 + ( qreal x, qreal y, qreal w, qreal h ) + + + mapToScene + mapToScene-6 + ( qreal x, qreal y ) + + + mouseDoubleClickEvent + mouseDoubleClickEvent + ( QGraphicsSceneMouseEvent * event ) + + + mouseMoveEvent + mouseMoveEvent + ( QGraphicsSceneMouseEvent * event ) + + + mousePressEvent + mousePressEvent + ( QGraphicsSceneMouseEvent * event ) + + + mouseReleaseEvent + mouseReleaseEvent + ( QGraphicsSceneMouseEvent * event ) + + + moveBy + moveBy + ( qreal dx, qreal dy ) + + + opaqueArea + opaqueArea + () + + + paint + paint + ( QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget = 0 ) + + + parentItem + parentItem + () + + + pos + pos + () + + + prepareGeometryChange + prepareGeometryChange + () + + + removeSceneEventFilter + removeSceneEventFilter + ( QGraphicsItem * filterItem ) + + + resetTransform + resetTransform + () + + + rotate + rotate + ( qreal angle ) + + + scale + scale + ( qreal sx, qreal sy ) + + + scene + scene + () + + + sceneBoundingRect + sceneBoundingRect + () + + + sceneEvent + sceneEvent + ( QEvent * event ) + + + sceneEventFilter + sceneEventFilter + ( QGraphicsItem * watched, QEvent * event ) + + + scenePos + scenePos + () + + + sceneTransform + sceneTransform + () + + + setAcceptDrops + setAcceptDrops + ( bool on ) + + + setAcceptedMouseButtons + setAcceptedMouseButtons + ( Qt::MouseButtons buttons ) + + + setAcceptsHoverEvents + setAcceptsHoverEvents + ( bool enabled ) + + + setCursor + setCursor + ( const QCursor & cursor ) + + + setData + setData + ( int key, const QVariant & value ) + + + setEnabled + setEnabled + ( bool enabled ) + + + setFlag + setFlag + ( GraphicsItemFlag flag, bool enabled = true ) + + + setFlags + setFlags + ( GraphicsItemFlags flags ) + + + setFocus + setFocus + ( Qt::FocusReason focusReason = Qt::OtherFocusReason ) + + + setGroup + setGroup + ( QGraphicsItemGroup * group ) + + + setHandlesChildEvents + setHandlesChildEvents + ( bool enabled ) + + + setParentItem + setParentItem + ( QGraphicsItem * parent ) + + + setPos + setPos + ( const QPointF & pos ) + + + setPos + setPos-2 + ( qreal x, qreal y ) + + + setSelected + setSelected + ( bool selected ) + + + setToolTip + setToolTip + ( const QString & toolTip ) + + + setTransform + setTransform + ( const QTransform & matrix, bool combine = false ) + + + setVisible + setVisible + ( bool visible ) + + + setZValue + setZValue + ( qreal z ) + + + shape + shape + () + + + shear + shear + ( qreal sh, qreal sv ) + + + show + show + () + + + toolTip + toolTip + () + + + topLevelItem + topLevelItem + () + + + transform + transform + () + + + translate + translate + ( qreal dx, qreal dy ) + + + type + type + () + + + unsetCursor + unsetCursor + () + + + update + update + ( const QRectF & rect = QRectF() + + + update + update-2 + ( qreal x, qreal y, qreal width, qreal height ) + + + wheelEvent + wheelEvent + ( QGraphicsSceneWheelEvent * event ) + + + x + x + () + + + y + y + () + + + zValue + zValue + () + + + UserType + UserType-var + + + + + QGraphicsItemAnimation + qgraphicsitemanimation.html + + QGraphicsItemAnimation + QGraphicsItemAnimation + ( QObject * parent = 0 ) + + + afterAnimationStep + afterAnimationStep + ( qreal step ) + + + beforeAnimationStep + beforeAnimationStep + ( qreal step ) + + + clear + clear + () + + + horizontalScaleAt + horizontalScaleAt + ( qreal step ) + + + horizontalShearAt + horizontalShearAt + ( qreal step ) + + + item + item + () + + + matrixAt + matrixAt + ( qreal step ) + + + posAt + posAt + ( qreal step ) + + + posList + posList + () + + + reset + reset + () + + + rotationAt + rotationAt + ( qreal step ) + + + rotationList + rotationList + () + + + scaleList + scaleList + () + + + setItem + setItem + ( QGraphicsItem * item ) + + + setPosAt + setPosAt + ( qreal step, const QPointF & point ) + + + setRotationAt + setRotationAt + ( qreal step, qreal angle ) + + + setScaleAt + setScaleAt + ( qreal step, qreal sx, qreal sy ) + + + setShearAt + setShearAt + ( qreal step, qreal sh, qreal sv ) + + + setStep + setStep + ( qreal step ) + + + setTimeLine + setTimeLine + ( QTimeLine * timeLine ) + + + setTranslationAt + setTranslationAt + ( qreal step, qreal dx, qreal dy ) + + + shearList + shearList + () + + + timeLine + timeLine + () + + + translationList + translationList + () + + + verticalScaleAt + verticalScaleAt + ( qreal step ) + + + verticalShearAt + verticalShearAt + ( qreal step ) + + + xTranslationAt + xTranslationAt + ( qreal step ) + + + yTranslationAt + yTranslationAt + ( qreal step ) + + + + QGraphicsItemGroup + qgraphicsitemgroup.html + + QGraphicsItemGroup + QGraphicsItemGroup + ( QGraphicsItem * parent = 0 ) + + + addToGroup + addToGroup + ( QGraphicsItem * item ) + + + removeFromGroup + removeFromGroup + ( QGraphicsItem * item ) + + + + QGraphicsLineItem + qgraphicslineitem.html + + QGraphicsLineItem + QGraphicsLineItem + ( QGraphicsItem * parent = 0 ) + + + QGraphicsLineItem + QGraphicsLineItem-2 + ( const QLineF & line, QGraphicsItem * parent = 0 ) + + + QGraphicsLineItem + QGraphicsLineItem-3 + ( qreal x1, qreal y1, qreal x2, qreal y2, QGraphicsItem * parent = 0 ) + + + line + line + () + + + pen + pen + () + + + setLine + setLine + ( const QLineF & line ) + + + setLine + setLine-2 + ( qreal x1, qreal y1, qreal x2, qreal y2 ) + + + setPen + setPen + ( const QPen & pen ) + + + + QGraphicsPathItem + qgraphicspathitem.html + + QGraphicsPathItem + QGraphicsPathItem + ( QGraphicsItem * parent = 0 ) + + + QGraphicsPathItem + QGraphicsPathItem-2 + ( const QPainterPath & path, QGraphicsItem * parent = 0 ) + + + path + path + () + + + setPath + setPath + ( const QPainterPath & path ) + + + + QGraphicsPixmapItem + qgraphicspixmapitem.html + + ShapeMode + ShapeMode-enum + + + + QGraphicsPixmapItem + QGraphicsPixmapItem + ( QGraphicsItem * parent = 0 ) + + + QGraphicsPixmapItem + QGraphicsPixmapItem-2 + ( const QPixmap & pixmap, QGraphicsItem * parent = 0 ) + + + offset + offset + () + + + pixmap + pixmap + () + + + setOffset + setOffset + ( const QPointF & offset ) + + + setOffset + setOffset-2 + ( qreal x, qreal y ) + + + setPixmap + setPixmap + ( const QPixmap & pixmap ) + + + setShapeMode + setShapeMode + ( ShapeMode mode ) + + + setTransformationMode + setTransformationMode + ( Qt::TransformationMode mode ) + + + shapeMode + shapeMode + () + + + TransformationMode + transformationMode + QGraphicsPixmapItem::transformationMode() + + + + QGraphicsPolygonItem + qgraphicspolygonitem.html + + QGraphicsPolygonItem + QGraphicsPolygonItem + ( QGraphicsItem * parent = 0 ) + + + QGraphicsPolygonItem + QGraphicsPolygonItem-2 + ( const QPolygonF & polygon, QGraphicsItem * parent = 0 ) + + + FillRule + fillRule + QGraphicsPolygonItem::fillRule() + + + polygon + polygon + () + + + setFillRule + setFillRule + ( Qt::FillRule rule ) + + + setPolygon + setPolygon + ( const QPolygonF & polygon ) + + + + QGraphicsRectItem + qgraphicsrectitem.html + + QGraphicsRectItem + QGraphicsRectItem + ( QGraphicsItem * parent = 0 ) + + + QGraphicsRectItem + QGraphicsRectItem-2 + ( const QRectF & rect, QGraphicsItem * parent = 0 ) + + + QGraphicsRectItem + QGraphicsRectItem-3 + ( qreal x, qreal y, qreal width, qreal height, QGraphicsItem * parent = 0 ) + + + rect + rect + () + + + setRect + setRect + ( const QRectF & rectangle ) + + + setRect + setRect-2 + ( qreal x, qreal y, qreal width, qreal height ) + + + + QGraphicsScene + qgraphicsscene.html + + ItemIndexMethod + ItemIndexMethod-enum + + + + QGraphicsScene + QGraphicsScene + ( QObject * parent = 0 ) + + + QGraphicsScene + QGraphicsScene-2 + ( const QRectF & sceneRect, QObject * parent = 0 ) + + + QGraphicsScene + QGraphicsScene-3 + ( qreal x, qreal y, qreal width, qreal height, QObject * parent = 0 ) + + + addEllipse + addEllipse + ( const QRectF & rect, const QPen & pen = QPen() + + + addEllipse + addEllipse-2 + ( qreal x, qreal y, qreal w, qreal h, const QPen & pen = QPen() + + + addItem + addItem + ( QGraphicsItem * item ) + + + addLine + addLine + ( const QLineF & line, const QPen & pen = QPen() + + + addLine + addLine-2 + ( qreal x1, qreal y1, qreal x2, qreal y2, const QPen & pen = QPen() + + + addPath + addPath + ( const QPainterPath & path, const QPen & pen = QPen() + + + addPixmap + addPixmap + ( const QPixmap & pixmap ) + + + addPolygon + addPolygon + ( const QPolygonF & polygon, const QPen & pen = QPen() + + + addRect + addRect + ( const QRectF & rect, const QPen & pen = QPen() + + + addRect + addRect-2 + ( qreal x, qreal y, qreal w, qreal h, const QPen & pen = QPen() + + + addSimpleText + addSimpleText + ( const QString & text, const QFont & font = QFont() + + + addText + addText + ( const QString & text, const QFont & font = QFont() + + + advance + advance + () + + + changed + changed + ( const QList<QRectF> & region ) + + + clearFocus + clearFocus + () + + + clearSelection + clearSelection + () + + + collidingItems + collidingItems + ( const QGraphicsItem * item, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape ) + + + contextMenuEvent + contextMenuEvent + ( QGraphicsSceneContextMenuEvent * contextMenuEvent ) + + + createItemGroup + createItemGroup + ( const QList<QGraphicsItem *> & items ) + + + destroyItemGroup + destroyItemGroup + ( QGraphicsItemGroup * group ) + + + dragEnterEvent + dragEnterEvent + ( QGraphicsSceneDragDropEvent * event ) + + + dragLeaveEvent + dragLeaveEvent + ( QGraphicsSceneDragDropEvent * event ) + + + dragMoveEvent + dragMoveEvent + ( QGraphicsSceneDragDropEvent * event ) + + + drawBackground + drawBackground + ( QPainter * painter, const QRectF & rect ) + + + drawForeground + drawForeground + ( QPainter * painter, const QRectF & rect ) + + + drawItems + drawItems + ( QPainter * painter, int numItems, QGraphicsItem *[] items, const QStyleOptionGraphicsItem[] options, QWidget * widget = 0 ) + + + dropEvent + dropEvent + ( QGraphicsSceneDragDropEvent * event ) + + + event + event + ( QEvent * event ) + + + focusInEvent + focusInEvent + ( QFocusEvent * focusEvent ) + + + focusItem + focusItem + () + + + focusOutEvent + focusOutEvent + ( QFocusEvent * focusEvent ) + + + hasFocus + hasFocus + () + + + height + height + () + + + helpEvent + helpEvent + ( QGraphicsSceneHelpEvent * helpEvent ) + + + inputMethodEvent + inputMethodEvent + ( QInputMethodEvent * event ) + + + inputMethodQuery + inputMethodQuery + ( Qt::InputMethodQuery query ) + + + invalidate + invalidate + ( qreal x, qreal y, qreal w, qreal h, SceneLayers layers = AllLayers ) + + + invalidate + invalidate-2 + ( const QRectF & rect = QRectF() + + + itemAt + itemAt + ( const QPointF & position ) + + + itemAt + itemAt-2 + ( qreal x, qreal y ) + + + items + items + () + + + items + items-2 + ( const QPointF & pos ) + + + items + items-3 + ( qreal x, qreal y, qreal w, qreal h, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape ) + + + items + items-4 + ( const QRectF & rectangle, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape ) + + + items + items-5 + ( const QPolygonF & polygon, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape ) + + + items + items-6 + ( const QPainterPath & path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape ) + + + itemsBoundingRect + itemsBoundingRect + () + + + keyPressEvent + keyPressEvent + ( QKeyEvent * keyEvent ) + + + keyReleaseEvent + keyReleaseEvent + ( QKeyEvent * keyEvent ) + + + mouseDoubleClickEvent + mouseDoubleClickEvent + ( QGraphicsSceneMouseEvent * mouseEvent ) + + + mouseGrabberItem + mouseGrabberItem + () + + + mouseMoveEvent + mouseMoveEvent + ( QGraphicsSceneMouseEvent * mouseEvent ) + + + mousePressEvent + mousePressEvent + ( QGraphicsSceneMouseEvent * mouseEvent ) + + + mouseReleaseEvent + mouseReleaseEvent + ( QGraphicsSceneMouseEvent * mouseEvent ) + + + removeItem + removeItem + ( QGraphicsItem * item ) + + + render + render + ( QPainter * painter, const QRectF & target = QRectF() + + + sceneRectChanged + sceneRectChanged + ( const QRectF & rect ) + + + selectedItems + selectedItems + () + + + selectionArea + selectionArea + () + + + selectionChanged + selectionChanged + () + + + setFocus + setFocus + ( Qt::FocusReason focusReason = Qt::OtherFocusReason ) + + + setFocusItem + setFocusItem + ( QGraphicsItem * item, Qt::FocusReason focusReason = Qt::OtherFocusReason ) + + + setSelectionArea + setSelectionArea + ( const QPainterPath & path ) + + + setSelectionArea + setSelectionArea-2 + ( const QPainterPath & path, Qt::ItemSelectionMode mode ) + + + update + update + ( qreal x, qreal y, qreal w, qreal h ) + + + update + update-2 + ( const QRectF & rect = QRectF() + + + views + views + () + + + wheelEvent + wheelEvent + ( QGraphicsSceneWheelEvent * wheelEvent ) + + + width + width + () + + + + QGraphicsSceneContextMenuEvent + qgraphicsscenecontextmenuevent.html + + Reason + Reason-enum + + + + KeyboardModifiers + modifiers + QGraphicsSceneContextMenuEvent::modifiers() + + + pos + pos + () + + + reason + reason + () + + + scenePos + scenePos + () + + + screenPos + screenPos + () + + + + QGraphicsSceneDragDropEvent + qgraphicsscenedragdropevent.html + + acceptProposedAction + acceptProposedAction + () + + + MouseButtons + buttons + QGraphicsSceneDragDropEvent::buttons() + + + DropAction + dropAction + QGraphicsSceneDragDropEvent::dropAction() + + + mimeData + mimeData + () + + + KeyboardModifiers + modifiers + QGraphicsSceneDragDropEvent::modifiers() + + + pos + pos + () + + + DropActions + possibleActions + QGraphicsSceneDragDropEvent::possibleActions() + + + DropAction + proposedAction + QGraphicsSceneDragDropEvent::proposedAction() + + + scenePos + scenePos + () + + + screenPos + screenPos + () + + + setDropAction + setDropAction + ( Qt::DropAction action ) + + + source + source + () + + + + QGraphicsSceneEvent + qgraphicssceneevent.html + + widget + widget + () + + + + QGraphicsSceneHelpEvent + qgraphicsscenehelpevent.html + + scenePos + scenePos + () + + + screenPos + screenPos + () + + + + QGraphicsSceneHoverEvent + qgraphicsscenehoverevent.html + + pos + pos + () + + + scenePos + scenePos + () + + + screenPos + screenPos + () + + + + QGraphicsSceneMouseEvent + qgraphicsscenemouseevent.html + + MouseButton + button + QGraphicsSceneMouseEvent::button() + + + buttonDownPos + buttonDownPos + ( Qt::MouseButton button ) + + + buttonDownScenePos + buttonDownScenePos + ( Qt::MouseButton button ) + + + buttonDownScreenPos + buttonDownScreenPos + ( Qt::MouseButton button ) + + + MouseButtons + buttons + QGraphicsSceneMouseEvent::buttons() + + + lastPos + lastPos + () + + + lastScenePos + lastScenePos + () + + + lastScreenPos + lastScreenPos + () + + + KeyboardModifiers + modifiers + QGraphicsSceneMouseEvent::modifiers() + + + pos + pos + () + + + scenePos + scenePos + () + + + screenPos + screenPos + () + + + + QGraphicsSceneWheelEvent + qgraphicsscenewheelevent.html + + MouseButtons + buttons + QGraphicsSceneWheelEvent::buttons() + + + delta + delta + () + + + KeyboardModifiers + modifiers + QGraphicsSceneWheelEvent::modifiers() + + + Orientation + orientation + QGraphicsSceneWheelEvent::orientation() + + + pos + pos + () + + + scenePos + scenePos + () + + + screenPos + screenPos + () + + + + QGraphicsSimpleTextItem + qgraphicssimpletextitem.html + + QGraphicsSimpleTextItem + QGraphicsSimpleTextItem + ( QGraphicsItem * parent = 0 ) + + + QGraphicsSimpleTextItem + QGraphicsSimpleTextItem-2 + ( const QString & text, QGraphicsItem * parent = 0 ) + + + font + font + () + + + setFont + setFont + ( const QFont & font ) + + + setText + setText + ( const QString & text ) + + + text + text + () + + + + QGraphicsSvgItem + qgraphicssvgitem.html + + QGraphicsSvgItem + QGraphicsSvgItem + ( QGraphicsItem * parent = 0 ) + + + QGraphicsSvgItem + QGraphicsSvgItem-2 + ( const QString & fileName, QGraphicsItem * parent = 0 ) + + + boundingRect + boundingRect + () + + + elementId + elementId + () + + + isCachingEnabled + isCachingEnabled + () + + + maximumCacheSize + maximumCacheSize + () + + + renderer + renderer + () + + + setCachingEnabled + setCachingEnabled + ( bool caching ) + + + setElementId + setElementId + ( const QString & id ) + + + setMaximumCacheSize + setMaximumCacheSize + ( const QSize & size ) + + + setSharedRenderer + setSharedRenderer + ( QSvgRenderer * renderer ) + + + + QGraphicsTextItem + qgraphicstextitem.html + + QGraphicsTextItem + QGraphicsTextItem + ( QGraphicsItem * parent = 0 ) + + + QGraphicsTextItem + QGraphicsTextItem-2 + ( const QString & text, QGraphicsItem * parent = 0 ) + + + adjustSize + adjustSize + () + + + defaultTextColor + defaultTextColor + () + + + document + document + () + + + font + font + () + + + linkActivated + linkActivated + ( const QString & link ) + + + linkHovered + linkHovered + ( const QString & link ) + + + setDefaultTextColor + setDefaultTextColor + ( const QColor & col ) + + + setDocument + setDocument + ( QTextDocument * document ) + + + setFont + setFont + ( const QFont & font ) + + + setHtml + setHtml + ( const QString & text ) + + + setPlainText + setPlainText + ( const QString & text ) + + + setTextInteractionFlags + setTextInteractionFlags + ( Qt::TextInteractionFlags flags ) + + + setTextWidth + setTextWidth + ( qreal width ) + + + TextInteractionFlags + textInteractionFlags + QGraphicsTextItem::textInteractionFlags() + + + textWidth + textWidth + () + + + toHtml + toHtml + () + + + toPlainText + toPlainText + () + + + + QGraphicsView + qgraphicsview.html + + DragMode + DragMode-enum + + + + ViewportAnchor + ViewportAnchor-enum + + + + ViewportUpdateMode + ViewportUpdateMode-enum + + + + Alignment + alignment-prop + + + + RenderHints + renderHints-prop + + + + ItemSelectionMode + rubberBandSelectionMode-prop + + + + QGraphicsView + QGraphicsView + ( QWidget * parent = 0 ) + + + QGraphicsView + QGraphicsView-2 + ( QGraphicsScene * scene, QWidget * parent = 0 ) + + + centerOn + centerOn + ( const QPointF & pos ) + + + centerOn + centerOn-2 + ( qreal x, qreal y ) + + + centerOn + centerOn-3 + ( const QGraphicsItem * item ) + + + drawBackground + drawBackground + ( QPainter * painter, const QRectF & rect ) + + + drawForeground + drawForeground + ( QPainter * painter, const QRectF & rect ) + + + drawItems + drawItems + ( QPainter * painter, int numItems, QGraphicsItem *[] items, const QStyleOptionGraphicsItem[] options ) + + + ensureVisible + ensureVisible + ( const QRectF & rect, int xmargin = 50, int ymargin = 50 ) + + + ensureVisible + ensureVisible-2 + ( qreal x, qreal y, qreal w, qreal h, int xmargin = 50, int ymargin = 50 ) + + + ensureVisible + ensureVisible-3 + ( const QGraphicsItem * item, int xmargin = 50, int ymargin = 50 ) + + + fitInView + fitInView + ( const QRectF & rect, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio ) + + + fitInView + fitInView-2 + ( qreal x, qreal y, qreal w, qreal h, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio ) + + + fitInView + fitInView-3 + ( const QGraphicsItem * item, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio ) + + + invalidateScene + invalidateScene + ( const QRectF & rect = QRectF() + + + itemAt + itemAt + ( const QPoint & pos ) + + + itemAt + itemAt-2 + ( int x, int y ) + + + items + items + () + + + items + items-2 + ( const QPoint & pos ) + + + items + items-3 + ( int x, int y ) + + + items + items-4 + ( int x, int y, int w, int h, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape ) + + + items + items-5 + ( const QRect & rect, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape ) + + + items + items-6 + ( const QPolygon & polygon, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape ) + + + items + items-7 + ( const QPainterPath & path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape ) + + + mapFromScene + mapFromScene + ( const QPointF & point ) + + + mapFromScene + mapFromScene-2 + ( const QRectF & rect ) + + + mapFromScene + mapFromScene-3 + ( const QPolygonF & polygon ) + + + mapFromScene + mapFromScene-4 + ( const QPainterPath & path ) + + + mapFromScene + mapFromScene-5 + ( qreal x, qreal y ) + + + mapFromScene + mapFromScene-6 + ( qreal x, qreal y, qreal w, qreal h ) + + + mapToScene + mapToScene + ( const QPoint & point ) + + + mapToScene + mapToScene-2 + ( const QRect & rect ) + + + mapToScene + mapToScene-3 + ( const QPolygon & polygon ) + + + mapToScene + mapToScene-4 + ( const QPainterPath & path ) + + + mapToScene + mapToScene-5 + ( int x, int y ) + + + mapToScene + mapToScene-6 + ( int x, int y, int w, int h ) + + + matrix + matrix + () + + + render + render + ( QPainter * painter, const QRectF & target = QRectF() + + + resetCachedContent + resetCachedContent + () + + + resetMatrix + resetMatrix + () + + + resetTransform + resetTransform + () + + + rotate + rotate + ( qreal angle ) + + + scale + scale + ( qreal sx, qreal sy ) + + + scene + scene + () + + + setMatrix + setMatrix + ( const QMatrix & matrix, bool combine = false ) + + + setOptimizationFlag + setOptimizationFlag + ( OptimizationFlag flag, bool enabled = true ) + + + setRenderHint + setRenderHint + ( QPainter::RenderHint hint, bool enabled = true ) + + + setScene + setScene + ( QGraphicsScene * scene ) + + + setTransform + setTransform + ( const QTransform & matrix, bool combine = false ) + + + setupViewport + setupViewport + ( QWidget * widget ) + + + shear + shear + ( qreal sh, qreal sv ) + + + transform + transform + () + + + translate + translate + ( qreal dx, qreal dy ) + + + updateScene + updateScene + ( const QList<QRectF> & rects ) + + + updateSceneRect + updateSceneRect + ( const QRectF & rect ) + + + viewportTransform + viewportTransform + () + + + 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 ) + + + + 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 ) + + + setSpacing + setSpacing + ( int spacing ) + + + spacing + spacing + () + + + 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-3 + ( QWidget * parent, const char * name ) + + + QGroupBox + QGroupBox-4 + ( const QString & title, QWidget * parent, const char * name ) + + + + QGroupBox + qgroupbox.html + + Alignment + alignment-prop + + + + QGroupBox + QGroupBox + ( QWidget * parent = 0 ) + + + QGroupBox + QGroupBox-2 + ( const QString & title, QWidget * parent = 0 ) + + + clicked + clicked + ( bool checked = false ) + + + initStyleOption + initStyleOption + ( QStyleOptionGroupBox * option ) + + + 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::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 ) + + + + QHash + qhash.html + + ConstIterator + ConstIterator-typedef + + + + Iterator + Iterator-typedef + + + + difference_type + difference_type-typedef + + + + key_type + key_type-typedef + + + + mapped_type + mapped_type-typedef + + + + size_type + size_type-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 ) + + + key + key-2 + ( const T & value, const Key & defaultKey ) + + + 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 ) + + + uniqueKeys + uniqueKeys + () + + + 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 ) + + + + 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-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 ) + + + + 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 + () + + + geometriesChanged + geometriesChanged + () + + + headerDataChanged + headerDataChanged + ( Qt::Orientation orientation, int logicalFirst, int logicalLast ) + + + hiddenSectionCount + hiddenSectionCount + () + + + hideSection + hideSection + ( int logicalIndex ) + + + horizontalOffset + horizontalOffset + () + + + initStyleOption + initStyleOption + ( QStyleOptionHeader * option ) + + + 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 ) + + + resizeSections + resizeSections-2 + () + + + restoreState + restoreState + ( const QByteArray & state ) + + + saveState + saveState + () + + + sectionAutoResize + sectionAutoResize + ( int logicalIndex, QHeaderView::ResizeMode mode ) + + + sectionClicked + sectionClicked + ( int logicalIndex ) + + + sectionCountChanged + sectionCountChanged + ( int oldCount, int newCount ) + + + sectionDoubleClicked + sectionDoubleClicked + ( int logicalIndex ) + + + sectionEntered + sectionEntered + ( 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 ) + + + setOffsetToLastSection + setOffsetToLastSection + () + + + setOffsetToSectionPosition + setOffsetToSectionPosition + ( int visualIndex ) + + + 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 + () + + + sortIndicatorChanged + sortIndicatorChanged + ( int logicalIndex, Qt::SortOrder order ) + + + SortOrder + sortIndicatorOrder + QHeaderView::sortIndicatorOrder() + + + sortIndicatorSection + sortIndicatorSection + () + + + stretchSectionCount + stretchSectionCount + () + + + swapSections + swapSections + ( int first, int second ) + + + 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 + () + + + ip4Addr + ip4Addr + () + + + isIPv4Address + isIPv4Address + () + + + isIPv6Address + isIPv6Address + () + + + isIp4Addr + isIp4Addr + () + + + + 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-not-eq + ( const QHostAddress & other ) + + + operator!= + operator-not-eq-2 + ( SpecialAddress other ) + + + 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 + () + + + closeConnection + closeConnection + () + + + readBlock + readBlock + ( char * data, quint64 maxlen ) + + + + QHttp + qhttp.html + + ConnectionMode + ConnectionMode-enum + + + + Error + Error-enum + + + + State + State-enum + + + + QHttp + QHttp + ( QObject * parent = 0 ) + + + QHttp + QHttp-2 + ( const QString & hostName, quint16 port = 80, QObject * parent = 0 ) + + + QHttp + QHttp-3 + ( const QString & hostName, ConnectionMode mode, quint16 port = 0, QObject * parent = 0 ) + + + abort + abort + () + + + authenticationRequired + authenticationRequired + ( const QString & hostname, quint16 port, QAuthenticator * authenticator ) + + + 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 ) + + + ignoreSslErrors + ignoreSslErrors + () + + + lastResponse + lastResponse + () + + + post + post + ( const QString & path, QIODevice * data, QIODevice * to = 0 ) + + + post + post-2 + ( const QString & path, const QByteArray & data, QIODevice * to = 0 ) + + + proxyAuthenticationRequired + proxyAuthenticationRequired + ( const QNetworkProxy & proxy, QAuthenticator * authenticator ) + + + 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 ) + + + setHost + setHost-2 + ( const QString & hostName, ConnectionMode mode, quint16 port = 0 ) + + + setProxy + setProxy + ( const QString & host, int port, const QString & username = QString() + + + setProxy + setProxy-2 + ( const QNetworkProxy & proxy ) + + + setSocket + setSocket + ( QTcpSocket * socket ) + + + setUser + setUser + ( const QString & userName, const QString & password = QString() + + + sslErrors + sslErrors + ( const QList<QSslError> & errors ) + + + state + state + () + + + stateChanged + stateChanged + ( int state ) + + + readBlock + readBlock + ( char * data, quint64 maxlen ) + + + + 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 ) + + + + 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 ) + + + serialNumber + serialNumber + () + + + 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 ) + + + + QIcon + qicon.html + + DataPtr + DataPtr-typedef + + + + 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 ) + + + QIcon + QIcon-6 + ( QIconEngineV2 * 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 ) + + + cacheKey + cacheKey + () + + + data_ptr + data_ptr + () + + + 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 ) + + + 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 ) + + + + 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 + () + + + + QIconEnginePluginV2 + qiconenginepluginv2.html + + QIconEnginePluginV2 + QIconEnginePluginV2 + ( QObject * parent = 0 ) + + + create + create + ( const QString & filename = QString() + + + keys + keys + () + + + + QIconEngineV2 + qiconenginev2.html + + clone + clone + () + + + key + key + () + + + read + read + ( QDataStream & in ) + + + write + write + ( QDataStream & out ) + + + serialNumber + serialNumber + () + + + 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-12 + ( int width, int height, int depth, int numColors = 0, Endian bitOrder = IgnoreEndian ) + + + QImage + QImage-13 + ( const QSize & size, int depth, int numColors = 0, Endian bitOrder = IgnoreEndian ) + + + QImage + QImage-14 + ( uchar * data, int width, int height, int depth, const QRgb * colortable, int numColors, Endian bitOrder ) + + + QImage + QImage-15 + ( uchar * data, int width, int height, int depth, int bytesPerLine, const QRgb * colortable, int numColors, Endian bitOrder ) + + + QImage + QImage-16 + ( 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 ) + + + + QImage + qimage.html + + DataPtr + DataPtr-typedef + + + + 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 uchar * data, int width, int height, Format format ) + + + QImage + QImage-6 + ( uchar * data, int width, int height, int bytesPerLine, Format format ) + + + QImage + QImage-7 + ( const uchar * data, int width, int height, int bytesPerLine, Format format ) + + + QImage + QImage-8 + ( const char * const[] xpm ) + + + QImage + QImage-9 + ( const QString & fileName, const char * format = 0 ) + + + QImage + QImage-10 + ( const char * fileName, const char * format = 0 ) + + + QImage + QImage-11 + ( const QImage & image ) + + + allGray + allGray + () + + + alphaChannel + alphaChannel + () + + + bits + bits + () + + + bits + bits-2 + () + + + bytesPerLine + bytesPerLine + () + + + cacheKey + cacheKey + () + + + 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 ) + + + createMaskFromColor + createMaskFromColor + ( QRgb color, Qt::MaskMode mode = Qt::MaskInColor ) + + + data_ptr + data_ptr + () + + + 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 + ( const QPoint & position ) + + + pixel + pixel-2 + ( int x, int y ) + + + pixelIndex + pixelIndex + ( const QPoint & position ) + + + pixelIndex + pixelIndex-2 + ( int x, int y ) + + + rect + rect + () + + + rgbSwapped + rgbSwapped + () + + + save + save + ( const QString & fileName, const char * format = 0, int quality = -1 ) + + + save + save-2 + ( QIODevice * device, const char * format = 0, 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 ) + + + 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 + ( const QPoint & position, uint index_or_rgb ) + + + setPixel + setPixel-2 + ( 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 ) + + + transformed + transformed-2 + ( const QTransform & matrix, Qt::TransformationMode mode = Qt::FastTransformation ) + + + trueMatrix + trueMatrix + ( const QMatrix & matrix, int width, int height ) + + + trueMatrix + trueMatrix-2 + ( const QTransform &, int w, int h ) + + + valid + valid + ( const QPoint & pos ) + + + valid + valid-2 + ( 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 ) + + + Endian + Endian-enum + + + + QImage + QImage-12 + ( int width, int height, int depth, int numColors = 0, Endian bitOrder = IgnoreEndian ) + + + QImage + QImage-13 + ( const QSize & size, int depth, int numColors = 0, Endian bitOrder = IgnoreEndian ) + + + QImage + QImage-14 + ( uchar * data, int width, int height, int depth, const QRgb * colortable, int numColors, Endian bitOrder ) + + + QImage + QImage-15 + ( uchar * data, int width, int height, int depth, int bytesPerLine, const QRgb * colortable, int numColors, Endian bitOrder ) + + + QImage + QImage-16 + ( 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 ) + + + name + name + () + + + + 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 ) + + + + 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 + () + + + + 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 + () + + + quality + quality + () + + + read + read + () + + + read + read-2 + ( QImage * image ) + + + 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 ) + + + setQuality + setQuality + ( int quality ) + + + setScaledClipRect + setScaledClipRect + ( const QRect & rect ) + + + setScaledSize + setScaledSize + ( const QSize & size ) + + + size + size + () + + + supportedImageFormats + supportedImageFormats + () + + + supportsAnimation + supportsAnimation + () + + + supportsOption + supportsOption + ( QImageIOHandler::ImageOption option ) + + + text + text + ( const QString & key ) + + + textKeys + textKeys + () + + + description + description + () + + + setDescription + setDescription + ( const QString & description ) + + + + 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 + () + + + compression + compression + () + + + device + device + () + + + error + error + () + + + errorString + errorString + () + + + fileName + fileName + () + + + format + format + () + + + gamma + gamma + () + + + quality + quality + () + + + setCompression + setCompression + ( int compression ) + + + 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 + () + + + supportsOption + supportsOption + ( QImageIOHandler::ImageOption option ) + + + write + write + ( const QImage & image ) + + + + 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 ) + + + + 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 ) + + + + 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 ) + + + 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::WindowFlags 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::WindowFlags 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::WindowFlags f = 0 ) + + + getText + getText-2 + ( const QString & title, const QString & label, QLineEdit::EchoMode echo = QLineEdit::Normal, const QString & text = QString() + + + + 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::WindowFlags 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::WindowFlags 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::WindowFlags 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::WindowFlags 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::WindowFlags 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::WindowFlags 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-3 + ( QObject * parent, const char * name ) + + + QIntValidator + QIntValidator-4 + ( int minimum, int maximum, QObject * parent, const char * name ) + + + + 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 ) + + + 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 ) + + + + 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 ) + + + drawBackground + drawBackground + ( QPainter * painter, 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 * editor, 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 ) + + + + QItemEditorCreator + qitemeditorcreator.html + + QItemEditorCreator + QItemEditorCreator + ( const QByteArray & valuePropertyName ) + + + + 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 + () + + + clearSelection + clearSelection + () + + + 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 ) + + + hasSelection + hasSelection + () + + + 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 ) + + + selectedColumns + selectedColumns + ( int row = 0 ) + + + selectedIndexes + selectedIndexes + () + + + selectedRows + selectedRows + ( int column = 0 ) + + + selection + selection + () + + + selectionChanged + selectionChanged + ( const QItemSelection & selected, const QItemSelection & deselected ) + + + setCurrentIndex + setCurrentIndex + ( const QModelIndex & index, QItemSelectionModel::SelectionFlags command ) + + + intersect + intersect + ( const QItemSelectionRange & other ) + + + + 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 ) + + + contains + contains-2 + ( int row, int column, const QModelIndex & parentIndex ) + + + height + height + () + + + indexes + indexes + () + + + intersected + intersected + ( 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-2 + ( Type type, int key, int ascii, int modifiers, const QString & text = QString() + + + ascii + ascii + () + + + ButtonState + state + QKeyEvent::state() + + + ButtonState + stateAfter + QKeyEvent::stateAfter() + + + + QKeyEvent + qkeyevent.html + + QKeyEvent + QKeyEvent + ( Type type, int key, Qt::KeyboardModifiers modifiers, const QString & text = QString() + + + count + count + () + + + isAutoRepeat + isAutoRepeat + () + + + key + key + () + + + matches + matches + ( QKeySequence::StandardKey key ) + + + KeyboardModifiers + modifiers + QKeyEvent::modifiers() + + + nativeModifiers + nativeModifiers + () + + + nativeScanCode + nativeScanCode + () + + + nativeVirtualKey + nativeVirtualKey + () + + + text + text + () + + + StandardKey + operator-eq-eq-46 + key ) + + + StandardKey + operator-eq-eq-47 + key, QKeyEvent * e ) + + + 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() + + + operator + operator-QString + QString() + + + operator + operator-int + int() + + + + QKeySequence + qkeysequence.html + + DataPtr + DataPtr-typedef + + + + SequenceFormat + SequenceFormat-enum + + + + SequenceMatch + SequenceMatch-enum + + + + StandardKey + StandardKey-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 ) + + + QKeySequence + QKeySequence-5 + ( StandardKey key ) + + + count + count + () + + + data_ptr + data_ptr + () + + + fromString + fromString + ( const QString & str, SequenceFormat format = PortableText ) + + + isEmpty + isEmpty + () + + + keyBindings + keyBindings + ( StandardKey key ) + + + matches + matches + ( const QKeySequence & seq ) + + + mnemonic + mnemonic + ( const QString & text ) + + + toString + toString + ( SequenceFormat format = PortableText ) + + + 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 ) + + + QLabel + QLabel-3 + ( QWidget * parent, const char * name, Qt::WindowFlags f = 0 ) + + + QLabel + QLabel-4 + ( const QString & text, QWidget * parent, const char * name, Qt::WindowFlags f = 0 ) + + + QLabel + QLabel-5 + ( QWidget * buddy, const QString & text, QWidget * parent = 0, const char * name = 0, Qt::WindowFlags f = 0 ) + + + setAlignment + setAlignment-2 + ( int alignment ) + + + + QLabel + qlabel.html + + Alignment + alignment-prop + + + + TextFormat + textFormat-prop + + + + TextInteractionFlags + textInteractionFlags-prop + + + + QLabel + QLabel + ( QWidget * parent = 0, Qt::WindowFlags f = 0 ) + + + QLabel + QLabel-2 + ( const QString & text, QWidget * parent = 0, Qt::WindowFlags f = 0 ) + + + buddy + buddy + () + + + clear + clear + () + + + linkActivated + linkActivated + ( const QString & link ) + + + linkHovered + linkHovered + ( const QString & link ) + + + 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::WindowFlags f = 0 ) + + + QLabel + QLabel-4 + ( const QString & text, QWidget * parent, const char * name, Qt::WindowFlags f = 0 ) + + + QLabel + QLabel-5 + ( QWidget * buddy, const QString & text, QWidget * parent = 0, const char * name = 0, Qt::WindowFlags 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-not-eq-2 + ( const char * other ) + + + operator< + operator-lt + ( const QString & other ) + + + operator< + operator-lt-2 + ( const char * other ) + + + operator<= + operator-lt-eq + ( const QString & other ) + + + operator<= + operator-lt-eq-2 + ( const char * other ) + + + operator= + operator-eq + ( const QLatin1String & other ) + + + operator== + operator-eq-eq + ( const QString & other ) + + + operator== + operator-eq-eq-2 + ( const char * other ) + + + operator> + operator-gt + ( const QString & other ) + + + operator> + operator-gt-2 + ( const char * other ) + + + operator>= + operator-gt-eq + ( const QString & other ) + + + operator>= + operator-gt-eq-2 + ( const char * other ) + + + 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 ) + + + + 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 ) + + + contentsRect + contentsRect + () + + + count + count + () + + + Orientations + expandingDirections + QLayout::expandingDirections() + + + getContentsMargins + getContentsMargins + ( int * left, int * top, int * right, int * bottom ) + + + 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 ) + + + setContentsMargins + setContentsMargins + ( int left, int top, int right, int bottom ) + + + setEnabled + setEnabled + ( bool enable ) + + + setMenuBar + setMenuBar + ( QWidget * widget ) + + + takeAt + takeAt + ( int index ) + + + update + update + () + + + 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 ) + + + + QLayoutItem + qlayoutitem.html + + QLayoutItem + QLayoutItem + ( Qt::Alignment alignment = 0 ) + + + Alignment + alignment + QLayoutItem::alignment() + + + ControlTypes + controlTypes + QLayoutItem::controlTypes() + + + 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 + () + + + QLCDNumber + QLCDNumber-3 + ( QWidget * parent, const char * name ) + + + QLCDNumber + QLCDNumber-4 + ( uint numDigits, QWidget * parent, const char * name ) + + + margin + margin + () + + + setMargin + setMargin + ( int margin ) + + + + 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 ) + + + margin + margin + () + + + setMargin + setMargin + ( int margin ) + + + library + library + () + + + setAutoUnload + setAutoUnload + ( bool b ) + + + + 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 ) + + + errorString + errorString + () + + + 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 + () + + + library + library + () + + + setAutoUnload + setAutoUnload + ( bool b ) + + + + QLibraryInfo + qlibraryinfo.html + + LibraryLocation + LibraryLocation-enum + + + + buildKey + buildKey + () + + + licensedProducts + licensedProducts + () + + + licensee + licensee + () + + + location + location + ( LibraryLocation loc ) + + + + 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 ) + + + + QLinearGradient + qlineargradient.html + + QLinearGradient + QLinearGradient + () + + + QLinearGradient + QLinearGradient-2 + ( const QPointF & start, const QPointF & finalStop ) + + + QLinearGradient + QLinearGradient-3 + ( qreal x1, qreal y1, qreal x2, qreal y2 ) + + + finalStop + finalStop + () + + + setFinalStop + setFinalStop + ( const QPointF & stop ) + + + setFinalStop + setFinalStop-2 + ( qreal x, qreal y ) + + + setStart + setStart + ( const QPointF & start ) + + + setStart + setStart-2 + ( qreal x, qreal y ) + + + start + start + () + + + 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 + () + + + margin + margin + () + + + markedText + markedText + () + + + repaintArea + repaintArea + ( int a, int b ) + + + setEdited + setEdited + ( bool on ) + + + setMargin + setMargin + ( int margin ) + + + validateAndSet + validateAndSet + ( const QString & newText, int newPos, int newMarkAnchor, int newMarkDrag ) + + + + 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 + () + + + completer + completer + () + + + 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 ) + + + initStyleOption + initStyleOption + ( QStyleOptionFrame * option ) + + + insert + insert + ( const QString & newText ) + + + keyPressEvent + keyPressEvent + ( QKeyEvent * event ) + + + minimumSizeHint + minimumSizeHint + () + + + paste + paste + () + + + redo + redo + () + + + returnPressed + returnPressed + () + + + selectAll + selectAll + () + + + selectionChanged + selectionChanged + () + + + selectionStart + selectionStart + () + + + setCompleter + setCompleter + ( QCompleter * c ) + + + 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 + () + + + margin + margin + () + + + markedText + markedText + () + + + repaintArea + repaintArea + ( int a, int b ) + + + setEdited + setEdited + ( bool on ) + + + setMargin + setMargin + ( int margin ) + + + 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 ) + + + + 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::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 ) + + + 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 ) + + + + QLinkedList + qlinkedlist.html + + ConstIterator + ConstIterator-typedef + + + + Iterator + Iterator-typedef + + + + const_pointer + const_pointer-typedef + + + + const_reference + const_reference-typedef + + + + difference_type + difference_type-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 ) + + + 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 ) + + + + 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 ) + + + + 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::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 ) + + + 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 ) + + + + QList + qlist.html + + ConstIterator + ConstIterator-typedef + + + + Iterator + Iterator-typedef + + + + const_pointer + const_pointer-typedef + + + + const_reference + const_reference-typedef + + + + difference_type + difference_type-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 ) + + + 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 ) + + + + 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 ) + + + + 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 + () + + + currentChanged + currentChanged + ( const QModelIndex & current, const QModelIndex & previous ) + + + indexesMoved + indexesMoved + ( const QModelIndexList & indexes ) + + + isRowHidden + isRowHidden + ( int row ) + + + rectForIndex + rectForIndex + ( const QModelIndex & index ) + + + selectionChanged + selectionChanged + ( const QItemSelection & selected, const QItemSelection & deselected ) + + + setPositionForIndex + setPositionForIndex + ( const QPoint & position, const QModelIndex & index ) + + + setRowHidden + setRowHidden + ( int row, bool hide ) + + + isItemHidden + isItemHidden + ( const QListWidgetItem * item ) + + + isItemSelected + isItemSelected + ( const QListWidgetItem * item ) + + + setItemHidden + setItemHidden + ( const QListWidgetItem * item, bool hide ) + + + setItemSelected + setItemSelected + ( const QListWidgetItem * item, bool select ) + + + + 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 ) + + + 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 ) + + + 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 ) + + + removeItemWidget + removeItemWidget + ( QListWidgetItem * item ) + + + row + row + ( const QListWidgetItem * item ) + + + scrollToItem + scrollToItem + ( const QListWidgetItem * item, QAbstractItemView::ScrollHint hint = EnsureVisible ) + + + selectedItems + selectedItems + () + + + setCurrentItem + setCurrentItem + ( QListWidgetItem * item ) + + + 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 ) + + + backgroundColor + backgroundColor + () + + + setBackgroundColor + setBackgroundColor + ( const QColor & color ) + + + setTextColor + setTextColor + ( const QColor & color ) + + + textColor + textColor + () + + + + QListWidgetItem + qlistwidgetitem.html + + ItemType + ItemType-enum + + + + 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 ) + + + background + background + () + + + CheckState + checkState + QListWidgetItem::checkState() + + + clone + clone + () + + + data + data + ( int role ) + + + ItemFlags + flags + QListWidgetItem::flags() + + + font + font + () + + + foreground + foreground + () + + + icon + icon + () + + + isHidden + isHidden + () + + + isSelected + isSelected + () + + + listWidget + listWidget + () + + + read + read + ( QDataStream & in ) + + + setBackground + setBackground + ( const QBrush & brush ) + + + setCheckState + setCheckState + ( Qt::CheckState state ) + + + setData + setData + ( int role, const QVariant & value ) + + + setFlags + setFlags + ( Qt::ItemFlags flags ) + + + setFont + setFont + ( const QFont & font ) + + + setForeground + setForeground + ( const QBrush & brush ) + + + setHidden + setHidden + ( bool hide ) + + + setIcon + setIcon + ( const QIcon & icon ) + + + setSelected + setSelected + ( bool select ) + + + setSizeHint + setSizeHint + ( const QSize & size ) + + + setStatusTip + setStatusTip + ( const QString & statusTip ) + + + setText + setText + ( const QString & text ) + + + setTextAlignment + setTextAlignment + ( int alignment ) + + + setToolTip + setToolTip + ( const QString & toolTip ) + + + setWhatsThis + setWhatsThis + ( const QString & whatsThis ) + + + sizeHint + sizeHint + () + + + statusTip + statusTip + () + + + text + text + () + + + textAlignment + textAlignment + () + + + toolTip + toolTip + () + + + type + type + () + + + whatsThis + whatsThis + () + + + write + write + ( QDataStream & out ) + + + operator< + operator-lt + ( const QListWidgetItem & other ) + + + operator= + operator-eq + ( const QListWidgetItem & other ) + + + + 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 + () + + + countriesForLanguage + countriesForLanguage + ( Language language ) + + + country + country + () + + + countryToString + countryToString + ( Country country ) + + + dateFormat + dateFormat + ( FormatType format = LongFormat ) + + + dayName + dayName + ( int day, FormatType type = LongFormat ) + + + decimalPoint + decimalPoint + () + + + exponential + exponential + () + + + groupSeparator + groupSeparator + () + + + language + language + () + + + languageToString + languageToString + ( Language language ) + + + monthName + monthName + ( int month, FormatType type = LongFormat ) + + + name + name + () + + + negativeSign + negativeSign + () + + + numberOptions + numberOptions + () + + + percent + percent + () + + + setDefault + setDefault + ( const QLocale & locale ) + + + setNumberOptions + setNumberOptions + ( NumberOptions options ) + + + 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 ) + + + + QMacPasteboardMime + qmacpasteboardmime.html + + QMacPasteboardMime + QMacPasteboardMime + ( char t ) + + + all + all + ( uchar t ) + + + canConvert + canConvert + ( const QString & mime, QString flav ) + + + convertFromMime + convertFromMime + ( const QString & mime, QVariant data, QString flav ) + + + convertToMime + convertToMime + ( const QString & mime, QList<QByteArray> data, QString flav ) + + + convertor + convertor + ( uchar t, const QString & mime, QString flav ) + + + convertorName + convertorName + () + + + flavorFor + flavorFor + ( const QString & mime ) + + + flavorToMime + flavorToMime + ( uchar t, QString flav ) + + + mimeFor + mimeFor + ( QString flav ) + + + focusRectPolicy + focusRectPolicy + ( const QWidget * w ) + + + setFocusRectPolicy + setFocusRectPolicy + ( QWidget * w, FocusRectPolicy policy ) + + + setWidgetSizePolicy + setWidgetSizePolicy + ( const QWidget * widget, WidgetSizePolicy policy ) + + + widgetSizePolicy + widgetSizePolicy + ( const QWidget * widget ) + + + + QMacStyle + qmacstyle.html + + FocusRectPolicy + FocusRectPolicy-enum + + + + WidgetSizePolicy + WidgetSizePolicy-enum + + + + QMacStyle + QMacStyle + () + + + QMainWindow + QMainWindow-2 + ( QWidget * parent, const char * name, Qt::WindowFlags flags = 0 ) + + + + QMainWindow + qmainwindow.html + + ToolButtonStyle + toolButtonStyle-prop + + + + QMainWindow + QMainWindow + ( QWidget * parent = 0, Qt::WindowFlags 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 + () + + + menuWidget + menuWidget + () + + + removeDockWidget + removeDockWidget + ( QDockWidget * dockwidget ) + + + removeToolBar + removeToolBar + ( QToolBar * toolbar ) + + + removeToolBarBreak + removeToolBarBreak + ( QToolBar * before ) + + + 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 ) + + + setMenuWidget + setMenuWidget + ( QWidget * menuBar ) + + + setStatusBar + setStatusBar + ( QStatusBar * statusbar ) + + + splitDockWidget + splitDockWidget + ( QDockWidget * first, QDockWidget * second, Qt::Orientation orientation ) + + + statusBar + statusBar + () + + + tabifyDockWidget + tabifyDockWidget + ( QDockWidget * first, QDockWidget * second ) + + + ToolBarArea + toolBarArea + QMainWindow::toolBarArea( QToolBar * toolbar ) + + + toolBarBreak + toolBarBreak + ( QToolBar * toolbar ) + + + toolButtonStyleChanged + toolButtonStyleChanged + ( Qt::ToolButtonStyle toolButtonStyle ) + + + QMainWindow + QMainWindow-2 + ( QWidget * parent, const char * name, Qt::WindowFlags flags = 0 ) + + + data + data + () + + + + 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 + () + + + data + data + () + + + + 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 ) + + + 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 ) + + + + QMap + qmap.html + + ConstIterator + ConstIterator-typedef + + + + Iterator + Iterator-typedef + + + + difference_type + difference_type-typedef + + + + key_type + key_type-typedef + + + + mapped_type + mapped_type-typedef + + + + size_type + size_type-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 ) + + + key + key-2 + ( const T & value, const Key & defaultKey ) + + + 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() + + + uniqueKeys + uniqueKeys + () + + + 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 ) + + + 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 ) + + + + 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 ) + + + invert + invert + ( bool * invertible = 0 ) + + + map + map-2 + ( const QRect & rect ) + + + mapToRegion + mapToRegion + ( const QRect & rectangle ) + + + + 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-QVariant + QVariant() + + + 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 ) + + + + QMdiArea + qmdiarea.html + + WindowOrder + WindowOrder-enum + + + + QMdiArea + QMdiArea + ( QWidget * parent = 0 ) + + + activateNextSubWindow + activateNextSubWindow + () + + + activatePreviousSubWindow + activatePreviousSubWindow + () + + + activeSubWindow + activeSubWindow + () + + + addSubWindow + addSubWindow + ( QWidget * widget, Qt::WindowFlags windowFlags = 0 ) + + + cascadeSubWindows + cascadeSubWindows + () + + + closeActiveSubWindow + closeActiveSubWindow + () + + + closeAllSubWindows + closeAllSubWindows + () + + + currentSubWindow + currentSubWindow + () + + + removeSubWindow + removeSubWindow + ( QWidget * widget ) + + + setActiveSubWindow + setActiveSubWindow + ( QMdiSubWindow * window ) + + + setOption + setOption + ( AreaOption option, bool on = true ) + + + setupViewport + setupViewport + ( QWidget * viewport ) + + + subWindowActivated + subWindowActivated + ( QMdiSubWindow * window ) + + + subWindowList + subWindowList + ( WindowOrder order = CreationOrder ) + + + testOption + testOption + ( AreaOption option ) + + + tileSubWindows + tileSubWindows + () + + + + QMdiSubWindow + qmdisubwindow.html + + QMdiSubWindow + QMdiSubWindow + ( QWidget * parent = 0, Qt::WindowFlags flags = 0 ) + + + aboutToActivate + aboutToActivate + () + + + isShaded + isShaded + () + + + setOption + setOption + ( SubWindowOption option, bool on = true ) + + + setSystemMenu + setSystemMenu + ( QMenu * systemMenu ) + + + setWidget + setWidget + ( QWidget * widget ) + + + showShaded + showShaded + () + + + showSystemMenu + showSystemMenu + () + + + systemMenu + systemMenu + () + + + testOption + testOption + ( SubWindowOption option ) + + + widget + widget + () + + + windowStateChanged + windowStateChanged + ( Qt::WindowStates oldState, Qt::WindowStates newState ) + + + 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 ) + + + + QMenu + qmenu.html + + QMenu + QMenu + ( QWidget * parent = 0 ) + + + QMenu + QMenu-2 + ( const QString & title, QWidget * parent = 0 ) + + + aboutToHide + aboutToHide + () + + + 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 ) + + + initStyleOption + initStyleOption + ( QStyleOptionMenuItem * option, const QAction * action ) + + + insertMenu + insertMenu + ( QAction * before, QMenu * menu ) + + + insertSeparator + insertSeparator + ( QAction * before ) + + + isEmpty + isEmpty + () + + + isTearOffMenuVisible + isTearOffMenuVisible + () + + + menuAction + menuAction + () + + + popup + popup + ( const QPoint & p, QAction * atAction = 0 ) + + + setActiveAction + setActiveAction + ( QAction * act ) + + + setDefaultAction + setDefaultAction + ( QAction * act ) + + + triggered + triggered + ( QAction * action ) + + + 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 ) + + + 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-2 + ( 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 ) + + + margin + margin + () + + + 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 ) + + + setMargin + setMargin + ( int margin ) + + + setSeparator + setSeparator + ( Separator sep ) + + + setWhatsThis + setWhatsThis + ( int id, const QString & w ) + + + text + text + ( int id ) + + + whatsThis + whatsThis + ( int id ) + + + + 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 ) + + + initStyleOption + initStyleOption + ( QStyleOptionMenuItem * option, const QAction * action ) + + + insertMenu + insertMenu + ( QAction * before, QMenu * menu ) + + + insertSeparator + insertSeparator + ( QAction * before ) + + + 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-2 + ( 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 ) + + + margin + margin + () + + + 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 ) + + + setMargin + setMargin + ( int margin ) + + + setSeparator + setSeparator + ( Separator sep ) + + + setWhatsThis + setWhatsThis + ( int id, const QString & w ) + + + text + text + ( int id ) + + + whatsThis + whatsThis + ( int id ) + + + QMenuItem + QMenuItem + () + + + id + id + () + + + signalValue + signalValue + () + + + + QMenuItem + qmenuitem.html + + QMenuItem + QMenuItem + () + + + id + id + () + + + signalValue + signalValue + () + + + Button + Button-typedef + + + + QMessageBox + QMessageBox-3 + ( const QString & title, const QString & text, Icon icon, int button0, int button1, int button2, QWidget * parent = 0, Qt::WindowFlags f = Qt::Dialog | Qt::MSWindowsFixedSizeDialogHint ) + + + buttonText + buttonText + ( int button ) + + + critical + critical-2 + ( QWidget * parent, const QString & title, const QString & text, int button0, int button1, int button2 = 0 ) + + + critical + critical-4 + ( QWidget * parent, const QString & title, const QString & text, const QString & button0Text, const QString & button1Text = QString() + + + information + information-2 + ( QWidget * parent, const QString & title, const QString & text, int button0, int button1 = 0, int button2 = 0 ) + + + information + information-4 + ( QWidget * parent, const QString & title, const QString & text, const QString & button0Text, const QString & button1Text = QString() + + + question + question-2 + ( QWidget * parent, const QString & title, const QString & text, int button0, int button1 = 0, int button2 = 0 ) + + + question + question-4 + ( QWidget * parent, const QString & title, const QString & text, const QString & button0Text, const QString & button1Text = QString() + + + setButtonText + setButtonText + ( int button, const QString & text ) + + + standardIcon + standardIcon-2 + ( Icon icon ) + + + warning + warning-2 + ( QWidget * parent, const QString & title, const QString & text, int button0, int button1, int button2 = 0 ) + + + warning + warning-4 + ( QWidget * parent, const QString & title, const QString & text, const QString & button0Text, const QString & button1Text = QString() + + + QMessageBox + QMessageBox-4 + ( const QString & title, const QString & text, Icon icon, int button0, int button1, int button2, QWidget * parent, const char * name, bool modal, Qt::WindowFlags f = Qt::Dialog | Qt::MSWindowsFixedSizeDialogHint ) + + + QMessageBox + QMessageBox-5 + ( QWidget * parent, const char * name ) + + + message + message + ( const QString & title, 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 ) + + + + QMessageBox + qmessagebox.html + + ButtonRole + ButtonRole-enum + + + + Icon + Icon-enum + + + + TextFormat + textFormat-prop + + + + QMessageBox + QMessageBox + ( QWidget * parent = 0 ) + + + QMessageBox + QMessageBox-2 + ( Icon icon, const QString & title, const QString & text, StandardButtons buttons = NoButton, QWidget * parent = 0, Qt::WindowFlags f = Qt::Dialog | Qt::MSWindowsFixedSizeDialogHint ) + + + about + about + ( QWidget * parent, const QString & title, const QString & text ) + + + aboutQt + aboutQt + ( QWidget * parent, const QString & title = QString() + + + addButton + addButton + ( QAbstractButton * button, ButtonRole role ) + + + addButton + addButton-2 + ( const QString & text, ButtonRole role ) + + + addButton + addButton-3 + ( StandardButton button ) + + + button + button + ( StandardButton which ) + + + clickedButton + clickedButton + () + + + critical + critical + ( QWidget * parent, const QString & title, const QString & text, StandardButtons buttons = Ok, StandardButton defaultButton = NoButton ) + + + defaultButton + defaultButton + () + + + escapeButton + escapeButton + () + + + exec + exec + () + + + information + information + ( QWidget * parent, const QString & title, const QString & text, StandardButtons buttons = Ok, StandardButton defaultButton = NoButton ) + + + question + question + ( QWidget * parent, const QString & title, const QString & text, StandardButtons buttons = Ok, StandardButton defaultButton = NoButton ) + + + removeButton + removeButton + ( QAbstractButton * button ) + + + setDefaultButton + setDefaultButton + ( QPushButton * button ) + + + setDefaultButton + setDefaultButton-2 + ( StandardButton button ) + + + setEscapeButton + setEscapeButton + ( QAbstractButton * button ) + + + setEscapeButton + setEscapeButton-2 + ( StandardButton button ) + + + setWindowModality + setWindowModality + ( Qt::WindowModality windowModality ) + + + setWindowTitle + setWindowTitle + ( const QString & title ) + + + standardButton + standardButton + ( QAbstractButton * button ) + + + warning + warning + ( QWidget * parent, const QString & title, const QString & text, StandardButtons buttons = Ok, StandardButton defaultButton = NoButton ) + + + QMessageBox + QMessageBox-4 + ( const QString & title, const QString & text, Icon icon, int button0, int button1, int button2, QWidget * parent, const char * name, bool modal, Qt::WindowFlags f = Qt::Dialog | Qt::MSWindowsFixedSizeDialogHint ) + + + QMessageBox + QMessageBox-5 + ( QWidget * parent, const char * name ) + + + message + message + ( const QString & title, 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 * object ) + + + 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 ) + + + normalizedType + normalizedType + ( const char * type ) + + + property + property + ( int index ) + + + propertyCount + propertyCount + () + + + propertyOffset + propertyOffset + () + + + superClass + superClass + () + + + userProperty + userProperty + () + + + isEditable + isEditable + ( const QObject * object = 0 ) + + + + QMetaProperty + qmetaproperty.html + + enumerator + enumerator + () + + + isDesignable + isDesignable + ( 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 + () + + + userType + userType + () + + + write + write + ( QObject * object, const QVariant & value ) + + + + QMetaType + qmetatype.html + + Type + Type-enum + + + + construct + construct + ( int type, const void * copy = 0 ) + + + 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 ) + + + ItemFlags + flags + QModelIndex::flags() + + + 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 ) + + + 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-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() + + + + 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 + () + + + finished + finished-2 + () + + + frameImage + frameImage + () + + + frameNumber + frameNumber + () + + + framePixmap + framePixmap + () + + + isNull + isNull + () + + + pause + pause + () + + + paused + paused + () + + + restart + restart + () + + + running + running + () + + + step + step + () + + + unpause + unpause + () + + + + 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 ) + + + constFind + constFind + ( const Key & key, const T & value ) + + + contains + contains + ( const Key & key, const T & value ) + + + count + count + ( const Key & key, const T & value ) + + + find + find + ( const Key & key, const T & value ) + + + find + find-2 + ( const Key & key, const T & value ) + + + insert + insert + ( const Key & key, const T & value ) + + + remove + remove + ( 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 ) + + + constFind + constFind + ( const Key & key, const T & value ) + + + contains + contains + ( const Key & key, const T & value ) + + + count + count + ( const Key & key, const T & value ) + + + find + find + ( const Key & key, const T & value ) + + + find + find-2 + ( const Key & key, const T & value ) + + + insert + insert + ( const Key & key, const T & value ) + + + remove + remove + ( 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 ) + + + + QMutableSetIterator + qmutablesetiterator.html + + QMutableSetIterator + QMutableSetIterator + ( 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 + () + + + remove + remove + () + + + toBack + toBack + () + + + toFront + toFront + () + + + value + value + () + + + operator= + operator-eq + ( QSet<T> & set ) + + + + 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-2 + ( bool recursive ) + + + locked + locked + () + + + + QMutex + qmutex.html + + RecursionMode + RecursionMode-enum + + + + QMutex + QMutex + ( RecursionMode mode = NonRecursive ) + + + lock + lock + () + + + tryLock + tryLock + () + + + tryLock + tryLock-2 + ( int timeout ) + + + unlock + unlock + () + + + QMutex + QMutex-2 + ( bool recursive ) + + + locked + locked + () + + + + QMutexLocker + qmutexlocker.html + + QMutexLocker + QMutexLocker + ( QMutex * mutex ) + + + mutex + mutex + () + + + relock + relock + () + + + unlock + unlock + () + + + + QNetworkAddressEntry + qnetworkaddressentry.html + + QNetworkAddressEntry + QNetworkAddressEntry + () + + + QNetworkAddressEntry + QNetworkAddressEntry-2 + ( const QNetworkAddressEntry & other ) + + + broadcast + broadcast + () + + + ip + ip + () + + + netmask + netmask + () + + + setBroadcast + setBroadcast + ( const QHostAddress & newBroadcast ) + + + setIp + setIp + ( const QHostAddress & newIp ) + + + setNetmask + setNetmask + ( const QHostAddress & newNetmask ) + + + operator= + operator-eq + ( const QNetworkAddressEntry & other ) + + + + QNetworkInterface + qnetworkinterface.html + + QNetworkInterface + QNetworkInterface + () + + + QNetworkInterface + QNetworkInterface-2 + ( const QNetworkInterface & other ) + + + addressEntries + addressEntries + () + + + allAddresses + allAddresses + () + + + allInterfaces + allInterfaces + () + + + flags + flags + () + + + hardwareAddress + hardwareAddress + () + + + interfaceFromIndex + interfaceFromIndex + ( int index ) + + + interfaceFromName + interfaceFromName + ( const QString & name ) + + + isValid + isValid + () + + + name + name + () + + + operator= + operator-eq + ( const QNetworkInterface & other ) + + + + 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 ) + + + 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 ) + + + + 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 + () + + + dynamicPropertyNames + dynamicPropertyNames + () + + + 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 = 0, int n = -1 ) + + + trUtf8 + trUtf8 + ( const char * sourceText, const char * comment = 0, int n = -1 ) + + + staticMetaObject + staticMetaObject-var + + + + 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 ) + + + + QObjectCleanupHandler + qobjectcleanuphandler.html + + QObjectCleanupHandler + QObjectCleanupHandler + () + + + add + add + ( QObject * object ) + + + clear + clear + () + + + isEmpty + isEmpty + () + + + remove + remove + ( QObject * object ) + + + + QPageSetupDialog + qpagesetupdialog.html + + QPageSetupDialog + QPageSetupDialog + ( QPrinter * printer, QWidget * parent = 0 ) + + + printer + printer + () + + + 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 + () + + + + 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 + () + + + brushNeedsResolving + brushNeedsResolving + () + + + brushOrigin + brushOrigin + () + + + ClipOperation + clipOperation + QPaintEngineState::clipOperation() + + + clipPath + clipPath + () + + + clipRegion + clipRegion + () + + + CompositionMode + compositionMode + QPaintEngineState::compositionMode() + + + font + font + () + + + isClipEnabled + isClipEnabled + () + + + matrix + matrix + () + + + opacity + opacity + () + + + painter + painter + () + + + pen + pen + () + + + penNeedsResolving + penNeedsResolving + () + + + RenderHints + renderHints + QPaintEngineState::renderHints() + + + DirtyFlags + state + QPaintEngineState::state() + + + transform + transform + () + + + matrix + matrix + () + + + matrixEnabled + matrixEnabled + () + + + setMatrix + setMatrix + ( const QMatrix & matrix, bool combine = false ) + + + setMatrixEnabled + setMatrixEnabled + ( bool enable ) + + + 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 ) + + + setWorldXForm + setWorldXForm + ( bool enabled ) + + + translationX + translationX + () + + + translationY + translationY + () + + + 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 ) + + + + 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 + () + + + combinedMatrix + combinedMatrix + () + + + combinedTransform + combinedTransform + () + + + compositionMode + compositionMode + () + + + device + device + () + + + deviceMatrix + deviceMatrix + () + + + deviceTransform + deviceTransform + () + + + 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() + + + opacity + opacity + () + + + paintEngine + paintEngine + () + + + pen + pen + () + + + redirected + redirected + ( const QPaintDevice * device, QPoint * offset = 0 ) + + + renderHints + renderHints + () + + + resetMatrix + resetMatrix + () + + + resetTransform + resetTransform + () + + + 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 ) + + + setOpacity + setOpacity + ( qreal opacity ) + + + 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 ) + + + setRenderHints + setRenderHints + ( RenderHints hints, bool on = true ) + + + setTransform + setTransform + ( const QTransform & transform, bool combine = false ) + + + 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 ) + + + setWorldMatrix + setWorldMatrix + ( const QMatrix & matrix, bool combine = false ) + + + setWorldMatrixEnabled + setWorldMatrixEnabled + ( bool enable ) + + + setWorldTransform + setWorldTransform + ( const QTransform & matrix, bool combine = false ) + + + shear + shear + ( qreal sh, qreal sv ) + + + strokePath + strokePath + ( const QPainterPath & path, const QPen & pen ) + + + testRenderHint + testRenderHint + ( RenderHint hint ) + + + transform + transform + () + + + translate + translate + ( const QPointF & offset ) + + + translate + translate-2 + ( const QPoint & offset ) + + + translate + translate-3 + ( qreal dx, qreal dy ) + + + viewTransformEnabled + viewTransformEnabled + () + + + viewport + viewport + () + + + window + window + () + + + worldMatrix + worldMatrix + () + + + worldMatrixEnabled + worldMatrixEnabled + () + + + worldTransform + worldTransform + () + + + 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 ) + + + setWorldXForm + setWorldXForm + ( bool enabled ) + + + translationX + translationX + () + + + translationY + translationY + () + + + 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 ) + + + + QPainterPath::Element + qpainterpath-element.html + + isCurveTo + isCurveTo + () + + + isLineTo + isLineTo + () + + + isMoveTo + isMoveTo + () + + + operator + operator-QPointF + QPointF() + + + operator!= + operator-not-eq + ( const Element & other ) + + + operator== + operator-eq-eq + ( const Element & other ) + + + 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 ) + + + addRoundRect + addRoundRect + ( const QRectF & r, int xRnd, int yRnd ) + + + addRoundRect + addRoundRect-2 + ( qreal x, qreal y, qreal w, qreal h, int xRnd, int yRnd ) + + + addRoundRect + addRoundRect-3 + ( const QRectF & rect, int roundness ) + + + addRoundRect + addRoundRect-4 + ( qreal x, qreal y, qreal w, qreal h, int roundness ) + + + addText + addText + ( const QPointF & point, const QFont & font, const QString & text ) + + + addText + addText-2 + ( qreal x, qreal y, const QFont & font, const QString & text ) + + + angleAtPercent + angleAtPercent + ( qreal t ) + + + arcMoveTo + arcMoveTo + ( const QRectF & rectangle, qreal angle ) + + + arcMoveTo + arcMoveTo-2 + ( qreal x, qreal y, qreal width, qreal height, qreal angle ) + + + 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 QPainterPath & p ) + + + contains + contains-3 + ( 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() + + + intersected + intersected + ( const QPainterPath & p ) + + + intersects + intersects + ( const QRectF & rectangle ) + + + intersects + intersects-2 + ( const QPainterPath & p ) + + + isEmpty + isEmpty + () + + + length + length + () + + + lineTo + lineTo + ( const QPointF & endPoint ) + + + lineTo + lineTo-2 + ( qreal x, qreal y ) + + + moveTo + moveTo + ( const QPointF & point ) + + + moveTo + moveTo-2 + ( qreal x, qreal y ) + + + percentAtLength + percentAtLength + ( qreal len ) + + + pointAtPercent + pointAtPercent + ( qreal t ) + + + quadTo + quadTo + ( const QPointF & c, const QPointF & endPoint ) + + + quadTo + quadTo-2 + ( qreal cx, qreal cy, qreal endPointX, qreal endPointY ) + + + setElementPositionAt + setElementPositionAt + ( int index, qreal x, qreal y ) + + + setFillRule + setFillRule + ( Qt::FillRule fillRule ) + + + slopeAtPercent + slopeAtPercent + ( qreal t ) + + + subtracted + subtracted + ( const QPainterPath & p ) + + + subtractedInverted + subtractedInverted + ( const QPainterPath & p ) + + + toFillPolygon + toFillPolygon + ( const QMatrix & matrix = QMatrix() + + + toFillPolygon + toFillPolygon-2 + ( const QTransform & matrix ) + + + toFillPolygons + toFillPolygons + ( const QMatrix & matrix = QMatrix() + + + toFillPolygons + toFillPolygons-2 + ( const QTransform & matrix ) + + + toReversed + toReversed + () + + + toSubpathPolygons + toSubpathPolygons + ( const QMatrix & matrix = QMatrix() + + + toSubpathPolygons + toSubpathPolygons-2 + ( const QTransform & matrix ) + + + united + united + ( const QPainterPath & p ) + + + 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 + () + + + dashOffset + dashOffset + () + + + dashPattern + dashPattern + () + + + PenJoinStyle + joinStyle + QPainterPathStroker::joinStyle() + + + miterLimit + miterLimit + () + + + setCapStyle + setCapStyle + ( Qt::PenCapStyle style ) + + + setCurveThreshold + setCurveThreshold + ( qreal threshold ) + + + setDashOffset + setDashOffset + ( qreal offset ) + + + 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 + () + + + QPaintEvent + QPaintEvent-3 + ( const QRegion & paintRegion, const QRect & paintRect ) + + + erased + erased + () + + + + 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-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 + () + + + serialNumber + serialNumber + () + + + 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 ) + + + + 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 group, ColorRole role ) + + + brush + brush-2 + ( ColorRole role ) + + + button + button + () + + + buttonText + buttonText + () + + + cacheKey + cacheKey + () + + + color + color + ( ColorGroup group, ColorRole role ) + + + color + color-2 + ( ColorRole role ) + + + currentColorGroup + currentColorGroup + () + + + dark + dark + () + + + highlight + highlight + () + + + highlightedText + highlightedText + () + + + isBrushSet + isBrushSet + ( ColorGroup cg, ColorRole cr ) + + + 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 ) + + + setBrush + setBrush + ( ColorRole role, const QBrush & brush ) + + + setBrush + setBrush-2 + ( ColorGroup group, ColorRole role, const QBrush & brush ) + + + setColor + setColor + ( ColorGroup group, ColorRole role, const QColor & color ) + + + setColor + setColor-2 + ( ColorRole role, const QColor & color ) + + + 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-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 + + DataPtr + DataPtr-typedef + + + + 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 + () + + + dashOffset + dashOffset + () + + + dashPattern + dashPattern + () + + + data_ptr + data_ptr + () + + + isCosmetic + isCosmetic + () + + + isSolid + isSolid + () + + + PenJoinStyle + joinStyle + QPen::joinStyle() + + + miterLimit + miterLimit + () + + + setBrush + setBrush + ( const QBrush & brush ) + + + setCapStyle + setCapStyle + ( Qt::PenCapStyle style ) + + + setColor + setColor + ( const QColor & color ) + + + setCosmetic + setCosmetic + ( bool cosmetic ) + + + setDashOffset + setDashOffset + ( qreal offset ) + + + 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 + ( const QModelIndex & index ) + + + QPersistentModelIndex + QPersistentModelIndex-3 + ( const QPersistentModelIndex & other ) + + + child + child + ( int row, int column ) + + + column + column + () + + + data + data + ( int role = Qt::DisplayRole ) + + + ItemFlags + flags + QPersistentModelIndex::flags() + + + 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 QPersistentModelIndex & other ) + + + operator!= + operator-not-eq-2 + ( 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 ) + + + inputFormatList + inputFormatList + () + + + inputFormats + inputFormats + () + + + outputFormatList + outputFormatList + () + + + outputFormats + outputFormats + () + + + pictureFormat + pictureFormat + ( const QString & fileName ) + + + copy + copy + () + + + + QPicture + qpicture.html + + DataPtr + DataPtr-typedef + + + + QPicture + QPicture + ( int formatVersion = -1 ) + + + QPicture + QPicture-2 + ( const QPicture & pic ) + + + boundingRect + boundingRect + () + + + data + data + () + + + data_ptr + data_ptr + () + + + isNull + isNull + () + + + load + load + ( const QString & fileName, const char * format = 0 ) + + + load + load-2 + ( QIODevice * dev, const char * format = 0 ) + + + metric + metric + ( PaintDeviceMetric m ) + + + 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 ) + + + copy + copy + () + + + + 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 ) + + + + 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 + () + + + serialNumber + serialNumber + () + + + 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 ) + + + + QPixmap + qpixmap.html + + DataPtr + DataPtr-typedef + + + + 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 + () + + + cacheKey + cacheKey + () + + + 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, Qt::MaskMode mode ) + + + createMaskFromColor + createMaskFromColor-2 + ( const QColor & maskColor ) + + + data_ptr + data_ptr + () + + + 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 ) + + + fromMacCGImageRef + fromMacCGImageRef + ( CGImageRef image ) + + + 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 = 0, int quality = -1 ) + + + save + save-2 + ( QIODevice * device, const char * format = 0, 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 ) + + + setAlphaChannel + setAlphaChannel + ( const QPixmap & alphaChannel ) + + + setMask + setMask + ( const QBitmap & newmask ) + + + size + size + () + + + toImage + toImage + () + + + toMacCGImageRef + toMacCGImageRef + () + + + toWinHBITMAP + toWinHBITMAP + ( HBitmapFormat format = NoAlpha ) + + + transformed + transformed + ( const QMatrix & matrix, Qt::TransformationMode mode = Qt::FastTransformation ) + + + transformed + transformed-2 + ( const QTransform &, Qt::TransformationMode mode = Qt::FastTransformation ) + + + trueMatrix + trueMatrix + ( const QMatrix & matrix, int width, int height ) + + + trueMatrix + trueMatrix-2 + ( const QTransform & m, int w, int h ) + + + 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 ) + + + find + find-2 + ( const QString & key ) + + + + 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 ) + + + + QPlastiqueStyle + qplastiquestyle.html + + QPlastiqueStyle + QPlastiqueStyle + () + + + + QPluginLoader + qpluginloader.html + + QPluginLoader + QPluginLoader + ( QObject * parent = 0 ) + + + QPluginLoader + QPluginLoader-2 + ( const QString & fileName, QObject * parent = 0 ) + + + errorString + errorString + () + + + instance + instance + () + + + isLoaded + isLoaded + () + + + load + load + () + + + staticInstances + staticInstances + () + + + unload + unload + () + + + + 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 ) + + + + 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 ) + + + + 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 + () + + + containsPoint + containsPoint + ( const QPoint & pt, Qt::FillRule fillRule ) + + + intersected + intersected + ( const QPolygon & r ) + + + 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, ... ) + + + subtracted + subtracted + ( const QPolygon & r ) + + + translate + translate + ( int dx, int dy ) + + + translate + translate-2 + ( const QPoint & offset ) + + + united + united + ( const QPolygon & r ) + + + operator + operator-QVariant + QVariant() + + + + 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 + () + + + containsPoint + containsPoint + ( const QPointF & point, Qt::FillRule fillRule ) + + + intersected + intersected + ( const QPolygonF & r ) + + + isClosed + isClosed + () + + + subtracted + subtracted + ( const QPolygonF & r ) + + + toPolygon + toPolygon + () + + + translate + translate + ( const QPointF & offset ) + + + translate + translate-2 + ( qreal dx, qreal dy ) + + + united + united + ( const QPolygonF & r ) + + + + 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 ) + + + 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 ) + + + + 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 + () + + + doubleSidedPrinting + doubleSidedPrinting + () + + + 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 ) + + + setDoubleSidedPrinting + setDoubleSidedPrinting + ( bool doubleSided ) + + + 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 ) + + + supportedPaperSources + supportedPaperSources + () + + + 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 ) + + + finished + finished-2 + ( int exitCode ) + + + readChannelMode + readChannelMode + () + + + setReadChannelMode + setReadChannelMode + ( ProcessChannelMode mode ) + + + + 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 + () + + + processChannelMode + processChannelMode + () + + + readAllStandardError + readAllStandardError + () + + + readAllStandardOutput + readAllStandardOutput + () + + + readChannel + readChannel + () + + + readyReadStandardError + readyReadStandardError + () + + + readyReadStandardOutput + readyReadStandardOutput + () + + + setEnvironment + setEnvironment + ( const QStringList & environment ) + + + setProcessChannelMode + setProcessChannelMode + ( ProcessChannelMode mode ) + + + setProcessState + setProcessState + ( ProcessState state ) + + + setReadChannel + setReadChannel + ( ProcessChannel channel ) + + + setStandardErrorFile + setStandardErrorFile + ( const QString & fileName, OpenMode mode = Truncate ) + + + setStandardInputFile + setStandardInputFile + ( const QString & fileName ) + + + setStandardOutputFile + setStandardOutputFile + ( const QString & fileName, OpenMode mode = Truncate ) + + + setStandardOutputProcess + setStandardOutputProcess + ( QProcess * destination ) + + + 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, const QString & workingDirectory, qint64 * pid = 0 ) + + + startDetached + startDetached-2 + ( const QString & program, const QStringList & arguments ) + + + startDetached + startDetached-3 + ( 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 + () + + + + QProgressBar + qprogressbar.html + + Direction + Direction-enum + + + + Alignment + alignment-prop + + + + Orientation + orientation-prop + + + + QProgressBar + QProgressBar + ( QWidget * parent = 0 ) + + + initStyleOption + initStyleOption + ( QStyleOptionProgressBar * option ) + + + reset + reset + () + + + setRange + setRange + ( int minimum, int maximum ) + + + valueChanged + valueChanged + ( int value ) + + + + QProgressDialog + qprogressdialog.html + + QProgressDialog + QProgressDialog + ( QWidget * parent = 0, Qt::WindowFlags f = 0 ) + + + QProgressDialog + QProgressDialog-2 + ( const QString & labelText, const QString & cancelButtonText, int minimum, int maximum, QWidget * parent = 0, Qt::WindowFlags 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-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 ) + + + + 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 ) + + + initStyleOption + initStyleOption + ( QStyleOptionButton * option ) + + + 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 + () + + + QRadialGradient + QRadialGradient-2 + ( const QPointF & center, qreal radius, const QPointF & focalPoint ) + + + QRadialGradient + QRadialGradient-3 + ( qreal cx, qreal cy, qreal radius, qreal fx, qreal fy ) + + + QRadialGradient + QRadialGradient-4 + ( const QPointF & center, qreal radius ) + + + QRadialGradient + QRadialGradient-5 + ( qreal cx, qreal cy, qreal radius ) + + + center + center + () + + + focalPoint + focalPoint + () + + + radius + radius + () + + + setCenter + setCenter + ( const QPointF & center ) + + + setCenter + setCenter-2 + ( qreal x, qreal y ) + + + setFocalPoint + setFocalPoint + ( const QPointF & focalPoint ) + + + setFocalPoint + setFocalPoint-2 + ( qreal x, qreal y ) + + + setRadius + setRadius + ( qreal radius ) + + + QRadioButton + QRadioButton-3 + ( QWidget * parent, const char * name ) + + + QRadioButton + QRadioButton-4 + ( const QString & text, QWidget * parent, const char * name ) + + + + QRadioButton + qradiobutton.html + + QRadioButton + QRadioButton + ( QWidget * parent = 0 ) + + + QRadioButton + QRadioButton-2 + ( const QString & text, QWidget * parent = 0 ) + + + initStyleOption + initStyleOption + ( QStyleOptionButton * option ) + + + QRadioButton + QRadioButton-3 + ( QWidget * parent, const char * name ) + + + QRadioButton + QRadioButton-4 + ( const QString & text, QWidget * parent, const char * name ) + + + + QRasterPaintEngine + qrasterpaintengine.html + + QRasterPaintEngine + QRasterPaintEngine + () + + + drawBufferSpan + drawBufferSpan + ( const uint * buffer, int size, int x, int y, int length, uint alpha ) + + + drawColorSpans + drawColorSpans + ( const QSpan * spans, int count, uint color ) + + + fillPolygon + fillPolygon + ( const QPointF * points, int pointCount, PolygonDrawMode mode ) + + + + QReadLocker + qreadlocker.html + + QReadLocker + QReadLocker + ( QReadWriteLock * lock ) + + + readWriteLock + readWriteLock + () + + + relock + relock + () + + + unlock + unlock + () + + + + QReadWriteLock + qreadwritelock.html + + QReadWriteLock + QReadWriteLock + () + + + lockForRead + lockForRead + () + + + lockForWrite + lockForWrite + () + + + tryLockForRead + tryLockForRead + () + + + tryLockForRead + tryLockForRead-2 + ( int timeout ) + + + tryLockForWrite + tryLockForWrite + () + + + tryLockForWrite + tryLockForWrite-2 + ( int timeout ) + + + unlock + unlock + () + + + intersect + intersect + ( const QRect & rectangle ) + + + unite + unite + ( 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 ) + + + + 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 + () + + + intersected + intersected + ( 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 ) + + + united + united + ( 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 ) + + + intersect + intersect + ( const QRectF & rectangle ) + + + unite + unite + ( const QRectF & rectangle ) + + + + QRectF + qrectf.html + + QRectF + QRectF + () + + + QRectF + QRectF-2 + ( const QPointF & topLeft, const QSizeF & size ) + + + QRectF + QRectF-3 + ( const QPointF & topLeft, const QPointF & bottomRight ) + + + QRectF + QRectF-4 + ( qreal x, qreal y, qreal width, qreal height ) + + + QRectF + QRectF-5 + ( 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 + () + + + intersected + intersected + ( 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 + () + + + toAlignedRect + toAlignedRect + () + + + 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 ) + + + united + united + ( 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 ) + + + 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 + () + + + + 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-3 + ( QObject * parent, const char * name ) + + + QRegExpValidator + QRegExpValidator-4 + ( const QRegExp & rx, QObject * parent, const char * name ) + + + + 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 ) + + + eor + eor + ( const QRegion & r ) + + + intersect + intersect + ( const QRegion & r ) + + + subtract + subtract + ( const QRegion & r ) + + + unite + unite + ( const QRegion & r ) + + + QRegion + QRegion-4 + ( const QPolygon & pa, bool winding ) + + + isNull + isNull + () + + + + 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 ) + + + handle + handle + () + + + intersected + intersected + ( const QRegion & r ) + + + intersects + intersects + ( const QRegion & region ) + + + intersects + intersects-2 + ( const QRect & rect ) + + + isEmpty + isEmpty + () + + + rects + rects + () + + + setRects + setRects + ( const QRect * rects, int number ) + + + subtracted + subtracted + ( 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 ) + + + united + united + ( const QRegion & r ) + + + xored + xored + ( 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 + () + + + addSearchPath + addSearchPath + ( const QString & path ) + + + + QResource + qresource.html + + QResource + QResource + ( const QString & file = QString() + + + absoluteFilePath + absoluteFilePath + () + + + children + children + () + + + data + data + () + + + fileName + fileName + () + + + isCompressed + isCompressed + () + + + isDir + isDir + () + + + isFile + isFile + () + + + isValid + isValid + () + + + locale + locale + () + + + registerResource + registerResource + ( const QString & rccFileName, const QString & mapRoot = QString() + + + registerResource + registerResource-2 + ( const uchar * rccData, const QString & mapRoot = QString() + + + searchPaths + searchPaths + () + + + setFileName + setFileName + ( const QString & file ) + + + setLocale + setLocale + ( const QLocale & locale ) + + + size + size + () + + + unregisterResource + unregisterResource + ( const QString & rccFileName, const QString & mapRoot = QString() + + + unregisterResource + unregisterResource-2 + ( const uchar * rccData, const QString & mapRoot = QString() + + + + QRubberBand + qrubberband.html + + Shape + Shape-enum + + + + QRubberBand + QRubberBand + ( Shape s, QWidget * p = 0 ) + + + initStyleOption + initStyleOption + ( QStyleOptionRubberBand * option ) + + + 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 + () + + + + 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 ) + + + createSurface + createSurface + ( const QString & key ) + + + createSurface + createSurface-2 + ( QWidget * widget ) + + + depth + depth + () + + + deviceHeight + deviceHeight + () + + + deviceWidth + deviceWidth + () + + + disconnect + disconnect + () + + + exposeRegion + exposeRegion + ( QRegion region, int windowIndex ) + + + height + height + () + + + initDevice + initDevice + () + + + instance + instance + () + + + isInterlaced + isInterlaced + () + + + isTransformed + isTransformed + () + + + 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 + () + + + offset + offset + () + + + onCard + onCard + ( const unsigned char * buffer ) + + + onCard + onCard-2 + ( const unsigned char * buffer, ulong & offset ) + + + physicalHeight + physicalHeight + () + + + physicalWidth + physicalWidth + () + + + Format + pixelFormat + QScreen::pixelFormat() + + + pixelType + pixelType + () + + + pixmapDepth + pixmapDepth + () + + + pixmapLinestepAlignment + pixmapLinestepAlignment + () + + + pixmapOffsetAlignment + pixmapOffsetAlignment + () + + + region + region + () + + + restore + restore + () + + + save + save + () + + + screenSize + screenSize + () + + + setDirty + setDirty + ( const QRect & rectangle ) + + + setMode + setMode + ( int width, int height, int depth ) + + + setPixelFormat + setPixelFormat + ( QImage::Format format ) + + + shutdownDevice + shutdownDevice + () + + + solidFill + solidFill + ( const QColor & color, const QRegion & region ) + + + subScreenIndexAt + subScreenIndexAt + ( const QPoint & position ) + + + subScreens + subScreens + () + + + supportsDepth + supportsDepth + ( int depth ) + + + totalSize + totalSize + () + + + transformOrientation + transformOrientation + () + + + width + width + () + + + + QScreenCursor + qscreencursor.html + + QScreenCursor + QScreenCursor + () + + + boundingRect + boundingRect + () + + + hide + hide + () + + + image + image + () + + + initSoftwareCursor + initSoftwareCursor + () + + + instance + instance + () + + + isAccelerated + isAccelerated + () + + + isVisible + isVisible + () + + + move + move + ( int x, int y ) + + + set + set + ( const QImage & image, int hotx, int hoty ) + + + show + show + () + + + + 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 + () + + + + QScriptable + qscriptable.html + + argument + argument + ( int index ) + + + argumentCount + argumentCount + () + + + context + context + () + + + engine + engine + () + + + thisObject + thisObject + () + + + + QScriptContext + qscriptcontext.html + + Error + Error-enum + + + + ExecutionState + ExecutionState-enum + + + + activationObject + activationObject + () + + + argument + argument + ( int index ) + + + argumentCount + argumentCount + () + + + argumentsObject + argumentsObject + () + + + backtrace + backtrace + () + + + callee + callee + () + + + engine + engine + () + + + isCalledAsConstructor + isCalledAsConstructor + () + + + parentContext + parentContext + () + + + setActivationObject + setActivationObject + ( const QScriptValue & activation ) + + + setThisObject + setThisObject + ( const QScriptValue & thisObject ) + + + state + state + () + + + thisObject + thisObject + () + + + throwError + throwError + ( Error error, const QString & text ) + + + throwError + throwError-2 + ( const QString & text ) + + + throwValue + throwValue + ( const QScriptValue & value ) + + + + QScriptEngine + qscriptengine.html + + FunctionSignature + FunctionSignature-typedef + + + + ValueOwnership + ValueOwnership-enum + + + + QScriptEngine + QScriptEngine + () + + + QScriptEngine + QScriptEngine-2 + ( QObject * parent ) + + + canEvaluate + canEvaluate + ( const QString & program ) + + + collectGarbage + collectGarbage + () + + + currentContext + currentContext + () + + + defaultPrototype + defaultPrototype + ( int metaTypeId ) + + + evaluate + evaluate + ( const QString & program, const QString & fileName = QString() + + + fromScriptValue + fromScriptValue + ( const QScriptValue & value ) + + + globalObject + globalObject + () + + + hasUncaughtException + hasUncaughtException + () + + + importExtension + importExtension + ( const QString & extension ) + + + newArray + newArray + ( uint length = 0 ) + + + newDate + newDate + ( qsreal value ) + + + newDate + newDate-2 + ( const QDateTime & value ) + + + newFunction + newFunction + ( FunctionSignature fun, int length = 0 ) + + + newFunction + newFunction-2 + ( FunctionSignature fun, const QScriptValue & prototype, int length = 0 ) + + + newObject + newObject + () + + + newQMetaObject + newQMetaObject + ( const QMetaObject * metaObject, const QScriptValue & ctor = QScriptValue() + + + newQObject + newQObject + ( QObject * object, ValueOwnership ownership = QtOwnership, const QObjectWrapOptions & options = 0 ) + + + newRegExp + newRegExp + ( const QRegExp & regexp ) + + + newRegExp + newRegExp-2 + ( const QString & pattern, const QString & flags ) + + + newVariant + newVariant + ( const QVariant & value ) + + + nullValue + nullValue + () + + + processEventsInterval + processEventsInterval + () + + + scriptValueFromQMetaObject + scriptValueFromQMetaObject + () + + + setDefaultPrototype + setDefaultPrototype + ( int metaTypeId, const QScriptValue & prototype ) + + + setProcessEventsInterval + setProcessEventsInterval + ( int interval ) + + + toScriptValue + toScriptValue + ( const T & value ) + + + uncaughtException + uncaughtException + () + + + uncaughtExceptionBacktrace + uncaughtExceptionBacktrace + () + + + uncaughtExceptionLineNumber + uncaughtExceptionLineNumber + () + + + undefinedValue + undefinedValue + () + + + FunctionSignature + FunctionSignature-typedef + + + + + QScriptExtensionPlugin + qscriptextensionplugin.html + + QScriptExtensionPlugin + QScriptExtensionPlugin + ( QObject * parent = 0 ) + + + initialize + initialize + ( const QString & key, QScriptEngine * engine ) + + + keys + keys + () + + + setupPackage + setupPackage + ( const QString & key, QScriptEngine * engine ) + + + + QScriptValue + qscriptvalue.html + + SpecialValue + SpecialValue-enum + + + + QScriptValue + QScriptValue + () + + + QScriptValue + QScriptValue-2 + ( const QScriptValue & other ) + + + QScriptValue + QScriptValue-3 + ( QScriptEngine * engine, SpecialValue value ) + + + QScriptValue + QScriptValue-4 + ( QScriptEngine * engine, bool value ) + + + QScriptValue + QScriptValue-5 + ( QScriptEngine * engine, int value ) + + + QScriptValue + QScriptValue-6 + ( QScriptEngine * engine, uint value ) + + + QScriptValue + QScriptValue-7 + ( QScriptEngine * engine, qsreal value ) + + + QScriptValue + QScriptValue-8 + ( QScriptEngine * engine, const QString & value ) + + + QScriptValue + QScriptValue-9 + ( QScriptEngine * engine, const char * value ) + + + call + call + ( const QScriptValue & thisObject = QScriptValue() + + + call + call-2 + ( const QScriptValue & thisObject, const QScriptValue & arguments ) + + + construct + construct + ( const QScriptValueList & args = QScriptValueList() + + + construct + construct-2 + ( const QScriptValue & arguments ) + + + engine + engine + () + + + equals + equals + ( const QScriptValue & other ) + + + instanceOf + instanceOf + ( const QScriptValue & ctorValue ) + + + isArray + isArray + () + + + isBoolean + isBoolean + () + + + isDate + isDate + () + + + isError + isError + () + + + isFunction + isFunction + () + + + isNull + isNull + () + + + isNumber + isNumber + () + + + isObject + isObject + () + + + isQMetaObject + isQMetaObject + () + + + isQObject + isQObject + () + + + isRegExp + isRegExp + () + + + isString + isString + () + + + isUndefined + isUndefined + () + + + isValid + isValid + () + + + isVariant + isVariant + () + + + lessThan + lessThan + ( const QScriptValue & other ) + + + property + property + ( const QString & name, const ResolveFlags & mode = ResolvePrototype ) + + + property + property-2 + ( quint32 arrayIndex, const ResolveFlags & mode = ResolvePrototype ) + + + PropertyFlags + propertyFlags + QScriptValue::propertyFlags( const QString & name, const ResolveFlags & mode = ResolvePrototype ) + + + prototype + prototype + () + + + setProperty + setProperty + ( const QString & name, const QScriptValue & value, const PropertyFlags & flags = KeepExistingFlags ) + + + setProperty + setProperty-2 + ( quint32 arrayIndex, const QScriptValue & value, const PropertyFlags & flags = KeepExistingFlags ) + + + setPrototype + setPrototype + ( const QScriptValue & prototype ) + + + strictlyEquals + strictlyEquals + ( const QScriptValue & other ) + + + toBoolean + toBoolean + () + + + toDateTime + toDateTime + () + + + toInt32 + toInt32 + () + + + toInteger + toInteger + () + + + toNumber + toNumber + () + + + toObject + toObject + () + + + toQMetaObject + toQMetaObject + () + + + toQObject + toQObject + () + + + toRegExp + toRegExp + () + + + toString + toString + () + + + toUInt16 + toUInt16 + () + + + toUInt32 + toUInt32 + () + + + toVariant + toVariant + () + + + operator= + operator-eq + ( const QScriptValue & other ) + + + + QScriptValueIterator + qscriptvalueiterator.html + + QScriptValueIterator + QScriptValueIterator + ( const QScriptValue & object ) + + + PropertyFlags + flags + QScriptValueIterator::flags() + + + hasNext + hasNext + () + + + hasPrevious + hasPrevious + () + + + name + name + () + + + next + next + () + + + previous + previous + () + + + remove + remove + () + + + setValue + setValue + ( const QScriptValue & value ) + + + toBack + toBack + () + + + toFront + toFront + () + + + value + value + () + + + operator= + operator-eq + ( QScriptValue & object ) + + + + QScrollArea + qscrollarea.html + + Alignment + alignment-prop + + + + QScrollArea + QScrollArea + ( QWidget * parent = 0 ) + + + ensureVisible + ensureVisible + ( int x, int y, int xmargin = 50, int ymargin = 50 ) + + + ensureWidgetVisible + ensureWidgetVisible + ( QWidget * childWidget, int xmargin = 50, int ymargin = 50 ) + + + setWidget + setWidget + ( QWidget * widget ) + + + takeWidget + takeWidget + () + + + widget + widget + () + + + 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 + () + + + + QScrollBar + qscrollbar.html + + QScrollBar + QScrollBar + ( QWidget * parent = 0 ) + + + QScrollBar + QScrollBar-2 + ( Qt::Orientation orientation, QWidget * parent = 0 ) + + + initStyleOption + initStyleOption + ( QStyleOptionSlider * option ) + + + 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 ) + + + tryAcquire + tryAcquire-2 + ( int n, int timeout ) + + + + 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 ) + + + 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-- + () + + + 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::iterator + qset-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 ) + + + + QSet + qset.html + + ConstIterator + ConstIterator-typedef + + + + Iterator + Iterator-typedef + + + + const_pointer + const_pointer-typedef + + + + const_reference + const_reference-typedef + + + + difference_type + difference_type-typedef + + + + key_type + key_type-typedef + + + + pointer + pointer-typedef + + + + reference + reference-typedef + + + + size_type + size_type-typedef + + + + value_type + value_type-typedef + + + + QSet + QSet + () + + + QSet + QSet-2 + ( const QSet<T> & other ) + + + begin + begin + () + + + begin + begin-2 + () + + + capacity + capacity + () + + + clear + clear + () + + + constBegin + constBegin + () + + + constEnd + constEnd + () + + + constFind + constFind + ( const T & value ) + + + contains + contains + ( const T & value ) + + + count + count + () + + + empty + empty + () + + + end + end + () + + + end + end-2 + () + + + erase + erase + ( iterator pos ) + + + find + find + ( const T & value ) + + + find + find-2 + ( const T & value ) + + + 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 ) + + + 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 ) + + + + 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() + + + 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 ) + + + + 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 + () + + + + QShortcutEvent + qshortcutevent.html + + QShortcutEvent + QShortcutEvent + ( const QKeySequence & key, int id, bool ambiguous = false ) + + + isAmbiguous + isAmbiguous + () + + + key + key + () + + + shortcutId + shortcutId + () + + + + QShowEvent + qshowevent.html + + QShowEvent + QShowEvent + () + + + QSignalMapper + QSignalMapper-2 + ( QObject * parent, const char * name ) + + + + 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 + () + + + + 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 ) + + + + 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-2 + ( QWidget * parent, const char * name ) + + + + 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 ) + + + ExpandData + ExpandData-enum + + + + SizeType + SizeType-typedef + + + + QSizePolicy + QSizePolicy-4 + ( Policy horizontal, Policy vertical, bool dependent ) + + + QSizePolicy + QSizePolicy-5 + ( 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 + () + + + + QSizePolicy + qsizepolicy.html + + Policy + Policy-enum + + + + PolicyFlag + PolicyFlag-enum + + + + QSizePolicy + QSizePolicy + () + + + QSizePolicy + QSizePolicy-2 + ( Policy horizontal, Policy vertical ) + + + QSizePolicy + QSizePolicy-3 + ( Policy horizontal, Policy vertical, ControlType type ) + + + controlType + controlType + () + + + Orientations + expandingDirections + QSizePolicy::expandingDirections() + + + hasHeightForWidth + hasHeightForWidth + () + + + horizontalPolicy + horizontalPolicy + () + + + horizontalStretch + horizontalStretch + () + + + setControlType + setControlType + ( ControlType type ) + + + 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-4 + ( Policy horizontal, Policy vertical, bool dependent ) + + + QSizePolicy + QSizePolicy-5 + ( 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-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 + () + + + + QSlider + qslider.html + + TickPosition + TickPosition-enum + + + + QSlider + QSlider + ( QWidget * parent = 0 ) + + + QSlider + QSlider-2 + ( Qt::Orientation orientation, QWidget * parent = 0 ) + + + initStyleOption + initStyleOption + ( QStyleOptionSlider * option ) + + + 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-2 + ( int socket, Type type, QObject * parent, const char * name ) + + + + 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 ) + + + clear + clear + () + + + filterChanged + filterChanged + () + + + + QSortFilterProxyModel + qsortfilterproxymodel.html + + CaseSensitivity + filterCaseSensitivity-prop + + + + CaseSensitivity + sortCaseSensitivity-prop + + + + QSortFilterProxyModel + QSortFilterProxyModel + ( QObject * parent = 0 ) + + + filterAcceptsColumn + filterAcceptsColumn + ( int source_column, const QModelIndex & source_parent ) + + + filterAcceptsRow + filterAcceptsRow + ( int source_row, const QModelIndex & source_parent ) + + + invalidate + invalidate + () + + + invalidateFilter + invalidateFilter + () + + + 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-2 + ( const QString & filename, QObject * parent, const char * name ) + + + available + available + () + + + + 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-2 + ( QWidget * parent, const char * name ) + + + QSpinBox + QSpinBox-3 + ( int minimum, int maximum, int step, QWidget * parent, const char * name = 0 ) + + + maxValue + maxValue + () + + + minValue + minValue + () + + + setLineStep + setLineStep + ( int step ) + + + setMaxValue + setMaxValue + ( int value ) + + + setMinValue + setMinValue + ( int value ) + + + + QSpinBox + qspinbox.html + + QSpinBox + QSpinBox + ( QWidget * parent = 0 ) + + + setRange + setRange + ( int minimum, int maximum ) + + + textFromValue + textFromValue + ( int value ) + + + 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 minimum, int maximum, int step, QWidget * parent, const char * name = 0 ) + + + maxValue + maxValue + () + + + minValue + minValue + () + + + setLineStep + setLineStep + ( int step ) + + + setMaxValue + setMaxValue + ( int value ) + + + setMinValue + setMinValue + ( int value ) + + + clear + clear + () + + + message + message + ( const QString & message, int alignment = Qt::AlignLeft, const QColor & color = Qt::black ) + + + + 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 ) + + + ResizeMode + ResizeMode-enum + + + + QSplitter + QSplitter-3 + ( QWidget * parent, const char * name ) + + + QSplitter + QSplitter-4 + ( Qt::Orientation orientation, QWidget * parent, const char * name ) + + + margin + margin + () + + + moveToFirst + moveToFirst + ( QWidget * widget ) + + + moveToLast + moveToLast + ( QWidget * widget ) + + + setCollapsible + setCollapsible-2 + ( QWidget * widget, bool collapsible ) + + + setMargin + setMargin + ( int margin ) + + + setResizeMode + setResizeMode + ( QWidget * widget, ResizeMode mode ) + + + + 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 ) + + + margin + margin + () + + + moveToFirst + moveToFirst + ( QWidget * widget ) + + + moveToLast + moveToLast + ( QWidget * widget ) + + + setCollapsible + setCollapsible-2 + ( QWidget * widget, bool collapsible ) + + + setMargin + setMargin + ( int margin ) + + + setResizeMode + setResizeMode + ( QWidget * widget, ResizeMode mode ) + + + + 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 + () + + + Confirm + Confirm-enum + + + + Op + Op-enum + + + + Location + Location-enum + + + + NumericalPrecisionPolicy + NumericalPrecisionPolicy-enum + + + + TableType + TableType-enum + + + + Confirm + Confirm-enum + + + + Op + Op-enum + + + + record + record-2 + ( const QSqlQuery & query ) + + + recordInfo + recordInfo + ( const QString & tablename ) + + + recordInfo + recordInfo-2 + ( const QSqlQuery & query ) + + + + 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 ) + + + formatValue + formatValue-2 + ( 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 ) + + + + 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 + ( 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 ) + + + formatValue + formatValue-2 + ( 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 ) + + + + QSqlDriverCreator + qsqldrivercreator.html + + + QSqlDriverCreatorBase + qsqldrivercreatorbase.html + + createObject + createObject + () + + + + QSqlDriverPlugin + qsqldriverplugin.html + + QSqlDriverPlugin + QSqlDriverPlugin + ( QObject * parent = 0 ) + + + create + create + ( const QString & key ) + + + keys + keys + () + + + + 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 ) + + + setNull + setNull + () + + + + 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 + () + + + toString + toString + ( const QString & prefix = QString() + + + toStringList + toStringList + ( const QString & prefix = QString() + + + + 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() + + + prev + prev + () + + + + QSqlQuery + qsqlquery.html + + BatchExecutionMode + BatchExecutionMode-enum + + + + 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 + () + + + execBatch + execBatch + ( BatchExecutionMode mode = ValuesAsRows ) + + + 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 + () + + + NumericalPrecisionPolicy + numericalPrecisionPolicy + QSqlQuery::numericalPrecisionPolicy() + + + prepare + prepare + ( const QString & query ) + + + previous + previous + () + + + record + record + () + + + result + result + () + + + seek + seek + ( int index, bool relative = false ) + + + setForwardOnly + setForwardOnly + ( bool forward ) + + + setNumericalPrecisionPolicy + setNumericalPrecisionPolicy + ( QSql::NumericalPrecisionPolicy precisionPolicy ) + + + size + size + () + + + value + value + ( int index ) + + + operator= + operator-eq + ( const QSqlQuery & other ) + + + prev + prev + () + + + + 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() + + + 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() + + + + 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() + + + + 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 + () + + + + 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 ) + + + + 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 ) + + + AlternateNameEntryType + AlternateNameEntryType-enum + + + + EncodingFormat + EncodingFormat-enum + + + + KeyAlgorithm + KeyAlgorithm-enum + + + + KeyType + KeyType-enum + + + + SslProtocol + SslProtocol-enum + + + + + QSslCertificate + qsslcertificate.html + + SubjectInfo + SubjectInfo-enum + + + + QSslCertificate + QSslCertificate + ( QIODevice * device, QSsl::EncodingFormat format = QSsl::Pem ) + + + QSslCertificate + QSslCertificate-2 + ( const QByteArray & data = QByteArray() + + + QSslCertificate + QSslCertificate-3 + ( const QSslCertificate & other ) + + + AlternateNameEntryType + alternateSubjectNames + , QString> QSslCertificate::alternateSubjectNames() + + + clear + clear + () + + + digest + digest + ( QCryptographicHash::Algorithm algorithm = QCryptographicHash::Md5 ) + + + effectiveDate + effectiveDate + () + + + expiryDate + expiryDate + () + + + fromData + fromData + ( const QByteArray & data, QSsl::EncodingFormat format = QSsl::Pem ) + + + fromDevice + fromDevice + ( QIODevice * device, QSsl::EncodingFormat format = QSsl::Pem ) + + + fromPath + fromPath + ( const QString & path, QSsl::EncodingFormat format = QSsl::Pem, QRegExp::PatternSyntax syntax = QRegExp::FixedString ) + + + HANDLE + handle + QSslCertificate::handle() + + + isNull + isNull + () + + + isValid + isValid + () + + + issuerInfo + issuerInfo + ( SubjectInfo subject ) + + + issuerInfo + issuerInfo-2 + ( const QByteArray & tag ) + + + publicKey + publicKey + () + + + serialNumber + serialNumber + () + + + subjectInfo + subjectInfo + ( SubjectInfo subject ) + + + subjectInfo + subjectInfo-2 + ( const QByteArray & tag ) + + + toDer + toDer + () + + + toPem + toPem + () + + + version + version + () + + + operator!= + operator-not-eq + ( const QSslCertificate & other ) + + + operator= + operator-eq + ( const QSslCertificate & other ) + + + operator== + operator-eq-eq + ( const QSslCertificate & other ) + + + + QSslCipher + qsslcipher.html + + QSslCipher + QSslCipher + () + + + QSslCipher + QSslCipher-2 + ( const QString & name, QSsl::SslProtocol protocol ) + + + QSslCipher + QSslCipher-3 + ( const QSslCipher & other ) + + + authenticationMethod + authenticationMethod + () + + + encryptionMethod + encryptionMethod + () + + + isNull + isNull + () + + + keyExchangeMethod + keyExchangeMethod + () + + + name + name + () + + + SslProtocol + protocol + QSslCipher::protocol() + + + protocolString + protocolString + () + + + supportedBits + supportedBits + () + + + usedBits + usedBits + () + + + operator!= + operator-not-eq + ( const QSslCipher & other ) + + + operator= + operator-eq + ( const QSslCipher & other ) + + + operator== + operator-eq-eq + ( const QSslCipher & other ) + + + + QSslError + qsslerror.html + + SslError + SslError-enum + + + + QSslError + QSslError + ( SslError error = NoError, const QSslCertificate & certificate = QSslCertificate() + + + QSslError + QSslError-2 + ( const QSslError & other ) + + + certificate + certificate + () + + + error + error + () + + + errorString + errorString + () + + + + QSslKey + qsslkey.html + + QSslKey + QSslKey + () + + + QSslKey + QSslKey-2 + ( const QByteArray & encoded, QSsl::KeyAlgorithm algorithm, QSsl::EncodingFormat encoding = QSsl::Pem, QSsl::KeyType type = QSsl::PrivateKey, const QByteArray & passPhrase = QByteArray() + + + QSslKey + QSslKey-3 + ( QIODevice * device, QSsl::KeyAlgorithm algorithm, QSsl::EncodingFormat encoding = QSsl::Pem, QSsl::KeyType type = QSsl::PrivateKey, const QByteArray & passPhrase = QByteArray() + + + QSslKey + QSslKey-4 + ( const QSslKey & other ) + + + KeyAlgorithm + algorithm + QSslKey::algorithm() + + + clear + clear + () + + + HANDLE + handle + QSslKey::handle() + + + isNull + isNull + () + + + length + length + () + + + toDer + toDer + ( const QByteArray & passPhrase = QByteArray() + + + toPem + toPem + ( const QByteArray & passPhrase = QByteArray() + + + KeyType + type + QSslKey::type() + + + operator!= + operator-not-eq + ( const QSslKey & other ) + + + operator= + operator-eq + ( const QSslKey & other ) + + + operator== + operator-eq-eq + ( const QSslKey & other ) + + + + QSslSocket + qsslsocket.html + + SslMode + SslMode-enum + + + + QSslSocket + QSslSocket + ( QObject * parent = 0 ) + + + abort + abort + () + + + addCaCertificate + addCaCertificate + ( const QSslCertificate & certificate ) + + + addCaCertificates + addCaCertificates + ( const QString & path, QSsl::EncodingFormat format = QSsl::Pem, QRegExp::PatternSyntax syntax = QRegExp::FixedString ) + + + addCaCertificates + addCaCertificates-2 + ( const QList<QSslCertificate> & certificates ) + + + addDefaultCaCertificate + addDefaultCaCertificate + ( const QSslCertificate & certificate ) + + + addDefaultCaCertificates + addDefaultCaCertificates + ( const QString & path, QSsl::EncodingFormat encoding = QSsl::Pem, QRegExp::PatternSyntax syntax = QRegExp::FixedString ) + + + addDefaultCaCertificates + addDefaultCaCertificates-2 + ( const QList<QSslCertificate> & certificates ) + + + caCertificates + caCertificates + () + + + ciphers + ciphers + () + + + connectToHostEncrypted + connectToHostEncrypted + ( const QString & hostName, quint16 port, OpenMode mode = ReadWrite ) + + + defaultCaCertificates + defaultCaCertificates + () + + + defaultCiphers + defaultCiphers + () + + + encrypted + encrypted + () + + + flush + flush + () + + + ignoreSslErrors + ignoreSslErrors + () + + + isEncrypted + isEncrypted + () + + + localCertificate + localCertificate + () + + + mode + mode + () + + + modeChanged + modeChanged + ( QSslSocket::SslMode mode ) + + + peerCertificate + peerCertificate + () + + + peerCertificateChain + peerCertificateChain + () + + + privateKey + privateKey + () + + + SslProtocol + protocol + QSslSocket::protocol() + + + sessionCipher + sessionCipher + () + + + setCaCertificates + setCaCertificates + ( const QList<QSslCertificate> & certificates ) + + + setCiphers + setCiphers + ( const QList<QSslCipher> & ciphers ) + + + setCiphers + setCiphers-2 + ( const QString & ciphers ) + + + setDefaultCaCertificates + setDefaultCaCertificates + ( const QList<QSslCertificate> & certificates ) + + + setDefaultCiphers + setDefaultCiphers + ( const QList<QSslCipher> & ciphers ) + + + setLocalCertificate + setLocalCertificate + ( const QSslCertificate & certificate ) + + + setLocalCertificate + setLocalCertificate-2 + ( const QString & path, QSsl::EncodingFormat format = QSsl::Pem ) + + + setPrivateKey + setPrivateKey + ( const QSslKey & key ) + + + setPrivateKey + setPrivateKey-2 + ( const QString & fileName, QSsl::KeyAlgorithm algorithm = QSsl::Rsa, QSsl::EncodingFormat format = QSsl::Pem, const QByteArray & passPhrase = QByteArray() + + + setProtocol + setProtocol + ( QSsl::SslProtocol protocol ) + + + setSocketDescriptor + setSocketDescriptor + ( int socketDescriptor, SocketState state = ConnectedState, OpenMode openMode = ReadWrite ) + + + sslErrors + sslErrors + () + + + sslErrors + sslErrors-2 + ( const QList<QSslError> & errors ) + + + startClientEncryption + startClientEncryption + () + + + startServerEncryption + startServerEncryption + () + + + supportedCiphers + supportedCiphers + () + + + supportsSsl + supportsSsl + () + + + systemCaCertificates + systemCaCertificates + () + + + waitForConnected + waitForConnected + ( int msecs = 30000 ) + + + waitForDisconnected + waitForDisconnected + ( int msecs = 30000 ) + + + waitForEncrypted + waitForEncrypted + ( int msecs = 30000 ) + + + + QStack + qstack.html + + QStack + QStack + () + + + pop + pop + () + + + push + push + ( const T & t ) + + + top + top + () + + + top + top-2 + () + + + + 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 ) + + + + QStandardItem + qstandarditem.html + + ItemType + ItemType-enum + + + + QStandardItem + QStandardItem + () + + + QStandardItem + QStandardItem-2 + ( const QString & text ) + + + QStandardItem + QStandardItem-3 + ( const QIcon & icon, const QString & text ) + + + QStandardItem + QStandardItem-4 + ( int rows, int columns = 1 ) + + + QStandardItem + QStandardItem-5 + ( const QStandardItem & other ) + + + accessibleDescription + accessibleDescription + () + + + accessibleText + accessibleText + () + + + appendColumn + appendColumn + ( const QList<QStandardItem *> & items ) + + + appendRow + appendRow + ( const QList<QStandardItem *> & items ) + + + appendRow + appendRow-2 + ( QStandardItem * item ) + + + appendRows + appendRows + ( const QList<QStandardItem *> & items ) + + + background + background + () + + + CheckState + checkState + QStandardItem::checkState() + + + child + child + ( int row, int column = 0 ) + + + clone + clone + () + + + column + column + () + + + columnCount + columnCount + () + + + data + data + ( int role = Qt::UserRole + 1 ) + + + ItemFlags + flags + QStandardItem::flags() + + + font + font + () + + + foreground + foreground + () + + + hasChildren + hasChildren + () + + + icon + icon + () + + + index + index + () + + + insertColumn + insertColumn + ( int column, const QList<QStandardItem *> & items ) + + + insertColumns + insertColumns + ( int column, int count ) + + + insertRow + insertRow + ( int row, const QList<QStandardItem *> & items ) + + + insertRow + insertRow-2 + ( int row, QStandardItem * item ) + + + insertRows + insertRows + ( int row, const QList<QStandardItem *> & items ) + + + insertRows + insertRows-2 + ( int row, int count ) + + + isCheckable + isCheckable + () + + + isDragEnabled + isDragEnabled + () + + + isDropEnabled + isDropEnabled + () + + + isEditable + isEditable + () + + + isEnabled + isEnabled + () + + + isSelectable + isSelectable + () + + + isTristate + isTristate + () + + + model + model + () + + + parent + parent + () + + + read + read + ( QDataStream & in ) + + + removeColumn + removeColumn + ( int column ) + + + removeColumns + removeColumns + ( int column, int count ) + + + removeRow + removeRow + ( int row ) + + + removeRows + removeRows + ( int row, int count ) + + + row + row + () + + + rowCount + rowCount + () + + + setAccessibleDescription + setAccessibleDescription + ( const QString & accessibleDescription ) + + + setAccessibleText + setAccessibleText + ( const QString & accessibleText ) + + + setBackground + setBackground + ( const QBrush & brush ) + + + setCheckState + setCheckState + ( Qt::CheckState state ) + + + setCheckable + setCheckable + ( bool checkable ) + + + setChild + setChild + ( int row, int column, QStandardItem * item ) + + + setChild + setChild-2 + ( int row, QStandardItem * item ) + + + setColumnCount + setColumnCount + ( int columns ) + + + setData + setData + ( const QVariant & value, int role = Qt::UserRole + 1 ) + + + setDragEnabled + setDragEnabled + ( bool dragEnabled ) + + + setDropEnabled + setDropEnabled + ( bool dropEnabled ) + + + setEditable + setEditable + ( bool editable ) + + + setEnabled + setEnabled + ( bool enabled ) + + + setFlags + setFlags + ( Qt::ItemFlags flags ) + + + setFont + setFont + ( const QFont & font ) + + + setForeground + setForeground + ( const QBrush & brush ) + + + setIcon + setIcon + ( const QIcon & icon ) + + + setRowCount + setRowCount + ( int rows ) + + + setSelectable + setSelectable + ( bool selectable ) + + + setSizeHint + setSizeHint + ( const QSize & size ) + + + setStatusTip + setStatusTip + ( const QString & statusTip ) + + + setText + setText + ( const QString & text ) + + + setTextAlignment + setTextAlignment + ( Qt::Alignment alignment ) + + + setToolTip + setToolTip + ( const QString & toolTip ) + + + setTristate + setTristate + ( bool tristate ) + + + setWhatsThis + setWhatsThis + ( const QString & whatsThis ) + + + sizeHint + sizeHint + () + + + sortChildren + sortChildren + ( int column, Qt::SortOrder order = Qt::AscendingOrder ) + + + statusTip + statusTip + () + + + takeChild + takeChild + ( int row, int column = 0 ) + + + takeColumn + takeColumn + ( int column ) + + + takeRow + takeRow + ( int row ) + + + text + text + () + + + Alignment + textAlignment + QStandardItem::textAlignment() + + + toolTip + toolTip + () + + + type + type + () + + + whatsThis + whatsThis + () + + + write + write + ( QDataStream & out ) + + + operator< + operator-lt + ( const QStandardItem & other ) + + + operator= + operator-eq + ( const QStandardItem & other ) + + + + QStandardItemEditorCreator + qstandarditemeditorcreator.html + + QStandardItemEditorCreator + QStandardItemEditorCreator + () + + + + QStandardItemModel + qstandarditemmodel.html + + QStandardItemModel + QStandardItemModel + ( QObject * parent = 0 ) + + + QStandardItemModel + QStandardItemModel-2 + ( int rows, int columns, QObject * parent = 0 ) + + + appendColumn + appendColumn + ( const QList<QStandardItem *> & items ) + + + appendRow + appendRow + ( const QList<QStandardItem *> & items ) + + + appendRow + appendRow-2 + ( QStandardItem * item ) + + + clear + clear + () + + + findItems + findItems + ( const QString & text, Qt::MatchFlags flags = Qt::MatchExactly, int column = 0 ) + + + horizontalHeaderItem + horizontalHeaderItem + ( int column ) + + + indexFromItem + indexFromItem + ( const QStandardItem * item ) + + + insertColumn + insertColumn + ( int column, const QList<QStandardItem *> & items ) + + + insertRow + insertRow + ( int row, const QList<QStandardItem *> & items ) + + + insertRow + insertRow-3 + ( int row, QStandardItem * item ) + + + invisibleRootItem + invisibleRootItem + () + + + item + item + ( int row, int column = 0 ) + + + itemChanged + itemChanged + ( QStandardItem * item ) + + + itemFromIndex + itemFromIndex + ( const QModelIndex & index ) + + + itemPrototype + itemPrototype + () + + + setColumnCount + setColumnCount + ( int columns ) + + + setHorizontalHeaderItem + setHorizontalHeaderItem + ( int column, QStandardItem * item ) + + + setHorizontalHeaderLabels + setHorizontalHeaderLabels + ( const QStringList & labels ) + + + setItem + setItem + ( int row, int column, QStandardItem * item ) + + + setItem + setItem-2 + ( int row, QStandardItem * item ) + + + setItemPrototype + setItemPrototype + ( const QStandardItem * item ) + + + setRowCount + setRowCount + ( int rows ) + + + setVerticalHeaderItem + setVerticalHeaderItem + ( int row, QStandardItem * item ) + + + setVerticalHeaderLabels + setVerticalHeaderLabels + ( const QStringList & labels ) + + + takeColumn + takeColumn + ( int column ) + + + takeHorizontalHeaderItem + takeHorizontalHeaderItem + ( int column ) + + + takeItem + takeItem + ( int row, int column = 0 ) + + + takeRow + takeRow + ( int row ) + + + takeVerticalHeaderItem + takeVerticalHeaderItem + ( int row ) + + + verticalHeaderItem + verticalHeaderItem + ( int row ) + + + 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 ) + + + + 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 + () + + + insertPermanentWidget + insertPermanentWidget + ( int index, QWidget * widget, int stretch = 0 ) + + + insertWidget + insertWidget + ( int index, QWidget * widget, int stretch = 0 ) + + + 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::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 *() + + + + QString + qstring.html + + DataPtr + DataPtr-typedef + + + + 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 + ( const QString & a1, const QString & a2, const QString & a3, const QString & a4, const QString & a5 ) + + + arg + arg-6 + ( const QString & a1, const QString & a2, const QString & a3, const QString & a4, const QString & a5, const QString & a6 ) + + + arg + arg-7 + ( const QString & a1, const QString & a2, const QString & a3, const QString & a4, const QString & a5, const QString & a6, const QString & a7 ) + + + arg + arg-8 + ( const QString & a1, const QString & a2, const QString & a3, const QString & a4, const QString & a5, const QString & a6, const QString & a7, const QString & a8 ) + + + arg + arg-9 + ( const QString & a1, const QString & a2, const QString & a3, const QString & a4, const QString & a5, const QString & a6, const QString & a7, const QString & a8, const QString & a9 ) + + + arg + arg-10 + ( int a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) + + + arg + arg-11 + ( uint a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) + + + arg + arg-12 + ( long a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) + + + arg + arg-13 + ( ulong a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) + + + arg + arg-14 + ( qlonglong a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) + + + arg + arg-15 + ( qulonglong a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) + + + arg + arg-16 + ( short a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) + + + arg + arg-17 + ( ushort a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) + + + arg + arg-18 + ( QChar a, int fieldWidth = 0, const QChar & fillChar = QLatin1Char( ' ' ) + + + arg + arg-19 + ( char a, int fieldWidth = 0, const QChar & fillChar = QLatin1Char( ' ' ) + + + arg + arg-20 + ( double a, int fieldWidth = 0, char format = 'g', int precision = -1, const QChar & fillChar = QLatin1Char( ' ' ) + + + at + at + ( int position ) + + + capacity + capacity + () + + + chop + chop + ( int n ) + + + clear + clear + () + + + compare + compare + ( const QString & s1, const QString & s2, Qt::CaseSensitivity cs ) + + + compare + compare-2 + ( const QString & s1, const QString & s2 ) + + + compare + compare-3 + ( const QString & s1, const QLatin1String & s2, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + compare + compare-4 + ( const QLatin1String & s1, const QString & s2, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + compare + compare-5 + ( const QString & other ) + + + compare + compare-6 + ( const QString & other, Qt::CaseSensitivity cs ) + + + compare + compare-7 + ( const QLatin1String & other, Qt::CaseSensitivity cs = Qt::CaseSensitive ) + + + 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 + () + + + data_ptr + data_ptr + () + + + 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 ) + + + fromUcs4 + fromUcs4 + ( const uint * unicode, int size = -1 ) + + + fromUtf8 + fromUtf8 + ( const char * str, int size = -1 ) + + + fromUtf16 + fromUtf16 + ( const ushort * unicode, int size = -1 ) + + + fromWCharArray + fromWCharArray + ( const wchar_t * string, 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 position, const QString & str ) + + + insert + insert-2 + ( int position, const QLatin1String & str ) + + + insert + insert-3 + ( int position, const QChar * unicode, int size ) + + + insert + insert-4 + ( int position, 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 n ) + + + 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 position, int n = -1 ) + + + normalized + normalized + ( NormalizationForm mode ) + + + normalized + normalized-2 + ( NormalizationForm mode, 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 format = 'g', int precision = 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 position, int n ) + + + 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 position, int n, const QString & after ) + + + replace + replace-6 + ( int position, int n, const QChar * unicode, int size ) + + + replace + replace-7 + ( int position, int n, 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 n ) + + + 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 format = 'g', int precision = 6 ) + + + setNum + setNum-10 + ( float n, char format = 'g', int precision = 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 + () + + + toCaseFolded + toCaseFolded + () + + + 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 ) + + + toUcs4 + toUcs4 + () + + + toUpper + toUpper + () + + + toUtf8 + toUtf8 + () + + + toWCharArray + toWCharArray + ( wchar_t * array ) + + + trimmed + trimmed + () + + + truncate + truncate + ( int position ) + + + 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 position ) + + + operator[] + operator-5b-5d-2 + ( int position ) + + + operator[] + operator-5b-5d-3 + ( uint position ) + + + operator[] + operator-5b-5d-4 + ( uint position ) + + + 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 *() + + + 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 ) + + + + 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 & separator ) + + + 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 ) + + + 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 ) + + + + 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 + () + + + + 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 ) + + + + QStringRef + qstringref.html + + QStringRef + QStringRef + () + + + QStringRef + QStringRef-2 + ( const QString * string, int position, int length ) + + + QStringRef + QStringRef-3 + ( const QString * string ) + + + QStringRef + QStringRef-4 + ( const QStringRef & other ) + + + appendTo + appendTo + ( QString * string ) + + + at + at + ( int position ) + + + clear + clear + () + + + constData + constData + () + + + count + count + () + + + data + data + () + + + isEmpty + isEmpty + () + + + isNull + isNull + () + + + length + length + () + + + position + position + () + + + size + size + () + + + string + string + () + + + toString + toString + () + + + unicode + unicode + () + + + operator= + operator-eq + ( const QStringRef & other ) + + + operator= + operator-eq-2 + ( const QString * string ) + + + standardPixmap + standardPixmap + ( StandardPixmap standardPixmap, const QStyleOption * option = 0, const QWidget * widget = 0 ) + + + + 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 + () + + + alignedRect + alignedRect + ( Qt::LayoutDirection direction, Qt::Alignment alignment, const QSize & size, const QRect & rectangle ) + + + combinedLayoutSpacing + combinedLayoutSpacing + ( QSizePolicy::ControlTypes controls1, QSizePolicy::ControlTypes controls2, Qt::Orientation orientation, QStyleOption * option = 0, QWidget * widget = 0 ) + + + 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 & rectangle, int alignment, const QPixmap & pixmap ) + + + drawItemText + drawItemText + ( QPainter * painter, const QRect & rectangle, int alignment, const QPalette & palette, bool enabled, const QString & text, QPalette::ColorRole textRole = QPalette::NoRole ) + + + drawPrimitive + drawPrimitive + ( PrimitiveElement element, 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 & position, const QWidget * widget = 0 ) + + + itemPixmapRect + itemPixmapRect + ( const QRect & rectangle, int alignment, const QPixmap & pixmap ) + + + itemTextRect + itemTextRect + ( const QFontMetrics & metrics, const QRect & rectangle, int alignment, bool enabled, const QString & text ) + + + layoutSpacing + layoutSpacing + ( QSizePolicy::ControlType control1, QSizePolicy::ControlType control2, Qt::Orientation orientation, const QStyleOption * option = 0, const QWidget * widget = 0 ) + + + layoutSpacingImplementation + layoutSpacingImplementation + ( QSizePolicy::ControlType control1, QSizePolicy::ControlType control2, Qt::Orientation orientation, const QStyleOption * option = 0, const QWidget * widget = 0 ) + + + pixelMetric + pixelMetric + ( PixelMetric metric, const QStyleOption * option = 0, const QWidget * widget = 0 ) + + + polish + polish + ( QWidget * widget ) + + + polish + polish-2 + ( QApplication * application ) + + + polish + polish-3 + ( QPalette & palette ) + + + 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 position, 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 + () + + + 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 * application ) + + + Alignment + visualAlignment + QStyle::visualAlignment( Qt::LayoutDirection direction, Qt::Alignment alignment ) + + + visualPos + visualPos + ( Qt::LayoutDirection direction, const QRect & boundingRectangle, const QPoint & logicalPosition ) + + + visualRect + visualRect + ( Qt::LayoutDirection direction, const QRect & boundingRectangle, const QRect & logicalRectangle ) + + + + QStyleFactory + qstylefactory.html + + create + create + ( const QString & key ) + + + keys + keys + () + + + + QStyleHintReturn + qstylehintreturn.html + + HintReturnType + HintReturnType-enum + + + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleHintReturn + QStyleHintReturn + ( int version = QStyleOption::Version, int type = SH_Default ) + + + type + type-varx + + + + version + version-var + + + + + QStyleHintReturnMask + qstylehintreturnmask.html + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleHintReturnMask + QStyleHintReturnMask + () + + + region + region-var + + + + + QStyleHintReturnVariant + qstylehintreturnvariant.html + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleHintReturnVariant + QStyleHintReturnVariant + () + + + variant + variant-var + + + + init + init + ( const QWidget * widget ) + + + + QStyleOption + qstyleoption.html + + OptionType + OptionType-enum + + + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-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 ) + + + LayoutDirection + direction-var + QStyleOption::direction + + + fontMetrics + fontMetrics-var + + + + palette + palette-var + + + + rect + rect-var + + + + State + state-var + QStyleOption::state + + + type + type-varx + + + + version + version-var + + + + + QStyleOptionButton + qstyleoptionbutton.html + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionButton + QStyleOptionButton + () + + + QStyleOptionButton + QStyleOptionButton-2 + ( const QStyleOptionButton & other ) + + + features + features-var + + + + icon + icon-var + + + + iconSize + iconSize-var + + + + text + text-var + + + + + QStyleOptionComboBox + qstyleoptioncombobox.html + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionComboBox + QStyleOptionComboBox + () + + + QStyleOptionComboBox + QStyleOptionComboBox-2 + ( const QStyleOptionComboBox & other ) + + + currentIcon + currentIcon-var + + + + currentText + currentText-var + + + + editable + editable-var + + + + frame + frame-var + + + + iconSize + iconSize-var + + + + popupRect + popupRect-var + + + + + QStyleOptionComplex + qstyleoptioncomplex.html + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionComplex + QStyleOptionComplex + ( int version = QStyleOptionComplex::Version, int type = SO_Complex ) + + + QStyleOptionComplex + QStyleOptionComplex-2 + ( const QStyleOptionComplex & other ) + + + SubControls + activeSubControls-var + QStyleOptionComplex::activeSubControls + + + SubControls + subControls-var + QStyleOptionComplex::subControls + + + + QStyleOptionDockWidget + qstyleoptiondockwidget.html + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionDockWidget + QStyleOptionDockWidget + () + + + QStyleOptionDockWidget + QStyleOptionDockWidget-2 + ( const QStyleOptionDockWidget & other ) + + + closable + closable-var + + + + floatable + floatable-var + + + + movable + movable-var + + + + title + title-var + + + + + QStyleOptionFocusRect + qstyleoptionfocusrect.html + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionFocusRect + QStyleOptionFocusRect + () + + + QStyleOptionFocusRect + QStyleOptionFocusRect-2 + ( const QStyleOptionFocusRect & other ) + + + backgroundColor + backgroundColor-var + + + + + QStyleOptionFrame + qstyleoptionframe.html + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionFrame + QStyleOptionFrame + () + + + QStyleOptionFrame + QStyleOptionFrame-2 + ( const QStyleOptionFrame & other ) + + + lineWidth + lineWidth-var + + + + midLineWidth + midLineWidth-var + + + + + QStyleOptionFrameV2 + qstyleoptionframev2.html + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionFrameV2 + QStyleOptionFrameV2 + () + + + QStyleOptionFrameV2 + QStyleOptionFrameV2-2 + ( const QStyleOptionFrameV2 & other ) + + + QStyleOptionFrameV2 + QStyleOptionFrameV2-3 + ( const QStyleOptionFrame & other ) + + + operator= + operator-eq + ( const QStyleOptionFrame & other ) + + + + QStyleOptionGraphicsItem + qstyleoptiongraphicsitem.html + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionGraphicsItem + QStyleOptionGraphicsItem + () + + + QStyleOptionGraphicsItem + QStyleOptionGraphicsItem-2 + ( const QStyleOptionGraphicsItem & other ) + + + exposedRect + exposedRect-var + + + + levelOfDetail + levelOfDetail-var + + + + matrix + matrix-var + + + + + QStyleOptionGroupBox + qstyleoptiongroupbox.html + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionGroupBox + QStyleOptionGroupBox + () + + + QStyleOptionGroupBox + QStyleOptionGroupBox-2 + ( const QStyleOptionGroupBox & other ) + + + FrameFeatures + features-var + QStyleOptionGroupBox::features + + + 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 + + + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionHeader + QStyleOptionHeader + () + + + QStyleOptionHeader + QStyleOptionHeader-2 + ( const QStyleOptionHeader & other ) + + + 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 + + + + QStyleOptionMenuItem + qstyleoptionmenuitem.html + + CheckType + CheckType-enum + + + + MenuItemType + MenuItemType-enum + + + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionMenuItem + QStyleOptionMenuItem + () + + + QStyleOptionMenuItem + QStyleOptionMenuItem-2 + ( const QStyleOptionMenuItem & other ) + + + 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 + + + + + QStyleOptionProgressBar + qstyleoptionprogressbar.html + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionProgressBar + QStyleOptionProgressBar + () + + + QStyleOptionProgressBar + QStyleOptionProgressBar-2 + ( const QStyleOptionProgressBar & other ) + + + maximum + maximum-var + + + + minimum + minimum-var + + + + progress + progress-var + + + + text + text-var + + + + Alignment + textAlignment-var + QStyleOptionProgressBar::textAlignment + + + textVisible + textVisible-var + + + + + QStyleOptionProgressBarV2 + qstyleoptionprogressbarv2.html + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + 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 + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionQ3DockWindow + QStyleOptionQ3DockWindow + () + + + QStyleOptionQ3DockWindow + QStyleOptionQ3DockWindow-2 + ( const QStyleOptionQ3DockWindow & other ) + + + closeEnabled + closeEnabled-var + + + + docked + docked-var + + + + + QStyleOptionQ3ListView + qstyleoptionq3listview.html + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionQ3ListView + QStyleOptionQ3ListView + () + + + QStyleOptionQ3ListView + QStyleOptionQ3ListView-2 + ( const QStyleOptionQ3ListView & other ) + + + 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 + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionQ3ListViewItem + QStyleOptionQ3ListViewItem + () + + + QStyleOptionQ3ListViewItem + QStyleOptionQ3ListViewItem-2 + ( const QStyleOptionQ3ListViewItem & other ) + + + childCount + childCount-var + + + + features + features-var + + + + height + height-var + + + + itemY + itemY-var + + + + totalHeight + totalHeight-var + + + + + QStyleOptionRubberBand + qstyleoptionrubberband.html + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionRubberBand + QStyleOptionRubberBand + () + + + QStyleOptionRubberBand + QStyleOptionRubberBand-2 + ( const QStyleOptionRubberBand & other ) + + + opaque + opaque-var + + + + Shape + shape-var + QStyleOptionRubberBand::shape + + + + QStyleOptionSizeGrip + qstyleoptionsizegrip.html + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionSizeGrip + QStyleOptionSizeGrip + () + + + QStyleOptionSizeGrip + QStyleOptionSizeGrip-2 + ( const QStyleOptionSizeGrip & other ) + + + Corner + corner-var + QStyleOptionSizeGrip::corner + + + + QStyleOptionSlider + qstyleoptionslider.html + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionSlider + QStyleOptionSlider + () + + + QStyleOptionSlider + QStyleOptionSlider-2 + ( const QStyleOptionSlider & other ) + + + 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 + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionSpinBox + QStyleOptionSpinBox + () + + + QStyleOptionSpinBox + QStyleOptionSpinBox-2 + ( const QStyleOptionSpinBox & other ) + + + ButtonSymbols + buttonSymbols-var + QStyleOptionSpinBox::buttonSymbols + + + frame + frame-var + + + + StepEnabled + stepEnabled-var + QStyleOptionSpinBox::stepEnabled + + + + QStyleOptionTab + qstyleoptiontab.html + + SelectedPosition + SelectedPosition-enum + + + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + TabPosition + TabPosition-enum + + + + QStyleOptionTab + QStyleOptionTab + () + + + QStyleOptionTab + QStyleOptionTab-2 + ( const QStyleOptionTab & other ) + + + cornerWidgets + cornerWidgets-var + + + + icon + icon-var + + + + position + position-var + + + + row + row-var + + + + selectedPosition + selectedPosition-var + + + + Shape + shape-var + QStyleOptionTab::shape + + + text + text-var + + + + + QStyleOptionTabBarBase + qstyleoptiontabbarbase.html + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionTabBarBase + QStyleOptionTabBarBase + () + + + QStyleOptionTabBarBase + QStyleOptionTabBarBase-2 + ( const QStyleOptionTabBarBase & other ) + + + selectedTabRect + selectedTabRect-var + + + + Shape + shape-var + QStyleOptionTabBarBase::shape + + + tabBarRect + tabBarRect-var + + + + + QStyleOptionTabV2 + qstyleoptiontabv2.html + + StyleOptionVersion + StyleOptionVersion-enum + + + + 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 + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionTabWidgetFrame + QStyleOptionTabWidgetFrame + () + + + QStyleOptionTabWidgetFrame + QStyleOptionTabWidgetFrame-2 + ( const QStyleOptionTabWidgetFrame & other ) + + + leftCornerWidgetSize + leftCornerWidgetSize-var + + + + lineWidth + lineWidth-var + + + + midLineWidth + midLineWidth-var + + + + rightCornerWidgetSize + rightCornerWidgetSize-var + + + + Shape + shape-var + QStyleOptionTabWidgetFrame::shape + + + tabBarSize + tabBarSize-var + + + + + QStyleOptionTitleBar + qstyleoptiontitlebar.html + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionTitleBar + QStyleOptionTitleBar + () + + + QStyleOptionTitleBar + QStyleOptionTitleBar-2 + ( const QStyleOptionTitleBar & other ) + + + icon + icon-var + + + + text + text-var + + + + WindowFlags + titleBarFlags-var + QStyleOptionTitleBar::titleBarFlags + + + titleBarState + titleBarState-var + + + + + QStyleOptionToolBar + qstyleoptiontoolbar.html + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + 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 + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionToolBox + QStyleOptionToolBox + () + + + QStyleOptionToolBox + QStyleOptionToolBox-2 + ( const QStyleOptionToolBox & other ) + + + icon + icon-var + + + + text + text-var + + + + + QStyleOptionToolBoxV2 + qstyleoptiontoolboxv2.html + + SelectedPosition + SelectedPosition-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + TabPosition + TabPosition-enum + + + + QStyleOptionToolBoxV2 + QStyleOptionToolBoxV2 + () + + + QStyleOptionToolBoxV2 + QStyleOptionToolBoxV2-2 + ( const QStyleOptionToolBoxV2 & other ) + + + QStyleOptionToolBoxV2 + QStyleOptionToolBoxV2-3 + ( const QStyleOptionToolBox & other ) + + + operator= + operator-eq + ( const QStyleOptionToolBox & other ) + + + selectedPosition + selectedPosition-var + + + + + QStyleOptionToolButton + qstyleoptiontoolbutton.html + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionToolButton + QStyleOptionToolButton + () + + + QStyleOptionToolButton + QStyleOptionToolButton-2 + ( const QStyleOptionToolButton & other ) + + + 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 + + + + StyleOptionType + StyleOptionType-enum + + + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionViewItem + QStyleOptionViewItem + () + + + QStyleOptionViewItem + QStyleOptionViewItem-2 + ( const QStyleOptionViewItem & other ) + + + 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 + + + + QStyleOptionViewItemV2 + qstyleoptionviewitemv2.html + + StyleOptionVersion + StyleOptionVersion-enum + + + + QStyleOptionViewItemV2 + QStyleOptionViewItemV2 + () + + + QStyleOptionViewItemV2 + QStyleOptionViewItemV2-2 + ( const QStyleOptionViewItemV2 & other ) + + + QStyleOptionViewItemV2 + QStyleOptionViewItemV2-3 + ( const QStyleOptionViewItem & other ) + + + operator= + operator-eq + ( const QStyleOptionViewItem & other ) + + + features + features-var + + + + + 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 + () + + + + QSvgGenerator + qsvggenerator.html + + QSvgGenerator + QSvgGenerator + () + + + fileName + fileName + () + + + outputDevice + outputDevice + () + + + paintEngine + paintEngine + () + + + resolution + resolution + () + + + setFileName + setFileName + ( const QString & fileName ) + + + setOutputDevice + setOutputDevice + ( QIODevice * outputDevice ) + + + setResolution + setResolution + ( int resolution ) + + + setSize + setSize + ( const QSize & size ) + + + size + size + () + + + + 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 + () + + + boundsOnElement + boundsOnElement + ( const QString & id ) + + + defaultSize + defaultSize + () + + + elementExists + elementExists + ( const QString & id ) + + + isValid + isValid + () + + + load + load + ( const QString & filename ) + + + load + load-2 + ( const QByteArray & contents ) + + + matrixForElement + matrixForElement + ( const QString & id ) + + + render + render + ( QPainter * painter ) + + + render + render-2 + ( QPainter * painter, const QRectF & bounds ) + + + render + render-3 + ( QPainter * painter, const QString & elementId, const QRectF & bounds = QRectF() + + + repaintNeeded + repaintNeeded + () + + + viewBox + viewBox + () + + + + 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 + () + + + rehighlight + rehighlight + () + + + 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 + + + + Sizes + Sizes-enum + + + + WinVersion + WinVersion-enum + + + + MacintoshVersion + MacintoshVersion-var + + + + WindowsVersion + WindowsVersion-var + + + + + QSystemLocale + qsystemlocale.html + + QueryType + QueryType-enum + + + + QSystemLocale + QSystemLocale + () + + + fallbackLocale + fallbackLocale + () + + + query + query + ( QueryType type, QVariant in ) + + + + QSystemTrayIcon + qsystemtrayicon.html + + ActivationReason + ActivationReason-enum + + + + MessageIcon + MessageIcon-enum + + + + QSystemTrayIcon + QSystemTrayIcon + ( QObject * parent = 0 ) + + + QSystemTrayIcon + QSystemTrayIcon-2 + ( const QIcon & icon, QObject * parent = 0 ) + + + activated + activated + ( QSystemTrayIcon::ActivationReason reason ) + + + contextMenu + contextMenu + () + + + geometry + geometry + () + + + hide + hide + () + + + isSystemTrayAvailable + isSystemTrayAvailable + () + + + messageClicked + messageClicked + () + + + setContextMenu + setContextMenu + ( QMenu * menu ) + + + show + show + () + + + showMessage + showMessage + ( const QString & title, const QString & message, MessageIcon icon = Information, int millisecondsTimeoutHint = 10000 ) + + + supportsMessages + supportsMessages + () + + + 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 + + + + AnchorAttribute + AnchorAttribute-enum + + + + ApplicationAttribute + ApplicationAttribute-enum + + + + ArrowType + ArrowType-enum + + + + AspectRatioMode + AspectRatioMode-enum + + + + Axis + Axis-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 + + + + DateFormat + DateFormat-enum + + + + DayOfWeek + DayOfWeek-enum + + + + Dock + Dock-enum + + + + EventPriority + EventPriority-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 + + + + ItemSelectionMode + ItemSelectionMode-enum + + + + Key + Key-enum + + + + LayoutDirection + LayoutDirection-enum + + + + MaskMode + MaskMode-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 ) + + + 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 + + + + selected + selected + ( int index ) + + + setCurrentTab + setCurrentTab + ( int index ) + + + + QTabBar + qtabbar.html + + Shape + Shape-enum + + + + TextElideMode + elideMode-prop + + + + QTabBar + QTabBar + ( QWidget * parent = 0 ) + + + addTab + addTab + ( const QString & text ) + + + addTab + addTab-2 + ( const QIcon & icon, const QString & text ) + + + currentChanged + currentChanged + ( int index ) + + + initStyleOption + initStyleOption + ( QStyleOptionTab * option, int tabIndex ) + + + 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 ) + + + tabAt + tabAt + ( const QPoint & position ) + + + 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 + () + + + sortByColumn + sortByColumn-2 + ( int column ) + + + + 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 ) + + + columnSpan + columnSpan + ( int row, int column ) + + + columnViewportPosition + columnViewportPosition + ( int column ) + + + columnWidth + columnWidth + ( int column ) + + + currentChanged + currentChanged + ( const QModelIndex & current, const QModelIndex & previous ) + + + 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 ) + + + rowSpan + rowSpan + ( int row, int column ) + + + rowViewportPosition + rowViewportPosition + ( int row ) + + + selectColumn + selectColumn + ( int column ) + + + selectRow + selectRow + ( int row ) + + + selectionChanged + selectionChanged + ( const QItemSelection & selected, const QItemSelection & deselected ) + + + 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 ) + + + setSpan + setSpan + ( int row, int column, int rowSpan, int columnSpan ) + + + setVerticalHeader + setVerticalHeader + ( QHeaderView * header ) + + + showColumn + showColumn + ( int column ) + + + showRow + showRow + ( int row ) + + + sizeHintForColumn + sizeHintForColumn + ( int column ) + + + sizeHintForRow + sizeHintForRow + ( int row ) + + + sortByColumn + sortByColumn + ( int column, Qt::SortOrder order ) + + + verticalHeader + verticalHeader + () + + + verticalOffset + verticalOffset + () + + + isItemSelected + isItemSelected + ( const QTableWidgetItem * item ) + + + setItemSelected + setItemSelected + ( const QTableWidgetItem * item, bool select ) + + + + 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 + () + + + clearContents + clearContents + () + + + 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 ) + + + findItems + findItems + ( const QString & text, Qt::MatchFlags flags ) + + + horizontalHeaderItem + horizontalHeaderItem + ( int column ) + + + indexFromItem + indexFromItem + ( QTableWidgetItem * item ) + + + insertColumn + insertColumn + ( int column ) + + + insertRow + insertRow + ( int row ) + + + 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 ) + + + removeCellWidget + removeCellWidget + ( int row, int column ) + + + 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 ) + + + 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 ) + + + backgroundColor + backgroundColor + () + + + setBackgroundColor + setBackgroundColor + ( const QColor & color ) + + + setTextColor + setTextColor + ( const QColor & color ) + + + textColor + textColor + () + + + + QTableWidgetItem + qtablewidgetitem.html + + ItemType + ItemType-enum + + + + QTableWidgetItem + QTableWidgetItem + ( int type = Type ) + + + QTableWidgetItem + QTableWidgetItem-2 + ( const QString & text, int type = Type ) + + + QTableWidgetItem + QTableWidgetItem-3 + ( const QIcon & icon, const QString & text, int type = Type ) + + + QTableWidgetItem + QTableWidgetItem-4 + ( const QTableWidgetItem & other ) + + + background + background + () + + + CheckState + checkState + QTableWidgetItem::checkState() + + + clone + clone + () + + + column + column + () + + + data + data + ( int role ) + + + ItemFlags + flags + QTableWidgetItem::flags() + + + font + font + () + + + foreground + foreground + () + + + icon + icon + () + + + isSelected + isSelected + () + + + read + read + ( QDataStream & in ) + + + row + row + () + + + setBackground + setBackground + ( const QBrush & brush ) + + + setCheckState + setCheckState + ( Qt::CheckState state ) + + + setData + setData + ( int role, const QVariant & value ) + + + setFlags + setFlags + ( Qt::ItemFlags flags ) + + + setFont + setFont + ( const QFont & font ) + + + setForeground + setForeground + ( const QBrush & brush ) + + + setIcon + setIcon + ( const QIcon & icon ) + + + setSelected + setSelected + ( bool select ) + + + setSizeHint + setSizeHint + ( const QSize & size ) + + + setStatusTip + setStatusTip + ( const QString & statusTip ) + + + setText + setText + ( const QString & text ) + + + setTextAlignment + setTextAlignment + ( int alignment ) + + + setToolTip + setToolTip + ( const QString & toolTip ) + + + setWhatsThis + setWhatsThis + ( const QString & whatsThis ) + + + sizeHint + sizeHint + () + + + statusTip + statusTip + () + + + tableWidget + tableWidget + () + + + text + text + () + + + textAlignment + textAlignment + () + + + toolTip + toolTip + () + + + type + type + () + + + whatsThis + whatsThis + () + + + write + write + ( QDataStream & out ) + + + operator< + operator-lt + ( const QTableWidgetItem & other ) + + + operator= + operator-eq + ( const QTableWidgetItem & other ) + + + + 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-2 + ( QWidget * parent, const char * name, Qt::WindowFlags 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 ) + + + selected + selected + ( const QString & tabLabel ) + + + 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 ) + + + + QTabWidget + qtabwidget.html + + TabPosition + TabPosition-enum + + + + TabShape + TabShape-enum + + + + TextElideMode + elideMode-prop + + + + QTabWidget + QTabWidget + ( QWidget * parent = 0 ) + + + addTab + addTab + ( QWidget * child, const QString & label ) + + + addTab + addTab-2 + ( QWidget * child, const QIcon & icon, const QString & label ) + + + clear + clear + () + + + cornerWidget + cornerWidget + ( Qt::Corner corner = Qt::TopRightCorner ) + + + currentChanged + currentChanged + ( int index ) + + + currentWidget + currentWidget + () + + + indexOf + indexOf + ( QWidget * w ) + + + initStyleOption + initStyleOption + ( QStyleOptionTabWidgetFrame * option ) + + + insertTab + insertTab + ( int index, QWidget * widget, const QString & label ) + + + insertTab + insertTab-4 + ( int index, QWidget * widget, 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::WindowFlags 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 ) + + + selected + selected + ( const QString & tabLabel ) + + + 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 ) + + + const_iterator + qBinaryFind-3 + qBinaryFind( const Container & container, const T & value ) + + + const_iterator + qFind-2 + qFind( const Container & container, const T & value ) + + + const_iterator + qLowerBound-3 + qLowerBound( const Container & container, const T & value ) + + + const_iterator + qUpperBound-3 + qUpperBound( const Container & container, const T & value ) + + + + 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 ) + + + 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 ) + + + toHexRepresentation + toHexRepresentation + ( const char * ba, int length ) + + + toString + toString + ( const QByteArray & ba ) + + + toString + toString-2 + ( const T & value ) + + + toString + toString-5 + ( const QLatin1String & string ) + + + toString + toString-6 + ( const QString & string ) + + + toString + toString-7 + ( const QTime & time ) + + + toString + toString-8 + ( const QDate & date ) + + + toString + toString-9 + ( const QDateTime & dateTime ) + + + toString + toString-10 + ( const QChar & character ) + + + toString + toString-11 + ( const QPoint & point ) + + + toString + toString-12 + ( const QSize & size ) + + + toString + toString-13 + ( const QRect & rectangle ) + + + toString + toString-14 + ( const QPointF & point ) + + + toString + toString-15 + ( const QSizeF & size ) + + + toString + toString-16 + ( const QRectF & rectangle ) + + + + 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 ) + + + + QTextBlock::iterator + qtextblock-iterator.html + + iterator + iterator + () + + + 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 ) + + + + QTextBlock + qtextblock.html + + Iterator + Iterator-typedef + + + + QTextBlock + QTextBlock + ( 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 ) + + + + QTextBlockFormat + qtextblockformat.html + + QTextBlockFormat + QTextBlockFormat + () + + + Alignment + alignment + QTextBlockFormat::alignment() + + + bottomMargin + bottomMargin + () + + + indent + indent + () + + + isValid + isValid + () + + + leftMargin + leftMargin + () + + + nonBreakableLines + nonBreakableLines + () + + + pageBreakPolicy + pageBreakPolicy + () + + + rightMargin + rightMargin + () + + + setAlignment + setAlignment + ( Qt::Alignment alignment ) + + + setBottomMargin + setBottomMargin + ( qreal margin ) + + + setIndent + setIndent + ( int indentation ) + + + setLeftMargin + setLeftMargin + ( qreal margin ) + + + setNonBreakableLines + setNonBreakableLines + ( bool b ) + + + setPageBreakPolicy + setPageBreakPolicy + ( PageBreakFlags policy ) + + + 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 ) + + + + QTextBlockUserData + qtextblockuserdata.html + + QTextBrowser + QTextBrowser-2 + ( QWidget * parent, const char * name ) + + + + QTextBrowser + qtextbrowser.html + + QTextBrowser + QTextBrowser + ( QWidget * parent = 0 ) + + + anchorClicked + anchorClicked + ( const QUrl & link ) + + + backward + backward + () + + + backwardAvailable + backwardAvailable + ( bool available ) + + + clearHistory + clearHistory + () + + + forward + forward + () + + + forwardAvailable + forwardAvailable + ( bool available ) + + + highlighted + highlighted + ( const QUrl & link ) + + + highlighted + highlighted-2 + ( const QString & link ) + + + home + home + () + + + isBackwardAvailable + isBackwardAvailable + () + + + isForwardAvailable + isForwardAvailable + () + + + 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 ) + + + anchorName + anchorName + () + + + setAnchorName + setAnchorName + ( const QString & name ) + + + + QTextCharFormat + qtextcharformat.html + + UnderlineStyle + UnderlineStyle-enum + + + + VerticalAlignment + VerticalAlignment-enum + + + + QTextCharFormat + QTextCharFormat + () + + + anchorHref + anchorHref + () + + + anchorNames + anchorNames + () + + + 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 ) + + + setAnchorNames + setAnchorNames + ( const QStringList & names ) + + + 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 ) + + + setTextOutline + setTextOutline + ( const QPen & pen ) + + + setToolTip + setToolTip + ( const QString & text ) + + + setUnderlineColor + setUnderlineColor + ( const QColor & color ) + + + setUnderlineStyle + setUnderlineStyle + ( UnderlineStyle style ) + + + setVerticalAlignment + setVerticalAlignment + ( VerticalAlignment alignment ) + + + textOutline + textOutline + () + + + toolTip + toolTip + () + + + underlineColor + underlineColor + () + + + underlineStyle + underlineStyle + () + + + verticalAlignment + verticalAlignment + () + + + + QTextCodec::ConverterState + qtextcodec-converterstate.html + + ConverterState + ConverterState + ( ConversionFlags flags = DefaultConversion ) + + + 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 ) + + + + 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 * codec ) + + + 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 ) + + + 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 ) + + + + QTextCodecPlugin + qtextcodecplugin.html + + QTextCodecPlugin + QTextCodecPlugin + ( QObject * parent = 0 ) + + + aliases + aliases + () + + + createForMib + createForMib + ( int mib ) + + + createForName + createForName + ( const QByteArray & name ) + + + mibEnums + mibEnums + () + + + names + names + () + + + + 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 + () + + + blockNumber + blockNumber + () + + + charFormat + charFormat + () + + + clearSelection + clearSelection + () + + + columnNumber + columnNumber + () + + + 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 ) + + + insertHtml + insertHtml + ( const QString & html ) + + + insertImage + insertImage + ( const QTextImageFormat & format ) + + + insertImage + insertImage-2 + ( const QTextImageFormat & format, QTextFrameFormat::Position alignment ) + + + insertImage + insertImage-3 + ( 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 + ( QString * target, const char * chars, int len ) + + + toUnicode + toUnicode-3 + ( const QByteArray & ba ) + + + + 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 ) + + + adjustSize + adjustSize + () + + + allFormats + allFormats + () + + + begin + begin + () + + + blockCountChanged + blockCountChanged + ( int newBlockCount ) + + + 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 + () + + + drawContents + drawContents + ( QPainter * p, const QRectF & rect = QRectF() + + + end + end + () + + + find + find + ( const QString & subString, const QTextCursor & cursor, FindFlags options = 0 ) + + + find + find-2 + ( const QRegExp & expr, const QTextCursor & cursor, FindFlags options = 0 ) + + + find + find-3 + ( const QString & subString, int position = 0, FindFlags options = 0 ) + + + find + find-4 + ( const QRegExp & expr, int position = 0, FindFlags options = 0 ) + + + findBlock + findBlock + ( int pos ) + + + idealWidth + idealWidth + () + + + 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 + ( QTextCursor * cursor ) + + + redo + redo-2 + () + + + 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 + ( QTextCursor * cursor ) + + + undo + undo-2 + () + + + undoAvailable + undoAvailable + ( bool available ) + + + + 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 ) + + + fromHtml + fromHtml-2 + ( const QString & text, const QTextDocument * resourceProvider ) + + + fromPlainText + fromPlainText + ( const QString & plainText ) + + + isEmpty + isEmpty + () + + + toHtml + toHtml + ( const QByteArray & encoding ) + + + toHtml + toHtml-2 + () + + + toPlainText + toPlainText + () + + + operator= + operator-eq + ( const QTextDocumentFragment & other ) + + + + QTextEdit::ExtraSelection + qtextedit-extraselection.html + + cursor + cursor-var + + + + format + format-var + + + + 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-2 + ( CursorAction action, QTextCursor::MoveMode mode = QTextCursor::MoveAnchor ) + + + moveCursor + moveCursor-3 + ( CursorAction action, bool select ) + + + pointSize + pointSize + () + + + redo + redo-2 + () + + + 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 ) + + + setTextFormat + setTextFormat + ( Qt::TextFormat f ) + + + setUnderline + setUnderline + ( bool b ) + + + sync + sync + () + + + text + text + () + + + TextFormat + textFormat + QTextEdit::textFormat() + + + underline + underline + () + + + undo + undo-2 + () + + + + QTextEdit + qtextedit.html + + CursorAction + CursorAction-enum + + + + LineWrapMode + LineWrapMode-enum + + + + TextInteractionFlags + textInteractionFlags-prop + + + + 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 ) + + + canPaste + canPaste + () + + + clear + clear + () + + + contextMenuEvent + contextMenuEvent + ( QContextMenuEvent * event ) + + + 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 + () + + + extraSelections + extraSelections + () + + + 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 ) + + + moveCursor + moveCursor + ( QTextCursor::MoveOperation operation, QTextCursor::MoveMode mode = QTextCursor::MoveAnchor ) + + + paste + paste + () + + + print + print + ( QPrinter * printer ) + + + redo + redo + () + + + 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 ) + + + setExtraSelections + setExtraSelections + ( const QList<ExtraSelection> & selections ) + + + setFontFamily + setFontFamily + ( const QString & fontFamily ) + + + setFontItalic + setFontItalic + ( bool italic ) + + + setFontPointSize + setFontPointSize + ( qreal s ) + + + setFontUnderline + setFontUnderline + ( bool underline ) + + + setFontWeight + setFontWeight + ( int weight ) + + + setText + setText + ( const QString & text ) + + + setTextColor + setTextColor + ( const QColor & c ) + + + setTextCursor + setTextCursor + ( const QTextCursor & cursor ) + + + textChanged + textChanged + () + + + textColor + textColor + () + + + textCursor + textCursor + () + + + undo + undo + () + + + 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-2 + ( CursorAction action, QTextCursor::MoveMode mode = QTextCursor::MoveAnchor ) + + + moveCursor + moveCursor-3 + ( CursorAction action, bool select ) + + + pointSize + pointSize + () + + + redo + redo-2 + () + + + 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 ) + + + setTextFormat + setTextFormat + ( Qt::TextFormat f ) + + + setUnderline + setUnderline + ( bool b ) + + + sync + sync + () + + + text + text + () + + + TextFormat + textFormat + QTextEdit::textFormat() + + + underline + underline + () + + + undo + undo-2 + () + + + + 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 ) + + + propertyCount + propertyCount + () + + + 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 + () + + + 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 ) + + + + QTextFrame::iterator + qtextframe-iterator.html + + iterator + iterator + () + + + 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 ) + + + + 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 ) + + + + QTextFrameFormat + qtextframeformat.html + + BorderStyle + BorderStyle-enum + + + + Position + Position-enum + + + + QTextFrameFormat + QTextFrameFormat + () + + + border + border + () + + + borderBrush + borderBrush + () + + + borderStyle + borderStyle + () + + + bottomMargin + bottomMargin + () + + + height + height + () + + + isValid + isValid + () + + + leftMargin + leftMargin + () + + + margin + margin + () + + + padding + padding + () + + + pageBreakPolicy + pageBreakPolicy + () + + + position + position + () + + + rightMargin + rightMargin + () + + + setBorder + setBorder + ( qreal width ) + + + setBorderBrush + setBorderBrush + ( const QBrush & brush ) + + + setBorderStyle + setBorderStyle + ( BorderStyle style ) + + + setBottomMargin + setBottomMargin + ( qreal margin ) + + + setHeight + setHeight + ( const QTextLength & height ) + + + setHeight + setHeight-2 + ( qreal height ) + + + setLeftMargin + setLeftMargin + ( qreal margin ) + + + setMargin + setMargin + ( qreal margin ) + + + setPadding + setPadding + ( qreal width ) + + + setPageBreakPolicy + setPageBreakPolicy + ( PageBreakFlags policy ) + + + setPosition + setPosition + ( Position policy ) + + + setRightMargin + setRightMargin + ( qreal margin ) + + + setTopMargin + setTopMargin + ( qreal margin ) + + + setWidth + setWidth + ( const QTextLength & width ) + + + setWidth + setWidth-2 + ( qreal width ) + + + topMargin + topMargin + () + + + width + width + () + + + + 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 + + format + format-var + + + + length + length-var + + + + start + start-var + + + + + 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, int width ) + + + drawCursor + drawCursor-2 + ( 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 + () + + + position + position + () + + + rect + rect + () + + + setLineWidth + setLineWidth + ( qreal width ) + + + setNumColumns + setNumColumns + ( int numColumns ) + + + setNumColumns + setNumColumns-2 + ( int numColumns, qreal alignmentWidth ) + + + setPosition + setPosition + ( const QPointF & pos ) + + + textLength + textLength + () + + + textStart + textStart + () + + + width + width + () + + + x + x + () + + + xToCursor + xToCursor + ( qreal x, CursorPosition cpos = CursorBetweenCharacters ) + + + y + y + () + + + isEmpty + isEmpty + () + + + + 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 ) + + + + QTextListFormat + qtextlistformat.html + + Style + Style-enum + + + + QTextListFormat + QTextListFormat + () + + + indent + indent + () + + + isValid + isValid + () + + + setIndent + setIndent + ( int indentation ) + + + setStyle + setStyle + ( Style style ) + + + style + style + () + + + + 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 ) + + + 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 + + + + + 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 + () + + + pos + pos + () + + + 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 + + + + + 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 ) + + + + 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 + () + + + setFormat + setFormat + ( const QTextCharFormat & format ) + + + 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 + () + + + headerRowCount + headerRowCount + () + + + isValid + isValid + () + + + setAlignment + setAlignment + ( Qt::Alignment alignment ) + + + setCellPadding + setCellPadding + ( qreal padding ) + + + setCellSpacing + setCellSpacing + ( qreal spacing ) + + + setColumnWidthConstraints + setColumnWidthConstraints + ( const QVector<QTextLength> & constraints ) + + + setHeaderRowCount + setHeaderRowCount + ( int count ) + + + finished + finished-2 + () + + + running + running + () + + + + 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 + () + + + idealThreadCount + idealThreadCount + () + + + 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 + ( Priority 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 ) + + + currentTime + currentTime-2 + ( Qt::TimeSpec specification ) + + + + 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 s ) + + + currentTime + currentTime + () + + + 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-2 + ( Qt::TimeSpec specification ) + + + + QTimeEdit + qtimeedit.html + + QTimeEdit + QTimeEdit + ( QWidget * parent = 0 ) + + + QTimeEdit + QTimeEdit-2 + ( const QTime & time, QWidget * parent = 0 ) + + + + QTimeLine + qtimeline.html + + CurveShape + CurveShape-enum + + + + Direction + Direction-enum + + + + State + State-enum + + + + QTimeLine + QTimeLine + ( int duration = 1000, QObject * parent = 0 ) + + + currentFrame + currentFrame + () + + + currentValue + currentValue + () + + + endFrame + endFrame + () + + + finished + finished + () + + + frameChanged + frameChanged + ( int frame ) + + + frameForTime + frameForTime + ( int msec ) + + + resume + resume + () + + + setEndFrame + setEndFrame + ( int frame ) + + + setFrameRange + setFrameRange + ( int startFrame, int endFrame ) + + + setPaused + setPaused + ( bool paused ) + + + setStartFrame + setStartFrame + ( int frame ) + + + start + start + () + + + startFrame + startFrame + () + + + state + state + () + + + stateChanged + stateChanged + ( QTimeLine::State newState ) + + + stop + stop + () + + + toggleDirection + toggleDirection + () + + + valueChanged + valueChanged + ( qreal value ) + + + valueForTime + valueForTime + ( int msec ) + + + QTimer + QTimer-2 + ( QObject * parent, const char * name ) + + + changeInterval + changeInterval + ( int msec ) + + + start + start-3 + ( int msec, bool sshot ) + + + + QTimer + qtimer.html + + QTimer + QTimer + ( QObject * parent = 0 ) + + + 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 ) + + + + QTimerEvent + qtimerevent.html + + QTimerEvent + QTimerEvent + ( int timerId ) + + + timerId + timerId + () + + + QToolBar + QToolBar-3 + ( QWidget * parent, const char * name ) + + + label + label + () + + + setLabel + setLabel + ( const QString & label ) + + + + 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 ) + + + widgetForAction + widgetForAction + ( QAction * action ) + + + QToolBar + QToolBar-3 + ( QWidget * parent, const char * name ) + + + label + label + () + + + setLabel + setLabel + ( const QString & label ) + + + QToolBox + QToolBox-2 + ( QWidget * parent, const char * name, Qt::WindowFlags f = 0 ) + + + currentItem + currentItem + () + + + item + item + ( int index ) + + + itemIconSet + itemIconSet + ( int index ) + + + itemLabel + itemLabel + ( int index ) + + + margin + margin + () + + + removeItem + removeItem-2 + ( QWidget * widget ) + + + setCurrentItem + setCurrentItem + ( QWidget * widget ) + + + setItemIconSet + setItemIconSet + ( int index, const QIcon & icon ) + + + setItemLabel + setItemLabel + ( int index, const QString & text ) + + + setMargin + setMargin + ( int margin ) + + + + QToolBox + qtoolbox.html + + QToolBox + QToolBox + ( QWidget * parent = 0, Qt::WindowFlags 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::WindowFlags f = 0 ) + + + currentItem + currentItem + () + + + item + item + ( int index ) + + + itemIconSet + itemIconSet + ( int index ) + + + itemLabel + itemLabel + ( int index ) + + + margin + margin + () + + + removeItem + removeItem-2 + ( QWidget * widget ) + + + setCurrentItem + setCurrentItem + ( QWidget * widget ) + + + setItemIconSet + setItemIconSet + ( int index, const QIcon & icon ) + + + setItemLabel + setItemLabel + ( int index, const QString & text ) + + + setMargin + setMargin + ( int margin ) + + + 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 + () + + + + QToolButton + qtoolbutton.html + + ToolButtonPopupMode + ToolButtonPopupMode-enum + + + + ArrowType + arrowType-prop + + + + ToolButtonStyle + toolButtonStyle-prop + + + + QToolButton + QToolButton + ( QWidget * parent = 0 ) + + + defaultAction + defaultAction + () + + + initStyleOption + initStyleOption + ( QStyleOptionToolButton * option ) + + + 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 + () + + + add + add + ( QWidget * widget, const QString & text ) + + + add + add-2 + ( QWidget * widget, const QRect & rect, const QString & text ) + + + remove + remove + ( QWidget * widget ) + + + + QToolTip + qtooltip.html + + font + font + () + + + hideText + hideText + () + + + palette + palette + () + + + setFont + setFont + ( const QFont & font ) + + + setPalette + setPalette + ( const QPalette & palette ) + + + showText + showText + ( const QPoint & pos, const QString & text, QWidget * w, const QRect & rect ) + + + showText + showText-2 + ( 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 ) + + + + QTransform + qtransform.html + + TransformationType + TransformationType-enum + + + + QTransform + QTransform + () + + + QTransform + QTransform-2 + ( qreal h11, qreal h12, qreal h13, qreal h21, qreal h22, qreal h23, qreal h31, qreal h32, qreal h33 = 1.0 ) + + + QTransform + QTransform-3 + ( qreal h11, qreal h12, qreal h21, qreal h22, qreal dx, qreal dy ) + + + QTransform + QTransform-4 + ( const QMatrix & matrix ) + + + m11 + m11 + () + + + m12 + m12 + () + + + m13 + m13 + () + + + m21 + m21 + () + + + m22 + m22 + () + + + m23 + m23 + () + + + m31 + m31 + () + + + m32 + m32 + () + + + m33 + m33 + () + + + adjoint + adjoint + () + + + det + det + () + + + determinant + determinant + () + + + dx + dx + () + + + dy + dy + () + + + inverted + inverted + ( bool * invertible = 0 ) + + + isAffine + isAffine + () + + + isIdentity + isIdentity + () + + + isInvertible + isInvertible + () + + + isRotating + isRotating + () + + + isScaling + isScaling + () + + + isTranslating + isTranslating + () + + + map + map + ( qreal x, qreal y, qreal * tx, qreal * ty ) + + + map + map-2 + ( const QPointF & p ) + + + map + map-3 + ( const QPoint & point ) + + + map + map-4 + ( const QLine & l ) + + + map + map-5 + ( const QLineF & line ) + + + map + map-6 + ( const QPolygonF & polygon ) + + + map + map-7 + ( const QPolygon & polygon ) + + + map + map-8 + ( const QRegion & region ) + + + map + map-9 + ( const QPainterPath & path ) + + + map + map-10 + ( int x, int y, int * tx, int * ty ) + + + mapRect + mapRect + ( const QRectF & rectangle ) + + + mapRect + mapRect-2 + ( const QRect & rectangle ) + + + mapToPolygon + mapToPolygon + ( const QRect & rectangle ) + + + quadToQuad + quadToQuad + ( const QPolygonF & one, const QPolygonF & two, QTransform & trans ) + + + quadToSquare + quadToSquare + ( const QPolygonF & quad, QTransform & trans ) + + + reset + reset + () + + + rotate + rotate + ( qreal angle, Qt::Axis axis = Qt::ZAxis ) + + + rotateRadians + rotateRadians + ( qreal angle, Qt::Axis axis = Qt::ZAxis ) + + + scale + scale + ( qreal sx, qreal sy ) + + + setMatrix + setMatrix + ( qreal m11, qreal m12, qreal m13, qreal m21, qreal m22, qreal m23, qreal m31, qreal m32, qreal m33 ) + + + shear + shear + ( qreal sh, qreal sv ) + + + squareToQuad + squareToQuad + ( const QPolygonF & quad, QTransform & trans ) + + + toAffine + toAffine + () + + + translate + translate + ( qreal dx, qreal dy ) + + + transposed + transposed + () + + + type + type + () + + + operator + operator-QVariant + QVariant() + + + operator!= + operator-not-eq + ( const QTransform & matrix ) + + + operator* + operator-2a + ( const QTransform & matrix ) + + + operator*= + operator-2a-eq + ( const QTransform & matrix ) + + + operator*= + operator-2a-eq-2 + ( qreal scalar ) + + + operator+= + operator-2b-eq + ( qreal scalar ) + + + operator-= + operator--eq + ( qreal scalar ) + + + operator/= + operator-2f-eq + ( qreal scalar ) + + + operator= + operator-eq + ( const QTransform & matrix ) + + + operator== + operator-eq-eq + ( const QTransform & matrix ) + + + QTranslator + QTranslator-2 + ( QObject * parent, const char * name ) + + + find + find + ( const char * context, const char * sourceText, const char * comment = 0 ) + + + + 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 ) + + + translate + translate-2 + ( const char * context, const char * sourceText, const char * comment, int n ) + + + QTranslator + QTranslator-2 + ( QObject * parent, const char * name ) + + + find + find + ( const char * context, const char * sourceText, const char * comment = 0 ) + + + sortByColumn + sortByColumn-2 + ( int column ) + + + + QTreeView + qtreeview.html + + QTreeView + QTreeView + ( QWidget * parent = 0 ) + + + collapse + collapse + ( const QModelIndex & index ) + + + collapseAll + collapseAll + () + + + 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 ) + + + currentChanged + currentChanged + ( const QModelIndex & current, const QModelIndex & previous ) + + + drawBranches + drawBranches + ( QPainter * painter, const QRect & rect, const QModelIndex & index ) + + + drawRow + drawRow + ( QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index ) + + + drawTree + drawTree + ( QPainter * painter, const QRegion & region ) + + + expand + expand + ( const QModelIndex & index ) + + + expandAll + expandAll + () + + + expandToDepth + expandToDepth + ( int depth ) + + + 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 ) + + + isFirstColumnSpanned + isFirstColumnSpanned + ( int row, const QModelIndex & parent ) + + + isRowHidden + isRowHidden + ( int row, const QModelIndex & parent ) + + + moveCursor + moveCursor + ( CursorAction cursorAction, Qt::KeyboardModifiers modifiers ) + + + resizeColumnToContents + resizeColumnToContents + ( int column ) + + + rowHeight + rowHeight + ( const QModelIndex & index ) + + + 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 + () + + + selectionChanged + selectionChanged + ( const QItemSelection & selected, const QItemSelection & deselected ) + + + setColumnHidden + setColumnHidden + ( int column, bool hide ) + + + setColumnWidth + setColumnWidth + ( int column, int width ) + + + setExpanded + setExpanded + ( const QModelIndex & index, bool expanded ) + + + setFirstColumnSpanned + setFirstColumnSpanned + ( int row, const QModelIndex & parent, bool span ) + + + 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, Qt::SortOrder order ) + + + verticalOffset + verticalOffset + () + + + visualRect + visualRect + ( const QModelIndex & index ) + + + visualRegionForSelection + visualRegionForSelection + ( const QItemSelection & selection ) + + + isItemExpanded + isItemExpanded + ( const QTreeWidgetItem * item ) + + + isItemHidden + isItemHidden + ( const QTreeWidgetItem * item ) + + + isItemSelected + isItemSelected + ( const QTreeWidgetItem * item ) + + + items + items + ( const QMimeData * data ) + + + setItemExpanded + setItemExpanded + ( const QTreeWidgetItem * item, bool expand ) + + + setItemHidden + setItemHidden + ( const QTreeWidgetItem * item, bool hide ) + + + setItemSelected + setItemSelected + ( const QTreeWidgetItem * item, bool select ) + + + + 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 ) + + + 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 ) + + + invisibleRootItem + invisibleRootItem + () + + + isFirstItemColumnSpanned + isFirstItemColumnSpanned + ( const QTreeWidgetItem * item ) + + + itemAbove + itemAbove + ( const QTreeWidgetItem * item ) + + + itemActivated + itemActivated + ( QTreeWidgetItem * item, int column ) + + + itemAt + itemAt + ( const QPoint & p ) + + + itemAt + itemAt-2 + ( int x, int y ) + + + itemBelow + itemBelow + ( const QTreeWidgetItem * item ) + + + 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 ) + + + mimeData + mimeData + ( const QList<QTreeWidgetItem *> items ) + + + mimeTypes + mimeTypes + () + + + openPersistentEditor + openPersistentEditor + ( QTreeWidgetItem * item, int column = 0 ) + + + removeItemWidget + removeItemWidget + ( QTreeWidgetItem * item, int column ) + + + scrollToItem + scrollToItem + ( const QTreeWidgetItem * item, QAbstractItemView::ScrollHint hint = EnsureVisible ) + + + selectedItems + selectedItems + () + + + setCurrentItem + setCurrentItem + ( QTreeWidgetItem * item ) + + + setCurrentItem + setCurrentItem-2 + ( QTreeWidgetItem * item, int column ) + + + setFirstItemColumnSpanned + setFirstItemColumnSpanned + ( const QTreeWidgetItem * item, bool span ) + + + setHeaderItem + setHeaderItem + ( QTreeWidgetItem * item ) + + + setHeaderLabel + setHeaderLabel + ( const QString & label ) + + + setHeaderLabels + setHeaderLabels + ( const QStringList & labels ) + + + 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 ) + + + backgroundColor + backgroundColor + ( int column ) + + + setBackgroundColor + setBackgroundColor + ( int column, const QColor & color ) + + + setTextColor + setTextColor + ( int column, const QColor & color ) + + + textColor + textColor + ( int column ) + + + + QTreeWidgetItem + qtreewidgetitem.html + + ChildIndicatorPolicy + ChildIndicatorPolicy-enum + + + + ItemType + ItemType-enum + + + + 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 ) + + + background + background + ( int column ) + + + CheckState + checkState + QTreeWidgetItem::checkState( int column ) + + + child + child + ( int index ) + + + childCount + childCount + () + + + ChildIndicatorPolicy + childIndicatorPolicy + QTreeWidgetItem::childIndicatorPolicy() + + + clone + clone + () + + + columnCount + columnCount + () + + + data + data + ( int column, int role ) + + + ItemFlags + flags + QTreeWidgetItem::flags() + + + font + font + ( int column ) + + + foreground + foreground + ( int column ) + + + icon + icon + ( int column ) + + + indexOfChild + indexOfChild + ( QTreeWidgetItem * child ) + + + insertChild + insertChild + ( int index, QTreeWidgetItem * child ) + + + insertChildren + insertChildren + ( int index, const QList<QTreeWidgetItem *> & children ) + + + isDisabled + isDisabled + () + + + isExpanded + isExpanded + () + + + isFirstColumnSpanned + isFirstColumnSpanned + () + + + isHidden + isHidden + () + + + isSelected + isSelected + () + + + parent + parent + () + + + read + read + ( QDataStream & in ) + + + removeChild + removeChild + ( QTreeWidgetItem * child ) + + + setBackground + setBackground + ( int column, const QBrush & brush ) + + + setCheckState + setCheckState + ( int column, Qt::CheckState state ) + + + setChildIndicatorPolicy + setChildIndicatorPolicy + ( QTreeWidgetItem::ChildIndicatorPolicy policy ) + + + setData + setData + ( int column, int role, const QVariant & value ) + + + setDisabled + setDisabled + ( bool disabled ) + + + setExpanded + setExpanded + ( bool expand ) + + + setFirstColumnSpanned + setFirstColumnSpanned + ( bool span ) + + + setFlags + setFlags + ( Qt::ItemFlags flags ) + + + setFont + setFont + ( int column, const QFont & font ) + + + setForeground + setForeground + ( int column, const QBrush & brush ) + + + setHidden + setHidden + ( bool hide ) + + + setIcon + setIcon + ( int column, const QIcon & icon ) + + + setSelected + setSelected + ( bool select ) + + + 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 ) + + + setToolTip + setToolTip + ( int column, const QString & toolTip ) + + + setWhatsThis + setWhatsThis + ( int column, const QString & whatsThis ) + + + sizeHint + sizeHint + ( int column ) + + + sortChildren + sortChildren + ( int column, Qt::SortOrder order ) + + + statusTip + statusTip + ( int column ) + + + takeChild + takeChild + ( int index ) + + + takeChildren + takeChildren + () + + + text + text + ( int column ) + + + textAlignment + textAlignment + ( 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 ) + + + + 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 + () + + + setWorkingDirectory + setWorkingDirectory + ( const QDir & dir ) + + + workingDirectory + workingDirectory + () + + + + QUndoCommand + qundocommand.html + + QUndoCommand + QUndoCommand + ( QUndoCommand * parent = 0 ) + + + QUndoCommand + QUndoCommand-2 + ( const QString & text, QUndoCommand * parent = 0 ) + + + id + id + () + + + mergeWith + mergeWith + ( const QUndoCommand * command ) + + + redo + redo + () + + + setText + setText + ( const QString & text ) + + + text + text + () + + + undo + undo + () + + + + QUndoGroup + qundogroup.html + + QUndoGroup + QUndoGroup + ( QObject * parent = 0 ) + + + activeStack + activeStack + () + + + activeStackChanged + activeStackChanged + ( QUndoStack * stack ) + + + addStack + addStack + ( QUndoStack * stack ) + + + canRedo + canRedo + () + + + canRedoChanged + canRedoChanged + ( bool canRedo ) + + + canUndo + canUndo + () + + + canUndoChanged + canUndoChanged + ( bool canUndo ) + + + cleanChanged + cleanChanged + ( bool clean ) + + + createRedoAction + createRedoAction + ( QObject * parent, const QString & prefix = QString() + + + createUndoAction + createUndoAction + ( QObject * parent, const QString & prefix = QString() + + + indexChanged + indexChanged + ( int idx ) + + + isClean + isClean + () + + + redo + redo + () + + + redoText + redoText + () + + + redoTextChanged + redoTextChanged + ( const QString & redoText ) + + + removeStack + removeStack + ( QUndoStack * stack ) + + + setActiveStack + setActiveStack + ( QUndoStack * stack ) + + + stacks + stacks + () + + + undo + undo + () + + + undoText + undoText + () + + + undoTextChanged + undoTextChanged + ( const QString & undoText ) + + + + QUndoStack + qundostack.html + + QUndoStack + QUndoStack + ( QObject * parent = 0 ) + + + beginMacro + beginMacro + ( const QString & text ) + + + canRedo + canRedo + () + + + canRedoChanged + canRedoChanged + ( bool canUndo ) + + + canUndo + canUndo + () + + + canUndoChanged + canUndoChanged + ( bool canUndo ) + + + cleanChanged + cleanChanged + ( bool clean ) + + + cleanIndex + cleanIndex + () + + + clear + clear + () + + + count + count + () + + + createRedoAction + createRedoAction + ( QObject * parent, const QString & prefix = QString() + + + createUndoAction + createUndoAction + ( QObject * parent, const QString & prefix = QString() + + + endMacro + endMacro + () + + + index + index + () + + + indexChanged + indexChanged + ( int idx ) + + + isClean + isClean + () + + + push + push + ( QUndoCommand * cmd ) + + + redo + redo + () + + + redoText + redoText + () + + + redoTextChanged + redoTextChanged + ( const QString & redoText ) + + + setClean + setClean + () + + + setIndex + setIndex + ( int idx ) + + + text + text + ( int idx ) + + + undo + undo + () + + + undoText + undoText + () + + + undoTextChanged + undoTextChanged + ( const QString & undoText ) + + + + QUndoView + qundoview.html + + QUndoView + QUndoView + ( QWidget * parent = 0 ) + + + QUndoView + QUndoView-2 + ( QUndoStack * stack, QWidget * parent = 0 ) + + + QUndoView + QUndoView-3 + ( QUndoGroup * group, QWidget * parent = 0 ) + + + group + group + () + + + setGroup + setGroup + ( QUndoGroup * group ) + + + setStack + setStack + ( QUndoStack * stack ) + + + stack + stack + () + + + fromPunycode + fromPunycode + ( const QByteArray & pc ) + + + toPunycode + toPunycode + ( const QString & uc ) + + + 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() + + + + QUrl + qurl.html + + DataPtr + DataPtr-typedef + + + + 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 + () + + + data_ptr + data_ptr + () + + + encodedQuery + encodedQuery + () + + + errorString + errorString + () + + + fragment + fragment + () + + + fromAce + fromAce + ( const QByteArray & domain ) + + + fromEncoded + fromEncoded + ( const QByteArray & input ) + + + fromEncoded + fromEncoded-2 + ( const QByteArray & input, ParsingMode parsingMode ) + + + fromLocalFile + fromLocalFile + ( const QString & localFile ) + + + fromPercentEncoding + fromPercentEncoding + ( const QByteArray & input ) + + + hasFragment + hasFragment + () + + + hasQuery + hasQuery + () + + + hasQueryItem + hasQueryItem + ( const QString & key ) + + + host + host + () + + + idnWhitelist + idnWhitelist + () + + + 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 ) + + + setIdnWhitelist + setIdnWhitelist + ( const QStringList & list ) + + + 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 ) + + + toAce + toAce + ( const QString & domain ) + + + toEncoded + toEncoded + ( FormattingOptions options = None ) + + + toLocalFile + toLocalFile + () + + + toPercentEncoding + toPercentEncoding + ( const QString & input, const QByteArray & exclude = QByteArray() + + + 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 ) + + + 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() + + + + 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-not-eq + ( const QUrlInfo & other ) + + + operator= + operator-eq + ( const QUrlInfo & ui ) + + + operator== + operator-eq-eq + ( const QUrlInfo & other ) + + + + 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-2 + ( QObject * parent, const char * name ) + + + + QValidator + qvalidator.html + + State + State-enum + + + + QValidator + QValidator + ( QObject * parent ) + + + fixup + fixup + ( QString & input ) + + + locale + locale + () + + + setLocale + setLocale + ( const QLocale & locale ) + + + validate + validate + ( QString & input, int & pos ) + + + QValidator + QValidator-2 + ( QObject * parent, const char * name ) + + + QVariant + QVariant-36 + ( 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 + () + + + + QVariant + qvariant.html + + DataPtr + DataPtr-typedef + + + + 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 ) + + + QVariant + QVariant-35 + ( Qt::GlobalColor color ) + + + canConvert + canConvert + ( Type t ) + + + canConvert + canConvert-2 + () + + + clear + clear + () + + + convert + convert + ( Type t ) + + + data_ptr + data_ptr + () + + + 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-36 + ( 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-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 ) + + + + 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 + + + + const_pointer + const_pointer-typedef + + + + const_reference + const_reference-typedef + + + + difference_type + difference_type-typedef + + + + iterator + iterator-typedefx + + + + pointer + pointer-typedef + + + + reference + reference-typedef + + + + size_type + size_type-typedef + + + + value_type + value_type-typedef + + + + 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 ) + + + + 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 + () + + + add + add + ( QWidget * w, const QString & s ) + + + remove + remove + ( QWidget * w ) + + + whatsThisButton + whatsThisButton + ( QWidget * parent ) + + + + 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 ) + + + + QWhatsThisClickedEvent + qwhatsthisclickedevent.html + + QWhatsThisClickedEvent + QWhatsThisClickedEvent + ( const QString & href ) + + + href + href + () + + + 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() + + + + 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() + + + isEnabledToTLW + isEnabledToTLW + () + + + isTopLevel + isTopLevel + () + + + languageChange + languageChange + () + + + topLevelWidget + topLevelWidget + () + + + BackgroundOrigin + BackgroundOrigin-enum + + + + QWidget + QWidget-3 + ( QWidget * parent, const char * name, Qt::WindowFlags 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::WindowFlags 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::WindowFlags 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 + () + + + + QWidget + qwidget.html + + ContextMenuPolicy + contextMenuPolicy-prop + + + + FocusPolicy + focusPolicy-prop + + + + LayoutDirection + layoutDirection-prop + + + + WindowFlags + windowFlags-prop + + + + WindowModality + windowModality-prop + + + + QWidget + QWidget + ( QWidget * parent = 0, Qt::WindowFlags 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 + () + + + HANDLE + macCGHandle + QWidget::macCGHandle() + + + macEvent + macEvent + ( EventHandlerCallRef caller, EventRef event ) + + + HANDLE + macQDHandle + QWidget::macQDHandle() + + + 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 ) + + + render + render + ( QPaintDevice * target, const QPoint & targetOffset = QPoint() + + + 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 ) + + + restoreGeometry + restoreGeometry + ( const QByteArray & geometry ) + + + saveGeometry + saveGeometry + () + + + 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 enable ) + + + 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::WindowFlags f ) + + + setShortcutAutoRepeat + setShortcutAutoRepeat + ( int id, bool enable = true ) + + + 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 ) + + + setWindowSurface + setWindowSurface + ( QWindowSurface * surface ) + + + 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() + + + windowSurface + windowSurface + () + + + WindowType + windowType + QWidget::windowType() + + + x11Event + x11Event + ( XEvent * event ) + + + x11Info + x11Info + () + + + HANDLE + x11PictureHandle + QWidget::x11PictureHandle() + + + BackgroundOrigin + BackgroundOrigin-enum + + + + QWidget + QWidget-3 + ( QWidget * parent, const char * name, Qt::WindowFlags 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::WindowFlags 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::WindowFlags 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 + () + + + + QWidgetAction + qwidgetaction.html + + QWidgetAction + QWidgetAction + ( QObject * parent ) + + + createWidget + createWidget + ( QWidget * parent ) + + + createdWidgets + createdWidgets + () + + + defaultWidget + defaultWidget + () + + + deleteWidget + deleteWidget + ( QWidget * widget ) + + + releaseWidget + releaseWidget + ( QWidget * widget ) + + + requestWidget + requestWidget + ( QWidget * parent ) + + + setDefaultWidget + setDefaultWidget + ( QWidget * widget ) + + + + QWidgetItem + qwidgetitem.html + + QWidgetItem + QWidgetItem + ( QWidget * widget ) + + + isEmpty + isEmpty + () + + + widget + widget + () + + + + 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() + + + + QWindowsVistaStyle + qwindowsvistastyle.html + + QWindowsVistaStyle + QWindowsVistaStyle + () + + + + QWindowsXPStyle + qwindowsxpstyle.html + + QWindowsXPStyle + QWindowsXPStyle + () + + + + QWizard + qwizard.html + + WizardButton + WizardButton-enum + + + + WizardPixmap + WizardPixmap-enum + + + + WizardStyle + WizardStyle-enum + + + + TextFormat + subTitleFormat-prop + + + + TextFormat + titleFormat-prop + + + + QWizard + QWizard + ( QWidget * parent = 0, Qt::WindowFlags flags = 0 ) + + + addPage + addPage + ( QWizardPage * page ) + + + back + back + () + + + button + button + ( WizardButton which ) + + + buttonText + buttonText + ( WizardButton which ) + + + cleanupPage + cleanupPage + ( int id ) + + + currentIdChanged + currentIdChanged + ( int id ) + + + currentPage + currentPage + () + + + customButtonClicked + customButtonClicked + ( int which ) + + + field + field + ( const QString & name ) + + + hasVisitedPage + hasVisitedPage + ( int id ) + + + helpRequested + helpRequested + () + + + initializePage + initializePage + ( int id ) + + + next + next + () + + + nextId + nextId + () + + + page + page + ( int id ) + + + pixmap + pixmap + ( WizardPixmap which ) + + + restart + restart + () + + + setButton + setButton + ( WizardButton which, QAbstractButton * button ) + + + setButtonLayout + setButtonLayout + ( const QList<WizardButton> & layout ) + + + setButtonText + setButtonText + ( WizardButton which, const QString & text ) + + + setDefaultProperty + setDefaultProperty + ( const char * className, const char * property, const char * changedSignal ) + + + setField + setField + ( const QString & name, const QVariant & value ) + + + setOption + setOption + ( WizardOption option, bool on = true ) + + + setPage + setPage + ( int id, QWizardPage * page ) + + + setPixmap + setPixmap + ( WizardPixmap which, const QPixmap & pixmap ) + + + testOption + testOption + ( WizardOption option ) + + + validateCurrentPage + validateCurrentPage + () + + + visitedPages + visitedPages + () + + + + QWizardPage + qwizardpage.html + + QWizardPage + QWizardPage + ( QWidget * parent = 0 ) + + + buttonText + buttonText + ( QWizard::WizardButton which ) + + + cleanupPage + cleanupPage + () + + + completeChanged + completeChanged + () + + + field + field + ( const QString & name ) + + + initializePage + initializePage + () + + + isCommitPage + isCommitPage + () + + + isComplete + isComplete + () + + + isFinalPage + isFinalPage + () + + + nextId + nextId + () + + + pixmap + pixmap + ( QWizard::WizardPixmap which ) + + + registerField + registerField + ( const QString & name, QWidget * widget, const char * property = 0, const char * changedSignal = 0 ) + + + setButtonText + setButtonText + ( QWizard::WizardButton which, const QString & text ) + + + setCommitPage + setCommitPage + ( bool commitPage ) + + + setField + setField + ( const QString & name, const QVariant & value ) + + + setFinalPage + setFinalPage + ( bool finalPage ) + + + setPixmap + setPixmap + ( QWizard::WizardPixmap which, const QPixmap & pixmap ) + + + validatePage + validatePage + () + + + wizard + wizard + () + + + QWorkspace + QWorkspace-2 + ( QWidget * parent, const char * name ) + + + setPaletteBackgroundColor + setPaletteBackgroundColor + ( const QColor & c ) + + + setPaletteBackgroundPixmap + setPaletteBackgroundPixmap + ( const QPixmap & pm ) + + + + QWorkspace + qworkspace.html + + WindowOrder + WindowOrder-enum + + + + QWorkspace + QWorkspace + ( QWidget * parent = 0 ) + + + activateNextWindow + activateNextWindow + () + + + activatePreviousWindow + activatePreviousWindow + () + + + activeWindow + activeWindow + () + + + addWindow + addWindow + ( QWidget * w, Qt::WindowFlags 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 + () + + + + QWSEmbedWidget + qwsembedwidget.html + + QWSEmbedWidget + QWSEmbedWidget + ( WId id, QWidget * parent = 0 ) + + + + QWSEvent + qwsevent.html + + Type + Type-enum + + + + + QWSGLWindowSurface + qwsglwindowsurface.html + + QWSGLWindowSurface + QWSGLWindowSurface + ( QWidget * window ) + + + QWSGLWindowSurface + QWSGLWindowSurface-2 + () + + + context + context + () + + + setContext + setContext + ( QGLContext * context ) + + + sendIMEvent + sendIMEvent + ( QWSServer::IMState state, const QString & text, int cursorPosition, int selectionLength = 0 ) + + + + 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 * event ) + + + 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 ) + + + + 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 + () + + + setScreen + setScreen + ( const QScreen * screen ) + + + suspend + suspend + () + + + + QWSPointerCalibrationData + qwspointercalibrationdata.html + + Location + Location-enum + + + + devPoints + devPoints-var + [5] + + + screenPoints + screenPoints-var + [5] + + + + QWSScreenSaver + qwsscreensaver.html + + restore + restore + () + + + save + save + ( int level ) + + + + QWSServer::KeyboardFilter + qwsserver-keyboardfilter.html + + filter + filter + ( int unicode, int keycode, int modifiers, bool isPress, bool autoRepeat ) + + + IMState + IMState-enum + + + + QWSServer + QWSServer-2 + ( int flags, QObject * parent, const char * name ) + + + setDesktopBackground + setDesktopBackground + ( const QImage & image ) + + + setDesktopBackground + setDesktopBackground-2 + ( const QColor & color ) + + + + 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 ) + + + instance + instance + () + + + isCursorVisible + isCursorVisible + () + + + 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 * driver ) + + + setMaxWindowRect + setMaxWindowRect + ( const QRect & rectangle ) + + + setMouseHandler + setMouseHandler + ( QWSMouseHandler * driver ) + + + setScreenSaver + setScreenSaver + ( QWSScreenSaver * screenSaver ) + + + setScreenSaverBlockLevel + setScreenSaverBlockLevel + ( int eventBlockLevel ) + + + setScreenSaverInterval + setScreenSaverInterval + ( int milliseconds ) + + + setScreenSaverIntervals + setScreenSaverIntervals + ( int * intervals ) + + + suspendMouse + suspendMouse + () + + + timerEvent + timerEvent + ( QTimerEvent * e ) + + + windowAt + windowAt + ( const QPoint & position ) + + + windowEvent + windowEvent + ( QWSWindow * window, QWSServer::WindowEvent eventType ) + + + QWSServer + QWSServer-2 + ( int flags, QObject * parent, const char * name ) + + + setDesktopBackground + setDesktopBackground + ( const QImage & image ) + + + setDesktopBackground + setDesktopBackground-2 + ( const QColor & color ) + + + + QWSWindow + qwswindow.html + + State + State-enum + + + + caption + caption + () + + + client + client + () + + + dirtyOnScreen + dirtyOnScreen + () + + + isFullyObscured + isFullyObscured + () + + + isOpaque + isOpaque + () + + + isVisible + isVisible + () + + + name + name + () + + + opacity + opacity + () + + + requestedRegion + requestedRegion + () + + + state + state + () + + + winId + winId + () + + + WindowFlags + windowFlags + QWSWindow::windowFlags() + + + + 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 QLatin1String & qName ) + + + index + index-3 + ( 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 QLatin1String & qName ) + + + value + value-4 + ( 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-3 + ( QFile & file ) + + + QXmlInputSource + QXmlInputSource-4 + ( QTextStream & stream ) + + + + 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 + () + + + parse + parse-2 + ( const QXmlInputSource & input ) + + + + 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 + ( 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 ) + + + + QXmlSimpleReader + qxmlsimplereader.html + + QXmlSimpleReader + QXmlSimpleReader + () + + + parse + parse + ( const QXmlInputSource * input, bool incremental ) + + + parseContinue + parseContinue + () + + + setFeature + setFeature + ( const QString & name, bool enable ) + + + + QXmlStreamAttribute + qxmlstreamattribute.html + + QXmlStreamAttribute + QXmlStreamAttribute + () + + + QXmlStreamAttribute + QXmlStreamAttribute-2 + ( const QString & qualifiedName, const QString & value ) + + + QXmlStreamAttribute + QXmlStreamAttribute-3 + ( const QString & namespaceUri, const QString & name, const QString & value ) + + + QXmlStreamAttribute + QXmlStreamAttribute-4 + ( const QXmlStreamAttribute & other ) + + + isDefault + isDefault + () + + + name + name + () + + + namespaceUri + namespaceUrix + () + + + qualifiedName + qualifiedName + () + + + value + value + () + + + operator!= + operator-not-eq + ( const QXmlStreamAttribute & other ) + + + operator= + operator-eq + ( const QXmlStreamAttribute & other ) + + + operator== + operator-eq-eq + ( const QXmlStreamAttribute & other ) + + + + QXmlStreamAttributes + qxmlstreamattributes.html + + append + append + ( const QString & namespaceUri, const QString & name, const QString & value ) + + + append + append-2 + ( const QString & qualifiedName, const QString & value ) + + + value + value + ( const QString & namespaceUri, const QString & name ) + + + value + value-2 + ( const QString & namespaceUri, const QLatin1String & name ) + + + value + value-3 + ( const QLatin1String & namespaceUri, const QLatin1String & name ) + + + value + value-4 + ( const QString & qualifiedName ) + + + value + value-5 + ( const QLatin1String & qualifiedName ) + + + + QXmlStreamEntityDeclaration + qxmlstreamentitydeclaration.html + + QXmlStreamEntityDeclaration + QXmlStreamEntityDeclaration + () + + + QXmlStreamEntityDeclaration + QXmlStreamEntityDeclaration-2 + ( const QXmlStreamEntityDeclaration & other ) + + + name + name + () + + + notationName + notationName + () + + + publicId + publicId + () + + + systemId + systemId + () + + + value + value + () + + + operator!= + operator-not-eq + ( const QXmlStreamEntityDeclaration & other ) + + + operator= + operator-eq + ( const QXmlStreamEntityDeclaration & other ) + + + operator== + operator-eq-eq + ( const QXmlStreamEntityDeclaration & other ) + + + + QXmlStreamNamespaceDeclaration + qxmlstreamnamespacedeclaration.html + + QXmlStreamNamespaceDeclaration + QXmlStreamNamespaceDeclaration + () + + + QXmlStreamNamespaceDeclaration + QXmlStreamNamespaceDeclaration-2 + ( const QXmlStreamNamespaceDeclaration & other ) + + + namespaceUri + namespaceUrix + () + + + prefix + prefix + () + + + operator!= + operator-not-eq + ( const QXmlStreamNamespaceDeclaration & other ) + + + operator= + operator-eq + ( const QXmlStreamNamespaceDeclaration & other ) + + + operator== + operator-eq-eq + ( const QXmlStreamNamespaceDeclaration & other ) + + + + QXmlStreamNotationDeclaration + qxmlstreamnotationdeclaration.html + + QXmlStreamNotationDeclaration + QXmlStreamNotationDeclaration + () + + + QXmlStreamNotationDeclaration + QXmlStreamNotationDeclaration-2 + ( const QXmlStreamNotationDeclaration & other ) + + + name + name + () + + + publicId + publicId + () + + + systemId + systemId + () + + + operator!= + operator-not-eq + ( const QXmlStreamNotationDeclaration & other ) + + + operator= + operator-eq + ( const QXmlStreamNotationDeclaration & other ) + + + operator== + operator-eq-eq + ( const QXmlStreamNotationDeclaration & other ) + + + + QXmlStreamReader + qxmlstreamreader.html + + Error + Error-enum + + + + TokenType + TokenType-enum + + + + QXmlStreamReader + QXmlStreamReader + () + + + QXmlStreamReader + QXmlStreamReader-2 + ( QIODevice * device ) + + + QXmlStreamReader + QXmlStreamReader-3 + ( const QByteArray & data ) + + + QXmlStreamReader + QXmlStreamReader-4 + ( const QString & data ) + + + QXmlStreamReader + QXmlStreamReader-5 + ( const char * data ) + + + addData + addData + ( const QByteArray & data ) + + + addData + addData-2 + ( const QString & data ) + + + addData + addData-3 + ( const char * data ) + + + atEnd + atEnd + () + + + attributes + attributes + () + + + characterOffset + characterOffset + () + + + clear + clear + () + + + columnNumber + columnNumber + () + + + device + device + () + + + entityDeclarations + entityDeclarations + () + + + error + error + () + + + errorString + errorString + () + + + hasError + hasError + () + + + isCDATA + isCDATA + () + + + isCharacters + isCharacters + () + + + isComment + isComment + () + + + isDTD + isDTD + () + + + isEndDocument + isEndDocument + () + + + isEndElement + isEndElement + () + + + isEntityReference + isEntityReference + () + + + isProcessingInstruction + isProcessingInstruction + () + + + isStandaloneDocument + isStandaloneDocument + () + + + isStartDocument + isStartDocument + () + + + isStartElement + isStartElement + () + + + isWhitespace + isWhitespace + () + + + lineNumber + lineNumber + () + + + name + name + () + + + namespaceDeclarations + namespaceDeclarations + () + + + namespaceUri + namespaceUrix + () + + + notationDeclarations + notationDeclarations + () + + + processingInstructionData + processingInstructionData + () + + + processingInstructionTarget + processingInstructionTarget + () + + + qualifiedName + qualifiedName + () + + + raiseError + raiseError + ( const QString & message = QString() + + + readElementText + readElementText + () + + + readNext + readNext + () + + + setDevice + setDevice + ( QIODevice * device ) + + + text + text + () + + + tokenString + tokenString + () + + + tokenType + tokenType + () + + + + QXmlStreamWriter + qxmlstreamwriter.html + + QXmlStreamWriter + QXmlStreamWriter + () + + + QXmlStreamWriter + QXmlStreamWriter-2 + ( QIODevice * device ) + + + QXmlStreamWriter + QXmlStreamWriter-3 + ( QByteArray * array ) + + + QXmlStreamWriter + QXmlStreamWriter-4 + ( QString * string ) + + + codec + codec + () + + + device + device + () + + + setCodec + setCodec + ( QTextCodec * codec ) + + + setCodec + setCodec-2 + ( const char * codecName ) + + + setDevice + setDevice + ( QIODevice * device ) + + + writeAttribute + writeAttribute + ( const QString & namespaceUri, const QString & name, const QString & value ) + + + writeAttribute + writeAttribute-2 + ( const QString & qualifiedName, const QString & value ) + + + writeAttribute + writeAttribute-3 + ( const QXmlStreamAttribute & attribute ) + + + writeAttributes + writeAttributes + ( const QXmlStreamAttributes & attributes ) + + + writeCDATA + writeCDATA + ( const QString & text ) + + + writeCharacters + writeCharacters + ( const QString & text ) + + + writeComment + writeComment + ( const QString & text ) + + + writeCurrentToken + writeCurrentToken + ( const QXmlStreamReader & reader ) + + + writeDTD + writeDTD + ( const QString & dtd ) + + + writeDefaultNamespace + writeDefaultNamespace + ( const QString & namespaceUri ) + + + writeEmptyElement + writeEmptyElement + ( const QString & namespaceUri, const QString & name ) + + + writeEmptyElement + writeEmptyElement-2 + ( const QString & qualifiedName ) + + + writeEndDocument + writeEndDocument + () + + + writeEndElement + writeEndElement + () + + + writeEntityReference + writeEntityReference + ( const QString & name ) + + + writeNamespace + writeNamespace + ( const QString & namespaceUri, const QString & prefix = QString() + + + writeProcessingInstruction + writeProcessingInstruction + ( const QString & target, const QString & data = QString() + + + writeStartDocument + writeStartDocument + ( const QString & version ) + + + writeStartDocument + writeStartDocument-2 + () + + + writeStartElement + writeStartElement + ( const QString & namespaceUri, const QString & name ) + + + writeStartElement + writeStartElement-2 + ( const QString & qualifiedName ) + + + writeTextElement + writeTextElement + ( const QString & namespaceUri, const QString & name, const QString & text ) + + + writeTextElement + writeTextElement-2 + ( const QString & qualifiedName, const QString & text ) + + +