| Home | All Classes | Main Classes | Annotated | Grouped Classes | Functions | |
The QWidget class is the base class of all user interface objects. More...
#include <qwidget.h>
Inherits QObject and QPaintDevice.
Inherited by QAxWidget, QButton, QFrame, QDialog, QComboBox, QDataBrowser, QDataView, QDateTimeEdit, QDesktopWidget, QDial, QDockArea, QGLWidget, QHeader, QMainWindow, QMotifWidget, QNPWidget, QScrollBar, QSizeGrip, QSlider, QSpinBox, QStatusBar, QTabBar, QTabWidget, QWorkspace, and QXtWidget.
The widget is the atom of the user interface: it receives mouse, keyboard and other events from the window system, and paints a representation of itself on the screen. Every widget is rectangular, and they are sorted in a Z-order. A widget is clipped by its parent and by the widgets in front of it.
A widget that isn't embedded in a parent widget is called a top-level widget. Usually, top-level widgets are windows with a frame and a title bar (although it is also possible to create top-level widgets without such decoration if suitable widget flags are used). In Qt, QMainWindow and the various subclasses of QDialog are the most common top-level windows.
A widget without a parent widget is always a top-level widget.
Non-top-level widgets are child widgets. These are child windows in their parent widgets. You cannot usually distinguish a child widget from its parent visually. Most other widgets in Qt are useful only as child widgets. (It is possible to make, say, a button into a top-level widget, but most people prefer to put their buttons inside other widgets, e.g. QDialog.)
QWidget has many member functions, but some of them have little direct functionality: for example, QWidget has a font property, but never uses this itself. There are many subclasses which provide real functionality, such as QPushButton, QListBox and QTabDialog, etc.
Every widget's constructor accepts two or three standard arguments:
The tictac/tictac.cpp example program is good example of a simple widget. It contains a few event handlers (as all widgets must), a few custom routines that are specific to it (as all useful widgets do), and has a few children and connections. Everything it does is done in response to an event: this is by far the most common way to design GUI applications.
You will need to supply the content for your widgets yourself, but here is a brief run-down of the events, starting with the most common ones:
If your widget only contains child widgets, you probably do not need to implement any event handlers. If you want to detect a mouse click in a child widget call the child's hasMouse() function inside the parent widget's mousePressEvent().
Widgets that accept keyboard input need to reimplement a few more event handlers:
Some widgets will also need to reimplement some of the less common event handlers:
There are also some rather obscure events. They are listed in qevent.h and you need to reimplement event() to handle them. The default implementation of event() handles Tab and Shift+Tab (to move the keyboard focus), and passes on most other events to one of the more specialized handlers above.
When implementing a widget, there are a few more things to consider.
See also QEvent, QPainter, QGridLayout, QBoxLayout, and Abstract Widget Classes.
This enum defines the origin used to draw a widget's background pixmap.
The pixmap is drawn using the:
This enum type defines the various policies a widget can have with respect to acquiring keyboard focus.
If parent is 0, the new widget becomes a top-level window. If parent is another widget, this widget becomes a child window inside parent. The new widget is deleted when its parent is deleted.
The name is sent to the QObject constructor.
The widget flags argument, f, is normally 0, but it can be set to customize the window frame of a top-level widget (i.e. parent must be 0). To customize the frame, set the WStyle_Customize flag OR'ed with any of the Qt::WidgetFlags.
If you add a child widget to an already visible widget you must explicitly show the child to make it visible.
Note that the X11 version of Qt may not be able to deliver all combinations of style flags on all systems. This is because on X11, Qt can only ask the window manager, and the window manager can override the application's settings. On Windows, Qt can set whatever flags you want.
Example:
QLabel *splashScreen = new QLabel( 0, "mySplashScreen",
WStyle_Customize | WStyle_Splash );
All this widget's children are deleted first. The application exits if this widget is the main widget.
Returns TRUE if drop events are enabled for this widget; otherwise returns FALSE. See the "acceptDrops" property for details.
Uses sizeHint() if valid (i.e if the size hint's width and height are >= 0), otherwise sets the size to the children rectangle (the union of all child widget geometries).
See also sizeHint and childrenRect.
Example: xform/xform.cpp.
Reimplemented in QMessageBox.
Returns TRUE if the auto mask feature is enabled for the widget; otherwise returns FALSE. See the "autoMask" property for details.
Returns the widget's background brush. See the "backgroundBrush" property for details.
Returns the color role used for painting the background of the widget. See the "backgroundMode" property for details.
Returns the origin of the widget's background. See the "backgroundOrigin" property for details.
Examples: themes/metal.cpp and themes/wood.cpp.
Returns the base size of the widget. See the "baseSize" property for details.
Returns the window caption (title). See the "caption" property for details.
If includeThis is TRUE, and there is no child visible at (x, y), the widget itself is returned.
Returns the visible child widget at point p in the widget's own coordinate system.
If includeThis is TRUE, and there is no child visible at p, the widget itself is returned.
Returns the bounding rectangle of the widget's children. See the "childrenRect" property for details.
Returns the combined region occupied by the widget's children. See the "childrenRegion" property for details.
If the widget has active focus, a focus out event is sent to this widget to tell it that it is about to lose the focus.
This widget must enable focus setting in order to get the keyboard input focus, i.e. it must call setFocusPolicy().
See also focus, setFocus(), focusInEvent(), focusOutEvent(), focusPolicy, and QApplication::focusWidget().
See also setMask().
Clears the widget flags f.
Widget flags are a combination of Qt::WidgetFlags.
See also testWFlags(), getWFlags(), and setWFlags().
Closes this widget. Returns TRUE if the widget was closed; otherwise returns FALSE.
First it sends the widget a QCloseEvent. The widget is hidden if it accepts the close event. The default implementation of QWidget::closeEvent() accepts the close event.
The QApplication::lastWindowClosed() signal is emitted when the last visible top level widget is closed.
Examples: dialog/mainwindow.cpp, mdi/application.cpp, and popup/popup.cpp.
Closes this widget. Returns TRUE if the widget was closed; otherwise returns FALSE.
If alsoDelete is TRUE or the widget has the WDestructiveClose widget flag, the widget is also deleted. The widget can prevent itself from being closed by rejecting the QCloseEvent it gets.
The QApplication::lastWindowClosed() signal is emitted when the last visible top level widget is closed.
Note that closing the QApplication::mainWidget() terminates the application.
See also closeEvent(), QCloseEvent, hide(), QApplication::quit(), QApplication::setMainWidget(), and QApplication::lastWindowClosed().
The default implementation calls e->accept(), which hides this widget. See the QCloseEvent documentation for more details.
See also event(), hide(), close(), and QCloseEvent.
Examples: action/application.cpp, application/application.cpp, chart/chartform.cpp, i18n/mywidget.cpp, mdi/application.cpp, popup/popup.cpp, and qwerty/qwerty.cpp.
Returns the current color group of the widget palette. See the "colorGroup" property for details.
Ensures that the widget is properly initialized by calling polish().
Call constPolish() from functions like sizeHint() that depends on the widget being initialized, and that may be called before show().
Warning: Do not call constPolish() on a widget from inside that widget's constructor.
See also polish().
The default implementation calls e->ignore(), which rejects the context event. See the QContextMenuEvent documentation for more details.
See also event() and QContextMenuEvent.
Example: menu/menu.cpp.
Initializes the window (sets the geometry etc.) if initializeWindow is TRUE. If initializeWindow is FALSE, no initialization is performed. This parameter only makes sense if window is a valid window.
Destroys the old window if destroyOldWindow is TRUE. If destroyOldWindow is FALSE, you are responsible for destroying the window yourself (using platform native code).
The QWidget constructor calls create(0,TRUE,TRUE) to create a window for this widget.
Returns the cursor shape for this widget. See the "cursor" property for details.
Returns TRUE if the widget wants to handle What's This help manually; otherwise returns FALSE. See the "customWhatsThis" property for details.
destroy() calls itself recursively for all the child widgets, passing destroySubWindows for the destroyWindow parameter. To have more control over destruction of subwidgets, destroy subwidgets selectively first.
This function is usually called from the QWidget destructor.
See the Drag-and-drop documentation for an overview of how to provide drag-and-drop in your application.
See also QTextDrag, QImageDrag, and QDragEnterEvent.
Example: iconview/simple_dd/main.cpp.
See the Drag-and-drop documentation for an overview of how to provide drag-and-drop in your application.
See also QTextDrag, QImageDrag, and QDragLeaveEvent.
See the Drag-and-drop documentation for an overview of how to provide drag-and-drop in your application.
See also QTextDrag, QImageDrag, and QDragMoveEvent.
The y position is the base line position of the text. The text is drawn using the default font and the default foreground color.
This function is provided for convenience. You will generally get more flexible results and often higher speed by using a a painter instead.
See also font, foregroundColor(), and QPainter::drawText().
Draws the string str at position pos.
See the Drag-and-drop documentation for an overview of how to provide drag-and-drop in your application.
See also QTextDrag, QImageDrag, and QDropEvent.
Example: iconview/simple_dd/main.cpp.
This virtual function is called from setEnabled(). oldEnabled is the previous setting; you can get the new setting from isEnabled().
Reimplement this function if your widget needs to know when it becomes enabled or disabled. You will almost certainly need to update the widget using update().
The default implementation repaints the visible part of the widget.
See also enabled, enabled, repaint(), update(), and visibleRect.
An event is sent to the widget when the mouse cursor enters the widget.
See also leaveEvent(), mouseMoveEvent(), and event().
If w is negative, it is replaced with width() - x. If h is negative, it is replaced width height() - y.
Child widgets are not affected.
See also repaint().
This version erases the entire widget.
Erases the specified area r in the widget without generating a paint event.
Erases the area defined by reg, without generating a paint event.
Child widgets are not affected.
Returns the erase color of the widget.
See also setEraseColor(), setErasePixmap(), and backgroundColor().
See also setErasePixmap() and eraseColor().
The main event handler first passes an event through all event filters that have been installed. If none of the filters intercept the event, it calls one of the specialized event handlers.
Key press and release events are treated differently from other events. event() checks for Tab and Shift+Tab and tries to move the focus appropriately. If there is no widget to move the focus to (or the key press is not Tab or Shift+Tab), event() calls keyPressEvent().
This function returns TRUE if it is able to pass the event over to someone (i.e. someone wanted the event); otherwise returns FALSE.
See also closeEvent(), focusInEvent(), focusOutEvent(), enterEvent(), keyPressEvent(), keyReleaseEvent(), leaveEvent(), mouseDoubleClickEvent(), mouseMoveEvent(), mousePressEvent(), mouseReleaseEvent(), moveEvent(), paintEvent(), resizeEvent(), QObject::event(), and QObject::timerEvent().
Reimplemented from QObject.
The window identifier type depends on the underlying window system, see qwindowdefs.h for the actual definition. If there is no widget with this identifier, 0 is returned.
Focus data always belongs to the top-level widget. The focus data list contains all the widgets in this top-level widget that can accept focus, in tab order. An iterator points to the current focus widget (focusWidget() returns a pointer to this widget).
This information is useful for implementing advanced versions of focusNextPrevChild().
A widget normally must setFocusPolicy() to something other than NoFocus in order to receive focus events. (Note that the application programmer can call setFocus() on any widget, even those that do not normally accept focus.)
The default implementation updates the widget if it accepts focus (see focusPolicy()). It also calls setMicroFocusHint(), hinting any system-specific input tools about the focus of the user's attention.
See also focusOutEvent(), focusPolicy, keyPressEvent(), keyReleaseEvent(), event(), and QFocusEvent.
If next is TRUE, this function searches "forwards", if next is FALSE, it searches "backwards".
Sometimes, you will want to reimplement this function. For example, a web browser might reimplement it to move its "current active link" forwards or backwards, and call QWidget::focusNextPrevChild() only when it reaches the last or first link on the "page".
Child widgets call focusNextPrevChild() on their parent widgets, but only the top-level widget decides where to redirect focus. By overriding this method for an object, you thus gain control of focus traversal for all child widgets.
See also focusData().
A widget normally must setFocusPolicy() to something other than NoFocus in order to receive focus events. (Note that the application programmer can call setFocus() on any widget, even those that do not normally accept focus.)
The default implementation calls repaint() since the widget's colorGroup() changes from active to normal, so the widget probably needs repainting. It also calls setMicroFocusHint(), hinting any system-specific input tools about the focus of the user's attention.
See also focusInEvent(), focusPolicy, keyPressEvent(), keyReleaseEvent(), event(), and QFocusEvent.
Example: qmag/qmag.cpp.
Returns the way the widget accepts keyboard focus. See the "focusPolicy" property for details.
See also setFocusProxy().
Returns the font currently set for the widget. See the "font" property for details.
This virtual function is called from setFont(). oldFont is the previous font; you can get the new font from font().
Reimplement this function if your widget needs to know when its font changes. You will almost certainly need to update the widget using update().
The default implementation updates the widget including its geometry.
See also font, font, update(), and updateGeometry().
Returns the font info for the widget's current font. Equivalent to QFontInto(widget->font()).
See also font, fontMetrics(), and font.
Returns the font metrics for the widget's current font. Equivalent to QFontMetrics(widget->font()).
See also font, fontInfo(), and font.
Examples: drawdemo/drawdemo.cpp and qmag/qmag.cpp.
Returns geometry of the widget relative to its parent including any window frame. See the "frameGeometry" property for details.
Returns the size of the widget including any window frame. See the "frameSize" property for details.
Returns the geometry of the widget relative to its parent and excluding the window frame. See the "geometry" property for details.
Returns the widget flags for this this widget.
Widget flags are a combination of Qt::WidgetFlags.
See also testWFlags(), setWFlags(), and clearWFlags().
This widget reveives all keyboard events until releaseKeyboard() is called; other widgets get no keyboard events at all. Mouse events are not affected. Use grabMouse() if you want to grab that.
The focus widget is not affected, except that it doesn't receive any keyboard events. setFocus() moves the focus as usual, but the new focus widget receives keyboard events only after releaseKeyboard() is called.
If a different widget is currently grabbing keyboard input, that widget's grab is released first.
See also releaseKeyboard(), grabMouse(), releaseMouse(), and focusWidget().
This widget receives all mouse events until releaseMouse() is called; other widgets get no mouse events at all. Keyboard events are not affected. Use grabKeyboard() if you want to grab that.
Warning: Bugs in mouse-grabbing applications very often lock the terminal. Use this function with extreme caution, and consider using the -nograb command line option while debugging.
It is almost never necessary to grab the mouse when using Qt, as Qt grabs and releases it sensibly. In particular, Qt grabs the mouse when a mouse button is pressed and keeps it until the last button is released.
Note that only visible widgets can grab mouse input. If isVisible() returns FALSE for a widget, that widget cannot call grabMouse().
See also releaseMouse(), grabKeyboard(), releaseKeyboard(), grabKeyboard(), and focusWidget().
Grabs the mouse input and changes the cursor shape.
The cursor will assume shape cursor (for as long as the mouse focus is grabbed) and this widget will be the only one to receive mouse events until releaseMouse() is called().
Warning: Grabbing the mouse might lock the terminal.
See also releaseMouse(), grabKeyboard(), releaseKeyboard(), and cursor.
Returns TRUE if this widget (or its focus proxy) has the keyboard input focus; otherwise returns FALSE. See the "focus" property for details.
Returns TRUE if the widget is under the mouse cursor; otherwise returns FALSE. See the "underMouse" property for details.
Returns TRUE if mouse tracking is enabled for the widget; otherwise returns FALSE. See the "mouseTracking" property for details.
Returns the height of the widget excluding any window frame. See the "height" property for details.
Warning: Does not look at the widget's layout.
Reimplemented in QMenuBar and QTextEdit.
You almost never have to reimplement this function. If you need to do something after a widget is hidden, use hideEvent() instead.
See also hideEvent(), hidden, show(), showMinimized(), visible, and close().
Examples: mdi/application.cpp, popup/popup.cpp, progress/progress.cpp, scrollview/scrollview.cpp, and xform/xform.cpp.
Reimplemented in QMenuBar.
Hide events are sent to widgets immediately after they have been hidden.
See also event() and QHideEvent.
Reimplemented in QScrollBar.
Returns the widget's icon. See the "icon" property for details.
Returns the widget's icon text. See the "iconText" property for details.
The default implementation calls e->ignore(), which rejects the Input Method event. See the QIMEvent documentation for more details.
See also event() and QIMEvent.
The default implementation calls e->ignore(), which rejects the Input Method event. See the QIMEvent documentation for more details.
See also event() and QIMEvent.
The default implementation calls e->ignore(), which rejects the Input Method event. See the QIMEvent documentation for more details.
See also event() and QIMEvent.
Returns TRUE if this widget is the active window; otherwise returns FALSE. See the "isActiveWindow" property for details.
Returns TRUE if the widget is a desktop widget, i.e. represents the desktop; otherwise returns FALSE. See the "isDesktop" property for details.
Returns TRUE if the widget is a dialog widget; otherwise returns FALSE. See the "isDialog" property for details.
Returns TRUE if the widget is enabled; otherwise returns FALSE. See the "enabled" property for details.
This is the case if neither the widget itself nor every parent up to but excluding ancestor has been explicitly disabled.
isEnabledTo(0) is equivalent to isEnabled().
This function is deprecated. It is equivalent to isEnabled()
Returns TRUE if the widget accepts keyboard focus; otherwise returns FALSE. See the "focusEnabled" property for details.
Returns TRUE if the widget is full screen; otherwise returns FALSE. See the "fullScreen" property for details.
Returns TRUE if the widget is explicitly hidden; otherwise returns FALSE. See the "hidden" property for details.
Returns TRUE if this widget is maximized; otherwise returns FALSE. See the "maximized" property for details.
Returns TRUE if this widget is minimized (iconified); otherwise returns FALSE. See the "minimized" property for details.
Returns TRUE if the widget is a modal widget; otherwise returns FALSE. See the "isModal" property for details.
Returns TRUE if the widget is a popup widget; otherwise returns FALSE. See the "isPopup" property for details.
Returns TRUE if the widget is shown; otherwise returns FALSE. See the "shown" property for details.
Returns TRUE if the widget is a top-level widget; otherwise returns FALSE. See the "isTopLevel" property for details.
Returns TRUE if updates are enabled; otherwise returns FALSE. See the "updatesEnabled" property for details.
Returns TRUE if the widget is visible; otherwise returns FALSE. See the "visible" property for details.
The TRUE case occurs if neither the widget itself nor any parent up to but excluding ancestor has been explicitly hidden.
This function will still return TRUE if the widget is obscured by other windows on the screen, but could be physically visible if it or they were to be moved.
isVisibleTo(0) is identical to isVisible().
See also show(), hide(), and visible.
This function is deprecated. It is equivalent to isVisible()
A widget must call setFocusPolicy() to accept focus initially and have focus in order to receive a key press event.
If you reimplement this handler, it is very important that you ignore() the event if you do not understand it, so that the widget's parent can interpret it.
The default implementation closes popup widgets if the user presses Esc. Otherwise the event is ignored.
See also keyReleaseEvent(), QKeyEvent::ignore(), focusPolicy, focusInEvent(), focusOutEvent(), event(), and QKeyEvent.
Examples: fileiconview/qfileiconview.cpp and picture/picture.cpp.
Reimplemented in QLineEdit and QTextEdit.
A widget must accept focus initially and have focus in order to receive a key release event.
If you reimplement this handler, it is very important that you ignore() the release if you do not understand it, so that the widget's parent can interpret it.
The default implementation ignores the event.
See also keyPressEvent(), QKeyEvent::ignore(), focusPolicy, focusInEvent(), focusOutEvent(), event(), and QKeyEvent.
If no widget in this application is currently grabbing the keyboard, 0 is returned.
See also grabMouse() and mouseGrabber().
Returns the layout engine that manages the geometry of this widget's children.
If the widget does not have a layout, layout() returns 0.
See also sizePolicy.
Examples: chart/optionsform.cpp and fonts/simple-qfont-demo/viewer.cpp.
A leave event is sent to the widget when the mouse cursor leaves the widget.
See also enterEvent(), mouseMoveEvent(), and event().
After this call the widget will be visually behind (and therefore obscured by) any overlapping sibling widgets.
See also raise() and stackUnder().
In your reimplementation of this function, if you want to stop the event being handled by Qt, return TRUE. If you return FALSE, this native event is passed back to Qt, which translates the event into a Qt event and sends it to the widget.
Warning: This function is not portable.
See also QApplication::macEventFilter().
See also mapTo(), mapFromParent(), mapFromGlobal(), and underMouse.
See also mapToGlobal(), mapFrom(), and mapFromParent().
Same as mapFromGlobal() if the widget has no parent.
See also mapToParent(), mapFrom(), mapFromGlobal(), and underMouse.
See also mapFrom(), mapToParent(), mapToGlobal(), and underMouse.
See also mapFromGlobal(), mapTo(), and mapToParent().
Example: scribble/scribble.cpp.
Same as mapToGlobal() if the widget has no parent.
See also mapFromParent(), mapTo(), mapToGlobal(), and underMouse.
Returns the widget's maximum height. See the "maximumHeight" property for details.
Returns the widget's maximum size. See the "maximumSize" property for details.
Returns the widget's maximum width. See the "maximumWidth" property for details.
Use the QPaintDeviceMetrics class instead.
m is the metric to get.
Returns the currently set micro focus hint for this widget. See the "microFocusHint" property for details.
Returns the widget's minimum height. See the "minimumHeight" property for details.
Returns the widget's minimum size. See the "minimumSize" property for details.
Returns the recommended minimum size for the widget. See the "minimumSizeHint" property for details.
Reimplemented in QLineEdit.
Returns the widget's minimum width. See the "minimumWidth" property for details.
The default implementation generates a normal mouse press event.
Note that the widgets gets a mousePressEvent() and a mouseReleaseEvent() before the mouseDoubleClickEvent().
See also mousePressEvent(), mouseReleaseEvent(), mouseMoveEvent(), event(), and QMouseEvent.
If no widget in this application is currently grabbing the mouse, 0 is returned.
See also grabMouse() and keyboardGrabber().
If mouse tracking is switched off, mouse move events only occur if a mouse button is pressed while the mouse is being moved. If mouse tracking is switched on, mouse move events occur even if no mouse button is pressed.
QMouseEvent::pos() reports the position of the mouse cursor, relative to this widget. For press and release events, the position is usually the same as the position of the last mouse move event, but it might be different if the user's hand shakes. This is a feature of the underlying window system, not Qt.
See also mouseTracking, mousePressEvent(), mouseReleaseEvent(), mouseDoubleClickEvent(), event(), and QMouseEvent.
Examples: aclock/aclock.cpp, drawlines/connect.cpp, iconview/simple_dd/main.cpp, life/life.cpp, popup/popup.cpp, qmag/qmag.cpp, and scribble/scribble.cpp.
Reimplemented in QSizeGrip.
If you create new widgets in the mousePressEvent() the mouseReleaseEvent() may not end up where you expect, depending on the underlying window system (or X11 window manager), the widgets' location and maybe more.
The default implementation implements the closing of popup widgets when you click outside the window. For other widget types it does nothing.
See also mouseReleaseEvent(), mouseDoubleClickEvent(), mouseMoveEvent(), event(), and QMouseEvent.
Examples: biff/biff.cpp, drawlines/connect.cpp, iconview/simple_dd/main.cpp, life/life.cpp, qmag/qmag.cpp, scribble/scribble.cpp, and tooltip/tooltip.cpp.
Reimplemented in QSizeGrip.
See also mouseDoubleClickEvent(), mouseMoveEvent(), event(), and QMouseEvent.
Examples: drawlines/connect.cpp, hello/hello.cpp, popup/popup.cpp, qmag/qmag.cpp, scribble/scribble.cpp, showimg/showimg.cpp, and t14/cannon.cpp.
Sets the position of the widget within its parent widget. See the "pos" property for details.
This corresponds to move( QSize(x, y) ).
The old position is accessible through QMoveEvent::oldPos().
See also resizeEvent(), event(), pos, and QMoveEvent.
Returns TRUE if the widget uses its own cursor; otherwise returns FALSE. See the "ownCursor" property for details.
Returns TRUE if the widget uses its own font; otherwise returns FALSE. See the "ownFont" property for details.
Returns TRUE if the widget uses its own palette; otherwise returns FALSE. See the "ownPalette" property for details.
A paint event is a request to repaint all or part of the widget. It can happen as a result of repaint() or update(), or because the widget was obscured and has now been uncovered, or for many other reasons.
Many widgets can simply repaint their entire surface when asked to, but some slow widgets need to optimize by painting only the requested region: QPaintEvent::region(). This speed optimization does not change the result, as painting is clipped to that region during event processing. QListView and QCanvas do this, for example.
Qt also tries to speed up painting by merging multiple paint events into one. When update() is called several times or the window system sends several paint events, Qt merges these events into one event with a larger region (see QRegion::unite()). repaint() does not permit this optimization, so we suggest using update() when possible.
When the paint event occurs, the update region has normally been erased, so that you're painting on the widget's background. There are a couple of exceptions and QPaintEvent::erased() tells you whether the widget has been erased or not.
The background can be set using setBackgroundMode(), setPaletteBackgroundColor() or setBackgroundPixmap(). The documentation for setBackgroundMode() elaborates on the background; we recommend reading it.
See also event(), repaint(), update(), QPainter, QPixmap, and QPaintEvent.
Examples: drawdemo/drawdemo.cpp, drawlines/connect.cpp, qmag/qmag.cpp, scribble/scribble.cpp, splitter/splitter.cpp, t8/cannon.cpp, and t9/cannon.cpp.
Reimplemented in QButton, QFrame, QGLWidget, QSizeGrip, QStatusBar, and QTabBar.
Returns the widget's palette. See the "palette" property for details.
Returns the background color of the widget. See the "paletteBackgroundColor" property for details.
Returns the background pixmap of the widget. See the "paletteBackgroundPixmap" property for details.
This virtual function is called from setPalette(). oldPalette is the previous palette; you can get the new palette from palette().
Reimplement this function if your widget needs to know when its palette changes.
Returns the foreground color of the widget. See the "paletteForegroundColor" property for details.
Returns the parent of this widget, or 0 if it does not have any parent widget. If sameWindow is TRUE and the widget is top level returns 0; otherwise returns the widget's parent.
Example: mdi/application.cpp.
This function will be called after a widget has been fully created and before it is shown the very first time.
Polishing is useful for final initialization which depends on having an instantiated widget. This is something a constructor cannot guarantee since the initialization of the subclasses might not be finished.
After this function, the widget has a proper font and palette and QApplication::polish() has been called.
Remember to call QWidget's implementation when reimplementing this function.
See also constPolish() and QApplication::polish().
Example: menu/menu.cpp.
Returns the position of the widget within its parent widget. See the "pos" property for details.
In your reimplementation of this function, if you want to stop the event being handled by Qt, return TRUE. If you return FALSE, this native event is passed back to Qt, which translates the event into a Qt event and sends it to the widget.
Warning: This function is not portable.
See also QApplication::qwsEventFilter().
After this call the widget will be visually in front of any overlapping sibling widgets.
See also lower() and stackUnder().
Example: showimg/showimg.cpp.
This function is obsolete. It is provided to keep old source working. We strongly advise against using it in new code.
This method is provided to aid porting from Qt 1.0 to 2.0. It has been renamed reparent() in Qt 2.0.
Returns the internal geometry of the widget excluding any window frame. See the "rect" property for details.
See also grabKeyboard(), grabMouse(), and releaseMouse().
See also grabMouse(), grabKeyboard(), and releaseKeyboard().
If erase is TRUE, Qt erases the area (x, y, w, h) before the paintEvent() call.
If w is negative, it is replaced with width() - x, and if h is negative, it is replaced width height() - y.
We suggest only using repaint() if you need an immediate repaint, for example during animation. In almost all circumstances update() is better, as it permits Qt to optimize for speed and minimize flicker.
Warning: If you call repaint() in a function which may itself be called from paintEvent(), you may get infinite recursion. The update() function never causes recursion.
See also update(), paintEvent(), updatesEnabled, and erase().
Example: qwerty/qwerty.cpp.
This version erases and repaints the entire widget.
This version repaints the entire widget.
Repaints the widget directly by calling paintEvent() directly, unless updates are disabled or the widget is hidden.
Erases the widget region r if erase is TRUE.
Repaints the widget directly by calling paintEvent() directly, unless updates are disabled or the widget is hidden.
Erases the widget region reg if erase is TRUE.
Only use repaint if your widget needs to be repainted immediately, for example when doing some animation. In all other cases, use update(). Calling update() many times in a row will generate a single paint event.
Warning: If you call repaint() in a function which may itself be called from paintEvent(), you may get infinite recursion. The update() function never causes recursion.
See also update(), paintEvent(), updatesEnabled, and erase().
If showIt is TRUE, show() is called once the widget has been reparented.
If the new parent widget is in a different top-level widget, the reparented widget a