/****************************************************************************

**

** Copyright (C) 2010 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$

** 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 Technology Preview License Agreement accompanying

** this package.

**

** 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.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $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"

#include "QtGui/qapplication.h"

#include <private/qgraphicseffect_p.h>

#include "QtGui/qgraphicsproxywidget.h"

#include "QtGui/qgraphicsscene.h"

#include "QtGui/qgraphicsview.h"

#include <private/qgesture_p.h>

#ifdef Q_WS_WIN

#include "QtCore/qt_windows.h"

#include <private/qdnd_p.h>

#endif // Q_WS_WIN

#ifdef Q_WS_X11

#include "QtGui/qx11info_x11.h"

#endif

#ifdef Q_WS_MAC

#include <private/qt_mac_p.h>

#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;

#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)

    uint inExpose : 1; // Prevents drawing recursion

#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

#ifndef QT_NO_GRAPHICSVIEW

    QGraphicsProxyWidget *proxyWidget; // if the widget is embedded

#endif

#ifndef QT_NO_CURSOR

    QCursor *curs;

#endif

    QPointer<QStyle> style;

    QPointer<QWidget> 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<QPointer<QWidget> > 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

#elif defined(Q_OS_SYMBIAN) // <----------------------------------------------------- Symbian

    uint activated : 1; // RWindowBase::Activated has been called

    /**

     * If this bit is set, each native widget receives the signals from the

     * Symbian control immediately before and immediately after draw ops are

     * sent to the window server for this control:

     *      void beginNativePaintEvent(const QRect &paintRect);

     *      void endNativePaintEvent(const QRect &paintRect);

     */

    uint receiveNativePaintEvents : 1;

    /**

     * Defines the behaviour of QSymbianControl::Draw.

     */

    enum NativePaintMode {

        /**

         * Normal drawing mode: blits the required region of the backing store

         * via WSERV.

         */

        Blit,

        /**

         * Disable drawing for this widget.

         */

        Disable,

        /**

         * Paint zeros into the WSERV framebuffer, using BitGDI APIs.  For windows

         * with an EColor16MU display mode, zero is written only into the R, G and B

         * channels of the pixel.

         */

        ZeroFill,

        Default = Blit

    };

    NativePaintMode nativePaintMode;

#endif

};

/*!

    \internal

    Returns true if \a p or any of its parents enable the

    Qt::BypassGraphicsProxyWidget window flag. Used in QWidget::show() and

    QWidget::setParent() to determine whether it's necessary to embed the

    widget into a QGraphicsProxyWidget or not.

*/

static inline bool bypassGraphicsProxyWidget(const QWidget *p)

{

    while (p) {

        if (p->windowFlags() & Qt::BypassGraphicsProxyWidget)

            return true;

        p = p->parentWidget();

    }

    return false;

}

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

    };

    enum Direction {

        DirectionNorth = 0x01,

        DirectionEast = 0x10,

        DirectionSouth = 0x02,

        DirectionWest = 0x20

    };

    // Functions.

    explicit QWidgetPrivate(int version = QObjectPrivateVersion);

    ~QWidgetPrivate();

    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 setSoftKeys_sys(const QList<QAction*> &softkeys);

    void activateSymbianWindow(WId wid = 0);

    void _q_delayedDestroy(WId winId);

#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 &, int flags = DrawAsRoot) const;

    bool isAboutToShow() const;

    QRegion prepareToRender(const QRegion &region, 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();

#ifndef QT_NO_GRAPHICSVIEW

    static QGraphicsProxyWidget * nearestGraphicsProxyWidget(const QWidget *origin);

#endif

    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 &region) const;

    void updateIsOpaque();

    void setOpaque(bool opaque);

    void updateIsTranslucent();

    bool paintOnScreen() const;

#ifndef QT_NO_GRAPHICSEFFECT

    void invalidateGraphicsEffectsRecursively();

#endif //QT_NO_GRAPHICSEFFECT

    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 &region);

    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;

#ifdef QT_KEYPAD_NAVIGATION

    static bool navigateToDirection(Direction direction);

    static QWidget *widgetInNavigationDirection(Direction direction);

    static bool canKeypadNavigate(Qt::Orientation orientation);

    static bool inTabWidget(QWidget *widget);

#endif

    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;

    inline QWidget *effectiveFocusWidget() {

        QWidget *w = q_func();

        while (w->focusProxy())

            w = w->focusProxy();

        return w;

    }

    void setModal_sys();

    // This is an helper function that return the available geometry for

    // a widget and takes care is this one is in QGraphicsView.

    // If the widget is not embed in a scene then the geometry available is

    // null, we let QDesktopWidget decide for us.

    static QRect screenGeometry(const QWidget *widget)

    {

        QRect screen;

#ifndef QT_NO_GRAPHICSVIEW

        QGraphicsProxyWidget *ancestorProxy = widget->d_func()->nearestGraphicsProxyWidget(widget);

        //It's embedded if it has an ancestor

        if (ancestorProxy) {

            if (!bypassGraphicsProxyWidget(widget) && ancestorProxy->scene() != 0) {

                // One view, let be smart and return the viewport rect then the popup is aligned

                if (ancestorProxy->scene()->views().size() == 1) {