Changeset 561 for trunk/src/gui/kernel/qwidget.cpp

Timestamp:

Feb 11, 2010, 11:19:06 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.1 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/gui/kernel/qwidget.cpp (modified) (183 diffs)

trunk/src/gui/kernel/qwidget.cpp

@@ -2 +2 @@
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -21 +22 @@
 ** 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.
+** 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
@@ -34 +34 @@
 ** 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 qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
@@ -83 +83 @@
 #include "private/qinputcontext_p.h"
 #include "qfileinfo.h"
+#include "private/qsoftkeymanager_p.h"
 
 #if defined (Q_WS_WIN)
@@ -97 +98 @@
 #endif
 
+#include <private/qgraphicseffect_p.h>
 #include <private/qwindowsurface_p.h>
 #include <private/qbackingstore_p.h>
@@ -103 +105 @@
 #endif
 #include <private/qpaintengine_raster_p.h>
+
+#if defined(Q_OS_SYMBIAN)
+#include "private/qt_s60_p.h"
+#endif
 
 #include "qwidget_p.h"
@@ -112 +118 @@
 #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
@@ -147 +155 @@
 }
 
-/*!
-    \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(QWidget *p)
-{
-    while (p) {
-        if (p->windowFlags() & Qt::BypassGraphicsProxyWidget)
-            return true;
-        p = p->parentWidget();
-    }
-    return false;
-}
-
 #ifdef Q_WS_MAC
 #  define QT_NO_PAINT_DEBUG
@@ -172 +162 @@
 extern QDesktopWidget *qt_desktopWidget; // qapplication.cpp
 
-QWidgetPrivate::QWidgetPrivate(int version) :
-        QObjectPrivate(version), extra(0), focus_child(0)
-        ,layout(0), widgetItem(0)
-        ,leftmargin(0), topmargin(0), rightmargin(0), bottommargin(0)
-        ,leftLayoutItemMargin(0), topLayoutItemMargin(0), rightLayoutItemMargin(0)
-        ,bottomLayoutItemMargin(0)
-        ,fg_role(QPalette::NoRole)
-        ,bg_role(QPalette::NoRole)
-        ,hd(0)
-        ,dirty(0)
-        ,needsFlush(0)
-        ,dirtyOpaqueChildren(1)
-        ,isOpaque(0)
-        ,inDirtyList(0)
-        ,isScrolled(0)
-        ,isMoved(0)
-#if defined(Q_WS_WIN) || defined(Q_WS_PM)
-        ,noPaintOnScreen(0)
-#endif
-        ,inheritedFontResolveMask(0)
-        ,inheritedPaletteResolveMask(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)
+      , usesDoubleBufferedGLContext(0)
 #if defined(Q_WS_X11)
-        ,picture(0)
-#endif
-#ifdef Q_WS_MAC
-        ,needWindowChange(0)
-        ,isGLWidget(0)
-#endif
-        ,polished(0)
-
-        , size_policy(QSizePolicy::Preferred, QSizePolicy::Preferred)
-        , redirectDev(0)
+      , picture(0)
+#elif defined(Q_WS_PM)
+      , noPaintOnScreen(0)
+#elif defined(Q_WS_WIN)
+      , noPaintOnScreen(0)
+      , nativeGesturePanEnabled(0)
+#elif defined(Q_WS_MAC)
+      , needWindowChange(0)
+      , isGLWidget(0)
+      , window_event(0)
+      , qd_hd(0)
+#endif
 {
     if (!qApp) {
@@ -229 +236 @@
     if (extra)
         deleteExtra();
+
+#ifndef QT_NO_GRAPHICSEFFECT
+    delete graphicsEffect;
+#endif //QT_NO_GRAPHICSEFFECT
 }
 
@@ -362 +373 @@
     change focus.
 
-    This feature is only available in Qt for Embedded Linux.
+    This feature is only available in Qt for Embedded Linux and Qt
+    for Symbian.
 
     \sa hasEditFocus(), QApplication::keypadNavigationEnabled()
@@ -446 +458 @@
 
     \ingroup basicwidgets
-    \mainclass
+
 
     The widget is the atom of the user interface: it receives mouse, keyboard
@@ -497 +509 @@
 
     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 Classes} for more
+    add a layout to the parent QWidget. See \l{Layout Management} for more
     information.
 
@@ -855 +867 @@
     \o X11: This feature relies on the use of an X server that supports ARGB visuals
     and a compositing window manager.
-    \o Windows: This feature requires Windows 2000 or later. The widget needs to have
-    the Qt::FramelessWindowHint window flag set for the translucency to work.
+    \o Windows: The widget needs to have the Qt::FramelessWindowHint window flag set
+    for the translucency to work.
     \endlist
 
@@ -882 +894 @@
 
     \sa QEvent, QPainter, QGridLayout, QBoxLayout
-*/
-
-QWidgetMapper *QWidgetPrivate::mapper = 0;                // widget with wid
-QWidgetSet *QWidgetPrivate::uncreatedWidgets = 0;         // widgets with no wid
+
+    \section1 Softkeys
+
+    Since Qt 4.6, Softkeys are usually physical keys on a device that have a corresponding label or
+    other visual representation on the screen that is generally located next to its
+    physical counterpart. They are most often found on mobile phone platforms. In
+    modern touch based user interfaces it is also possible to have softkeys that do
+    not correspond to any physical keys. Softkeys differ from other onscreen labels
+    in that they are contextual.
+
+    In Qt, contextual softkeys are added to a widget by calling addAction() and
+    passing a \c QAction with a softkey role set on it. When the widget
+    containing the softkey actions has focus, its softkeys should appear in
+    the user interface. Softkeys are discovered by traversing the widget
+    hierarchy so it is possible to define a single set of softkeys that are
+    present at all times by calling addAction() for a given top level widget.
+
+    On some platforms, this concept overlaps with \c QMenuBar such that if no
+    other softkeys are found and the top level widget is a QMainWindow containing
+    a QMenuBar, the menubar actions may appear on one of the softkeys.
+
+    Note: Currently softkeys are only supported on the Symbian Platform.
+
+    \sa addAction(), QAction, QMenuBar
+
+*/
+
+QWidgetMapper *QWidgetPrivate::mapper = 0;          // widget with wid
+QWidgetSet *QWidgetPrivate::allWidgets = 0;         // widgets with no wid
 
 
@@ -925 +962 @@
 */
 
+struct QWidgetExceptionCleaner
+{
+    /* this cleans up when the constructor throws an exception */
+    static inline void cleanup(QWidget *that, QWidgetPrivate *d)
+    {
+#ifdef QT_NO_EXCEPTIONS
+        Q_UNUSED(that);
+        Q_UNUSED(d);
+#else
+        QWidgetPrivate::allWidgets->remove(that);
+        if (d->focus_next != that) {
+            if (d->focus_next)
+                d->focus_next->d_func()->focus_prev = d->focus_prev;
+            if (d->focus_prev)
+                d->focus_prev->d_func()->focus_next = d->focus_next;
+        }
+#endif
+    }
+};
+
 /*!
     Constructs a widget which is a child of \a parent, with  widget
@@ -954 +1011 @@
     : QObject(*new QWidgetPrivate, 0), QPaintDevice()
 {
-    d_func()->init(parent, f);
+    QT_TRY {
+        d_func()->init(parent, f);
+    } QT_CATCH(...) {
+        QWidgetExceptionCleaner::cleanup(this, d_func());
+        QT_RETHROW;
+    }
 }
 
@@ -965 +1027 @@
     : QObject(*new QWidgetPrivate, 0), QPaintDevice()
 {
-    d_func()->init(parent , f);
-    setObjectName(QString::fromAscii(name));
+    QT_TRY {
+        d_func()->init(parent , f);
+        setObjectName(QString::fromAscii(name));
+    } QT_CATCH(...) {
+        QWidgetExceptionCleaner::cleanup(this, d_func());
+        QT_RETHROW;
+    }
 }
 #endif
@@ -975 +1042 @@
     : QObject(dd, 0), QPaintDevice()
 {
-    d_func()->init(parent, f);
+    Q_D(QWidget);
+    QT_TRY {
+        d->init(parent, f);
+    } QT_CATCH(...) {
+        QWidgetExceptionCleaner::cleanup(this, d_func());
+        QT_RETHROW;
+    }
 }
 
@@ -1031 +1104 @@
         ; // don't modify window flags if the user explicitely set them.
     else if (type == Qt::Dialog || type == Qt::Sheet)
-#ifndef Q_OS_WINCE
+#ifndef Q_WS_WINCE
         flags |= Qt::WindowTitleHint | Qt::WindowSystemMenuHint | Qt::WindowContextHelpButtonHint | Qt::WindowCloseButtonHint;
 #else
@@ -1047 +1120 @@
 {
     Q_Q(QWidget);
-    if (qApp->type() == QApplication::Tty)
+    if (QApplication::type() == QApplication::Tty)
         qFatal("QWidget: Cannot create a QWidget when no GUI is being used");
 
-    Q_ASSERT(uncreatedWidgets);
-    uncreatedWidgets->insert(q);
+    Q_ASSERT(allWidgets);
+    allWidgets->insert(q);
 
     QWidget *desktopWidget = 0;
@@ -1062 +1135 @@
 
 #ifndef QT_NO_THREAD
-    if (!q->parent()) {
+    if (!parent) {
         Q_ASSERT_X(q->thread() == qApp->thread(), "QWidget",
                    "Widgets must be created in the GUI thread.");
@@ -1097 +1170 @@
     if (f & Qt::MSWindowsOwnDC)
         q->setAttribute(Qt::WA_NativeWindow);
-
-#ifdef Q_OS_WINCE
-    data.window_state_internal = 0;
-#endif
 
     q->setAttribute(Qt::WA_QuitOnClose); // might be cleared in adjustQuitOnCloseAttribute()
@@ -1257 +1326 @@
 
     // a real toplevel window needs a backing store
-    if (isWindow()) {
+    if (isWindow() && windowType() != Qt::Desktop) {
         delete d->topData()->backingStore;
         // QWidgetBackingStore will check this variable, hence it must be 0
@@ -1280 +1349 @@
     if (isWindow() && !d->topData()->iconText.isEmpty())
         d->setWindowIconText_helper(d->topData()->iconText);
+    if (isWindow() && !d->topData()->caption.isEmpty())
+        d->setWindowTitle_helper(d->topData()->caption);
     if (windowType() != Qt::Desktop) {
         d->updateSystemBackground();
@@ -1340 +1411 @@
     if (QApplicationPrivate::main_widget == this) {        // reset main widget
         QApplicationPrivate::main_widget = 0;
-        qApp->quit();
-    }
-#endif
-
-    clearFocus();
+        QApplication::quit();
+    }
+#endif
+
+    QT_TRY {
+        clearFocus();
+    } QT_CATCH(...) {
+        // swallow this problem because we are in a destructor
+    }
 
     d->setDirtyOpaqueRegion();
 
-    if (isWindow() && isVisible() && internalWinId())
-        hide();
-#if defined(Q_WS_WIN) || defined(Q_WS_PM) || defined(Q_WS_X11)
-    else if (!internalWinId() && isVisible())
+    if (isWindow() && isVisible() && internalWinId()) {
+        QT_TRY {
+            d->close_helper(QWidgetPrivate::CloseNoEvent);
+        } QT_CATCH(...) {
+            // if we're out of memory, at least hide the window.
+            QT_TRY {
+                hide();
+            } QT_CATCH(...) {
+                // and if that also doesn't work, then give up
+            }
+        }
+    }
+
+#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined (Q_WS_QWS) || defined(Q_WS_PM)
+    else if (!internalWinId() && isVisible()) {
         qApp->d_func()->sendSyntheticEnterLeave(this);
+#ifdef Q_WS_QWS
+    } else if (isVisible()) {
+        qApp->d_func()->sendSyntheticEnterLeave(this);
+#endif
+    }
 #endif
 
@@ -1367 +1458 @@
     QObjectPrivate::clearGuards(this);
 
+    if (d->declarativeData) {
+        d->declarativeData->destroyed(this);
+        d->declarativeData = 0;                 // don't activate again in ~QObject
+    }
+
     if (!d->children.isEmpty())
         d->deleteChildren();
@@ -1372 +1468 @@
     QApplication::removePostedEvents(this);
 
-    destroy();                                        // platform-dependent cleanup
-
+    QT_TRY {
+        destroy();                                        // platform-dependent cleanup
+    } QT_CATCH(...) {
+        // if this fails we can't do anything about it but at least we are not allowed to throw.
+    }
     --QWidgetPrivate::instanceCounter;
 
-    if (QWidgetPrivate::uncreatedWidgets) // might have been deleted by ~QApplication
-        QWidgetPrivate::uncreatedWidgets->remove(this);
+    if (QWidgetPrivate::allWidgets) // might have been deleted by ~QApplication
+        QWidgetPrivate::allWidgets->remove(this);
 
     QEvent e(QEvent::Destroy);
@@ -1397 +1496 @@
     if (mapper && data.winid && !userDesktopWidget) {
         mapper->remove(data.winid);
-        uncreatedWidgets->insert(q);
-    }
+    }
+
+    const WId oldWinId = data.winid;
 
     data.winid = id;
@@ -1406 +1506 @@
     if (mapper && id && !userDesktopWidget) {
         mapper->insert(data.winid, q);
-        uncreatedWidgets->remove(q);
+    }
+
+    if(oldWinId != id) {
+        // Do not emit an event when the old winId is destroyed.  This only
+        // happens (a) during widget destruction, and (b) immediately prior
+        // to creation of a new winId, for example as a result of re-parenting.
+        if(id != 0) {
+            QEvent e(QEvent::WinIdChange);
+            QCoreApplication::sendEvent(q, &e);
+        }
     }
 }
@@ -1416 +1525 @@
     if (!extra->topextra) {
         QTLWExtra* x = extra->topextra = new QTLWExtra;
+        x->icon = 0;
+        x->iconPixmap = 0;
+        x->backingStore = 0;
         x->windowSurface = 0;
+        x->sharedPainter = 0;
+        x->incw = x->inch = 0;
+        x->basew = x->baseh = 0;
+        x->frameStrut.setCoords(0, 0, 0, 0);
+        x->normalGeometry = QRect(0,0,-1,-1);
+        x->savedFlags = 0;
         x->opacity = 255;
         x->posFromMove = false;
@@ -1422 +1540 @@
         x->inTopLevelResize = false;
         x->inRepaint = false;
-        x->backingStore = 0;
-        x->icon = 0;
-        x->iconPixmap = 0;
-        x->frameStrut.setCoords(0, 0, 0, 0);
-        x->incw = x->inch = 0;
-        x->basew = x->baseh = 0;
-        x->normalGeometry = QRect(0,0,-1,-1);
-#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined(Q_WS_MAC)
         x->embedded = 0;
-#endif
-#if defined(Q_WS_X11)
-        x->parentWinId = 0;
-        x->spont_unmapped = 0;
-        x->dnd = 0;
-#endif
-        x->savedFlags = 0;
-#if defined(Q_WS_QWS) && !defined(QT_NO_QWS_MANAGER)
-        x->qwsManager = 0;
-#endif
-        x->sharedPainter = 0;
         createTLSysExtra();
 #ifdef QWIDGET_EXTRA_DEBUG
-    static int count = 0;
-    qDebug() << "tlextra" << ++count;
+        static int count = 0;
+        qDebug() << "tlextra" << ++count;
 #endif
     }
@@ -1459 +1558 @@
     if (!extra) {                                // if not exists
         extra = new QWExtra;
-        extra->minw = extra->minh = 0;
-        extra->maxw = extra->maxh = QWIDGETSIZE_MAX;
+        extra->glContext = 0;
+        extra->topextra = 0;
+#ifndef QT_NO_GRAPHICSVIEW
+        extra->proxyWidget = 0;
+#endif
+#ifndef QT_NO_CURSOR
+        extra->curs = 0;
+#endif
+        extra->minw = 0;
+        extra->minh = 0;
+        extra->maxw = QWIDGETSIZE_MAX;
+        extra->maxh = QWIDGETSIZE_MAX;
+        extra->customDpiX = 0;
+        extra->customDpiY = 0;
         extra->explicitMinSize = 0;
         extra->explicitMaxSize = 0;
@@ -1467 +1578 @@
         extra->inRenderWithPainter = 0;
         extra->hasMask = 0;
-#ifndef QT_NO_CURSOR
-        extra->curs = 0;
-#endif
-        extra->style = 0;
-        extra->topextra = 0;
-        extra->proxyWidget = 0;
-        extra->glContext = 0;
-        extra->customDpiX = 0;
-        extra->customDpiY = 0;
         createSysExtra();
 #ifdef QWIDGET_EXTRA_DEBUG
-    static int count = 0;
-    qDebug() << "extra" << ++count;
+        static int count = 0;
+        qDebug() << "extra" << ++count;
 #endif
     }
@@ -1517 +1619 @@
         extra = 0;
     }
-}
-
-/*
-  Returns true if the background is inherited; otherwise returns
-  false.
-
-  Mainly used in the paintOnScreen case.
-*/
-
-bool QWidgetPrivate::isBackgroundInherited() const
-{
-    Q_Q(const QWidget);
-
-    // windows do not inherit their background
-    if (q->isWindow() || q->windowType() == Qt::SubWindow)
-        return false;
-
-    if (q->testAttribute(Qt::WA_NoSystemBackground) || q->testAttribute(Qt::WA_OpaquePaintEvent))
-        return false;
-
-    const QPalette &pal = q->palette();
-    QPalette::ColorRole bg = q->backgroundRole();
-    QBrush brush = pal.brush(bg);
-
-    // non opaque brushes leaves us no choice, we must inherit
-    if (!q->autoFillBackground() || !brush.isOpaque())
-        return true;
-
-    if (brush.style() == Qt::SolidPattern) {
-        // the background is just a solid color. If there is no
-        // propagated contents, then we claim as performance
-        // optimization that it was not inheritet. This is the normal
-        // case in standard Windows or Motif style.
-        const QWidget *w = q->parentWidget();
-        if (!w->d_func()->isBackgroundInherited())
-            return false;
-    }
-
-    return true;
 }
 
