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

**

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

**

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

#include "qapplication.h"

#include "qapplication_p.h"

#include "qbrush.h"

#include "qcursor.h"

#include "qdesktopwidget.h"

#include "qevent.h"

#include "qhash.h"

#include "qlayout.h"

#include "qmenu.h"

#include "qmetaobject.h"

#include "qpixmap.h"

#include "qpointer.h"

#include "qstack.h"

#include "qstyle.h"

#include "qstylefactory.h"

#include "qvariant.h"

#include "qwidget.h"

#include "qstyleoption.h"

#ifndef QT_NO_ACCESSIBILITY

# include "qaccessible.h"

#endif

#if defined(Q_WS_WIN)

# include "qt_windows.h"

#endif

#ifdef Q_WS_MAC

# include "qt_mac_p.h"

# include "qt_cocoa_helpers_mac_p.h"

# include "qmainwindow.h"

#endif

#if defined(Q_WS_QWS)

# include "qwsdisplay_qws.h"

# include "qwsmanager_qws.h"

# include "qpaintengine.h" // for PorterDuff

# include "private/qwindowsurface_qws_p.h"

#endif

#include "qpainter.h"

#include "qtooltip.h"

#include "qwhatsthis.h"

#include "qdebug.h"

#include "private/qstylesheetstyle_p.h"

#include "private/qstyle_p.h"

#include "private/qinputcontext_p.h"

#include "qfileinfo.h"

#include "private/qsoftkeymanager_p.h"

#if defined (Q_WS_WIN)

# include <private/qwininputcontext_p.h>

#endif

#if defined(Q_WS_X11)

# include <private/qpaintengine_x11_p.h>

# include "qx11info_x11.h"

#endif

#include <private/qgraphicseffect_p.h>

#include <private/qwindowsurface_p.h>

#include <private/qbackingstore_p.h>

#ifdef Q_WS_MAC

# include <private/qpaintengine_mac_p.h>

#endif

#include <private/qpaintengine_raster_p.h>

#if defined(Q_OS_SYMBIAN)

#include "private/qt_s60_p.h"

#endif

#include "qwidget_p.h"

#include "qaction_p.h"

#include "qlayout_p.h"

#include "QtGui/qgraphicsproxywidget.h"

#include "QtGui/qgraphicsscene.h"

#include "private/qgraphicsproxywidget_p.h"

#include "QtGui/qabstractscrollarea.h"

#include "private/qabstractscrollarea_p.h"

#include "private/qevent_p.h"

#include "private/qgraphicssystem_p.h"

#include "private/qgesturemanager_p.h"

// widget/widget data creation count

//#define QWIDGET_EXTRA_DEBUG

//#define ALIEN_DEBUG

QT_BEGIN_NAMESPACE

#if !defined(Q_WS_QWS)

static bool qt_enable_backingstore = true;

#endif

#ifdef Q_WS_X11

// for compatibility with Qt 4.0

Q_GUI_EXPORT void qt_x11_set_global_double_buffer(bool enable)

{

    qt_enable_backingstore = enable;

}

#endif

static inline bool qRectIntersects(const QRect &r1, const QRect &r2)

{

    return (qMax(r1.left(), r2.left()) <= qMin(r1.right(), r2.right()) &&

            qMax(r1.top(), r2.top()) <= qMin(r1.bottom(), r2.bottom()));

}

static inline bool hasBackingStoreSupport()

{

#ifdef Q_WS_MAC

    return QApplicationPrivate::graphicsSystem() != 0;

#else

    return true;

#endif

}

#ifdef Q_WS_MAC

#  define QT_NO_PAINT_DEBUG

#endif

extern bool qt_sendSpontaneousEvent(QObject*, QEvent*); // qapplication.cpp

extern QDesktopWidget *qt_desktopWidget; // qapplication.cpp

QWidgetPrivate::QWidgetPrivate(int version)

    : QObjectPrivate(version)

      , extra(0)

      , focus_next(0)

      , focus_prev(0)

      , focus_child(0)

      , layout(0)

      , needsFlush(0)

      , redirectDev(0)

      , widgetItem(0)

      , extraPaintEngine(0)

      , polished(0)

      , graphicsEffect(0)

#if !defined(QT_NO_IM)

      , imHints(Qt::ImhNone)

#endif

      , inheritedFontResolveMask(0)

      , inheritedPaletteResolveMask(0)

      , leftmargin(0)

      , topmargin(0)

      , rightmargin(0)

      , bottommargin(0)

      , leftLayoutItemMargin(0)

      , topLayoutItemMargin(0)

      , rightLayoutItemMargin(0)

      , bottomLayoutItemMargin(0)

      , hd(0)

      , size_policy(QSizePolicy::Preferred, QSizePolicy::Preferred)

      , fg_role(QPalette::NoRole)

      , bg_role(QPalette::NoRole)

      , dirtyOpaqueChildren(1)

      , isOpaque(0)

      , inDirtyList(0)

      , isScrolled(0)

      , isMoved(0)

      , usesDoubleBufferedGLContext(0)

