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

**

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

**

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

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

# include "qtoolbar.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"

#ifdef QT_KEYPAD_NAVIGATION

#include "qtabwidget.h" // Needed in inTabWidget()

#endif // QT_KEYPAD_NAVIGATION

// 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

    :   m_ptr(0)

{

}

{

    delete m_ptr;

}

{

    destroy();

    m_ptr = new QWidgetBackingStore(widget);

}

{

    delete m_ptr;

    m_ptr = 0;

{

    Q_ASSERT(m_ptr);

    Q_ASSERT(w->internalWinId());

    Q_ASSERT(qt_widget_private(w)->maybeBackingStore() == m_ptr);

        delete m_ptr;

        m_ptr = 0;

    }

}

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)

      , isGLWidget(0)

      , usesDoubleBufferedGLContext(0)

#if defined(Q_WS_X11)

      , picture(0)

#elif defined(Q_WS_WIN)

      , noPaintOnScreen(0)

  #ifndef QT_NO_GESTURES

      , nativeGesturePanEnabled(0)

  #endif

#elif defined(Q_WS_MAC)

      , needWindowChange(0)

      , hasAlienChildren(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));

#if QT_MAC_USE_COCOA

    drawRectOriginalAdded = false;

    originalDrawMethod = true;

    changeMethods = false;

#endif // QT_MAC_USE_COCOA

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

    QWindowSurface *surface;

    if (QApplicationPrivate::graphicsSystem())

        surface = QApplicationPrivate::graphicsSystem()->createWindowSurface(q);

    else

        surface = createDefaultWindowSurface_sys();

    return surface;

}

/*!

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

    return qApp->inputContext();

#else

    return 0;

#endif

}

/*!

    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.

  Qt takes ownership of the given input \a context.

  \sa inputContext()

*/

void QWidget::setInputContext(QInputContext *context)

{

    Q_D(QWidget);

    if (!testAttribute(Qt::WA_InputMethodEnabled))

        return;

#ifndef QT_NO_IM

    if (context == d->ic)

        return;

    if (d->ic)

        delete d->ic;

    d->ic = context;

    if (d->ic)

        d->ic->setParent(this);

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