@@ -1583 +1646 @@
             }
 
-            if (qRectIntersects(sibling->data->crect, r)) {
+            if (qRectIntersects(sibling->d_func()->effectiveRectFor(sibling->data->crect), r)) {
                 const QWExtra *siblingExtra = sibling->d_func()->extra;
-                if (siblingExtra && siblingExtra->hasMask
+                if (siblingExtra && siblingExtra->hasMask && !sibling->d_func()->graphicsEffect
                     && !siblingExtra->mask.translated(sibling->data->crect.topLeft()).intersects(r)) {
                     continue;
@@ -1649 +1712 @@
     Q_Q(QWidget);
     // Propagate a new inherited mask to all children.
+#ifndef QT_NO_GRAPHICSVIEW
     if (!q->parentWidget() && extra && extra->proxyWidget) {
-#ifndef QT_NO_GRAPHICSVIEW
         QGraphicsProxyWidget *p = extra->proxyWidget;
         inheritedPaletteResolveMask = p->d_func()->inheritedPaletteResolveMask | p->palette().resolve();
+    } else
 #endif //QT_NO_GRAPHICSVIEW
-    } else if (q->isWindow() && !q->testAttribute(Qt::WA_WindowPropagation)) {
+        if (q->isWindow() && !q->testAttribute(Qt::WA_WindowPropagation)) {
         inheritedPaletteResolveMask = 0;
     }
@@ -1684 +1748 @@
     if (!w->isVisible())
         return QRect();
-    QRect r = q->rect();
+    QRect r = effectiveRectFor(q->rect());
     int ox = 0;
     int oy = 0;
@@ -1739 +1803 @@
 }
 
+#ifndef QT_NO_GRAPHICSEFFECT
+void QWidgetPrivate::invalidateGraphicsEffectsRecursively()
+{
+    Q_Q(QWidget);
+    QWidget *w = q;
+    do {
+        if (w->graphicsEffect()) {
+            QWidgetEffectSourcePrivate *sourced =
+                static_cast<QWidgetEffectSourcePrivate *>(w->graphicsEffect()->source()->d_func());
+            if (!sourced->updateDueToGraphicsEffect)
+                w->graphicsEffect()->source()->d_func()->invalidateCache();
+        }
+        w = w->parentWidget();
+    } while (w);
+}
+#endif //QT_NO_GRAPHICSEFFECT
+
 void QWidgetPrivate::setDirtyOpaqueRegion()
 {
@@ -1744 +1825 @@
 
     dirtyOpaqueChildren = true;
+
+#ifndef QT_NO_GRAPHICSEFFECT
+    invalidateGraphicsEffectsRecursively();
+#endif //QT_NO_GRAPHICSEFFECT
 
     if (q->isWindow())
@@ -1758 +1843 @@
 }
 
-QRegion QWidgetPrivate::getOpaqueRegion() const
-{
-    Q_Q(const QWidget);
-
-    QRegion r = isOpaque ? q->rect() : getOpaqueChildren();
-    if (extra && extra->hasMask)
-        r &= extra->mask;
-    if (r.isEmpty())
-        return r;
-    return r & clipRect();
-}
-
 const QRegion &QWidgetPrivate::getOpaqueChildren() const
 {
@@ -1784 +1857 @@
 
         const QPoint offset = child->geometry().topLeft();
-        that->opaqueChildren += child->d_func()->getOpaqueRegion().translated(offset);
-    }
-
+        QWidgetPrivate *childd = child->d_func();
+        QRegion r = childd->isOpaque ? child->rect() : childd->getOpaqueChildren();
+        if (childd->extra && childd->extra->hasMask)
+            r &= childd->extra->mask;
+        if (r.isEmpty())
+            continue;
+        r.translate(offset);
+        that->opaqueChildren += r;
+    }
+
+    that->opaqueChildren &= q_func()->rect();
     that->dirtyOpaqueChildren = false;
 
@@ -1826 +1907 @@
         QWidgetPrivate *pd = w->parentWidget()->d_func();
         const int myIndex = pd->children.indexOf(const_cast<QWidget *>(w));
+        const QRect widgetGeometry = w->d_func()->effectiveRectFor(w->data->crect);
         for (int i = myIndex + 1; i < pd->children.size(); ++i) {
             QWidget *sibling = qobject_cast<QWidget *>(pd->children.at(i));
@@ -1831 +1913 @@
                 continue;
 
-            if (!qRectIntersects(sibling->data->crect, w->data->crect))
+            const QRect siblingGeometry = sibling->d_func()->effectiveRectFor(sibling->data->crect);
+            if (!qRectIntersects(siblingGeometry, widgetGeometry))
                 continue;
 
@@ -1839 +1922 @@
             }
 
-            if (!qRectIntersects(sibling->data->crect, clipBoundingRect.translated(parentOffset)))
+            if (!qRectIntersects(siblingGeometry, clipBoundingRect.translated(parentOffset)))
                 continue;
 
@@ -1851 +1934 @@
             QRegion siblingDirty(parentClip);
             siblingDirty &= (siblingClipRect.translated(siblingPos));
-            const bool hasMask = sibling->d_func()->extra && sibling->d_func()->extra->hasMask;
+            const bool hasMask = sibling->d_func()->extra && sibling->d_func()->extra->hasMask
+                                 && !sibling->d_func()->graphicsEffect;
             if (hasMask)
                 siblingDirty &= sibling->d_func()->extra->mask.translated(siblingPos);
@@ -1862 +1946 @@
                     sourceRegion -= siblingDirty;
                 } else {
-                    sourceRegion -= sibling->data->crect.translated(-parentOffset);
+                    sourceRegion -= siblingGeometry.translated(-parentOffset);
                 }
             } else {
@@ -1893 +1977 @@
     QPoint offset;
 
+#ifndef QT_NO_GRAPHICSEFFECT
+    if (graphicsEffect) {
+        w = q->parentWidget();
+        offset -= data.crect.topLeft();
+    }
+#endif //QT_NO_GRAPHICSEFFECT
+
     while (w) {
         const QWidgetPrivate *wd = w->d_func();
@@ -1902 +1993 @@
         w = w->parentWidget();
     }
-}
-
-bool QWidgetPrivate::hasBackground() const
-{
-    Q_Q(const QWidget);
-    if (!q->isWindow() && q->parentWidget() && q->parentWidget()->testAttribute(Qt::WA_PaintOnScreen))
-        return true;
-    if (q->testAttribute(Qt::WA_PaintOnScreen))
-        return true;
-    if (!q->testAttribute(Qt::WA_OpaquePaintEvent) && !q->testAttribute(Qt::WA_NoSystemBackground)) {
-        const QPalette &pal = q->palette();
-        QPalette::ColorRole bg = q->backgroundRole();
-        QBrush bgBrush = pal.brush(bg);
-        return (bgBrush.style() != Qt::NoBrush &&
-                ((q->isWindow() || q->windowType() == Qt::SubWindow)
-                 || (QPalette::ColorRole(bg_role) != QPalette::NoRole || (pal.resolve() & (1<<bg)))));
-    }
-    return false;
 }
 