#if defined(Q_WS_X11)

      , picture(0)

#elif defined(Q_WS_WIN)

      , noPaintOnScreen(0)

      , nativeGesturePanEnabled(0)

#elif defined(Q_WS_MAC)

      , needWindowChange(0)

      , window_event(0)

      , qd_hd(0)

#endif

{

    if (!qApp) {

        qFatal("QWidget: Must construct a QApplication before a QPaintDevice");

        return;

    }

    if (version != QObjectPrivateVersion)

        qFatal("Cannot mix incompatible Qt libraries");

    isWidget = true;

    memset(high_attributes, 0, sizeof(high_attributes));

#ifdef QWIDGET_EXTRA_DEBUG

    static int count = 0;

    qDebug() << "widgets" << ++count;

#endif

}

QWidgetPrivate::~QWidgetPrivate()

{

    if (widgetItem)

        widgetItem->wid = 0;

    if (extra)

        deleteExtra();

#ifndef QT_NO_GRAPHICSEFFECT

    delete graphicsEffect;

#endif //QT_NO_GRAPHICSEFFECT

}

QWindowSurface *QWidgetPrivate::createDefaultWindowSurface()

{

    Q_Q(QWidget);

    if (QApplicationPrivate::graphicsSystem())

        return QApplicationPrivate::graphicsSystem()->createWindowSurface(q);

    return createDefaultWindowSurface_sys();

}

/*!

    \internal

*/

void QWidgetPrivate::scrollChildren(int dx, int dy)

{

    Q_Q(QWidget);

    if (q->children().size() > 0) {        // scroll children

        QPoint pd(dx, dy);

        QObjectList childObjects = q->children();

        for (int i = 0; i < childObjects.size(); ++i) { // move all children

            QWidget *w = qobject_cast<QWidget*>(childObjects.at(i));

            if (w && !w->isWindow()) {

                QPoint oldp = w->pos();

                QRect  r(w->pos() + pd, w->size());

                w->data->crect = r;

#ifndef Q_WS_QWS

                if (w->testAttribute(Qt::WA_WState_Created))

                    w->d_func()->setWSGeometry();

#endif

                w->d_func()->setDirtyOpaqueRegion();

                QMoveEvent e(r.topLeft(), oldp);

                QApplication::sendEvent(w, &e);

            }

        }

    }

}

QInputContext *QWidgetPrivate::inputContext() const

{

#ifndef QT_NO_IM

    if (ic)

        return ic;

#endif

    return qApp->inputContext();

}

/*!

    This function returns the QInputContext for this widget. By

    default the input context is inherited from the widgets

    parent. For toplevels it is inherited from QApplication.

    You can override this and set a special input context for this

    widget by using the setInputContext() method.

    \sa setInputContext()

*/

QInputContext *QWidget::inputContext()

{

    Q_D(QWidget);

    if (!testAttribute(Qt::WA_InputMethodEnabled))

        return 0;

    return d->inputContext();

}

/*!

  This function sets the input context \a context

  on this widget.

  \sa inputContext()

*/

void QWidget::setInputContext(QInputContext *context)

{

    Q_D(QWidget);

    if (!testAttribute(Qt::WA_InputMethodEnabled))

        return;

#ifndef QT_NO_IM

    if (d->ic)

        delete d->ic;

    d->ic = context;

#endif

}

/*!

    \obsolete

    This function can be called on the widget that currently has focus

    to reset the input method operating on it.

    This function is providing for convenience, instead you should use

    \l{QInputContext::}{reset()} on the input context that was

    returned by inputContext().

    \sa QInputContext, inputContext(), QInputContext::reset()

*/

void QWidget::resetInputContext()

{

    if (!hasFocus())

        return;

#ifndef QT_NO_IM

    QInputContext *qic = this->inputContext();

    if(qic)

        qic->reset();

#endif // QT_NO_IM

}

#ifdef QT_KEYPAD_NAVIGATION

QPointer<QWidget> QWidgetPrivate::editingWidget;

/*!

    Returns true if this widget currently has edit focus; otherwise false.

    This feature is only available in Qt for Embedded Linux.

    \sa setEditFocus(), QApplication::keypadNavigationEnabled()

*/

bool QWidget::hasEditFocus() const

{

    const QWidget* w = this;

    while (w->d_func()->extra && w->d_func()->extra->focus_proxy)

        w = w->d_func()->extra->focus_proxy;

    return QWidgetPrivate::editingWidget == w;

}

/*!

    \fn void QWidget::setEditFocus(bool enable)

    If \a enable is true, make this widget have edit focus, in which

    case Qt::Key_Up and Qt::Key_Down will be delivered to the widget

    normally; otherwise, Qt::Key_Up and Qt::Key_Down are used to

    change focus.

    This feature is only available in Qt for Embedded Linux and Qt

    for Symbian.

    \sa hasEditFocus(), QApplication::keypadNavigationEnabled()

*/

void QWidget::setEditFocus(bool on)

