/**************************************************************************** ** ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). ** Contact: Nokia Corporation (qt-info@nokia.com) ** ** This file is part of the QtGui module of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:LGPL$ ** No Commercial Usage ** This file contains pre-release code and may not be distributed. ** You may use this file in accordance with the terms and conditions ** contained in the either Technology Preview License Agreement or the ** Beta Release License Agreement. ** ** GNU Lesser General Public License Usage ** Alternatively, 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.0, 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. ** ** If you are unsure which license is appropriate for your use, please ** contact the sales department at http://www.qtsoftware.com/contact. ** $QT_END_LICENSE$ ** ****************************************************************************/ #ifndef QWIDGET_P_H #define QWIDGET_P_H // // W A R N I N G // ------------- // // This file is not part of the Qt API. It exists for the convenience // of qapplication_*.cpp, qwidget*.cpp and qfiledialog.cpp. This header // file may change from version to version without notice, or even be removed. // // We mean it. // #include "QtGui/qwidget.h" #include "private/qobject_p.h" #include "QtCore/qrect.h" #include "QtCore/qlocale.h" #include "QtCore/qset.h" #include "QtGui/qregion.h" #include "QtGui/qsizepolicy.h" #include "QtGui/qstyle.h" #ifdef Q_WS_WIN #include "QtCore/qt_windows.h" #include #endif // Q_WS_WIN #ifdef Q_WS_X11 #include "QtGui/qx11info_x11.h" #endif #ifdef Q_WS_MAC #include #endif #if defined(Q_WS_QWS) #include "QtGui/qinputcontext.h" #include "QtGui/qscreen_qws.h" #endif #if defined(Q_OS_SYMBIAN) class RDrawableWindow; class CCoeControl; // The following 2 defines may only be needed for s60. To be seen. const int SOFTKEYSTART=5000; const int SOFTKEYEND=5004; #endif QT_BEGIN_NAMESPACE // Extra QWidget data // - to minimize memory usage for members that are seldom used. // - top-level widgets have extra extra data to reduce cost further #if defined(Q_WS_QWS) class QWSManager; #endif #if defined(Q_WS_MAC) class QCoreGraphicsPaintEnginePrivate; #endif class QPaintEngine; class QPixmap; class QWidgetBackingStore; class QGraphicsProxyWidget; class QWidgetItemV2; class QStyle; struct QTLWExtra { // *************************** Cross-platform variables ***************************** // Regular pointers (keep them together to avoid gaps on 64 bits architectures). QIcon *icon; // widget icon QPixmap *iconPixmap; QWidgetBackingStore *backingStore; QWindowSurface *windowSurface; QPainter *sharedPainter; // Implicit pointers (shared_null). QString caption; // widget caption QString iconText; // widget icon text QString role; // widget role QString filePath; // widget file path // Other variables. short incw, inch; // size increments short basew, baseh; // base sizes // frame strut, don't use these directly, use QWidgetPrivate::frameStrut() instead. QRect frameStrut; QRect normalGeometry; // used by showMin/maximized/FullScreen Qt::WindowFlags savedFlags; // Save widget flags while showing fullscreen // *************************** Cross-platform bit fields **************************** uint opacity : 8; uint posFromMove : 1; uint sizeAdjusted : 1; uint inTopLevelResize : 1; uint inRepaint : 1; uint embedded : 1; // *************************** Platform specific values (bit fields first) ********** #if defined(Q_WS_X11) // <----------------------------------------------------------- X11 uint spont_unmapped: 1; // window was spontaneously unmapped uint dnd : 1; // DND properties installed uint validWMState : 1; // is WM_STATE valid? uint waitingForMapNotify : 1; // show() has been called, haven't got the MapNotify yet WId parentWinId; // parent window Id (valid after reparenting) WId userTimeWindow; // window id that contains user-time timestamp when WM supports a _NET_WM_USER_TIME_WINDOW atom QPoint fullScreenOffset; #ifndef QT_NO_XSYNC WId syncUpdateCounter; ulong syncRequestTimestamp; qint32 newCounterValueHi; quint32 newCounterValueLo; #endif #elif defined(Q_WS_WIN) // <--------------------------------------------------------- WIN HICON winIconBig; // internal big Windows icon HICON winIconSmall; // internal small Windows icon #elif defined(Q_WS_MAC) // <--------------------------------------------------------- MAC uint resizer : 4; uint isSetGeometry : 1; uint isMove : 1; quint32 wattr; quint32 wclass; WindowGroupRef group; IconRef windowIcon; // the current window icon, if set with setWindowIcon_sys. quint32 savedWindowAttributesFromMaximized; // Saved attributes from when the calling updateMaximizeButton_sys() #elif defined(Q_WS_QWS) // <--------------------------------------------------------- QWS #ifndef QT_NO_QWS_MANAGER QWSManager *qwsManager; #endif #elif defined(Q_OS_SYMBIAN) // <--------------------------------------------------------- SYMBIAN uint activated : 1; // RWindowBase::Activated has been called RDrawableWindow *rwindow; #endif }; struct QWExtra { // *************************** Cross-platform variables ***************************** // Regular pointers (keep them together to avoid gaps on 64 bits architectures). void *glContext; // if the widget is hijacked by QGLWindowSurface QTLWExtra *topextra; // only useful for TLWs QGraphicsProxyWidget *proxyWidget; // if the widget is embedded #ifndef QT_NO_CURSOR QCursor *curs; #endif QPointer style; QPointer focus_proxy; // Implicit pointers (shared_empty/shared_null). QRegion mask; // widget mask QString styleSheet; // Other variables. qint32 minw; qint32 minh; // minimum size qint32 maxw; qint32 maxh; // maximum size quint16 customDpiX; quint16 customDpiY; QSize staticContentsSize; // *************************** Cross-platform bit fields **************************** uint explicitMinSize : 2; uint explicitMaxSize : 2; uint autoFillBackground : 1; uint nativeChildrenForced : 1; uint inRenderWithPainter : 1; uint hasMask : 1; // *************************** Platform specific values (bit fields first) ********** #if defined(Q_WS_WIN) // <----------------------------------------------------------- WIN #ifndef QT_NO_DRAGANDDROP QOleDropTarget *dropTarget; // drop target QList > oleDropWidgets; #endif #elif defined(Q_WS_X11) // <--------------------------------------------------------- X11 uint compress_events : 1; WId xDndProxy; // XDND forwarding to embedded windows #elif defined(Q_WS_MAC) // <------------------------------------------------------ MAC #ifdef QT_MAC_USE_COCOA // Cocoa Mask stuff QImage maskBits; CGImageRef imageMask; #endif #endif }; class Q_GUI_EXPORT QWidgetPrivate : public QObjectPrivate { Q_DECLARE_PUBLIC(QWidget) public: // *************************** Cross-platform *************************************** enum DrawWidgetFlags { DrawAsRoot = 0x01, DrawPaintOnScreen = 0x02, DrawRecursive = 0x04, DrawInvisible = 0x08, DontSubtractOpaqueChildren = 0x10, DontSetCompositionMode = 0x20, DontDrawOpaqueChildren = 0x40 }; enum CloseMode { CloseNoEvent, CloseWithEvent, CloseWithSpontaneousEvent }; // Functions. explicit QWidgetPrivate(int version = QObjectPrivateVersion); ~QWidgetPrivate(); void setSoftKeys_sys(const QList &softkeys); QWExtra *extraData() const; QTLWExtra *topData() const; QTLWExtra *maybeTopData() const; QPainter *sharedPainter() const; void setSharedPainter(QPainter *painter); QWidgetBackingStore *maybeBackingStore() const; void init(QWidget *desktopWidget, Qt::WindowFlags f); void create_sys(WId window, bool initializeWindow, bool destroyOldWindow); void createRecursively(); void createWinId(WId id = 0); void createTLExtra(); void createExtra(); void deleteExtra(); void createSysExtra(); void deleteSysExtra(); void createTLSysExtra(); void deleteTLSysExtra(); void updateSystemBackground(); void propagatePaletteChange(); void setPalette_helper(const QPalette &); void resolvePalette(); QPalette naturalWidgetPalette(uint inheritedMask) const; void setMask_sys(const QRegion &); #ifdef Q_OS_SYMBIAN void handleSymbianDeferredFocusChanged(); #endif void raise_sys(); void lower_sys(); void stackUnder_sys(QWidget *); void setFocus_sys(); void updateFont(const QFont &); inline void setFont_helper(const QFont &font) { if (data.fnt == font && data.fnt.resolve() == font.resolve()) return; updateFont(font); } void resolveFont(); QFont naturalWidgetFont(uint inheritedMask) const; void setLayoutDirection_helper(Qt::LayoutDirection); void resolveLayoutDirection(); void setLocale_helper(const QLocale &l, bool forceUpdate = false); void resolveLocale(); void setStyle_helper(QStyle *newStyle, bool propagate, bool metalHack = false); void inheritStyle(); void setUpdatesEnabled_helper(bool ); void paintBackground(QPainter *, const QRegion &, const QPoint & = QPoint(), int flags = DrawAsRoot) const; bool isAboutToShow() const; QRegion prepareToRender(const QRegion ®ion, QWidget::RenderFlags renderFlags); void render_helper(QPainter *painter, const QPoint &targetOffset, const QRegion &sourceRegion, QWidget::RenderFlags renderFlags); void drawWidget(QPaintDevice *pdev, const QRegion &rgn, const QPoint &offset, int flags, QPainter *sharedPainter = 0, QWidgetBackingStore *backingStore = 0); void paintSiblingsRecursive(QPaintDevice *pdev, const QObjectList& children, int index, const QRegion &rgn, const QPoint &offset, int flags #ifdef Q_BACKINGSTORE_SUBSURFACES , const QWindowSurface *currentSurface #endif , QPainter *sharedPainter, QWidgetBackingStore *backingStore); QPainter *beginSharedPainter(); bool endSharedPainter(); static QGraphicsProxyWidget * nearestGraphicsProxyWidget(QWidget *origin); QWindowSurface *createDefaultWindowSurface(); QWindowSurface *createDefaultWindowSurface_sys(); void repaint_sys(const QRegion &rgn); QRect clipRect() const; QRegion clipRegion() const; void subtractOpaqueChildren(QRegion &rgn, const QRect &clipRect) const; void subtractOpaqueSiblings(QRegion &source, bool *hasDirtySiblingsAbove = 0, bool alsoNonOpaque = false) const; void clipToEffectiveMask(QRegion ®ion) const; void updateIsOpaque(); void setOpaque(bool opaque); void updateIsTranslucent(); bool paintOnScreen() const; QRegion getOpaqueRegion() const; const QRegion &getOpaqueChildren() const; void setDirtyOpaqueRegion(); bool close_helper(CloseMode mode); void setWindowIcon_helper(); void setWindowIcon_sys(bool forceReset = false); void setWindowOpacity_sys(qreal opacity); void adjustQuitOnCloseAttribute(); void scrollChildren(int dx, int dy); void moveRect(const QRect &, int dx, int dy); void scrollRect(const QRect &, int dx, int dy); void invalidateBuffer_resizeHelper(const QPoint &oldPos, const QSize &oldSize); // ### Qt 4.6: Merge into a template function (after MSVC isn't supported anymore). void invalidateBuffer(const QRegion &); void invalidateBuffer(const QRect &); bool isOverlapped(const QRect&) const; void syncBackingStore(); void syncBackingStore(const QRegion ®ion); void reparentFocusWidgets(QWidget *oldtlw); static int pointToRect(const QPoint &p, const QRect &r); void setWinId(WId); void showChildren(bool spontaneous); void hideChildren(bool spontaneous); void setParent_sys(QWidget *parent, Qt::WindowFlags); void scroll_sys(int dx, int dy); void scroll_sys(int dx, int dy, const QRect &r); void deactivateWidgetCleanup(); void setGeometry_sys(int, int, int, int, bool); void sendPendingMoveAndResizeEvents(bool recursive = false, bool disableUpdates = false); void activateChildLayoutsRecursively(); void show_recursive(); void show_helper(); void show_sys(); void hide_sys(); void hide_helper(); void _q_showIfNotHidden(); void setEnabled_helper(bool); void registerDropSite(bool); static void adjustFlags(Qt::WindowFlags &flags, QWidget *w = 0); void updateFrameStrut(); QRect frameStrut() const; void setWindowIconText_sys(const QString &cap); void setWindowIconText_helper(const QString &cap); void setWindowTitle_sys(const QString &cap); #ifndef QT_NO_CURSOR void setCursor_sys(const QCursor &cursor); void unsetCursor_sys(); #endif void setWindowTitle_helper(const QString &cap); void setWindowFilePath_helper(const QString &filePath); bool setMinimumSize_helper(int &minw, int &minh); bool setMaximumSize_helper(int &maxw, int &maxh); void setConstraints_sys(); QWidget *childAt_helper(const QPoint &, bool) const; void updateGeometry_helper(bool forceUpdate); void getLayoutItemMargins(int *left, int *top, int *right, int *bottom) const; void setLayoutItemMargins(int left, int top, int right, int bottom); void setLayoutItemMargins(QStyle::SubElement element, const QStyleOption *opt = 0); QInputContext *inputContext() const; void setModal_sys(); inline void setRedirected(QPaintDevice *replacement, const QPoint &offset) { Q_ASSERT(q_func()->testAttribute(Qt::WA_WState_InPaintEvent)); redirectDev = replacement; redirectOffset = offset; } inline QPaintDevice *redirected(QPoint *offset) const { if (offset) *offset = redirectDev ? redirectOffset : QPoint(); return redirectDev; } inline void restoreRedirected() { redirectDev = 0; } inline void enforceNativeChildren() { if (!extra) createExtra(); if (extra->nativeChildrenForced) return; extra->nativeChildrenForced = 1; for (int i = 0; i < children.size(); ++i) { if (QWidget *child = qobject_cast(children.at(i))) child->setAttribute(Qt::WA_NativeWindow); } } inline bool nativeChildrenForced() const { return extra ? extra->nativeChildrenForced : false; } QSize adjustedSize() const; #ifndef Q_WS_QWS // Almost cross-platform :-) void setWSGeometry(bool dontShow=false, const QRect &oldRect = QRect()); inline QPoint mapToWS(const QPoint &p) const { return p - data.wrect.topLeft(); } inline QPoint mapFromWS(const QPoint &p) const { return p + data.wrect.topLeft(); } inline QRect mapToWS(const QRect &r) const { QRect rr(r); rr.translate(-data.wrect.topLeft()); return rr; } inline QRect mapFromWS(const QRect &r) const { QRect rr(r); rr.translate(data.wrect.topLeft()); return rr; } #endif // Variables. // Regular pointers (keep them together to avoid gaps on 64 bit architectures). QWExtra *extra; QWidget *focus_next; QWidget *focus_prev; QWidget *focus_child; QList softKeys; QLayout *layout; QRegion *needsFlush; QPaintDevice *redirectDev; QWidgetItemV2 *widgetItem; QPaintEngine *extraPaintEngine; mutable const QMetaObject *polished; // All widgets are initially added into the uncreatedWidgets set. Once // they receive a window id they are removed and added to the mapper static QWidgetMapper *mapper; static QWidgetSet *uncreatedWidgets; #if !defined(QT_NO_IM) QPointer ic; Qt::InputMethodHints imHints; #endif #ifdef QT_KEYPAD_NAVIGATION static QPointer editingWidget; #endif // Implicit pointers (shared_null/shared_empty). QRegion opaqueChildren; QRegion dirty; #ifndef QT_NO_TOOLTIP QString toolTip; #endif #ifndef QT_NO_STATUSTIP QString statusTip; #endif #ifndef QT_NO_WHATSTHIS QString whatsThis; #endif #ifndef QT_NO_ACCESSIBILITY QString accessibleName; QString accessibleDescription; #endif // Other variables. uint inheritedFontResolveMask; uint inheritedPaletteResolveMask; short leftmargin; short topmargin; short rightmargin; short bottommargin; signed char leftLayoutItemMargin; signed char topLayoutItemMargin; signed char rightLayoutItemMargin; signed char bottomLayoutItemMargin; static int instanceCounter; // Current number of widget instances static int maxInstances; // Maximum number of widget instances Qt::HANDLE hd; QWidgetData data; QSizePolicy size_policy; QLocale locale; QPoint redirectOffset; #ifndef QT_NO_ACTION QList actions; #endif QSet gestures; int grabGesture(int gestureId); bool releaseGesture(int gestureId); bool hasGesture(const QString &type) const; // Bit fields. uint high_attributes[3]; // the low ones are in QWidget::widget_attributes QPalette::ColorRole fg_role : 8; QPalette::ColorRole bg_role : 8; uint dirtyOpaqueChildren : 1; uint isOpaque : 1; uint inDirtyList : 1; uint isScrolled : 1; uint isMoved : 1; uint usesDoubleBufferedGLContext : 1; // *************************** Platform specific ************************************ #if defined(Q_WS_X11) // <----------------------------------------------------------- X11 QX11Info xinfo; Qt::HANDLE picture; static QWidget *mouseGrabber; static QWidget *keyboardGrabber; void setWindowRole(); void sendStartupMessage(const char *message) const; void setNetWmWindowTypes(); void x11UpdateIsOpaque(); bool isBackgroundInherited() const; #elif defined(Q_WS_WIN) // <--------------------------------------------------------- WIN uint noPaintOnScreen : 1; // see qwidget_win.cpp ::paintEngine() bool shouldShowMaximizeButton(); void winUpdateIsOpaque(); void reparentChildren(); #ifndef QT_NO_DRAGANDDROP QOleDropTarget *registerOleDnd(QWidget *widget); void unregisterOleDnd(QWidget *widget, QOleDropTarget *target); #endif void grabMouseWhileInWindow(); void registerTouchWindow(); #elif defined(Q_WS_MAC) // <--------------------------------------------------------- MAC // This is new stuff uint needWindowChange : 1; uint isGLWidget : 1; // Each wiget keeps a list of all its child and grandchild OpenGL widgets. // This list is used to update the gl context whenever a parent and a granparent // moves, and also to check for intersections with gl widgets within the window // when a widget moves. struct GlWidgetInfo { GlWidgetInfo(QWidget *widget) : widget(widget), lastUpdateWidget(0) { } bool operator==(const GlWidgetInfo &other) const { return (widget == other.widget); } QWidget * widget; QWidget * lastUpdateWidget; }; // dirtyOnWidget contains the areas in the widget that needs to be repained, // in the same way as dirtyOnScreen does for the window. Areas are added in // dirtyWidget_sys and cleared in the paint event. In scroll_sys we then use // this information repaint invalid areas when widgets are scrolled. QRegion dirtyOnWidget; EventHandlerRef window_event; QList glWidgets; //these are here just for code compat (HIViews) Qt::HANDLE qd_hd; void macUpdateSizeAttribute(); void macUpdateHideOnSuspend(); void macUpdateOpaqueSizeGrip(); void macUpdateIgnoreMouseEvents(); void macUpdateMetalAttribute(); void macUpdateIsOpaque(); void setEnabled_helper_sys(bool enable); bool isRealWindow() const; void adjustWithinMaxAndMinSize(int &w, int &h); void applyMaxAndMinSizeOnWindow(); void update_sys(const QRect &rect); void update_sys(const QRegion &rgn); void setGeometry_sys_helper(int, int, int, int, bool); void setWindowModified_sys(bool b); void updateMaximizeButton_sys(); void setWindowFilePath_sys(const QString &filePath); void createWindow_sys(); void recreateMacWindow(); #ifndef QT_MAC_USE_COCOA void initWindowPtr(); void finishCreateWindow_sys_Carbon(OSWindowRef windowRef); #else void finishCreateWindow_sys_Cocoa(void * /*NSWindow * */ windowRef); void syncCocoaMask(); void finishCocoaMaskSetup(); #endif void determineWindowClass(); void transferChildren(); bool qt_mac_dnd_event(uint, DragRef); void toggleDrawers(bool); //mac event functions static bool qt_create_root_win(); static void qt_clean_root_win(); static bool qt_mac_update_sizer(QWidget *, int up = 0); static OSStatus qt_window_event(EventHandlerCallRef er, EventRef event, void *); static OSStatus qt_widget_event(EventHandlerCallRef er, EventRef event, void *); static bool qt_widget_rgn(QWidget *, short, RgnHandle, bool); void registerTouchWindow(); #elif defined(Q_WS_QWS) // <--------------------------------------------------------- QWS void setMaxWindowState_helper(); void setFullScreenSize_helper(); void moveSurface(QWindowSurface *surface, const QPoint &offset); QRegion localRequestedRegion() const; QRegion localAllocatedRegion() const; friend class QWSManager; friend class QWSManagerPrivate; friend class QDecoration; #ifndef QT_NO_CURSOR void updateCursor() const; #endif QScreen* getScreen() const; #elif defined(Q_OS_SYMBIAN) // <--------------------------------------------------------- SYMBIAN static QWidget *mouseGrabber; static QWidget *keyboardGrabber; void s60UpdateIsOpaque(); void reparentChildren(); #endif }; inline QWExtra *QWidgetPrivate::extraData() const { return extra; } inline QTLWExtra *QWidgetPrivate::topData() const { const_cast(this)->createTLExtra(); return extra->topextra; } inline QTLWExtra *QWidgetPrivate::maybeTopData() const { return extra ? extra->topextra : 0; } inline QPainter *QWidgetPrivate::sharedPainter() const { Q_Q(const QWidget); QTLWExtra *x = q->window()->d_func()->maybeTopData(); return x ? x->sharedPainter : 0; } inline void QWidgetPrivate::setSharedPainter(QPainter *painter) { Q_Q(QWidget); QTLWExtra *x = q->window()->d_func()->topData(); x->sharedPainter = painter; } inline QWidgetBackingStore *QWidgetPrivate::maybeBackingStore() const { Q_Q(const QWidget); QTLWExtra *x = q->window()->d_func()->maybeTopData(); return x ? x->backingStore : 0; } QT_END_NAMESPACE #endif // QWIDGET_P_H