@@ -1944 +2017 @@
     setDirtyOpaqueRegion();
 
+#ifndef QT_NO_GRAPHICSEFFECT
+    if (graphicsEffect) {
+        // ### We should probably add QGraphicsEffect::isOpaque at some point.
+        setOpaque(false);
+        return;
+    }
+#endif //QT_NO_GRAPHICSEFFECT
+
     Q_Q(QWidget);
 #ifdef Q_WS_X11
@@ -1991 +2072 @@
     winUpdateIsOpaque();
 #endif
+#ifdef Q_OS_SYMBIAN
+    s60UpdateIsOpaque();
+#endif
 }
 
@@ -2003 +2087 @@
 #ifdef Q_WS_WIN
     winUpdateIsOpaque();
+#endif
+#ifdef Q_OS_SYMBIAN
+    s60UpdateIsOpaque();
 #endif
 }
@@ -2024 +2111 @@
     p.translate(-off);
     widget->d_func()->paintBackground(&p, QRect(off, size()));
-
-}
-
-static inline void fillRegion(QPainter *painter, const QRegion &rgn, const QPoint &offset, const QBrush &brush)
+}
+
+static inline void fillRegion(QPainter *painter, const QRegion &rgn, const QBrush &brush)
 {
     Q_ASSERT(painter);
@@ -2036 +2122 @@
         // when filling with the standard widget background.
         // Defined in qmacstyle_mac.cpp
-        extern void qt_mac_fill_background(QPainter *painter, const QRegion &rgn, const QPoint &offset, const QBrush &brush);
-        qt_mac_fill_background(painter, rgn, offset, brush);
+        extern void qt_mac_fill_background(QPainter *painter, const QRegion &rgn, const QBrush &brush);
+        qt_mac_fill_background(painter, rgn, brush);
 #else
-        const QRegion translated = rgn.translated(offset);
-        const QRect rect(translated.boundingRect());
-        painter->setClipRegion(translated);
-        painter->drawTiledPixmap(rect, brush.texture(), rect.topLeft());
-#endif
+#if !defined(QT_NO_STYLE_S60)
+        // Defined in qs60style.cpp
+        extern bool qt_s60_fill_background(QPainter *painter, const QRegion &rgn, const QBrush &brush);
+        if (!qt_s60_fill_background(painter, rgn, brush))
+#endif // !defined(QT_NO_STYLE_S60)
+        {
+            const QRect rect(rgn.boundingRect());
+            painter->setClipRegion(rgn);
+            painter->drawTiledPixmap(rect, brush.texture(), rect.topLeft());
+        }
+#endif // Q_WS_MAC
+
+    } else if (brush.gradient()
+               && brush.gradient()->coordinateMode() == QGradient::ObjectBoundingMode) {
+        painter->save();
+        painter->setClipRegion(rgn);
+        painter->fillRect(0, 0, painter->device()->width(), painter->device()->height(), brush);
+        painter->restore();
     } else {
         const QVector<QRect> &rects = rgn.rects();
         for (int i = 0; i < rects.size(); ++i)
-            painter->fillRect(rects.at(i).translated(offset), brush);
-    }
-}
-
-
-void QWidgetPrivate::paintBackground(QPainter *painter, const QRegion &rgn, const QPoint &offset, int flags) const
+            painter->fillRect(rects.at(i), brush);
+    }
+}
+
+void QWidgetPrivate::paintBackground(QPainter *painter, const QRegion &rgn, int flags) const
 {
     Q_Q(const QWidget);
+
+#ifndef QT_NO_SCROLLAREA
+    bool resetBrushOrigin = false;
+    QPointF oldBrushOrigin;
+    //If we are painting the viewport of a scrollarea, we must apply an offset to the brush in case we are drawing a texture
+    QAbstractScrollArea *scrollArea = qobject_cast<QAbstractScrollArea *>(parent);
+    if (scrollArea && scrollArea->viewport() == q) {
+        QObjectData *scrollPrivate = static_cast<QWidget *>(scrollArea)->d_ptr.data();
+        QAbstractScrollAreaPrivate *priv = static_cast<QAbstractScrollAreaPrivate *>(scrollPrivate);
+        oldBrushOrigin = painter->brushOrigin();
+        resetBrushOrigin = true;
+        painter->setBrushOrigin(-priv->contentsOffset());
+
+    }
+#endif // QT_NO_SCROLLAREA
 
     const QBrush autoFillBrush = q->palette().brush(q->backgroundRole());
@@ -2064 +2177 @@
             painter->setCompositionMode(QPainter::CompositionMode_Source); //copy alpha straight in
 #endif
-        fillRegion(painter, rgn, offset, bg);
+        fillRegion(painter, rgn, bg);
     }
 
     if (q->autoFillBackground())
-        fillRegion(painter, rgn, offset, autoFillBrush);
+        fillRegion(painter, rgn, autoFillBrush);
 
     if (q->testAttribute(Qt::WA_StyledBackground)) {
-        painter->setClipRegion(rgn.translated(offset));
+        painter->setClipRegion(rgn);
         QStyleOption opt;
         opt.initFrom(q);
         q->style()->drawPrimitive(QStyle::PE_Widget, &opt, painter, q);
     }
+
+#ifndef QT_NO_SCROLLAREA
+    if (resetBrushOrigin)
+        painter->setBrushOrigin(oldBrushOrigin);
+#endif // QT_NO_SCROLLAREA
 }
 
@@ -2095 +2213 @@
     Q_Q(QWidget);
     // If this was the active application window, reset it
-    if (qApp->activeWindow() == q)
-        qApp->setActiveWindow(0);
+    if (QApplication::activeWindow() == q)
+        QApplication::setActiveWindow(0);
     // If the is the active mouse press widget, reset it
     if (q == qt_button_down)
@@ -2137 +2255 @@
     will be provided a native handle.
 
-    \note We recommend that you do not store this value as it is likely to
-    change at run-time.
+    On Mac OS X, the type returned depends on which framework Qt was linked
+    against. If Qt is using Carbon, the {WId} is actually an HIViewRef. If Qt
+    is using Cocoa, {WId} is a pointer to an NSView.
+
+    This value may change at run-time. An event with type QEvent::WinIdChange
+    will be sent to the widget following a change in window system identifier.
 
     \sa find()
@@ -2239 +2361 @@
     widget's style, as described in the \l{Qt Style Sheets} document.
 
-    \note Qt style sheets are currently not supported for QMacStyle
-    (the default style on Mac OS X). We plan to address this in some future
-    release.
+    Since Qt 4.5, Qt style sheets fully supports Mac OS X.
+
+    \warning Qt style sheets are currently not supported for custom QStyle
+    subclasses. We plan to address this in some future release.
 
     \sa setStyle(), QApplication::styleSheet, {Qt Style Sheets}
@@ -2292 +2415 @@
     if (d->extra && d->extra->style)
         return d->extra->style;
-    return qApp->style();
+    return QApplication::style();
 }
 
