| /**************************************************************************** |
| ** |
| ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). |
| ** All rights reserved. |
| ** Contact: Nokia Corporation (qt-info@nokia.com) |
| ** |
| ** This file is part of the QtGui module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** GNU Lesser General Public License Usage |
| ** This file may be used under the terms of the GNU Lesser General Public |
| ** License version 2.1 as published by the Free Software Foundation and |
| ** appearing in the file LICENSE.LGPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU Lesser |
| ** General Public License version 2.1 requirements will be met: |
| ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. |
| ** |
| ** In addition, as a special exception, Nokia gives you certain additional |
| ** rights. These rights are described in the Nokia Qt LGPL Exception |
| ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU General |
| ** Public License version 3.0 as published by the Free Software Foundation |
| ** and appearing in the file LICENSE.GPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU General |
| ** Public License version 3.0 requirements will be met: |
| ** http://www.gnu.org/copyleft/gpl.html. |
| ** |
| ** Other Usage |
| ** Alternatively, this file may be used in accordance with the terms and |
| ** conditions contained in a signed written agreement between you and Nokia. |
| ** |
| ** |
| ** |
| ** |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #ifndef QWIDGET_H |
| #define QWIDGET_H |
| |
| #include <QtGui/qwindowdefs.h> |
| #include <QtCore/qobject.h> |
| #include <QtCore/qmargins.h> |
| #include <QtGui/qpaintdevice.h> |
| #include <QtGui/qpalette.h> |
| #include <QtGui/qfont.h> |
| #include <QtGui/qfontmetrics.h> |
| #include <QtGui/qfontinfo.h> |
| #include <QtGui/qsizepolicy.h> |
| #include <QtGui/qregion.h> |
| #include <QtGui/qbrush.h> |
| #include <QtGui/qcursor.h> |
| #include <QtGui/qkeysequence.h> |
| |
| #ifdef QT_INCLUDE_COMPAT |
| #include <QtGui/qevent.h> |
| #endif |
| |
| QT_BEGIN_HEADER |
| |
| QT_BEGIN_NAMESPACE |
| |
| QT_MODULE(Gui) |
| |
| class QLayout; |
| class QWSRegionManager; |
| class QStyle; |
| class QAction; |
| class QVariant; |
| |
| class QActionEvent; |
| class QMouseEvent; |
| class QWheelEvent; |
| class QHoverEvent; |
| class QKeyEvent; |
| class QFocusEvent; |
| class QPaintEvent; |
| class QMoveEvent; |
| class QResizeEvent; |
| class QCloseEvent; |
| class QContextMenuEvent; |
| class QInputMethodEvent; |
| class QTabletEvent; |
| class QDragEnterEvent; |
| class QDragMoveEvent; |
| class QDragLeaveEvent; |
| class QDropEvent; |
| class QShowEvent; |
| class QHideEvent; |
| class QInputContext; |
| class QIcon; |
| class QWindowSurface; |
| class QLocale; |
| class QGraphicsProxyWidget; |
| class QGraphicsEffect; |
| #if defined(Q_WS_X11) |
| class QX11Info; |
| #endif |
| |
| class QWidgetData |
| { |
| public: |
| WId winid; |
| uint widget_attributes; |
| Qt::WindowFlags window_flags; |
| uint window_state : 4; |
| uint focus_policy : 4; |
| uint sizehint_forced :1; |
| uint is_closing :1; |
| uint in_show : 1; |
| uint in_set_window_state : 1; |
| mutable uint fstrut_dirty : 1; |
| uint context_menu_policy : 3; |
| uint window_modality : 2; |
| uint in_destructor : 1; |
| uint unused : 13; |
| QRect crect; |
| mutable QPalette pal; |
| QFont fnt; |
| #if defined(Q_WS_QWS) |
| // QRegion req_region; // Requested region |
| // mutable QRegion paintable_region; // Paintable region |
| // mutable bool paintable_region_dirty;// needs to be recalculated |
| // mutable QRegion alloc_region; // Allocated region |
| // mutable bool alloc_region_dirty; // needs to be recalculated |
| // mutable int overlapping_children; // Handle overlapping children |
| |
| int alloc_region_index; |
| // int alloc_region_revision; |
| #endif |
| QRect wrect; |
| }; |
| |
| class QWidgetPrivate; |
| |
| class Q_GUI_EXPORT QWidget : public QObject, public QPaintDevice |
| { |
| Q_OBJECT |
| Q_DECLARE_PRIVATE(QWidget) |
| |
| Q_PROPERTY(bool modal READ isModal) |
| Q_PROPERTY(Qt::WindowModality windowModality READ windowModality WRITE setWindowModality) |
| Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled) |
| Q_PROPERTY(QRect geometry READ geometry WRITE setGeometry) |
| Q_PROPERTY(QRect frameGeometry READ frameGeometry) |
| Q_PROPERTY(QRect normalGeometry READ normalGeometry) |
| Q_PROPERTY(int x READ x) |
| Q_PROPERTY(int y READ y) |
| Q_PROPERTY(QPoint pos READ pos WRITE move DESIGNABLE false STORED false) |
| Q_PROPERTY(QSize frameSize READ frameSize) |
| Q_PROPERTY(QSize size READ size WRITE resize DESIGNABLE false STORED false) |
| Q_PROPERTY(int width READ width) |
| Q_PROPERTY(int height READ height) |
| Q_PROPERTY(QRect rect READ rect) |
| Q_PROPERTY(QRect childrenRect READ childrenRect) |
| Q_PROPERTY(QRegion childrenRegion READ childrenRegion) |
| Q_PROPERTY(QSizePolicy sizePolicy READ sizePolicy WRITE setSizePolicy) |
| Q_PROPERTY(QSize minimumSize READ minimumSize WRITE setMinimumSize) |
| Q_PROPERTY(QSize maximumSize READ maximumSize WRITE setMaximumSize) |
| Q_PROPERTY(int minimumWidth READ minimumWidth WRITE setMinimumWidth STORED false DESIGNABLE false) |
| Q_PROPERTY(int minimumHeight READ minimumHeight WRITE setMinimumHeight STORED false DESIGNABLE false) |
| Q_PROPERTY(int maximumWidth READ maximumWidth WRITE setMaximumWidth STORED false DESIGNABLE false) |
| Q_PROPERTY(int maximumHeight READ maximumHeight WRITE setMaximumHeight STORED false DESIGNABLE false) |
| Q_PROPERTY(QSize sizeIncrement READ sizeIncrement WRITE setSizeIncrement) |
| Q_PROPERTY(QSize baseSize READ baseSize WRITE setBaseSize) |
| Q_PROPERTY(QPalette palette READ palette WRITE setPalette) |
| Q_PROPERTY(QFont font READ font WRITE setFont) |
| #ifndef QT_NO_CURSOR |
| Q_PROPERTY(QCursor cursor READ cursor WRITE setCursor RESET unsetCursor) |
| #endif |
| Q_PROPERTY(bool mouseTracking READ hasMouseTracking WRITE setMouseTracking) |
| Q_PROPERTY(bool isActiveWindow READ isActiveWindow) |
| Q_PROPERTY(Qt::FocusPolicy focusPolicy READ focusPolicy WRITE setFocusPolicy) |
| Q_PROPERTY(bool focus READ hasFocus) |
| Q_PROPERTY(Qt::ContextMenuPolicy contextMenuPolicy READ contextMenuPolicy WRITE setContextMenuPolicy) |
| Q_PROPERTY(bool updatesEnabled READ updatesEnabled WRITE setUpdatesEnabled DESIGNABLE false) |
| Q_PROPERTY(bool visible READ isVisible WRITE setVisible DESIGNABLE false) |
| Q_PROPERTY(bool minimized READ isMinimized) |
| Q_PROPERTY(bool maximized READ isMaximized) |
| Q_PROPERTY(bool fullScreen READ isFullScreen) |
| Q_PROPERTY(QSize sizeHint READ sizeHint) |
| Q_PROPERTY(QSize minimumSizeHint READ minimumSizeHint) |
| Q_PROPERTY(bool acceptDrops READ acceptDrops WRITE setAcceptDrops) |
| Q_PROPERTY(QString windowTitle READ windowTitle WRITE setWindowTitle DESIGNABLE isWindow) |
| Q_PROPERTY(QIcon windowIcon READ windowIcon WRITE setWindowIcon DESIGNABLE isWindow) |
| Q_PROPERTY(QString windowIconText READ windowIconText WRITE setWindowIconText DESIGNABLE isWindow) |
| Q_PROPERTY(double windowOpacity READ windowOpacity WRITE setWindowOpacity DESIGNABLE isWindow) |
| Q_PROPERTY(bool windowModified READ isWindowModified WRITE setWindowModified DESIGNABLE isWindow) |
| #ifndef QT_NO_TOOLTIP |
| Q_PROPERTY(QString toolTip READ toolTip WRITE setToolTip) |
| #endif |
| #ifndef QT_NO_STATUSTIP |
| Q_PROPERTY(QString statusTip READ statusTip WRITE setStatusTip) |
| #endif |
| #ifndef QT_NO_WHATSTHIS |
| Q_PROPERTY(QString whatsThis READ whatsThis WRITE setWhatsThis) |
| #endif |
| #ifndef QT_NO_ACCESSIBILITY |
| Q_PROPERTY(QString accessibleName READ accessibleName WRITE setAccessibleName) |
| Q_PROPERTY(QString accessibleDescription READ accessibleDescription WRITE setAccessibleDescription) |
| #endif |
| Q_PROPERTY(Qt::LayoutDirection layoutDirection READ layoutDirection WRITE setLayoutDirection RESET unsetLayoutDirection) |
| QDOC_PROPERTY(Qt::WindowFlags windowFlags READ windowFlags WRITE setWindowFlags) |
| Q_PROPERTY(bool autoFillBackground READ autoFillBackground WRITE setAutoFillBackground) |
| #ifndef QT_NO_STYLE_STYLESHEET |
| Q_PROPERTY(QString styleSheet READ styleSheet WRITE setStyleSheet) |
| #endif |
| Q_PROPERTY(QLocale locale READ locale WRITE setLocale RESET unsetLocale) |
| Q_PROPERTY(QString windowFilePath READ windowFilePath WRITE setWindowFilePath DESIGNABLE isWindow) |
| Q_PROPERTY(Qt::InputMethodHints inputMethodHints READ inputMethodHints WRITE setInputMethodHints) |
| |
| public: |
| enum RenderFlag { |
| DrawWindowBackground = 0x1, |
| DrawChildren = 0x2, |
| IgnoreMask = 0x4 |
| }; |
| Q_DECLARE_FLAGS(RenderFlags, RenderFlag) |
| |
| explicit QWidget(QWidget* parent = 0, Qt::WindowFlags f = 0); |
| #ifdef QT3_SUPPORT |
| QT3_SUPPORT_CONSTRUCTOR QWidget(QWidget* parent, const char *name, Qt::WindowFlags f = 0); |
| #endif |
| ~QWidget(); |
| |
| int devType() const; |
| |
| WId winId() const; |
| void createWinId(); // internal, going away |
| inline WId internalWinId() const { return data->winid; } |
| WId effectiveWinId() const; |
| |
| // GUI style setting |
| QStyle *style() const; |
| void setStyle(QStyle *); |
| // Widget types and states |
| |
| bool isTopLevel() const; |
| bool isWindow() const; |
| |
| bool isModal() const; |
| Qt::WindowModality windowModality() const; |
| void setWindowModality(Qt::WindowModality windowModality); |
| |
| bool isEnabled() const; |
| bool isEnabledTo(QWidget*) const; |
| bool isEnabledToTLW() const; |
| |
| public Q_SLOTS: |
| void setEnabled(bool); |
| void setDisabled(bool); |
| void setWindowModified(bool); |
| |
| // Widget coordinates |
| |
| public: |
| QRect frameGeometry() const; |
| const QRect &geometry() const; |
| QRect normalGeometry() const; |
| |
| int x() const; |
| int y() const; |
| QPoint pos() const; |
| QSize frameSize() const; |
| QSize size() const; |
| inline int width() const; |
| inline int height() const; |
| inline QRect rect() const; |
| QRect childrenRect() const; |
| QRegion childrenRegion() const; |
| |
| QSize minimumSize() const; |
| QSize maximumSize() const; |
| int minimumWidth() const; |
| int minimumHeight() const; |
| int maximumWidth() const; |
| int maximumHeight() const; |
| void setMinimumSize(const QSize &); |
| void setMinimumSize(int minw, int minh); |
| void setMaximumSize(const QSize &); |
| void setMaximumSize(int maxw, int maxh); |
| void setMinimumWidth(int minw); |
| void setMinimumHeight(int minh); |
| void setMaximumWidth(int maxw); |
| void setMaximumHeight(int maxh); |
| |
| #ifdef Q_QDOC |
| void setupUi(QWidget *widget); |
| #endif |
| |
| QSize sizeIncrement() const; |
| void setSizeIncrement(const QSize &); |
| void setSizeIncrement(int w, int h); |
| QSize baseSize() const; |
| void setBaseSize(const QSize &); |
| void setBaseSize(int basew, int baseh); |
| |
| void setFixedSize(const QSize &); |
| void setFixedSize(int w, int h); |
| void setFixedWidth(int w); |
| void setFixedHeight(int h); |
| |
| // Widget coordinate mapping |
| |
| QPoint mapToGlobal(const QPoint &) const; |
| QPoint mapFromGlobal(const QPoint &) const; |
| QPoint mapToParent(const QPoint &) const; |
| QPoint mapFromParent(const QPoint &) const; |
| QPoint mapTo(QWidget *, const QPoint &) const; |
| QPoint mapFrom(QWidget *, const QPoint &) const; |
| |
| QWidget *window() const; |
| QWidget *nativeParentWidget() const; |
| inline QWidget *topLevelWidget() const { return window(); } |
| |
| // Widget appearance functions |
| const QPalette &palette() const; |
| void setPalette(const QPalette &); |
| |
| void setBackgroundRole(QPalette::ColorRole); |
| QPalette::ColorRole backgroundRole() const; |
| |
| void setForegroundRole(QPalette::ColorRole); |
| QPalette::ColorRole foregroundRole() const; |
| |
| const QFont &font() const; |
| void setFont(const QFont &); |
| QFontMetrics fontMetrics() const; |
| QFontInfo fontInfo() const; |
| |
| #ifndef QT_NO_CURSOR |
| QCursor cursor() const; |
| void setCursor(const QCursor &); |
| void unsetCursor(); |
| #endif |
| |
| void setMouseTracking(bool enable); |
| bool hasMouseTracking() const; |
| bool underMouse() const; |
| |
| void setMask(const QBitmap &); |
| void setMask(const QRegion &); |
| QRegion mask() const; |
| void clearMask(); |
| |
| void render(QPaintDevice *target, const QPoint &targetOffset = QPoint(), |
| const QRegion &sourceRegion = QRegion(), |
| RenderFlags renderFlags = RenderFlags(DrawWindowBackground | DrawChildren)); |
| |
| void render(QPainter *painter, const QPoint &targetOffset = QPoint(), |
| const QRegion &sourceRegion = QRegion(), |
| RenderFlags renderFlags = RenderFlags(DrawWindowBackground | DrawChildren)); |
| |
| #ifndef QT_NO_GRAPHICSEFFECT |
| QGraphicsEffect *graphicsEffect() const; |
| void setGraphicsEffect(QGraphicsEffect *effect); |
| #endif //QT_NO_GRAPHICSEFFECT |
| |
| #ifndef QT_NO_GESTURES |
| void grabGesture(Qt::GestureType type, Qt::GestureFlags flags = Qt::GestureFlags()); |
| void ungrabGesture(Qt::GestureType type); |
| #endif |
| |
| public Q_SLOTS: |
| void setWindowTitle(const QString &); |
| #ifndef QT_NO_STYLE_STYLESHEET |
| void setStyleSheet(const QString& styleSheet); |
| #endif |
| public: |
| #ifndef QT_NO_STYLE_STYLESHEET |
| QString styleSheet() const; |
| #endif |
| QString windowTitle() const; |
| void setWindowIcon(const QIcon &icon); |
| QIcon windowIcon() const; |
| void setWindowIconText(const QString &); |
| QString windowIconText() const; |
| void setWindowRole(const QString &); |
| QString windowRole() const; |
| void setWindowFilePath(const QString &filePath); |
| QString windowFilePath() const; |
| |
| void setWindowOpacity(qreal level); |
| qreal windowOpacity() const; |
| |
| bool isWindowModified() const; |
| #ifndef QT_NO_TOOLTIP |
| void setToolTip(const QString &); |
| QString toolTip() const; |
| #endif |
| #ifndef QT_NO_STATUSTIP |
| void setStatusTip(const QString &); |
| QString statusTip() const; |
| #endif |
| #ifndef QT_NO_WHATSTHIS |
| void setWhatsThis(const QString &); |
| QString whatsThis() const; |
| #endif |
| #ifndef QT_NO_ACCESSIBILITY |
| QString accessibleName() const; |
| void setAccessibleName(const QString &name); |
| QString accessibleDescription() const; |
| void setAccessibleDescription(const QString &description); |
| #endif |
| |
| void setLayoutDirection(Qt::LayoutDirection direction); |
| Qt::LayoutDirection layoutDirection() const; |
| void unsetLayoutDirection(); |
| |
| void setLocale(const QLocale &locale); |
| QLocale locale() const; |
| void unsetLocale(); |
| |
| inline bool isRightToLeft() const { return layoutDirection() == Qt::RightToLeft; } |
| inline bool isLeftToRight() const { return layoutDirection() == Qt::LeftToRight; } |
| |
| public Q_SLOTS: |
| inline void setFocus() { setFocus(Qt::OtherFocusReason); } |
| |
| public: |
| bool isActiveWindow() const; |
| void activateWindow(); |
| void clearFocus(); |
| |
| void setFocus(Qt::FocusReason reason); |
| Qt::FocusPolicy focusPolicy() const; |
| void setFocusPolicy(Qt::FocusPolicy policy); |
| bool hasFocus() const; |
| static void setTabOrder(QWidget *, QWidget *); |
| void setFocusProxy(QWidget *); |
| QWidget *focusProxy() const; |
| Qt::ContextMenuPolicy contextMenuPolicy() const; |
| void setContextMenuPolicy(Qt::ContextMenuPolicy policy); |
| |
| // Grab functions |
| void grabMouse(); |
| #ifndef QT_NO_CURSOR |
| void grabMouse(const QCursor &); |
| #endif |
| void releaseMouse(); |
| void grabKeyboard(); |
| void releaseKeyboard(); |
| #ifndef QT_NO_SHORTCUT |
| int grabShortcut(const QKeySequence &key, Qt::ShortcutContext context = Qt::WindowShortcut); |
| void releaseShortcut(int id); |
| void setShortcutEnabled(int id, bool enable = true); |
| void setShortcutAutoRepeat(int id, bool enable = true); |
| #endif |
| static QWidget *mouseGrabber(); |
| static QWidget *keyboardGrabber(); |
| |
| // Update/refresh functions |
| inline bool updatesEnabled() const; |
| void setUpdatesEnabled(bool enable); |
| |
| #if 0 //def Q_WS_QWS |
| void repaintUnclipped(const QRegion &, bool erase = true); |
| #endif |
| |
| #ifndef QT_NO_GRAPHICSVIEW |
| QGraphicsProxyWidget *graphicsProxyWidget() const; |
| #endif |
| |
| public Q_SLOTS: |
| void update(); |
| void repaint(); |
| |
| public: |
| inline void update(int x, int y, int w, int h); |
| void update(const QRect&); |
| void update(const QRegion&); |
| |
| void repaint(int x, int y, int w, int h); |
| void repaint(const QRect &); |
| void repaint(const QRegion &); |
| |
| public Q_SLOTS: |
| // Widget management functions |
| |
| virtual void setVisible(bool visible); |
| inline void setHidden(bool hidden) { setVisible(!hidden); } |
| #ifndef Q_WS_WINCE |
| inline void show() { setVisible(true); } |
| #else |
| void show(); |
| #endif |
| inline void hide() { setVisible(false); } |
| inline QT_MOC_COMPAT void setShown(bool shown) { setVisible(shown); } |
| |
| void showMinimized(); |
| void showMaximized(); |
| void showFullScreen(); |
| void showNormal(); |
| |
| bool close(); |
| void raise(); |
| void lower(); |
| |
| public: |
| void stackUnder(QWidget*); |
| void move(int x, int y); |
| void move(const QPoint &); |
| void resize(int w, int h); |
| void resize(const QSize &); |
| inline void setGeometry(int x, int y, int w, int h); |
| void setGeometry(const QRect &); |
| QByteArray saveGeometry() const; |
| bool restoreGeometry(const QByteArray &geometry); |
| void adjustSize(); |
| bool isVisible() const; |
| bool isVisibleTo(QWidget*) const; |
| // ### Qt 5: bool isVisibleTo(_const_ QWidget *) const |
| inline bool isHidden() const; |
| |
| bool isMinimized() const; |
| bool isMaximized() const; |
| bool isFullScreen() const; |
| |
| Qt::WindowStates windowState() const; |
| void setWindowState(Qt::WindowStates state); |
| void overrideWindowState(Qt::WindowStates state); |
| |
| virtual QSize sizeHint() const; |
| virtual QSize minimumSizeHint() const; |
| |
| QSizePolicy sizePolicy() const; |
| void setSizePolicy(QSizePolicy); |
| inline void setSizePolicy(QSizePolicy::Policy horizontal, QSizePolicy::Policy vertical); |
| virtual int heightForWidth(int) const; |
| |
| QRegion visibleRegion() const; |
| |
| void setContentsMargins(int left, int top, int right, int bottom); |
| void setContentsMargins(const QMargins &margins); |
| void getContentsMargins(int *left, int *top, int *right, int *bottom) const; |
| QMargins contentsMargins() const; |
| |
| QRect contentsRect() const; |
| |
| public: |
| QLayout *layout() const; |
| void setLayout(QLayout *); |
| void updateGeometry(); |
| |
| void setParent(QWidget *parent); |
| void setParent(QWidget *parent, Qt::WindowFlags f); |
| |
| void scroll(int dx, int dy); |
| void scroll(int dx, int dy, const QRect&); |
| |
| // Misc. functions |
| |
| QWidget *focusWidget() const; |
| QWidget *nextInFocusChain() const; |
| QWidget *previousInFocusChain() const; |
| |
| // drag and drop |
| bool acceptDrops() const; |
| void setAcceptDrops(bool on); |
| |
| #ifndef QT_NO_ACTION |
| //actions |
| void addAction(QAction *action); |
| void addActions(QList<QAction*> actions); |
| void insertAction(QAction *before, QAction *action); |
| void insertActions(QAction *before, QList<QAction*> actions); |
| void removeAction(QAction *action); |
| QList<QAction*> actions() const; |
| #endif |
| |
| QWidget *parentWidget() const; |
| |
| void setWindowFlags(Qt::WindowFlags type); |
| inline Qt::WindowFlags windowFlags() const; |
| void overrideWindowFlags(Qt::WindowFlags type); |
| |
| inline Qt::WindowType windowType() const; |
| |
| static QWidget *find(WId); |
| #ifdef QT3_SUPPORT |
| static QT3_SUPPORT QWidgetMapper *wmapper(); |
| #endif |
| inline QWidget *childAt(int x, int y) const; |
| QWidget *childAt(const QPoint &p) const; |
| |
| #if defined(Q_WS_X11) |
| const QX11Info &x11Info() const; |
| Qt::HANDLE x11PictureHandle() const; |
| #endif |
| |
| #if defined(Q_WS_MAC) |
| Qt::HANDLE macQDHandle() const; |
| Qt::HANDLE macCGHandle() const; |
| #endif |
| |
| #if defined(Q_WS_WIN) |
| HDC getDC() const; |
| void releaseDC(HDC) const; |
| #else |
| Qt::HANDLE handle() const; |
| #endif |
| |
| void setAttribute(Qt::WidgetAttribute, bool on = true); |
| inline bool testAttribute(Qt::WidgetAttribute) const; |
| |
| QPaintEngine *paintEngine() const; |
| |
| void ensurePolished() const; |
| |
| QInputContext *inputContext(); |
| void setInputContext(QInputContext *); |
| |
| bool isAncestorOf(const QWidget *child) const; |
| |
| #ifdef QT_KEYPAD_NAVIGATION |
| bool hasEditFocus() const; |
| void setEditFocus(bool on); |
| #endif |
| |
| bool autoFillBackground() const; |
| void setAutoFillBackground(bool enabled); |
| |
| void setWindowSurface(QWindowSurface *surface); |
| QWindowSurface *windowSurface() const; |
| |
| Q_SIGNALS: |
| void customContextMenuRequested(const QPoint &pos); |
| |
| protected: |
| // Event handlers |
| bool event(QEvent *); |
| virtual void mousePressEvent(QMouseEvent *); |
| virtual void mouseReleaseEvent(QMouseEvent *); |
| virtual void mouseDoubleClickEvent(QMouseEvent *); |
| virtual void mouseMoveEvent(QMouseEvent *); |
| #ifndef QT_NO_WHEELEVENT |
| virtual void wheelEvent(QWheelEvent *); |
| #endif |
| virtual void keyPressEvent(QKeyEvent *); |
| virtual void keyReleaseEvent(QKeyEvent *); |
| virtual void focusInEvent(QFocusEvent *); |
| virtual void focusOutEvent(QFocusEvent *); |
| virtual void enterEvent(QEvent *); |
| virtual void leaveEvent(QEvent *); |
| virtual void paintEvent(QPaintEvent *); |
| virtual void moveEvent(QMoveEvent *); |
| virtual void resizeEvent(QResizeEvent *); |
| virtual void closeEvent(QCloseEvent *); |
| #ifndef QT_NO_CONTEXTMENU |
| virtual void contextMenuEvent(QContextMenuEvent *); |
| #endif |
| #ifndef QT_NO_TABLETEVENT |
| virtual void tabletEvent(QTabletEvent *); |
| #endif |
| #ifndef QT_NO_ACTION |
| virtual void actionEvent(QActionEvent *); |
| #endif |
| |
| #ifndef QT_NO_DRAGANDDROP |
| virtual void dragEnterEvent(QDragEnterEvent *); |
| virtual void dragMoveEvent(QDragMoveEvent *); |
| virtual void dragLeaveEvent(QDragLeaveEvent *); |
| virtual void dropEvent(QDropEvent *); |
| #endif |
| |
| virtual void showEvent(QShowEvent *); |
| virtual void hideEvent(QHideEvent *); |
| |
| #if defined(Q_WS_MAC) |
| virtual bool macEvent(EventHandlerCallRef, EventRef); |
| #endif |
| #if defined(Q_WS_WIN) |
| virtual bool winEvent(MSG *message, long *result); |
| #endif |
| #if defined(Q_WS_X11) |
| virtual bool x11Event(XEvent *); |
| #endif |
| #if defined(Q_WS_QWS) |
| virtual bool qwsEvent(QWSEvent *); |
| #endif |
| |
| // Misc. protected functions |
| virtual void changeEvent(QEvent *); |
| |
| int metric(PaintDeviceMetric) const; |
| |
| virtual void inputMethodEvent(QInputMethodEvent *); |
| public: |
| virtual QVariant inputMethodQuery(Qt::InputMethodQuery) const; |
| |
| Qt::InputMethodHints inputMethodHints() const; |
| void setInputMethodHints(Qt::InputMethodHints hints); |
| |
| protected: |
| void resetInputContext(); |
| protected Q_SLOTS: |
| void updateMicroFocus(); |
| protected: |
| |
| void create(WId = 0, bool initializeWindow = true, |
| bool destroyOldWindow = true); |
| void destroy(bool destroyWindow = true, |
| bool destroySubWindows = true); |
| |
| virtual bool focusNextPrevChild(bool next); |
| inline bool focusNextChild() { return focusNextPrevChild(true); } |
| inline bool focusPreviousChild() { return focusNextPrevChild(false); } |
| |
| protected: |
| QWidget(QWidgetPrivate &d, QWidget* parent, Qt::WindowFlags f); |
| private: |
| |
| bool testAttribute_helper(Qt::WidgetAttribute) const; |
| |
| QLayout *takeLayout(); |
| |
| friend class QBackingStoreDevice; |
| friend class QWidgetBackingStore; |
| friend class QApplication; |
| friend class QApplicationPrivate; |
| friend class QBaseApplication; |
| friend class QPainter; |
| friend class QPainterPrivate; |
| friend class QPixmap; // for QPixmap::fill() |
| friend class QFontMetrics; |
| friend class QFontInfo; |
| friend class QETWidget; |
| friend class QLayout; |
| friend class QWidgetItem; |
| friend class QWidgetItemV2; |
| friend class QGLContext; |
| friend class QGLWidget; |
| friend class QGLWindowSurface; |
| friend class QX11PaintEngine; |
| friend class QWin32PaintEngine; |
| friend class QShortcutPrivate; |
| friend class QShortcutMap; |
| friend class QWindowSurface; |
| friend class QGraphicsProxyWidget; |
| friend class QGraphicsProxyWidgetPrivate; |
| friend class QStyleSheetStyle; |
| friend struct QWidgetExceptionCleaner; |
| #ifndef QT_NO_GESTURES |
| friend class QGestureManager; |
| friend class QWinNativePanGestureRecognizer; |
| #endif // QT_NO_GESTURES |
| friend class QWidgetEffectSourcePrivate; |
| |
| #ifdef Q_WS_MAC |
| friend class QCoreGraphicsPaintEnginePrivate; |
| friend QPoint qt_mac_posInWindow(const QWidget *w); |
| friend OSWindowRef qt_mac_window_for(const QWidget *w); |
| friend bool qt_mac_is_metal(const QWidget *w); |
| friend OSViewRef qt_mac_nativeview_for(const QWidget *w); |
| friend void qt_event_request_window_change(QWidget *widget); |
| friend bool qt_mac_sendMacEventToWidget(QWidget *widget, EventRef ref); |
| #endif |
| #ifdef Q_WS_QWS |
| friend class QWSBackingStore; |
| friend class QWSManager; |
| friend class QWSManagerPrivate; |
| friend class QDecoration; |
| friend class QWSWindowSurface; |
| friend class QScreen; |
| friend class QVNCScreen; |
| friend bool isWidgetOpaque(const QWidget *); |
| friend class QGLWidgetPrivate; |
| #endif |
| #ifdef Q_OS_SYMBIAN |
| friend class QSymbianControl; |
| friend class QS60WindowSurface; |
| #endif |
| #ifdef Q_WS_X11 |
| friend void qt_net_update_user_time(QWidget *tlw, unsigned long timestamp); |
| friend void qt_net_remove_user_time(QWidget *tlw); |
| friend void qt_set_winid_on_widget(QWidget*, Qt::HANDLE); |
| #endif |
| |
| friend Q_GUI_EXPORT QWidgetData *qt_qwidget_data(QWidget *widget); |
| friend Q_GUI_EXPORT QWidgetPrivate *qt_widget_private(QWidget *widget); |
| |
| private: |
| Q_DISABLE_COPY(QWidget) |
| Q_PRIVATE_SLOT(d_func(), void _q_showIfNotHidden()) |
| #ifdef Q_OS_SYMBIAN |
| Q_PRIVATE_SLOT(d_func(), void _q_delayedDestroy(WId winId)) |
| #endif |
| |
| QWidgetData *data; |
| |
| #ifdef QT3_SUPPORT |
| public: |
| inline QT3_SUPPORT bool isUpdatesEnabled() const { return updatesEnabled(); } |
| QT3_SUPPORT QStyle *setStyle(const QString&); |
| inline QT3_SUPPORT bool isVisibleToTLW() const; |
| QT3_SUPPORT QRect visibleRect() const; |
| inline QT3_SUPPORT void iconify() { showMinimized(); } |
| inline QT3_SUPPORT void constPolish() const { ensurePolished(); } |
| inline QT3_SUPPORT void polish() { ensurePolished(); } |
| inline QT3_SUPPORT void reparent(QWidget *parent, Qt::WindowFlags f, const QPoint &p, bool showIt=false) |
| { setParent(parent, f); setGeometry(p.x(),p.y(),width(),height()); if (showIt) show(); } |
| inline QT3_SUPPORT void reparent(QWidget *parent, const QPoint &p, bool showIt=false) |
| { setParent(parent, windowFlags() & ~Qt::WindowType_Mask); setGeometry(p.x(),p.y(),width(),height()); if (showIt) show(); } |
| inline QT3_SUPPORT void recreate(QWidget *parent, Qt::WindowFlags f, const QPoint & p, bool showIt=false) |
| { setParent(parent, f); setGeometry(p.x(),p.y(),width(),height()); if (showIt) show(); } |
| inline QT3_SUPPORT void setSizePolicy(QSizePolicy::Policy hor, QSizePolicy::Policy ver, bool hfw) |
| { QSizePolicy sp(hor, ver); sp.setHeightForWidth(hfw); setSizePolicy(sp);} |
| inline QT3_SUPPORT bool hasMouse() const { return testAttribute(Qt::WA_UnderMouse); } |
| #ifndef QT_NO_CURSOR |
| inline QT3_SUPPORT bool ownCursor() const { return testAttribute(Qt::WA_SetCursor); } |
| #endif |
| inline QT3_SUPPORT bool ownFont() const { return testAttribute(Qt::WA_SetFont); } |
| inline QT3_SUPPORT void unsetFont() { setFont(QFont()); } |
| inline QT3_SUPPORT bool ownPalette() const { return testAttribute(Qt::WA_SetPalette); } |
| inline QT3_SUPPORT void unsetPalette() { setPalette(QPalette()); } |
| Qt::BackgroundMode QT3_SUPPORT backgroundMode() const; |
| void QT3_SUPPORT setBackgroundMode(Qt::BackgroundMode, Qt::BackgroundMode = Qt::PaletteBackground); |
| const QT3_SUPPORT QColor &eraseColor() const; |
| void QT3_SUPPORT setEraseColor(const QColor &); |
| const QT3_SUPPORT QColor &foregroundColor() const; |
| const QT3_SUPPORT QPixmap *erasePixmap() const; |
| void QT3_SUPPORT setErasePixmap(const QPixmap &); |
| const QT3_SUPPORT QColor &paletteForegroundColor() const; |
| void QT3_SUPPORT setPaletteForegroundColor(const QColor &); |
| const QT3_SUPPORT QColor &paletteBackgroundColor() const; |
| void QT3_SUPPORT setPaletteBackgroundColor(const QColor &); |
| const QT3_SUPPORT QPixmap *paletteBackgroundPixmap() const; |
| void QT3_SUPPORT setPaletteBackgroundPixmap(const QPixmap &); |
| const QT3_SUPPORT QBrush& backgroundBrush() const; |
| const QT3_SUPPORT QColor &backgroundColor() const; |
| const QT3_SUPPORT QPixmap *backgroundPixmap() const; |
| void QT3_SUPPORT setBackgroundPixmap(const QPixmap &); |
| QT3_SUPPORT void setBackgroundColor(const QColor &); |
| QT3_SUPPORT QColorGroup colorGroup() const; |
| QT3_SUPPORT QWidget *parentWidget(bool sameWindow) const; |
| inline QT3_SUPPORT void setKeyCompression(bool b) { setAttribute(Qt::WA_KeyCompression, b); } |
| inline QT3_SUPPORT void setFont(const QFont &f, bool) { setFont(f); } |
| inline QT3_SUPPORT void setPalette(const QPalette &p, bool) { setPalette(p); } |
| enum BackgroundOrigin { WidgetOrigin, ParentOrigin, WindowOrigin, AncestorOrigin }; |
| inline QT3_SUPPORT void setBackgroundOrigin(BackgroundOrigin) {} |
| inline QT3_SUPPORT BackgroundOrigin backgroundOrigin() const { return WindowOrigin; } |
| inline QT3_SUPPORT QPoint backgroundOffset() const { return QPoint(); } |
| inline QT3_SUPPORT void repaint(bool) { repaint(); } |
| inline QT3_SUPPORT void repaint(int x, int y, int w, int h, bool) { repaint(x,y,w,h); } |
| inline QT3_SUPPORT void repaint(const QRect &r, bool) { repaint(r); } |
| inline QT3_SUPPORT void repaint(const QRegion &rgn, bool) { repaint(rgn); } |
| QT3_SUPPORT void erase(); |
| inline QT3_SUPPORT void erase(int x, int y, int w, int h) { erase_helper(x, y, w, h); } |
| QT3_SUPPORT void erase(const QRect &); |
| QT3_SUPPORT void erase(const QRegion &); |
| QT3_SUPPORT void drawText(const QPoint &p, const QString &s) |
| { drawText_helper(p.x(), p.y(), s); } |
| inline QT3_SUPPORT void drawText(int x, int y, const QString &s) |
| { drawText_helper(x, y, s); } |
| QT3_SUPPORT bool close(bool); |
| inline QT3_SUPPORT QWidget *childAt(int x, int y, bool includeThis) const |
| { |
| QWidget *w = childAt(x, y); |
| return w ? w : ((includeThis && rect().contains(x,y))?const_cast<QWidget*>(this):0); |
| } |
| inline QT3_SUPPORT QWidget *childAt(const QPoint &p, bool includeThis) const |
| { |
| QWidget *w = childAt(p); |
| return w ? w : ((includeThis && rect().contains(p))?const_cast<QWidget*>(this):0); |
| } |
| inline QT3_SUPPORT void setCaption(const QString &c) { setWindowTitle(c); } |
| QT3_SUPPORT void setIcon(const QPixmap &i); |
| inline QT3_SUPPORT void setIconText(const QString &it) { setWindowIconText(it); } |
| inline QT3_SUPPORT QString caption() const { return windowTitle(); } |
| QT3_SUPPORT const QPixmap *icon() const; |
| inline QT3_SUPPORT QString iconText() const { return windowIconText(); } |
| inline QT3_SUPPORT void setInputMethodEnabled(bool b) { setAttribute(Qt::WA_InputMethodEnabled, b); } |
| inline QT3_SUPPORT bool isInputMethodEnabled() const { return testAttribute(Qt::WA_InputMethodEnabled); } |
| inline QT3_SUPPORT void setActiveWindow() { activateWindow(); } |
| inline QT3_SUPPORT bool isShown() const { return !isHidden(); } |
| inline QT3_SUPPORT bool isDialog() const { return windowType() == Qt::Dialog; } |
| inline QT3_SUPPORT bool isPopup() const { return windowType() == Qt::Popup; } |
| inline QT3_SUPPORT bool isDesktop() const { return windowType() == Qt::Desktop; } |
| |
| |
| private: |
| void drawText_helper(int x, int y, const QString &); |
| void erase_helper(int x, int y, int w, int h); |
| #endif // QT3_SUPPORT |
| |
| protected: |
| virtual void styleChange(QStyle&); // compat |
| virtual void enabledChange(bool); // compat |
| virtual void paletteChange(const QPalette &); // compat |
| virtual void fontChange(const QFont &); // compat |
| virtual void windowActivationChange(bool); // compat |
| virtual void languageChange(); // compat |
| }; |
| |
| Q_DECLARE_OPERATORS_FOR_FLAGS(QWidget::RenderFlags) |
| |
| #if defined Q_CC_MSVC && _MSC_VER < 1300 |
| template <> inline QWidget *qobject_cast_helper<QWidget*>(QObject *o, QWidget *) |
| { |
| if (!o || !o->isWidgetType()) return 0; |
| return (QWidget*)(o); |
| } |
| #else |
| template <> inline QWidget *qobject_cast<QWidget*>(QObject *o) |
| { |
| if (!o || !o->isWidgetType()) return 0; |
| return static_cast<QWidget*>(o); |
| } |
| template <> inline const QWidget *qobject_cast<const QWidget*>(const QObject *o) |
| { |
| if (!o || !o->isWidgetType()) return 0; |
| return static_cast<const QWidget*>(o); |
| } |
| #endif |
| |
| inline QWidget *QWidget::childAt(int ax, int ay) const |
| { return childAt(QPoint(ax, ay)); } |
| |
| inline Qt::WindowType QWidget::windowType() const |
| { return static_cast<Qt::WindowType>(int(data->window_flags & Qt::WindowType_Mask)); } |
| inline Qt::WindowFlags QWidget::windowFlags() const |
| { return data->window_flags; } |
| |
| inline bool QWidget::isTopLevel() const |
| { return (windowType() & Qt::Window); } |
| |
| inline bool QWidget::isWindow() const |
| { return (windowType() & Qt::Window); } |
| |
| inline bool QWidget::isEnabled() const |
| { return !testAttribute(Qt::WA_Disabled); } |
| |
| inline bool QWidget::isModal() const |
| { return data->window_modality != Qt::NonModal; } |
| |
| inline bool QWidget::isEnabledToTLW() const |
| { return isEnabled(); } |
| |
| inline int QWidget::minimumWidth() const |
| { return minimumSize().width(); } |
| |
| inline int QWidget::minimumHeight() const |
| { return minimumSize().height(); } |
| |
| inline int QWidget::maximumWidth() const |
| { return maximumSize().width(); } |
| |
| inline int QWidget::maximumHeight() const |
| { return maximumSize().height(); } |
| |
| inline void QWidget::setMinimumSize(const QSize &s) |
| { setMinimumSize(s.width(),s.height()); } |
| |
| inline void QWidget::setMaximumSize(const QSize &s) |
| { setMaximumSize(s.width(),s.height()); } |
| |
| inline void QWidget::setSizeIncrement(const QSize &s) |
| { setSizeIncrement(s.width(),s.height()); } |
| |
| inline void QWidget::setBaseSize(const QSize &s) |
| { setBaseSize(s.width(),s.height()); } |
| |
| inline const QFont &QWidget::font() const |
| { return data->fnt; } |
| |
| inline QFontMetrics QWidget::fontMetrics() const |
| { return QFontMetrics(data->fnt); } |
| |
| inline QFontInfo QWidget::fontInfo() const |
| { return QFontInfo(data->fnt); } |
| |
| inline void QWidget::setMouseTracking(bool enable) |
| { setAttribute(Qt::WA_MouseTracking, enable); } |
| |
| inline bool QWidget::hasMouseTracking() const |
| { return testAttribute(Qt::WA_MouseTracking); } |
| |
| inline bool QWidget::underMouse() const |
| { return testAttribute(Qt::WA_UnderMouse); } |
| |
| inline bool QWidget::updatesEnabled() const |
| { return !testAttribute(Qt::WA_UpdatesDisabled); } |
| |
| inline void QWidget::update(int ax, int ay, int aw, int ah) |
| { update(QRect(ax, ay, aw, ah)); } |
| |
| inline bool QWidget::isVisible() const |
| { return testAttribute(Qt::WA_WState_Visible); } |
| |
| inline bool QWidget::isHidden() const |
| { return testAttribute(Qt::WA_WState_Hidden); } |
| |
| inline void QWidget::move(int ax, int ay) |
| { move(QPoint(ax, ay)); } |
| |
| inline void QWidget::resize(int w, int h) |
| { resize(QSize(w, h)); } |
| |
| inline void QWidget::setGeometry(int ax, int ay, int aw, int ah) |
| { setGeometry(QRect(ax, ay, aw, ah)); } |
| |
| inline QRect QWidget::rect() const |
| { return QRect(0,0,data->crect.width(),data->crect.height()); } |
| |
| inline const QRect &QWidget::geometry() const |
| { return data->crect; } |
| |
| inline QSize QWidget::size() const |
| { return data->crect.size(); } |
| |
| inline int QWidget::width() const |
| { return data->crect.width(); } |
| |
| inline int QWidget::height() const |
| { return data->crect.height(); } |
| |
| inline QWidget *QWidget::parentWidget() const |
| { return static_cast<QWidget *>(QObject::parent()); } |
| |
| inline void QWidget::setSizePolicy(QSizePolicy::Policy hor, QSizePolicy::Policy ver) |
| { setSizePolicy(QSizePolicy(hor, ver)); } |
| |
| inline bool QWidget::testAttribute(Qt::WidgetAttribute attribute) const |
| { |
| if (attribute < int(8*sizeof(uint))) |
| return data->widget_attributes & (1<<attribute); |
| return testAttribute_helper(attribute); |
| } |
| |
| #ifdef QT3_SUPPORT |
| inline bool QWidget::isVisibleToTLW() const |
| { return isVisible(); } |
| inline QWidget *QWidget::parentWidget(bool sameWindow) const |
| { |
| if (sameWindow && isWindow()) |
| return 0; |
| return static_cast<QWidget *>(QObject::parent()); |
| } |
| inline QColorGroup QWidget::colorGroup() const |
| { return QColorGroup(palette()); } |
| inline void QWidget::setPaletteForegroundColor(const QColor &c) |
| { QPalette p = palette(); p.setColor(foregroundRole(), c); setPalette(p); } |
| inline const QBrush& QWidget::backgroundBrush() const { return palette().brush(backgroundRole()); } |
| inline void QWidget::setBackgroundPixmap(const QPixmap &pm) |
| { QPalette p = palette(); p.setBrush(backgroundRole(), QBrush(pm)); setPalette(p); } |
| inline const QPixmap *QWidget::backgroundPixmap() const { return 0; } |
| inline void QWidget::setBackgroundColor(const QColor &c) |
| { QPalette p = palette(); p.setColor(backgroundRole(), c); setPalette(p); } |
| inline const QColor & QWidget::backgroundColor() const { return palette().color(backgroundRole()); } |
| inline const QColor &QWidget::foregroundColor() const { return palette().color(foregroundRole());} |
| inline const QColor &QWidget::eraseColor() const { return palette().color(backgroundRole()); } |
| inline void QWidget::setEraseColor(const QColor &c) |
| { QPalette p = palette(); p.setColor(backgroundRole(), c); setPalette(p); } |
| inline const QPixmap *QWidget::erasePixmap() const { return 0; } |
| inline void QWidget::setErasePixmap(const QPixmap &pm) |
| { QPalette p = palette(); p.setBrush(backgroundRole(), QBrush(pm)); setPalette(p); } |
| inline const QColor &QWidget::paletteForegroundColor() const { return palette().color(foregroundRole());} |
| inline const QColor &QWidget::paletteBackgroundColor() const { return palette().color(backgroundRole()); } |
| inline void QWidget::setPaletteBackgroundColor(const QColor &c) |
| { QPalette p = palette(); p.setColor(backgroundRole(), c); setPalette(p); } |
| inline const QPixmap *QWidget::paletteBackgroundPixmap() const |
| { return 0; } |
| inline void QWidget::setPaletteBackgroundPixmap(const QPixmap &pm) |
| { QPalette p = palette(); p.setBrush(backgroundRole(), QBrush(pm)); setPalette(p); } |
| inline QT3_SUPPORT void QWidget::erase() { erase_helper(0, 0, data->crect.width(), data->crect.height()); } |
| inline QT3_SUPPORT void QWidget::erase(const QRect &r) { erase_helper(r.x(), r.y(), r.width(), r.height()); } |
| #endif |
| |
| #define QWIDGETSIZE_MAX ((1<<24)-1) |
| |
| QT_END_NAMESPACE |
| |
| QT_END_HEADER |
| |
| #endif // QWIDGET_H |