{

    QWidget *f = this;

    while (f->d_func()->extra && f->d_func()->extra->focus_proxy)

        f = f->d_func()->extra->focus_proxy;

    if (QWidgetPrivate::editingWidget && QWidgetPrivate::editingWidget != f)

        QWidgetPrivate::editingWidget->setEditFocus(false);

    if (on && !f->hasFocus())

        f->setFocus();

    if ((!on && !QWidgetPrivate::editingWidget)

        || (on && QWidgetPrivate::editingWidget == f)) {

        return;

    }

    if (!on && QWidgetPrivate::editingWidget == f) {

        QWidgetPrivate::editingWidget = 0;

        QEvent event(QEvent::LeaveEditFocus);

        QApplication::sendEvent(f, &event);

        QApplication::sendEvent(f->style(), &event);

    } else if (on) {

        QWidgetPrivate::editingWidget = f;

        QEvent event(QEvent::EnterEditFocus);

        QApplication::sendEvent(f, &event);

        QApplication::sendEvent(f->style(), &event);

    }

}

#endif

/*!

    \property QWidget::autoFillBackground

    \brief whether the widget background is filled automatically

    \since 4.1

    If enabled, this property will cause Qt to fill the background of the

    widget before invoking the paint event. The color used is defined by the

    QPalette::Window color role from the widget's \l{QPalette}{palette}.

    In addition, Windows are always filled with QPalette::Window, unless the

    WA_OpaquePaintEvent or WA_NoSystemBackground attributes are set.

    This property cannot be turned off (i.e., set to false) if a widget's

    parent has a static gradient for its background.

    \warning Use this property with caution in conjunction with

    \l{Qt Style Sheets}. When a widget has a style sheet with a valid

    background or a border-image, this property is automatically disabled.

    By default, this property is false.

    \sa Qt::WA_OpaquePaintEvent, Qt::WA_NoSystemBackground,

    {QWidget#Transparency and Double Buffering}{Transparency and Double Buffering}

*/

bool QWidget::autoFillBackground() const

{

    Q_D(const QWidget);

    return d->extra && d->extra->autoFillBackground;

}

void QWidget::setAutoFillBackground(bool enabled)

{

    Q_D(QWidget);

    if (!d->extra)

        d->createExtra();

    if (d->extra->autoFillBackground == enabled)

        return;

    d->extra->autoFillBackground = enabled;

    d->updateIsOpaque();

    update();

    d->updateIsOpaque();

}

/*!

    \class QWidget

    \brief The QWidget class is the base class of all user interface objects.

    \ingroup basicwidgets

    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 is not embedded in a parent widget is called a window.

    Usually, windows have a frame and a title bar, although it is also possible

    to create windows without such decoration using suitable

    \l{Qt::WindowFlags}{window flags}). In Qt, QMainWindow and the various

    subclasses of QDialog are the most common window types.

    Every widget's constructor accepts one or two standard arguments:

    \list 1

        \i  \c{QWidget *parent = 0} is the parent of the new widget. If it is 0

            (the default), the new widget will be a window. If not, it will be

            a child of \e parent, and be constrained by \e parent's geometry

            (unless you specify Qt::Window as window flag).

        \i  \c{Qt::WindowFlags f = 0} (where available) sets the window flags;

            the default is suitable for almost all widgets, but to get, for

            example, a window without a window system frame, you must use

            special flags.

    \endlist

    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 QLabel, QPushButton, QListWidget, and QTabWidget.

    \section1 Top-Level and Child Widgets

    A widget without a parent widget is always an independent window (top-level

    widget). For these widgets, setWindowTitle() and setWindowIcon() set the

    title bar and icon respectively.

    Non-window widgets are child widgets, displayed within their parent

    widgets. Most widgets in Qt are mainly useful as child widgets. For

    example, it is possible to display a button as a top-level window, but most

    people prefer to put their buttons inside other widgets, such as QDialog.

    \image parent-child-widgets.png A parent widget containing various child widgets.

    The diagram above shows a QGroupBox widget being used to hold various child

    widgets in a layout provided by QGridLayout. The QLabel child widgets have

    been outlined to indicate their full sizes.

    If you want to use a QWidget to hold child widgets you will usually want to

    add a layout to the parent QWidget. See \l{Layout Management} for more

    information.

    \section1 Composite Widgets

    When a widget is used as a container to group a number of child widgets, it

    is known as a composite widget. These can be created by constructing a

    widget with the required visual properties - a QFrame, for example - and

    adding child widgets to it, usually managed by a layout. The above diagram

    shows such a composite widget that was created using \l{Qt Designer}.

    Composite widgets can also be created by subclassing a standard widget,

    such as QWidget or QFrame, and adding the necessary layout and child

    widgets in the constructor of the subclass. Many of the \l{Qt Examples}

    {examples provided with Qt} use this approach, and it is also covered in

    the Qt \l{Tutorials}.

    \section1 Custom Widgets and Painting

    Since QWidget is a subclass of QPaintDevice, subclasses can be used to

    display custom content that is composed using a series of painting