@@ -2342 +2465 @@
 {
     Q_Q(QWidget);
-    createExtra();
-
     QStyle *oldStyle  = q->style();
 #ifndef QT_NO_STYLE_STYLESHEET
-    QStyle *origStyle = extra->style;
-#endif
-    extra->style = newStyle;
+    QStyle *origStyle = 0;
+#endif
+
+#ifdef Q_WS_MAC
+    // the metalhack boolean allows Qt/Mac to do a proper re-polish depending
+    // on how the Qt::WA_MacBrushedMetal attribute is set. It is only ever
+    // set when changing that attribute and passes the widget's CURRENT style.
+    // therefore no need to do a reassignment.
+    if (!metalHack)
+#endif
+    {
+        createExtra();
+
+#ifndef QT_NO_STYLE_STYLESHEET
+        origStyle = extra->style;
+#endif
+        extra->style = newStyle;
+    }
 
     // repolish
@@ -2598 +2734 @@
 Qt::WindowStates QWidget::windowState() const
 {
-    return (Qt::WindowStates)data->window_state;
+    return Qt::WindowStates(data->window_state);
 }
 
@@ -2610 +2746 @@
 void QWidget::overrideWindowState(Qt::WindowStates newstate)
 {
-    QWindowStateChangeEvent e((Qt::WindowStates)data->window_state, true);
+    QWindowStateChangeEvent e(Qt::WindowStates(data->window_state), true);
     data->window_state  = newstate;
     QApplication::sendEvent(this, &e);
@@ -2709 +2845 @@
 
     On X11, this function may not work properly with certain window
-    managers. See \l{geometry.html}{Window Geometry} for an explanation.
+    managers. See the \l{Window Geometry} documentation for an explanation.
 
     \sa setWindowState(), showNormal(), showMinimized(), show(), hide(), isVisible()
@@ -2764 +2900 @@
 {
     const QWidget * w = this;
-    while (w && !w->testAttribute(Qt::WA_ForceDisabled)
+    while (!w->testAttribute(Qt::WA_ForceDisabled)
             && !w->isWindow()
             && w->parentWidget()
@@ -2948 +3084 @@
         // enforce the windows behavior of clearing the cursor on
         // disabled widgets
-        extern void qt_x11_enforce_cursor(QWidget * w); // defined in qwidget_x11.cpp
         qt_x11_enforce_cursor(q);
     }
@@ -2955 +3090 @@
     setEnabled_helper_sys(enable);
 #endif
-#if defined (Q_WS_WIN)
-    if (q->hasFocus())
-        QInputContextPrivate::updateImeStatus(q, true);
-#endif
+#ifndef QT_NO_IM
+    if (q->testAttribute(Qt::WA_InputMethodEnabled) && q->hasFocus()) {
+        QWidget *focusWidget = effectiveFocusWidget();
+        QInputContext *qic = focusWidget->d_func()->inputContext();
+        if (enable) {
+            qic->setFocusWidget(focusWidget);
+        } else {
+            qic->reset();
+            qic->setFocusWidget(0);
+        }
+    }
+#endif //QT_NO_IM
     QEvent e(QEvent::EnabledChange);
     QApplication::sendEvent(q, &e);
@@ -3053 +3196 @@
     window frame
 
-    See the \link geometry.html Window Geometry documentation\endlink
-    for an overview of geometry issues with windows.
+    See the \l{Window Geometry} documentation for an overview of geometry
+    issues with windows.
 
     By default, this property contains a value that depends on the user's
@@ -3080 +3223 @@
     any window frame
 
-    See the \link geometry.html Window Geometry documentation\endlink
-    for an overview of window geometry.
+    See the \l{Window Geometry} documentation for an overview of geometry
+    issues with windows.
 
     By default, this property has a value of 0.
@@ -3100 +3243 @@
     including any window frame
 
-    See the \link geometry.html Window Geometry documentation\endlink
-    for an overview of window geometry.
+    See the \l{Window Geometry} documentation for an overview of geometry
+    issues with windows.
 
     By default, this property has a value of 0.
@@ -3133 +3276 @@
     lead to infinite recursion.
 
-    See the \link geometry.html Window Geometry documentation\endlink
-    for an overview of window geometry.
+    See the \l{Window Geometry} documentation for an overview of geometry
+    issues with windows.
 
     \sa frameGeometry, size x(), y()
@@ -3164 +3307 @@
     can lead to infinite recursion.
 
-    See the \link geometry.html Window Geometry documentation\endlink
-    for an overview of window geometry.
+    See the \l{Window Geometry} documentation for an overview of geometry
+    issues with windows.
 
     By default, this property contains a value that depends on the user's
@@ -3214 +3357 @@
     \brief the width of the widget excluding any window frame
 
-    See the \link geometry.html Window Geometry documentation\endlink
-    for an overview of window geometry.
+    See the \l{Window Geometry} documentation for an overview of geometry
+    issues with windows.
 
     \note Do not use this function to find the width of a screen on
     a \l{QDesktopWidget}{multiple screen desktop}. Read
-    \l{multiple screens note}{this note} for details.
+    \l{QDesktopWidget#Screen Geometry}{this note} for details.
 
     By default, this property contains a value that depends on the user's
@@ -3231 +3374 @@
     \brief the height of the widget excluding any window frame
 
-    See the \link geometry.html Window Geometry documentation\endlink
-    for an overview of window geometry.
+    See the \l{Window Geometry} documentation for an overview of geometry
+    issues with windows.
 
     \note Do not use this function to find the height of a screen
-    on a \l {QDesktopWidget} {multiple screen desktop}. Read
-    \l {multiple screens note} {this note} for details.
+    on a \l{QDesktopWidget}{multiple screen desktop}. Read
+    \l{QDesktopWidget#Screen Geometry}{this note} for details.
 
     By default, this property contains a value that depends on the user's
@@ -3251 +3394 @@
     The rect property equals QRect(0, 0, width(), height()).
 
-    See the \link geometry.html Window Geometry documentation\endlink
-    for an overview of window geometry.
+    See the \l{Window Geometry} documentation for an overview of geometry
+    issues with windows.
 
     By default, this property contains a value that depends on the user's
@@ -3492 +3635 @@
     }
 #endif
+    int mw = minw, mh = minh;
+    if (mw == QWIDGETSIZE_MAX)
+        mw = 0;
+    if (mh == QWIDGETSIZE_MAX)
+        mh = 0;
     if (minw > QWIDGETSIZE_MAX || minh > QWIDGETSIZE_MAX) {
         qWarning("QWidget::setMinimumSize: (%s/%s) "
@@ -3497 +3645 @@
                  q->objectName().toLocal8Bit().data(), q->metaObject()->className(), QWIDGETSIZE_MAX,
                 QWIDGETSIZE_MAX);
-        minw = qMin<int>(minw, QWIDGETSIZE_MAX);
-        minh = qMin<int>(minh, QWIDGETSIZE_MAX);
+        minw = mw = qMin<int>(minw, QWIDGETSIZE_MAX);
+        minh = mh = qMin<int>(minh, QWIDGETSIZE_MAX);
     }
     if (minw < 0 || minh < 0) {
@@ -3504 +3652 @@
                 "are not possible",
                 q->objectName().toLocal8Bit().data(), q->metaObject()->className(), minw, minh);
-        minw = qMax(minw, 0);
-        minh = qMax(minh, 0);
+        minw = mw = qMax(minw, 0);
+        minh = mh = qMax(minh, 0);
     }
     createExtra();
-    if (extra->minw == minw && extra->minh == minh)
+    if (extra->minw == mw && extra->minh == mh)
         return false;
-    extra->minw = minw;
-    extra->minh = minh;
-    extra->explicitMinSize = (minw ? Qt::Horizontal : 0) | (minh ? Qt::Vertical : 0);
+    extra->minw = mw;
+    extra->minh = mh;
+    extra->explicitMinSize = (mw ? Qt::Horizontal : 0) | (mh ? Qt::Vertical : 0);
     return true;
 }
@@ -3572 +3720 @@
     extra->maxw = maxw;
     extra->maxh = maxh;
-    extra->explicitMaxSize = (maxw != QWIDGETSIZE_MAX ? Qt::Horizontal : 0) | (maxh != QWIDGETSIZE_MAX ? Qt::Vertical : 0);
+    extra->explicitMaxSize = (maxw != QWIDGETSIZE_MAX ? Qt::Horizontal : 0) |
+                             (maxh != QWIDGETSIZE_MAX ? Qt::Vertical : 0);
     return true;
 }
@@ -3651 +3800 @@
     This will override the default size constraints set by QLayout.
 
+    To remove constraints, set the size to QWIDGETSIZE_MAX.
+
     Alternatively, if you want the widget to have a
     fixed size based on its contents, you can call
@@ -3692 +3843 @@
         d->updateGeometry_helper(true);
 
-    resize(w, h);
+    if (w != QWIDGETSIZE_MAX || h != QWIDGETSIZE_MAX)
+        resize(w, h);
 }
 
@@ -4065 +4217 @@
   parent's background role.
 
+  Note that styles are free to choose any color from the palette.
+  You can modify the palette or set a style sheet if you don't
+  achieve the result you want with setBackgroundRole().
+
   \sa backgroundRole(), foregroundRole()
  */
@@ -4127 +4283 @@
   that contrasts with the background role.
 
+  Note that styles are free to choose any color from the palette.
+  You can modify the palette or set a style sheet if you don't
+  achieve the result you want with setForegroundRole().
+
   \sa foregroundRole(), backgroundRole()
  */
@@ -4180 +4340 @@
     appearance of the widget. Instead, you may choose to apply a \l
     styleSheet. You can refer to our Knowledge Base article
-    \l{http://qtsoftware.com/developer/knowledgebase/22}{here} for more
+    \l{http://qt.nokia.com/developer/knowledgebase/22}{here} for more
     information.
 
@@ -4195 +4355 @@
         data->pal.setCurrentColorGroup(QPalette::Disabled);
     } else if ((!isVisible() || isActiveWindow())
-#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
+#if defined(Q_OS_WIN) && !defined(Q_WS_WINCE)
         && !QApplicationPrivate::isBlockedByModal(const_cast<QWidget *>(this))
 #endif
@@ -4240 +4400 @@
     QPalette naturalPalette = QApplication::palette(q);
     if (!q->testAttribute(Qt::WA_StyleSheet)
-        && (!q->isWindow() || q->testAttribute(Qt::WA_WindowPropagation) || (extra && extra->proxyWidget))) {
+        && (!q->isWindow() || q->testAttribute(Qt::WA_WindowPropagation)
+#ifndef QT_NO_GRAPHICSVIEW
+            || (extra && extra->proxyWidget)
+#endif //QT_NO_GRAPHICSVIEW
+            )) {
         if (QWidget *p = q->parentWidget()) {
             if (!p->testAttribute(Qt::WA_StyleSheet)) {
@@ -4251 +4415 @@
                 }
             }
-        } else if (extra && extra->proxyWidget) {
+        }
 #ifndef QT_NO_GRAPHICSVIEW
+        else if (extra && extra->proxyWidget) {
             QPalette inheritedPalette = extra->proxyWidget->palette();
             inheritedPalette.resolve(inheritedMask);
             naturalPalette = inheritedPalette.resolve(naturalPalette);
+        }
 #endif //QT_NO_GRAPHICSVIEW
-        }
     }
     naturalPalette.resolve(0);
@@ -4375 +4540 @@
     QFont naturalFont = QApplication::font(q);
     if (!q->testAttribute(Qt::WA_StyleSheet)
-        && (!q->isWindow() || q->testAttribute(Qt::WA_WindowPropagation) || (extra && extra->proxyWidget))) {
+        && (!q->isWindow() || q->testAttribute(Qt::WA_WindowPropagation)
+#ifndef QT_NO_GRAPHICSVIEW
+            || (extra && extra->proxyWidget)
+#endif //QT_NO_GRAPHICSVIEW
+            )) {
         if (QWidget *p = q->parentWidget()) {
             if (!p->testAttribute(Qt::WA_StyleSheet)) {
@@ -4386 +4555 @@
                 }
             }
-        } else if (extra && extra->proxyWidget) {
+        }
 #ifndef QT_NO_GRAPHICSVIEW
+        else if (extra && extra->proxyWidget) {
             QFont inheritedFont = extra->proxyWidget->font();
             inheritedFont.resolve(inheritedMask);
             naturalFont = inheritedFont.resolve(naturalFont);
+        }
 #endif //QT_NO_GRAPHICSVIEW
-        }
     }
     naturalFont.resolve(0);
@@ -4439 +4609 @@
 #endif
     // Combine new mask with natural mask and propagate to children.
+#ifndef QT_NO_GRAPHICSVIEW
     if (!q->parentWidget() && extra && extra->proxyWidget) {
-#ifndef QT_NO_GRAPHICSVIEW
         QGraphicsProxyWidget *p = extra->proxyWidget;
         inheritedFontResolveMask = p->d_func()->inheritedFontResolveMask | p->font().resolve();
+    } else
 #endif //QT_NO_GRAPHICSVIEW
-    } else if (q->isWindow() && !q->testAttribute(Qt::WA_WindowPropagation)) {
+    if (q->isWindow() && !q->testAttribute(Qt::WA_WindowPropagation)) {
         inheritedFontResolveMask = 0;
     }
@@ -4514 +4685 @@
 
     When the layout direction is set on a widget, it will propagate to
-    the widget's children. Children added after the call to \c
-    setLayoutDirection() will not inherit the parent's layout
+    the widget's children, but not to a child that is a window and not
+    to a child for which setLayoutDirection() has been explicitly
+    called. Also, child widgets added \e after setLayoutDirection()
+    has been called for the parent do not inherit the parent's layout
     direction.
 
@@ -4575 +4748 @@
     By default, this property contains a cursor with the Qt::ArrowCursor
     shape.
+
+    Some underlying window implementations will reset the cursor if it
+    leaves a widget even if the mouse is grabbed. If you want to have
+    a cursor set for all widgets, even when outside the window, consider
+    QApplication::setOverrideCursor().
 
     \sa QApplication::setOverrideCursor()
@@ -4602 +4780 @@
     {
         d->createExtra();
+        QCursor *newCursor = new QCursor(cursor);
         delete d->extra->curs;
-        d->extra->curs = new QCursor(cursor);
+        d->extra->curs = newCursor;
     }
     setAttribute(Qt::WA_SetCursor);
@@ -4713 +4892 @@
         target = redirected;
         offset -= redirectionOffset;
-        if (!inRenderWithPainter) { // Clip handled by shared painter (in qpainter.cpp).
-            const QRegion redirectedSystemClip = redirected->paintEngine()->systemClip();
-            if (!redirectedSystemClip.isEmpty())
-                paintRegion &= redirectedSystemClip.translated(-offset);
+    }
+
+    if (!inRenderWithPainter) { // Clip handled by shared painter (in qpainter.cpp).
+        if (QPaintEngine *targetEngine = target->paintEngine()) {
+            const QRegion targetSystemClip = targetEngine->systemClip();
+            if (!targetSystemClip.isEmpty())
+                paintRegion &= targetSystemClip.translated(-offset);
         }
     }
@@ -4780 +4962 @@
 
     const qreal opacity = painter->opacity();
-    if (qFuzzyCompare(opacity + 1, qreal(1.0)))
+    if (qFuzzyIsNull(opacity))
         return; // Fully transparent.
 
@@ -4801 +4983 @@
     QPaintEnginePrivate *enginePriv = engine->d_func();
     Q_ASSERT(enginePriv);
-    QPaintDevice *target = painter->worldMatrixEnabled() ? engine->paintDevice() : painter->device();
+    QPaintDevice *target = engine->paintDevice();
     Q_ASSERT(target);
 
@@ -4820 +5002 @@
     const QRegion oldSystemViewport = enginePriv->systemViewport;
 
-    // This ensures that transformed system clips are inside the current system clip.
-    enginePriv->setSystemViewport(oldSystemClip);
+    // This ensures that all painting triggered by render() is clipped to the current engine clip.
+    if (painter->hasClipping()) {
+        const QRegion painterClip = painter->deviceTransform().map(painter->clipRegion());
+        enginePriv->setSystemViewport(oldSystemClip.isEmpty() ? painterClip : oldSystemClip & painterClip);
+    } else {
+        enginePriv->setSystemViewport(oldSystemClip);
+    }
 
     render(target, targetOffset, toBePainted, renderFlags);
@@ -4836 +5023 @@
     d->extra->inRenderWithPainter = false;
 }
+
+/*!
+    \brief The graphicsEffect function returns a pointer to the
+    widget's graphics effect.
+
+    If the widget has no graphics effect, 0 is returned.
+
+    \since 4.6
+
+    \sa setGraphicsEffect()
+*/
+#ifndef QT_NO_GRAPHICSEFFECT
+QGraphicsEffect *QWidget::graphicsEffect() const
+{
+    Q_D(const QWidget);
+    return d->graphicsEffect;
+}
+#endif //QT_NO_GRAPHICSEFFECT
+
+/*!
+
+  \brief The setGraphicsEffect function is for setting the widget's graphics effect.
+
+    Sets \a effect as the widget's effect. If there already is an effect installed
+    on this widget, QWidget will delete the existing effect before installing
+    the new \a effect.
+
+    If \a effect is the installed on a different widget, setGraphicsEffect() will remove
+    the effect from the widget and install it on this widget.
+
+    QWidget takes ownership of \a effect.
+
+    \note This function will apply the effect on itself and all its children.
+
+    \since 4.6
+
+    \sa graphicsEffect()
+*/
+#ifndef QT_NO_GRAPHICSEFFECT
+void QWidget::setGraphicsEffect(QGraphicsEffect *effect)
+{
+    Q_D(QWidget);
+    if (d->graphicsEffect == effect)
+        return;
+
+    if (d->graphicsEffect) {
+        d->invalidateBuffer(rect());
+        delete d->graphicsEffect;
+        d->graphicsEffect = 0;
+    }
+
+    if (effect) {
+        // Set new effect.
+        QGraphicsEffectSourcePrivate *sourced = new QWidgetEffectSourcePrivate(this);
+        QGraphicsEffectSource *source = new QGraphicsEffectSource(*sourced);
+        d->graphicsEffect = effect;
+        effect->d_func()->setGraphicsEffectSource(source);
+        update();
+    }
+
+    d->updateIsOpaque();
+}
+#endif //QT_NO_GRAPHICSEFFECT
 
 bool QWidgetPrivate::isAboutToShow() const
@@ -4928 +5178 @@
 
         QPixmap pixmap(size);
-        if (!(renderFlags & QWidget::DrawWindowBackground))
+        if (!(renderFlags & QWidget::DrawWindowBackground) || !isOpaque)
             pixmap.fill(Qt::transparent);
         q->render(&pixmap, QPoint(), toBePainted, renderFlags);
@@ -4981 +5231 @@
 
     Q_Q(QWidget);
+#ifndef QT_NO_GRAPHICSEFFECT
+    if (graphicsEffect && graphicsEffect->isEnabled()) {
+        QGraphicsEffectSource *source = graphicsEffect->d_func()->source;
+        QWidgetEffectSourcePrivate *sourced = static_cast<QWidgetEffectSourcePrivate *>
+                                                         (source->d_func());
+        if (!sourced->context) {
+            QWidgetPaintContext context(pdev, rgn, offset, flags, sharedPainter, backingStore);
+            sourced->context = &context;
+            if (!sharedPainter) {
+                QPaintEngine *paintEngine = pdev->paintEngine();
+                paintEngine->d_func()->systemClip = rgn.translated(offset);
+                QPainter p(pdev);
+                p.translate(offset);
+                context.painter = &p;
+                graphicsEffect->draw(&p);
+                paintEngine->d_func()->systemClip = QRegion();
+            } else {
+                context.painter = sharedPainter;
+                if (sharedPainter->worldTransform() != sourced->lastEffectTransform) {
+                    sourced->invalidateCache();
+                    sourced->lastEffectTransform = sharedPainter->worldTransform();
+                }
+                sharedPainter->save();
+                sharedPainter->translate(offset);
+                graphicsEffect->draw(sharedPainter);
+                sharedPainter->restore();
+            }
+            sourced->context = 0;
+            return;
+        }
+    }
+#endif //QT_NO_GRAFFICSEFFECT
+
     const bool asRoot = flags & DrawAsRoot;
     const bool alsoOnScreen = flags & DrawPaintOnScreen;
@@ -5013 +5296 @@
                     paintEngine->d_func()->systemClip = toBePainted;
                 else
-                    paintEngine->setSystemRect(q->data->crect);
+                    paintEngine->d_func()->systemRect = q->data->crect;
 
                 //paint the background
@@ -5020 +5303 @@
 
                     QPainter p(q);
-                    QPoint scrollAreaOffset;
-
-#ifndef QT_NO_SCROLLAREA
-                    QAbstractScrollArea *scrollArea = qobject_cast<QAbstractScrollArea *>(q->parent());
-                    if (scrollArea && scrollArea->viewport() == q) {
-                        QObjectData *scrollPrivate = static_cast<QWidget *>(scrollArea)->d_ptr;
-                        QAbstractScrollAreaPrivate *priv = static_cast<QAbstractScrollAreaPrivate *>(scrollPrivate);
-                        scrollAreaOffset = priv->contentsOffset();
-                        p.translate(-scrollAreaOffset);
-                    }
-#endif // QT_NO_SCROLLAREA
-
-                    paintBackground(&p, toBePainted, scrollAreaOffset, (asRoot || onScreen) ? flags | DrawAsRoot : 0);
+                    paintBackground(&p, toBePainted, (asRoot || onScreen) ? flags | DrawAsRoot : 0);
                 }
 
@@ -5064 +5335 @@
                 restoreRedirected();
                 if (!sharedPainter)
-                    paintEngine->setSystemRect(QRect());
+                    paintEngine->d_func()->systemRect = QRect();
                 else
                     paintEngine->d_func()->currentClipWidget = 0;
@@ -5127 +5398 @@
             }
 
-            if (qRectIntersects(boundingRect, x->data->crect)) {
+            if (qRectIntersects(boundingRect, x->d_func()->effectiveRectFor(x->data->crect))) {
 #ifdef Q_BACKINGSTORE_SUBSURFACES
                 if (x->windowSurface() == currentSurface)
@@ -5145 +5416 @@
     QWidgetPrivate *wd = w->d_func();
     const QPoint widgetPos(w->data->crect.topLeft());
-    const bool hasMask = wd->extra && wd->extra->hasMask;
-
+    const bool hasMask = wd->extra && wd->extra->hasMask && !wd->graphicsEffect;
     if (index > 0) {
         QRegion wr(rgn);
@@ -5158 +5428 @@
     }
 
-    if (w->updatesEnabled() && (!w->d_func()->extra || !w->d_func()->extra->proxyWidget)) {
+    if (w->updatesEnabled()
+#ifndef QT_NO_GRAPHICSVIEW
+            && (!w->d_func()->extra || !w->d_func()->extra->proxyWidget)
+#endif //QT_NO_GRAPHICSVIEW
+       ) {
         QRegion wRegion(rgn);
-        wRegion &= w->data->crect;
+        wRegion &= wd->effectiveRectFor(w->data->crect);
         wRegion.translate(-widgetPos);
         if (hasMask)
@@ -5168 +5442 @@
 }
 
+#ifndef QT_NO_GRAPHICSEFFECT
+QRectF QWidgetEffectSourcePrivate::boundingRect(Qt::CoordinateSystem system) const
+{
+    if (system != Qt::DeviceCoordinates)
+        return m_widget->rect();
+
+    if (!context) {
+        // Device coordinates without context not yet supported.
+        qWarning("QGraphicsEffectSource::boundingRect: Not yet implemented, lacking device context");
+        return QRectF();
+    }
+
+    return context->painter->worldTransform().mapRect(m_widget->rect());
+}
+
+void QWidgetEffectSourcePrivate::draw(QPainter *painter)
+{
+    if (!context || context->painter != painter) {
+        m_widget->render(painter);
+        return;
+    }
+
+    // The region saved in the context is neither clipped to the rect
+    // nor the mask, so we have to clip it here before calling drawWidget.
+    QRegion toBePainted = context->rgn;
+    toBePainted &= m_widget->rect();
+    QWidgetPrivate *wd = qt_widget_private(m_widget);
+    if (wd->extra && wd->extra->hasMask)
+        toBePainted &= wd->extra->mask;
+
+    wd->drawWidget(context->pdev, toBePainted, context->offset, context->flags,
+                   context->sharedPainter, context->backingStore);
+}
+
+QPixmap QWidgetEffectSourcePrivate::pixmap(Qt::CoordinateSystem system, QPoint *offset,
+                                           QGraphicsEffect::PixmapPadMode mode) const
+{
+    const bool deviceCoordinates = (system == Qt::DeviceCoordinates);
+    if (!context && deviceCoordinates) {
+        // Device coordinates without context not yet supported.
+        qWarning("QGraphicsEffectSource::pixmap: Not yet implemented, lacking device context");
+        return QPixmap();
+    }
+
+    QPoint pixmapOffset;
+    QRectF sourceRect = m_widget->rect();
+
+    if (deviceCoordinates) {
+        const QTransform &painterTransform = context->painter->worldTransform();
+        sourceRect = painterTransform.mapRect(sourceRect);
+        pixmapOffset = painterTransform.map(pixmapOffset);
+    }
+
+
+    QRect effectRect;
+
+    if (mode == QGraphicsEffect::PadToEffectiveBoundingRect) {
+        effectRect = m_widget->graphicsEffect()->boundingRectFor(sourceRect).toAlignedRect();
+
+    } else if (mode == QGraphicsEffect::PadToTransparentBorder) {
+        effectRect = sourceRect.adjusted(-1, -1, 1, 1).toAlignedRect();
+
+    } else {
+        effectRect = sourceRect.toAlignedRect();
+
+    }
+
+    if (offset)
+        *offset = effectRect.topLeft();
+
+    if (deviceCoordinates) {
+        // Clip to device rect.
+        int left, top, right, bottom;
+        effectRect.getCoords(&left, &top, &right, &bottom);
+        if (left < 0) {
+            if (offset)
+                offset->rx() += -left;
+            effectRect.setX(0);
+        }
+        if (top < 0) {
+            if (offset)
+                offset->ry() += -top;
+            effectRect.setY(0);
+        }
+        // NB! We use +-1 for historical reasons (see QRect documentation).
+        QPaintDevice *device = context->painter->device();
+        const int deviceWidth = device->width();
+        const int deviceHeight = device->height();
+        if (right + 1 > deviceWidth)
+            effectRect.setRight(deviceWidth - 1);
+        if (bottom + 1 > deviceHeight)
+            effectRect.setBottom(deviceHeight -1);
+    }
+
+    pixmapOffset -= effectRect.topLeft();
+
+    QPixmap pixmap(effectRect.size());
+    pixmap.fill(Qt::transparent);
+    m_widget->render(&pixmap, pixmapOffset);
+    return pixmap;
+}
+#endif //QT_NO_GRAPHICSEFFECT
+
+#ifndef QT_NO_GRAPHICSVIEW
 /*!
     \internal
@@ -5176 +5554 @@
     widget was found.
 */
-QGraphicsProxyWidget * QWidgetPrivate::nearestGraphicsProxyWidget(QWidget *origin)
+QGraphicsProxyWidget * QWidgetPrivate::nearestGraphicsProxyWidget(const QWidget *origin)
 {
     if (origin) {
@@ -5186 +5564 @@
     return 0;
 }
+#endif
 
 /*!
@@ -5266 +5645 @@
     QString appName = QApplication::applicationName();
     if (!appName.isEmpty())
-        windowTitle += QLatin1String(" ") + QChar(0x2014) + QLatin1String(" ") + appName;
+        windowTitle += QLatin1Char(' ') + QChar(0x2014) + QLatin1Char(' ') + appName;
 #endif
     return windowTitle;
@@ -5301 +5680 @@
 }
 
+/*!
+    Returns a modified window title with the [*] place holder
+    replaced according to the rules described in QWidget::setWindowTitle
+
+    This function assumes that "[*]" can be quoted by another
+    "[*]", so it will replace two place holders by one and
+    a single last one by either "*" or nothing depending on
+    the modified flag.
+
+    \internal
+*/
 QString qt_setWindowTitle_helperHelper(const QString &title, const QWidget *widget)
 {
@@ -5312 +5702 @@
 #endif
 
-    QString placeHolder(QLatin1String("[*]"));
+    if (cap.isEmpty())
+        return cap;
+
+    QLatin1String placeHolder("[*]");
+    int placeHolderLength = 3; // QLatin1String doesn't have length()
 
     int index = cap.indexOf(placeHolder);
 
+    // here the magic begins
     while (index != -1) {
-        index += placeHolder.length();
+        index += placeHolderLength;
         int count = 1;
         while (cap.indexOf(placeHolder, index) == index) {
             ++count;
-            index += placeHolder.length();
+            index += placeHolderLength;
         }
 
@@ -5330 +5725 @@
                 cap.replace(lastIndex, 3, QWidget::tr("*"));
             else
-                cap.replace(lastIndex, 3, QLatin1String(""));
+                cap.remove(lastIndex, 3);
         }
 
@@ -5336 +5731 @@
     }
 
-    cap.replace(QLatin1String("[*][*]"), QLatin1String("[*]"));
+    cap.replace(QLatin1String("[*][*]"), placeHolder);
 
     return cap;
@@ -5344 +5739 @@
 {
     Q_Q(QWidget);
-    if (!q->testAttribute(Qt::WA_WState_Created))
-        createWinId();
-    setWindowTitle_sys(qt_setWindowTitle_helperHelper(title, q));
+    if (q->testAttribute(Qt::WA_WState_Created))
+        setWindowTitle_sys(qt_setWindowTitle_helperHelper(title, q));
 }
 
@@ -5371 +5765 @@
 void QWidget::setWindowTitle(const QString &title)
 {
-    if (QWidget::windowTitle() == title)
+    if (QWidget::windowTitle() == title && !title.isEmpty() && !title.isNull())
         return;
 
@@ -5402 +5796 @@
         w = w->parentWidget();
     }
-    return qApp->windowIcon();
+    return QApplication::windowIcon();
 }
 
@@ -5465 +5859 @@
     \list
     \o The file name of the specified path, obtained using QFileInfo::fileName().
-    \o An optional \c{*} character, if the \l windowModified property is set,
-    as per the Apple Human Interface Guidelines.
     \endlist
 
@@ -5515 +5907 @@
     if (extra->topextra && extra->topextra->caption.isEmpty()) {
 #ifdef Q_WS_MAC
-        setWindowTitle_helper(filePath);
+        setWindowTitle_helper(QFileInfo(filePath).fileName());
 #else
         Q_Q(QWidget);
@@ -5648 +6040 @@
     be passed into any focus event sent from this function, it is used
     to give an explanation of what caused the widget to get focus.
+    If the window is not active, the widget will be given the focus when
+    the window becomes active.
 
     First, a focus out event is sent to the focus widget (if any) to
@@ -5655 +6049 @@
     same.)
 
+    \note On embedded platforms, setFocus() will not cause an input panel
+    to be opened by the input method. If you want this to happen, you
+    have to send a QEvent::RequestSoftwareInputPanel event to the
+    widget yourself.
+
     setFocus() gives focus to a widget regardless of its focus policy,
     but does not clear any keyboard grab (see grabKeyboard()).
@@ -5666 +6065 @@
 
     \sa hasFocus(), clearFocus(), focusInEvent(), focusOutEvent(),
-    setFocusPolicy(), QApplication::focusWidget(), grabKeyboard(),
-    grabMouse(), {Keyboard Focus}
+    setFocusPolicy(), focusWidget(), QApplication::focusWidget(), grabKeyboard(),
+    grabMouse(), {Keyboard Focus}, QEvent::RequestSoftwareInputPanel
 */
 
@@ -5782 +6181 @@
 {
     QWidget *w = this;
-    while (w && w->d_func()->focus_child == this) {
-        w->d_func()->focus_child = 0;
+    while (w) {
+        if (w->d_func()->focus_child == this)
+            w->d_func()->focus_child = 0;
         w = w->parentWidget();
     }
@@ -5885 +6285 @@
 /*!
     Returns the next widget in this widget's focus chain.
+
+    \sa previousInFocusChain()
 */
 QWidget *QWidget::nextInFocusChain() const
 {
     return const_cast<QWidget *>(d_func()->focus_next);
+}
+
+/*!
+    \brief The previousInFocusChain function returns the previous
+    widget in this widget's focus chain.
+
+    \sa nextInFocusChain()
+
+    \since 4.6
+*/
+QWidget *QWidget::previousInFocusChain() const
+{
+    return const_cast<QWidget *>(d_func()->focus_prev);
 }
 
@@ -5909 +6324 @@
 {
     QWidget *tlw = window();
-    if(tlw == qApp->activeWindow() || (isVisible() && (tlw->windowType() == Qt::Popup)))
+    if(tlw == QApplication::activeWindow() || (isVisible() && (tlw->windowType() == Qt::Popup)))
         return true;
 
@@ -5924 +6339 @@
        tlw->parentWidget() && tlw->parentWidget()->isActiveWindow())
         return true;
+
+    extern bool qt_mac_insideKeyWindow(const QWidget *); //qwidget_mac.cpp
+    if (QApplication::testAttribute(Qt::AA_MacPluginApplication) && qt_mac_insideKeyWindow(tlw))
+        return true;
 #endif
     if(style()->styleHint(QStyle::SH_Widget_ShareActivation, 0, this)) {
@@ -5930 +6349 @@
            (!tlw->parentWidget() || tlw->parentWidget()->isActiveWindow()))
            return true;
-        QWidget *w = qApp->activeWindow();
+        QWidget *w = QApplication::activeWindow();
         while(w && tlw->windowType() == Qt::Tool &&
               !w->isModal() && w->parentWidget()) {
@@ -6113 +6532 @@
   This function is called from QDesktopwidget::screen(QPoint) to find the
   closest screen for a point.
+  In directional KeypadNavigation, it is called to find the closest
+  widget to the current focus widget center.
 */
 int QWidgetPrivate::pointToRect(const QPoint &p, const QRect &r)
@@ -6127 +6548 @@
         dy = p.y() - r.bottom();
     return dx + dy;
-}
-
-QRect QWidgetPrivate::fromOrToLayoutItemRect(const QRect &rect, int sign) const
-{
-    QRect r = rect;
-    r.adjust(-sign * leftLayoutItemMargin, -sign * topLayoutItemMargin,
-             +sign * rightLayoutItemMargin, +sign * bottomLayoutItemMargin);
-    return r;
 }
 
@@ -6225 +6638 @@
     \snippet doc/src/snippets/code/src_gui_kernel_qwidget.cpp 11
 
-    See the \link geometry.html Window Geometry documentation\endlink
-    for an overview of geometry issues with windows.
+    See the \l{Window Geometry} documentation for an overview of geometry
+    issues with windows.
 
     Use QMainWindow::saveState() to save the geometry and the state of
@@ -6260 +6673 @@
 
     If the restored geometry is off-screen, it will be modified to be
-    inside the the available screen geometry.
+    inside the available screen geometry.
 
     To restore geometry saved using QSettings, you can use code like
@@ -6267 +6680 @@
     \snippet doc/src/snippets/code/src_gui_kernel_qwidget.cpp 12
 
-    See the \link geometry.html Window Geometry documentation\endlink
-    for an overview of geometry issues with windows.
+    See the \l{Window Geometry} documentation for an overview of geometry
+    issues with windows.
 
     Use QMainWindow::restoreState() to restore the geometry and the
@@ -6385 +6798 @@
 
 /*!
-    Sets the margins around the contents of the widget to have the
-    sizes \a left, \a top, \a right, and \a bottom. The margins are
-    used by the layout system, and may be used by subclasses to
-    specify the area to draw in (e.g. excluding the frame).
-
-    Changing the margins will trigger a resizeEvent().
-
-    \sa contentsRect(), getContentsMargins()
+  Sets the margins around the contents of the widget to have the sizes
+  \a left, \a top, \a right, and \a bottom. The margins are used by
+  the layout system, and may be used by subclasses to specify the area
+  to draw in (e.g. excluding the frame).
+
+  Changing the margins will trigger a resizeEvent().
+
+  \sa contentsRect(), getContentsMargins()
 */
 void QWidget::setContentsMargins(int left, int top, int right, int bottom)
@@ -6423 +6836 @@
 }
 
-/*!  Returns the widget's contents margins for \a left, \a top, \a
+/*!
+  \overload
+  \since 4.6
+
+  \brief The setContentsMargins function sets the margins around the
+  widget's contents.
+
+  Sets the margins around the contents of the widget to have the
+  sizes determined by \a margins. The margins are
+  used by the layout system, and may be used by subclasses to
+  specify the area to draw in (e.g. excluding the frame).
+
+  Changing the margins will trigger a resizeEvent().
+
+  \sa contentsRect(), getContentsMargins()
+*/
+void QWidget::setContentsMargins(const QMargins &margins)
+{
+    setContentsMargins(margins.left(), margins.top(),
+                       margins.right(), margins.bottom());
+}
+
+/*!
+  Returns the widget's contents margins for \a left, \a top, \a
   right, and \a bottom.
 
@@ -6440 +6876 @@
         *bottom = d->bottommargin;
 }
+
+/*!
+  \since 4.6
+
+  \brief The contentsMargins function returns the widget's contents margins.
+
+  \sa getContentsMargins(), setContentsMargins(), contentsRect()
+ */
+QMargins QWidget::contentsMargins() const
+{
+    Q_D(const QWidget);
+    return QMargins(d->leftmargin, d->topmargin, d->rightmargin, d->bottommargin);
+}
+
 
 /*!
@@ -6723 +7173 @@
     // stores the correct old focus widget even if it's stolen in the
     // showevent
-#if defined(Q_WS_WIN) || defined(Q_WS_MAC)
+#if defined(Q_WS_WIN) || defined(Q_WS_MAC) || defined(Q_OS_SYMBIAN)
     if (!isEmbedded && q->windowType() == Qt::Popup)
         qApp->d_func()->openPopup(q);
@@ -6740 +7190 @@
     show_sys();
 
-#if !defined(Q_WS_WIN) && !defined(Q_WS_MAC)
+#if !defined(Q_WS_WIN) && !defined(Q_WS_MAC) && !defined(Q_OS_SYMBIAN)
     if (!isEmbedded && q->windowType() == Qt::Popup)
         qApp->d_func()->openPopup(q);
@@ -6822 +7272 @@
     // hidden.
     if (wasVisible) {
-#if defined(Q_WS_WIN) || defined(Q_WS_PM) || defined(Q_WS_X11)
+#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined (Q_WS_QWS) || defined(Q_WS_PM) 
         qApp->d_func()->sendSyntheticEnterLeave(q);
 #endif
@@ -6860 +7310 @@
 
 
-    Widgets are  hidden if they were created as independent
-    windows or as children of visible widgets, or if hide() or setVisible(false) was called.
-
+    Widgets are hidden if:
+    \list
+        \o they were created as independent windows,
+        \o they were created as children of visible widgets,
+        \o hide() or setVisible(false) was called.
+    \endlist
 */
 
@@ -6926 +7379 @@
                 parent = parent->parentWidget();
             }
-            if (parent && !d->getOpaqueRegion().isEmpty())
+            if (parent)
                 parent->d_func()->setDirtyOpaqueRegion();
         }
@@ -6951 +7404 @@
             d->show_helper();
 
-#if defined(Q_WS_WIN) || defined(Q_WS_PM) || defined(Q_WS_X11)
+#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined (Q_WS_QWS) || defined(Q_WS_PM)
             qApp->d_func()->sendSyntheticEnterLeave(this);
 #endif
@@ -7066 +7519 @@
             }
         }
-#if defined(Q_WS_WIN) || defined(Q_WS_PM) || defined(Q_WS_X11)
+#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined (Q_WS_QWS) || defined(Q_WS_PM)
         qApp->d_func()->sendSyntheticEnterLeave(widget);
 #endif
@@ -7108 +7561 @@
 #ifdef QT3_SUPPORT
     if (isMain)
-        qApp->quit();
+        QApplication::quit();
 #endif
     // Attempt to close the application only if this widget has the
@@ -7233 +7686 @@
         return isVisible();
     const QWidget * w = this;
-    while (w
-            && !w->isHidden()
+    while (!w->isHidden()
             && !w->isWindow()
             && w->parentWidget()
@@ -7291 +7743 @@
     if (q->isWindow()) {
         Qt::Orientations exp;
-        if (QLayout *l = q->layout()) {
-            if (l->hasHeightForWidth())
-                s.setHeight(l->totalHeightForWidth(s.width()));
-            exp = l->expandingDirections();
+        if (layout) {
+            if (layout->hasHeightForWidth())
+                s.setHeight(layout->totalHeightForWidth(s.width()));
+            exp = layout->expandingDirections();
         } else
         {
@@ -7310 +7762 @@
         QRect screen = QApplication::desktop()->screenGeometry(q->pos());
 #endif
-#if defined (Q_OS_WINCE)
+#if defined (Q_WS_WINCE) || defined (Q_OS_SYMBIAN)
         s.setWidth(qMin(s.width(), screen.width()));
         s.setHeight(qMin(s.height(), screen.height()));
@@ -7352 +7804 @@
     ensurePolished();
     QSize s = d->adjustedSize();
+
+    if (d->layout)
+        d->layout->activate();
+
     if (s.isValid())
         resize(s);
@@ -7497 +7953 @@
         case QEvent::MouseButtonDblClick:
         case QEvent::MouseMove:
+        case QEvent::TouchBegin:
+        case QEvent::TouchUpdate:
+        case QEvent::TouchEnd:
         case QEvent::ContextMenu:
 #ifndef QT_NO_WHEELEVENT
@@ -7562 +8021 @@
         if (!k->isAccepted() && QApplication::keypadNavigationEnabled()
             && !(k->modifiers() & (Qt::ControlModifier | Qt::AltModifier | Qt::ShiftModifier))) {
-            if (k->key() == Qt::Key_Up)
-                res = focusNextPrevChild(false);
-            else if (k->key() == Qt::Key_Down)
-                res = focusNextPrevChild(true);
+            if (QApplication::navigationMode() == Qt::NavigationModeKeypadTabOrder) {
+                if (k->key() == Qt::Key_Up)
+                    res = focusNextPrevChild(false);
+                else if (k->key() == Qt::Key_Down)
+                    res = focusNextPrevChild(true);
+            } else if (QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional) {
+                if (k->key() == Qt::Key_Up)
+                    res = QWidgetPrivate::navigateToDirection(QWidgetPrivate::DirectionNorth);
+                else if (k->key() == Qt::Key_Right)
+                    res = QWidgetPrivate::navigateToDirection(QWidgetPrivate::DirectionEast);
+                else if (k->key() == Qt::Key_Down)
+                    res = QWidgetPrivate::navigateToDirection(QWidgetPrivate::DirectionSouth);
+                else if (k->key() == Qt::Key_Left)
+                    res = QWidgetPrivate::navigateToDirection(QWidgetPrivate::DirectionWest);
+            }
             if (res) {
                 k->accept();
@@ -7618 +8088 @@
         break;
     case QEvent::FocusIn:
-#if defined(Q_WS_WIN)
-        QInputContextPrivate::updateImeStatus(this, true);
+#ifdef QT_SOFTKEYS_ENABLED
+        QSoftKeyManager::updateSoftKeys();
 #endif
         focusInEvent((QFocusEvent*)event);
@@ -7625 +8095 @@
 
     case QEvent::FocusOut:
-#if defined(Q_WS_WIN)
-        QInputContextPrivate::updateImeStatus(this, false);
-#endif
         focusOutEvent((QFocusEvent*)event);
         break;
@@ -7773 +8240 @@
                 QApplication::sendEvent(w, event);
         }
+
+#ifdef QT_SOFTKEYS_ENABLED
+        if (isWindow() && isActiveWindow())
+            QSoftKeyManager::updateSoftKeys();
+#endif
+
         break; }
 
@@ -7784 +8257 @@
             for (int i = 0; i < childList.size(); ++i) {
                 QObject *o = childList.at(i);
-                QApplication::sendEvent(o, event);
+                if (o)
+                    QApplication::sendEvent(o, event);
             }
         }
@@ -7813 +8287 @@
             for (int i = 0; i < childList.size(); ++i) {
                 QObject *o = childList.at(i);
-                if (o != qApp->activeModalWidget()) {
+                if (o && o != QApplication::activeModalWidget()) {
                     if (qobject_cast<QWidget *>(o) && static_cast<QWidget *>(o)->isWindow()) {
                         // do not forward the event to child windows,
@@ -7880 +8354 @@
     case QEvent::ActionRemoved:
     case QEvent::ActionChanged:
+#ifdef QT_SOFTKEYS_ENABLED
+        QSoftKeyManager::updateSoftKeys();
+#endif
         actionEvent((QActionEvent*)event);
         break;
@@ -7902 +8379 @@
         break;
 #endif
+    case QEvent::TouchBegin:
+    case QEvent::TouchUpdate:
+    case QEvent::TouchEnd:
+    {
+#ifndef Q_WS_MAC
+        QTouchEvent *touchEvent = static_cast<QTouchEvent *>(event);
+        const QTouchEvent::TouchPoint &touchPoint = touchEvent->touchPoints().first();
+        if (touchPoint.isPrimary() || touchEvent->deviceType() == QTouchEvent::TouchPad)
+            break;
+
+        // fake a mouse event!
+        QEvent::Type eventType = QEvent::None;
+        switch (touchEvent->type()) {
+        case QEvent::TouchBegin:
+            eventType = QEvent::MouseButtonPress;
+            break;
+        case QEvent::TouchUpdate:
+            eventType = QEvent::MouseMove;
+            break;
+        case QEvent::TouchEnd:
+            eventType = QEvent::MouseButtonRelease;
+            break;
+        default:
+            Q_ASSERT(!true);
+            break;
+        }
+        if (eventType == QEvent::None)
+            break;
+
+        QMouseEvent mouseEvent(eventType,
+                               touchPoint.pos().toPoint(),
+                               touchPoint.screenPos().toPoint(),
+                               Qt::LeftButton,
+                               Qt::LeftButton,
+                               touchEvent->modifiers());
+        (void) QApplication::sendEvent(this, &mouseEvent);
+#endif // Q_WS_MAC
+        break;
+    }
+    case QEvent::Gesture:
+        event->ignore();
+        break;
 #ifndef QT_NO_PROPERTIES
     case QEvent::DynamicPropertyChange: {
@@ -7953 +8472 @@
     case QEvent::FontChange:
     case QEvent::StyleChange: {
+        Q_D(QWidget);
         update();
         updateGeometry();
+        if (d->layout)
+            d->layout->invalidate();
 #ifdef Q_WS_QWS
-        Q_D(QWidget);
         if (isWindow())
             d->data.fstrut_dirty = true;
@@ -8036 +8557 @@
         event->accept();
         QWidget* w;
-        while ((w = qApp->activePopupWidget()) && w != this){
+        while ((w = QApplication::activePopupWidget()) && w != this){
             w->close();
-            if (qApp->activePopupWidget() == w) // widget does not want to dissappear
+            if (QApplication::activePopupWidget() == w) // widget does not want to dissappear
                 w->hide(); // hide at least
         }
@@ -8066 +8587 @@
     The default implementation generates a normal mouse press event.
 
-    Note that the widgets gets a mousePressEvent() and a
-    mouseReleaseEvent() before the mouseDoubleClickEvent().
+    \note The widget will also receive mouse press and mouse release
+    events in addition to the double click event. It is up to the
+    developer to ensure that the application interprets these events
+    correctly.
 
     \sa mousePressEvent(), mouseReleaseEvent() mouseMoveEvent(),
@@ -8448 +8971 @@
     \a query specifies which property is queried.
 
-    \sa inputMethodEvent(), QInputMethodEvent, QInputContext
+    \sa inputMethodEvent(), QInputMethodEvent, QInputContext, inputMethodHints
 */
 QVariant QWidget::inputMethodQuery(Qt::InputMethodQuery query) const
@@ -8457 +8980 @@
     case Qt::ImFont:
         return font();
+    case Qt::ImAnchorPosition:
+        // Fallback.
+        return inputMethodQuery(Qt::ImCursorPosition);
     default:
         return QVariant();
     }
 }
+
+/*!
+    \property QWidget::inputMethodHints
+    \brief What input method specific hints the widget has.
+
+    This is only relevant for input widgets. It is used by
+    the input method to retrieve hints as to how the input method
+    should operate. For example, if the Qt::ImhFormattedNumbersOnly flag
+    is set, the input method may change its visual components to reflect
+    that only numbers can be entered.
+
+    \note The flags are only hints, so the particular input method
+          implementation is free to ignore them. If you want to be
+          sure that a certain type of characters are entered,
+          you should also set a QValidator on the widget.
+
+    The default value is Qt::ImhNone.
+
+    \since 4.6
+
+    \sa inputMethodQuery(), QInputContext
+*/
+Qt::InputMethodHints QWidget::inputMethodHints() const
+{
+    Q_D(const QWidget);
+#ifndef QT_NO_IM
+    return d->imHints;
+#else //QT_NO_IM
+    return 0;
+#endif //QT_NO_IM
+}
+
+void QWidget::setInputMethodHints(Qt::InputMethodHints hints)
+{
+#ifndef QT_NO_IM
+    Q_D(QWidget);
+    d->imHints = hints;
+    // Optimisation to update input context only it has already been created.
+    if (d->ic || qApp->d_func()->inputContext) {
+        QInputContext *ic = inputContext();
+        if (ic)
+            ic->update();
+    }
+#endif //QT_NO_IM
+}
+
 
 #ifndef QT_NO_DRAGANDDROP
@@ -8803 +9375 @@
     that have been added to the layout.
 
-    \sa setLayout(), sizePolicy(), {Layout Classes}
+    \sa setLayout(), sizePolicy(), {Layout Management}
 */
 QLayout *QWidget::layout() const
@@ -8833 +9405 @@
     The QWidget will take ownership of \a layout.
 
-    \sa layout(), {Layout Classes}
+    \sa layout(), {Layout Management}
 */
 
@@ -9234 +9806 @@
 #endif
 
-    if (newParent) {
-        if (QWidgetBackingStore *oldBs = oldtlw->d_func()->maybeBackingStore()) {
+    if (QWidgetBackingStore *oldBs = oldtlw->d_func()->maybeBackingStore()) {
+        if (newParent)
             oldBs->removeDirtyWidget(this);
-            // Move the widget and all its static children from
-            // the old backing store to the new one.
-            oldBs->moveStaticWidgets(this);
-        }
+        // Move the widget and all its static children from
+        // the old backing store to the new one.
+        oldBs->moveStaticWidgets(this);
     }
 
@@ -9268 +9839 @@
     d->resolveLocale();
 
-    // Note: GL widgets under Windows will always need a ParentChange
-    // event to handle recreation/rebinding of the GL context, hence
-    // the (f & Qt::MSWindowsOwnDC) clause
+    // Note: GL widgets under WGL or EGL will always need a ParentChange
+    // event to handle recreation/rebinding of the GL context, hence the
+    // (f & Qt::MSWindowsOwnDC) clause (which is set on QGLWidgets on all
+    // platforms).
     if (newParent
-#ifdef Q_WS_WIN
+#if defined(Q_WS_WIN) || defined(QT_OPENGL_ES)
         || (f & Qt::MSWindowsOwnDC)
 #endif
@@ -9370 +9942 @@
 #ifndef QT_NO_GRAPHICSVIEW
     if (QGraphicsProxyWidget *proxy = QWidgetPrivate::nearestGraphicsProxyWidget(this)) {
-        // Graphics View maintains its own dirty region as a list of rects;
-        // until we can connect item updates directly to the view, we must
-        // separately add a translated dirty region.
-        if (!d->dirty.isEmpty()) {
-            foreach (const QRect &rect, (d->dirty.translated(dx, dy)).rects())
-                proxy->update(rect);
-        }
+        // Graphics View maintains its own dirty region as a list of rects;
+        // until we can connect item updates directly to the view, we must
+        // separately add a translated dirty region.
+        if (!d->dirty.isEmpty()) {
+            foreach (const QRect &rect, (d->dirty.translated(dx, dy)).rects())
+                proxy->update(rect);
+        }
         proxy->scroll(dx, dy, proxy->subWidgetRect(this));
         return;
@@ -9405 +9977 @@
 #ifndef QT_NO_GRAPHICSVIEW
     if (QGraphicsProxyWidget *proxy = QWidgetPrivate::nearestGraphicsProxyWidget(this)) {
-        // Graphics View maintains its own dirty region as a list of rects;
-        // until we can connect item updates directly to the view, we must
-        // separately add a translated dirty region.
-        if (!d->dirty.isEmpty()) {
-            foreach (const QRect &rect, (d->dirty.translated(dx, dy) & r).rects())
-                proxy->update(rect);
-        }
+        // Graphics View maintains its own dirty region as a list of rects;
+        // until we can connect item updates directly to the view, we must
+        // separately add a translated dirty region.
+        if (!d->dirty.isEmpty()) {
+            foreach (const QRect &rect, (d->dirty.translated(dx, dy) & r).rects())
+                proxy->update(rect);
+        }
         proxy->scroll(dx, dy, r.translated(proxy->subWidgetRect(this).topLeft().toPoint()));
         return;
@@ -9477 +10049 @@
         return;
 
-    QTLWExtra *tlwExtra = !d->paintOnScreen() ? window()->d_func()->maybeTopData() : 0;
-    if (tlwExtra && !tlwExtra->inTopLevelResize && tlwExtra->backingStore) {
-        tlwExtra->inRepaint = true;
-        tlwExtra->backingStore->markDirty(rect, this, true);
-        tlwExtra->inRepaint = false;
+    if (hasBackingStoreSupport()) {
+        QTLWExtra *tlwExtra = window()->d_func()->maybeTopData();
+        if (tlwExtra && !tlwExtra->inTopLevelResize && tlwExtra->backingStore) {
+            tlwExtra->inRepaint = true;
+            tlwExtra->backingStore->markDirty(rect, this, true);
+            tlwExtra->inRepaint = false;
+        }
     } else {
         d->repaint_sys(rect);
@@ -9504 +10078 @@
         return;
 
-    QTLWExtra *tlwExtra = !d->paintOnScreen() ? window()->d_func()->maybeTopData() : 0;
-    if (tlwExtra && !tlwExtra->inTopLevelResize && tlwExtra->backingStore) {
-        tlwExtra->inRepaint = true;
-        tlwExtra->backingStore->markDirty(rgn, this, true);
-        tlwExtra->inRepaint = false;
+    if (hasBackingStoreSupport()) {
+        QTLWExtra *tlwExtra = window()->d_func()->maybeTopData();
+        if (tlwExtra && !tlwExtra->inTopLevelResize && tlwExtra->backingStore) {
+            tlwExtra->inRepaint = true;
+            tlwExtra->backingStore->markDirty(rgn, this, true);
+            tlwExtra->inRepaint = false;
+        }
     } else {
         d->repaint_sys(rgn);
@@ -9690 +10266 @@
 
 #if defined(Q_WS_WIN) || defined(Q_WS_PM)
-    if (attribute == Qt::WA_PaintOnScreen && on) {
+    // ### Don't use PaintOnScreen+paintEngine() to do native painting in 5.0
+    if (attribute == Qt::WA_PaintOnScreen && on && !inherits("QGLWidget")) {
         // see qwidget_[win|pm].cpp, ::paintEngine for details
         paintEngine();
@@ -9804 +10381 @@
                                     ? Qt::WindowModal
                                     : Qt::ApplicationModal;
+            // Some window managers does not allow us to enter modal after the
+            // window is showing. Therefore, to be consistent, we cannot call
+            // QApplicationPrivate::enterModal(this) here. The window must be
+            // hidden before changing modality.
         }
         if (testAttribute(Qt::WA_WState_Created)) {
@@ -9814 +10395 @@
         QApplication::sendEvent(this, &e);
         break; }
-#if !defined(QT_NO_DIRECT3D) && defined(Q_WS_WIN)
-    case Qt::WA_MSWindowsUseDirect3D:
-        if (!qApp->testAttribute(Qt::AA_MSWindowsUseDirect3DByDefault)) {
-            if (on) {
-                if (!d->extra)
-                    d->createExtra();
-                d->extra->had_auto_fill_bg = d->extra->autoFillBackground;
-                d->extra->had_no_system_bg = testAttribute(Qt::WA_NoSystemBackground);
-                d->extra->had_paint_on_screen = testAttribute(Qt::WA_PaintOnScreen);
-                // enforce the opaque widget state D3D needs
-                d->extra->autoFillBackground = true;
-                setAttribute(Qt::WA_PaintOnScreen);
-                setAttribute(Qt::WA_NoSystemBackground);
-            } else if (d->extra) {
-                d->extra->autoFillBackground = d->extra->had_auto_fill_bg;
-                setAttribute(Qt::WA_PaintOnScreen, d->extra->had_paint_on_screen);
-                setAttribute(Qt::WA_NoSystemBackground, d->extra->had_no_system_bg);
-            }
-        }
-        break;
-#endif
     case Qt::WA_NativeWindow: {
 #ifndef QT_NO_IM
+        QWidget *focusWidget = d->effectiveFocusWidget();
         QInputContext *ic = 0;
         if (on && !internalWinId() && testAttribute(Qt::WA_InputMethodEnabled) && hasFocus()) {
-            ic = d->inputContext();
+            ic = focusWidget->d_func()->inputContext();
             ic->reset();
             ic->setFocusWidget(0);
@@ -9848 +10409 @@
         if (on && !internalWinId() && testAttribute(Qt::WA_WState_Created))
             d->createWinId();
-#ifndef QT_NO_IM
-        if (ic)
-            ic->setFocusWidget(this);
-#endif
+        if (ic && isEnabled())
+            ic->setFocusWidget(focusWidget);
+#endif //QT_NO_IM
         break;
     }
@@ -9881 +10441 @@
         break;
     case Qt::WA_InputMethodEnabled: {
-#if defined(Q_WS_WIN) || (defined(Q_WS_QWS) && !defined(QT_NO_QWS_INPUTMETHODS))
-        if (hasFocus())
-            QInputContextPrivate::updateImeStatus(this, true);
-#endif
 #ifndef QT_NO_IM
-        QInputContext *ic = d->ic;
-        if (!ic) {
-            // implicitly create input context only if we have a focus
-            if (hasFocus())
-                ic = d->inputContext();
-        }
+        QWidget *focusWidget = d->effectiveFocusWidget();
+        QInputContext *ic = focusWidget->d_func()->ic;
+        if (!ic && (!on || hasFocus()))
+            ic = focusWidget->d_func()->inputContext();
         if (ic) {
-            if (on && hasFocus() && ic->focusWidget() != this) {
-                ic->setFocusWidget(this);
-            } else if (!on && ic->focusWidget() == this) {
+            if (on && hasFocus() && ic->focusWidget() != focusWidget && isEnabled()) {
+                ic->setFocusWidget(focusWidget);
+            } else if (!on && ic->focusWidget() == focusWidget) {
                 ic->reset();
                 ic->setFocusWidget(0);
             }
         }
-#endif
+#endif //QT_NO_IM
         break;
     }
@@ -9971 +10525 @@
 
         break;
+    case Qt::WA_AcceptTouchEvents:
+#if defined(Q_WS_WIN) || defined(Q_WS_MAC) || defined(Q_WS_S60)
+        if (on)
+            d->registerTouchWindow();
+#endif
+        break;
     default:
         break;
@@ -10001 +10561 @@
   By default the value of this property is 1.0.
 
-  This feature is available on Embedded Linux, Mac OS X, X11 platforms that
-  support the Composite extension, and Windows 2000 and later.
+  This feature is available on Embedded Linux, Mac OS X, Windows,
+  and X11 platforms that support the Composite extension.
 
   This feature is not available on Windows CE.
@@ -10326 +10886 @@
 void QWidget::updateMicroFocus()
 {
-#if !defined(QT_NO_IM) && (defined(Q_WS_X11) || defined(Q_WS_QWS))
+#if !defined(QT_NO_IM) && (defined(Q_WS_X11) || defined(Q_WS_QWS) || defined(Q_OS_SYMBIAN))
     Q_D(QWidget);
     // and optimisation to update input context only it has already been created.
@@ -11033 +11593 @@
 */
 
+/*!
+    \fn QWidget::setupUi(QWidget *widget)
+
+    Sets up the user interface for the specified \a widget.
+
+    \note This function is available with widgets that derive from user
+    interface descriptions created using \l{uic}.
+
+    \sa {Using a Designer UI File in Your Application}
+*/
+
 QRect QWidgetPrivate::frameStrut() const
 {
@@ -11051 +11622 @@
     return maybeTopData() ? maybeTopData()->frameStrut : QRect();
 }
+
+#ifdef QT_KEYPAD_NAVIGATION
+/*!
+    \internal
+
+    Changes the focus  from the current focusWidget to a widget in
+    the \a direction.
+
+    Returns true, if there was a widget in that direction
+*/
+bool QWidgetPrivate::navigateToDirection(Direction direction)
+{
+    QWidget *targetWidget = widgetInNavigationDirection(direction);
+    if (targetWidget)
+        targetWidget->setFocus();
+    return (targetWidget != 0);
+}
+
+/*!
+    \internal
+
+    Searches for a widget that is positioned in the \a direction, starting
+    from the current focusWidget.
+
+    Returns the pointer to a found widget or 0, if there was no widget in
+    that direction.
+*/
+QWidget *QWidgetPrivate::widgetInNavigationDirection(Direction direction)
+{
+    const QWidget *sourceWidget = QApplication::focusWidget();
+    if (!sourceWidget)
+        return 0;
+    const QRect sourceRect = sourceWidget->rect().translated(sourceWidget->mapToGlobal(QPoint()));
+    const int sourceX =
+            (direction == DirectionNorth || direction == DirectionSouth) ?
+                (sourceRect.left() + (sourceRect.right() - sourceRect.left()) / 2)
+                :(direction == DirectionEast ? sourceRect.right() : sourceRect.left());
+    const int sourceY =
+            (direction == DirectionEast || direction == DirectionWest) ?
+                (sourceRect.top() + (sourceRect.bottom() - sourceRect.top()) / 2)
+                :(direction == DirectionSouth ? sourceRect.bottom() : sourceRect.top());
+    const QPoint sourcePoint(sourceX, sourceY);
+    const QPoint sourceCenter = sourceRect.center();
+    const QWidget *sourceWindow = sourceWidget->window();
+
+    QWidget *targetWidget = 0;
+    int shortestDistance = INT_MAX;
+    foreach(QWidget *targetCandidate, QApplication::allWidgets()) {
+
+        const QRect targetCandidateRect = targetCandidate->rect().translated(targetCandidate->mapToGlobal(QPoint()));
+
+        // For focus proxies, the child widget handling the focus can have keypad navigation focus,
+        // but the owner of the proxy cannot.
+        // Additionally, empty widgets should be ignored.
+        if (targetCandidate->focusProxy() || targetCandidateRect.isEmpty())
+            continue;
+
+        // Only navigate to a target widget that...
+        if (       targetCandidate != sourceWidget
+                   // ...takes the focus,
+                && targetCandidate->focusPolicy() & Qt::TabFocus
+                   // ...is above if DirectionNorth,
+                && !(direction == DirectionNorth && targetCandidateRect.bottom() > sourceRect.top())
+                   // ...is on the right if DirectionEast,
+                && !(direction == DirectionEast  && targetCandidateRect.left()   < sourceRect.right())
+                   // ...is below if DirectionSouth,
+                && !(direction == DirectionSouth && targetCandidateRect.top()    < sourceRect.bottom())
+                   // ...is on the left if DirectionWest,
+                && !(direction == DirectionWest  && targetCandidateRect.right()  > sourceRect.left())
+                   // ...is enabled,
+                && targetCandidate->isEnabled()
+                   // ...is visible,
+                && targetCandidate->isVisible()
+                   // ...is in the same window,
+                && targetCandidate->window() == sourceWindow) {
+            const int targetCandidateDistance = pointToRect(sourcePoint, targetCandidateRect);
+            if (targetCandidateDistance < shortestDistance) {
+                shortestDistance = targetCandidateDistance;
+                targetWidget = targetCandidate;
+            }
+        }
+    }
+    return targetWidget;
+}
+#endif
 
 /*!
@@ -11210 +11866 @@
 
 
-
-
 #ifndef QT_NO_GRAPHICSVIEW
 /*!
@@ -11240 +11894 @@
 */
 
-QT_END_NAMESPACE
-
-#include "moc_qwidget.cpp"
+/*!
+    Subscribes the widget to a given \a gesture with specific \a flags.
+
+    \sa ungrabGesture(), QGestureEvent
+    \since 4.6
+*/
+void QWidget::grabGesture(Qt::GestureType gesture, Qt::GestureFlags flags)
+{
+    Q_D(QWidget);
+    d->gestureContext.insert(gesture, flags);
+    (void)QGestureManager::instance(); // create a gesture manager
+}
+
+/*!
+    Unsubscribes the widget from a given \a gesture type
+
+    \sa grabGesture(), QGestureEvent
+    \since 4.6
+*/
+void QWidget::ungrabGesture(Qt::GestureType gesture)
+{
+    Q_D(QWidget);
+    if (d->gestureContext.remove(gesture)) {
+        QGestureManager *manager = QGestureManager::instance();
+        manager->cleanupCachedGestures(this, gesture);
+    }
+}
+
 
 /*!
@@ -11314 +11993 @@
     button is released.
 
-    Note that only visible widgets can grab mouse input. If
-    isVisible() returns false for a widget, that widget cannot call
-    grabMouse().
-
-    \sa releaseMouse() grabKeyboard() releaseKeyboard() grabKeyboard()
-    focusWidget()
+    \note Only visible widgets can grab mouse input. If isVisible()
+    returns false for a widget, that widget cannot call grabMouse().
+
+    \note \bold{(Mac OS X developers)} For \e Cocoa, calling
+    grabMouse() on a widget only works when the mouse is inside the
+    frame of that widget.  For \e Carbon, it works outside the widget's
+    frame as well, like for Windows and X11.
+
+    \sa releaseMouse() grabKeyboard() releaseKeyboard()
 */
 
 /*!
     \fn void QWidget::grabMouse(const QCursor &cursor)
-    \overload
+    \overload grabMouse()
 
     Grabs the mouse input and changes the cursor shape.
@@ -11333 +12015 @@
 
     \warning Grabbing the mouse might lock the terminal.
+
+    \note \bold{(Mac OS X developers)} See the note in QWidget::grabMouse().
 
     \sa releaseMouse(), grabKeyboard(), releaseKeyboard(), setCursor()
@@ -11539 +12223 @@
 }
 
+/*! \fn const QX11Info &QWidget::x11Info() const
+    Returns information about the configuration of the X display used to display
+    the widget.
+
+    \warning This function is only available on X11.
+*/
+
+/*! \fn Qt::HANDLE QWidget::x11PictureHandle() const
+    Returns the X11 Picture handle of the widget for XRender
+    support. Use of this function is not portable. This function will
+    return 0 if XRender support is not compiled into Qt, if the
+    XRender extension is not supported on the X11 display, or if the
+    handle could not be created.
+*/
+
+#ifdef Q_OS_SYMBIAN
+void QWidgetPrivate::_q_delayedDestroy(WId winId)
+{
+    delete winId;
+}
+#endif
+
+QT_END_NAMESPACE
+
+#include "moc_qwidget.cpp"
+