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

Timestamp:

May 5, 2011, 5:36:53 AM (14 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.

Location:

trunk

Files:

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

trunk/src/gui/kernel/qwidget.cpp

@@ -1 +1 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
@@ -68 +68 @@
 # include "qt_cocoa_helpers_mac_p.h"
 # include "qmainwindow.h"
+# include "qtoolbar.h"
+# include <private/qmainwindowlayout_p.h>
 #endif
 #if defined(Q_WS_QWS)
@@ -127 +129 @@
 #endif // QT_KEYPAD_NAVIGATION
 
+#ifdef Q_WS_S60
+#include <aknappui.h>
+#endif
+
 // widget/widget data creation count
 //#define QWIDGET_EXTRA_DEBUG
@@ -165 +171 @@
 extern bool qt_sendSpontaneousEvent(QObject*, QEvent*); // qapplication.cpp
 extern QDesktopWidget *qt_desktopWidget; // qapplication.cpp
+
+/*!
+    \internal
+    \class QWidgetBackingStoreTracker
+    \brief Class which allows tracking of which widgets are using a given backing store
+
+    QWidgetBackingStoreTracker is a thin wrapper around a QWidgetBackingStore pointer,
+    which maintains a list of the QWidgets which are currently using the backing
+    store.  This list is modified via the registerWidget and unregisterWidget functions.
+ */
+
+QWidgetBackingStoreTracker::QWidgetBackingStoreTracker()
+    :   m_ptr(0)
+{
+
+}
+
+QWidgetBackingStoreTracker::~QWidgetBackingStoreTracker()
+{
+    delete m_ptr;
+}
+
+/*!
+    \internal
+    Destroy the contained QWidgetBackingStore, if not null, and clear the list of
+    widgets using the backing store, then create a new QWidgetBackingStore, providing
+    the QWidget.
+ */
+void QWidgetBackingStoreTracker::create(QWidget *widget)
+{
+    destroy();
+    m_ptr = new QWidgetBackingStore(widget);
+}
+
+/*!
+    \internal
+    Destroy the contained QWidgetBackingStore, if not null, and clear the list of
+    widgets using the backing store.
+ */
+void QWidgetBackingStoreTracker::destroy()
+{
+    delete m_ptr;
+    m_ptr = 0;
+    m_widgets.clear();
+}
+
+/*!
+    \internal
+    Add the widget to the list of widgets currently using the backing store.
+    If the widget was already in the list, this function is a no-op.
+ */
+void QWidgetBackingStoreTracker::registerWidget(QWidget *w)
+{
+    Q_ASSERT(m_ptr);
+    Q_ASSERT(w->internalWinId());
+    Q_ASSERT(qt_widget_private(w)->maybeBackingStore() == m_ptr);
+    m_widgets.insert(w);
+}
+
+/*!
+    \internal
+    Remove the widget from the list of widgets currently using the backing store.
+    If the widget was in the list, and removing it causes the list to be empty,
+    the backing store is deleted.
+    If the widget was not in the list, this function is a no-op.
+ */
+void QWidgetBackingStoreTracker::unregisterWidget(QWidget *w)
+{
+    if (m_widgets.remove(w) && m_widgets.isEmpty()) {
+        delete m_ptr;
+        m_ptr = 0;
+    }
+}
+
+/*!
+    \internal
+    Recursively remove widget and all of its descendents.
+ */
+void QWidgetBackingStoreTracker::unregisterWidgetSubtree(QWidget *widget)
+{
+    unregisterWidget(widget);
+    foreach (QObject *child, widget->children())
+        if (QWidget *childWidget = qobject_cast<QWidget *>(child))
+            unregisterWidgetSubtree(childWidget);
+}
 
 QWidgetPrivate::QWidgetPrivate(int version)
@@ -203 +294 @@
       , isGLWidget(0)
       , usesDoubleBufferedGLContext(0)
+#ifndef QT_NO_IM
+      , inheritsInputMethodHints(0)
+#endif
 #if defined(Q_WS_X11)
       , picture(0)
@@ -209 +303 @@
 #elif defined(Q_WS_WIN)
       , noPaintOnScreen(0)
+  #ifndef QT_NO_GESTURES
       , nativeGesturePanEnabled(0)
+  #endif
 #elif defined(Q_WS_MAC)
       , needWindowChange(0)
+      , hasAlienChildren(0)
       , window_event(0)
       , qd_hd(0)
@@ -226 +323 @@
     isWidget = true;
     memset(high_attributes, 0, sizeof(high_attributes));
+#if QT_MAC_USE_COCOA
+    drawRectOriginalAdded = false;
+    originalDrawMethod = true;
+    changeMethods = false;
+#endif // QT_MAC_USE_COCOA
 #ifdef QWIDGET_EXTRA_DEBUG
     static int count = 0;
@@ -246 +348 @@
 }
 
+class QDummyWindowSurface : public QWindowSurface
+{
+public:
+    QDummyWindowSurface(QWidget *window) : QWindowSurface(window) {}
+    QPaintDevice *paintDevice() { return window(); }
+    void flush(QWidget *, const QRegion &, const QPoint &) {}
+};
+
 QWindowSurface *QWidgetPrivate::createDefaultWindowSurface()
 {
     Q_Q(QWidget);
-    if (QApplicationPrivate::graphicsSystem())
-        return QApplicationPrivate::graphicsSystem()->createWindowSurface(q);
-    return createDefaultWindowSurface_sys();
+
+    QWindowSurface *surface;
+    if (q->property("_q_DummyWindowSurface").toBool()) {
+        surface = new QDummyWindowSurface(q);
+    } else {
+        if (QApplicationPrivate::graphicsSystem())
+            surface = QApplicationPrivate::graphicsSystem()->createWindowSurface(q);
+        else
+            surface = createDefaultWindowSurface_sys();
+    }
+
+    return surface;
 }
 
@@ -286 +405 @@
     if (ic)
         return ic;
-#endif
     return qApp->inputContext();
+#else
+    return 0;
+#endif
 }
 
@@ -312 +433 @@
   This function sets the input context \a context
   on this widget.
+
+  Qt takes ownership of the given input \a context.
 
   \sa inputContext()
@@ -321 +444 @@
     if (!testAttribute(Qt::WA_InputMethodEnabled))
         return;
+    if (context == d->ic)
+        return;
     if (d->ic)
         delete d->ic;
     d->ic = context;
+    if (d->ic)
+        d->ic->setParent(this);
 #endif
 }
@@ -639 +766 @@
         \i  mouseMoveEvent() is called whenever the mouse moves while a mouse
             button is held down. This can be useful during drag and drop
-            operations. If you call setMouseTracking(true), you get mouse move
-            events even when no buttons are held down. (See also the \l{Drag
-            and Drop} guide.)
+            operations. If you call \l{setMouseTracking()}{setMouseTracking}(true),
+            you get mouse move events even when no buttons are held down.
+            (See also the \l{Drag and Drop} guide.)
         \i  keyReleaseEvent() is called whenever a key is released and while it
             is held down (if the key is auto-repeating). In that case, the
@@ -671 +798 @@
     one of the more specialized handlers above.
 
-    Events and the mechanism used to deliver them are covered in the
-    \l{Events and Event Filters} document.
+    Events and the mechanism used to deliver them are covered in 
+    \l{The Event System}.
 
     \section1 Groups of Functions and Properties
@@ -1011 +1138 @@
     \sa windowFlags
 */
-
 QWidget::QWidget(QWidget *parent, Qt::WindowFlags f)
     : QObject(*new QWidgetPrivate, 0), QPaintDevice()
@@ -1106 +1232 @@
     }
     if (customize)
-        ; // don't modify window flags if the user explicitely set them.
+        ; // don't modify window flags if the user explicitly set them.
     else if (type == Qt::Dialog || type == Qt::Sheet)
 #ifndef Q_WS_WINCE
@@ -1128 +1254 @@
 
     Q_ASSERT(allWidgets);
-    allWidgets->insert(q);
+    if (allWidgets)
+        allWidgets->insert(q);
 
     QWidget *desktopWidget = 0;
@@ -1175 +1302 @@
         q->setAttribute(Qt::WA_NativeWindow);
 
+#ifdef Q_WS_MAC
+    q->setAttribute(Qt::WA_NativeWindow);
+#endif
+
     q->setAttribute(Qt::WA_QuitOnClose); // might be cleared in adjustQuitOnCloseAttribute()
     adjustQuitOnCloseAttribute();
@@ -1181 +1312 @@
 
     //give potential windows a bigger "pre-initial" size; create_sys() will give them a new size later
+#ifdef Q_OS_SYMBIAN
+    if (isGLWidget) {
+        // Don't waste GPU mem for unnecessary large egl surface
+        data.crect = QRect(0,0,2,2);
+    } else {
+        data.crect = parentWidget ? QRect(0,0,100,30) : QRect(0,0,360,640);
+    }
+#else
     data.crect = parentWidget ? QRect(0,0,100,30) : QRect(0,0,640,480);
+#endif
 
     focus_next = focus_prev = q;
@@ -1270 +1410 @@
 
     if (QWidget *parent = parentWidget()) {
+#ifdef Q_WS_MAC
+        if (testAttribute(Qt::WA_NativeWindow) == false)
+            parent->d_func()->hasAlienChildren = true;
+#endif
         if (type & Qt::Window) {
             if (!parent->testAttribute(Qt::WA_WState_Created))
@@ -1331 +1475 @@
     // a real toplevel window needs a backing store
     if (isWindow() && windowType() != Qt::Desktop) {
-        delete d->topData()->backingStore;
-        // QWidgetBackingStore will check this variable, hence it must be 0
-        d->topData()->backingStore = 0;
+        d->topData()->backingStore.destroy();
         if (hasBackingStoreSupport())
-            d->topData()->backingStore = new QWidgetBackingStore(this);
+            d->topData()->backingStore.create(this);
     }
 
@@ -1378 +1520 @@
     if (paintingActive())
         qWarning("QWidget: %s (%s) deleted while being painted", className(), name());
+#endif
+
+#ifndef QT_NO_GESTURES
+    foreach (Qt::GestureType type, d->gestureContext.keys())
+        ungrabGesture(type);
 #endif
 
@@ -1440 +1587 @@
     }
 
-#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined (Q_WS_QWS) || defined(Q_WS_PM)
+#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined (Q_WS_QWS) || defined(Q_WS_MAC) || defined(Q_WS_PM)
     else if (!internalWinId() && isVisible()) {
         qApp->d_func()->sendSyntheticEnterLeave(this);
@@ -1458 +1605 @@
         // not have a reference to this widget that will be used later to
         // notify the window it no longer has a surface.
-        delete d->extra->topextra->backingStore;
-        d->extra->topextra->backingStore = 0;
+        d->extra->topextra->backingStore.destroy();
     }
 #endif
@@ -1475 +1621 @@
 
     if (d->declarativeData) {
-        d->declarativeData->destroyed(this);
+        QAbstractDeclarativeData::destroyed(d->declarativeData, this);
         d->declarativeData = 0;                 // don't activate again in ~QObject
     }
+
+#ifdef QT_MAC_USE_COCOA
+    // QCocoaView holds a pointer back to this widget. Clear it now
+    // to make sure it's not followed later on. The lifetime of the
+    // QCocoaView might exceed the lifetime of this widget in cases
+    // where Cocoa itself holds references to it.
+    extern void qt_mac_clearCocoaViewQWidgetPointers(QWidget *);
+    qt_mac_clearCocoaViewQWidgetPointers(this);
+#endif
 
     if (!d->children.isEmpty())
@@ -1529 +1684 @@
 
     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);
-        }
+        QEvent e(QEvent::WinIdChange);
+        QCoreApplication::sendEvent(q, &e);
     }
 }
@@ -1547 +1697 @@
         x->icon = 0;
         x->iconPixmap = 0;
-        x->backingStore = 0;
         x->windowSurface = 0;
         x->sharedPainter = 0;
@@ -1561 +1710 @@
         x->inRepaint = false;
         x->embedded = 0;
+#ifdef Q_WS_MAC
+#ifdef QT_MAC_USE_COCOA
+        x->wasMaximized = false;
+#endif // QT_MAC_USE_COCOA
+#endif // Q_WS_MAC
         createTLSysExtra();
 #ifdef QWIDGET_EXTRA_DEBUG
@@ -1626 +1780 @@
         if (extra->topextra) {
             deleteTLSysExtra();
-            delete extra->topextra->backingStore;
+            extra->topextra->backingStore.destroy();
             delete extra->topextra->icon;
             delete extra->topextra->iconPixmap;
@@ -2308 +2462 @@
 {
     if (!testAttribute(Qt::WA_WState_Created) || !internalWinId()) {
+#ifdef ALIEN_DEBUG
+        qDebug() << "QWidget::winId: creating native window for" << this;
+#endif
         QWidget *that = const_cast<QWidget*>(this);
         that->setAttribute(Qt::WA_NativeWindow);
@@ -2320 +2477 @@
 {
     Q_Q(QWidget);
+
+#ifdef ALIEN_DEBUG
+    qDebug() << "QWidgetPrivate::createWinId for" << q << winid;
+#endif
     const bool forceNativeWindow = q->testAttribute(Qt::WA_NativeWindow);
     if (!q->testAttribute(Qt::WA_WState_Created) || (forceNativeWindow && !q->internalWinId())) {
@@ -2362 +2523 @@
 {
     Q_D(QWidget);
+#ifdef ALIEN_DEBUG
+    qDebug()  << "QWidget::createWinId" << this;
+#endif
 //    qWarning("QWidget::createWinId is obsolete, please fix your code.");
     d->createWinId();
@@ -2508 +2672 @@
     QStyle *oldStyle  = q->style();
 #ifndef QT_NO_STYLE_STYLESHEET
-    QStyle *origStyle = 0;
+    QWeakPointer<QStyle> origStyle;
 #endif
 
@@ -2522 +2686 @@
 
 #ifndef QT_NO_STYLE_STYLESHEET
-        origStyle = extra->style;
+        origStyle = extra->style.data();
 #endif
         extra->style = newStyle;
@@ -2551 +2715 @@
     }
 
+#ifndef QT_NO_STYLE_STYLESHEET
+    if (!qobject_cast<QStyleSheetStyle*>(newStyle)) {
+        if (const QStyleSheetStyle* cssStyle = qobject_cast<QStyleSheetStyle*>(origStyle.data())) {
+            cssStyle->clearWidgetFont(q);
+        }
+    }
+#endif
+
     QEvent e(QEvent::StyleChange);
     QApplication::sendEvent(q, &e);
@@ -2558 +2730 @@
 
 #ifndef QT_NO_STYLE_STYLESHEET
-    if (!qobject_cast<QStyleSheetStyle*>(newStyle)) {
-        if (const QStyleSheetStyle* cssStyle = qobject_cast<QStyleSheetStyle*>(origStyle)) {
-            cssStyle->clearWidgetFont(q);
-        }
-    }
-#endif
-
-#ifndef QT_NO_STYLE_STYLESHEET
     // dereference the old stylesheet style
-    if (QStyleSheetStyle *proxy = qobject_cast<QStyleSheetStyle *>(origStyle))
+    if (QStyleSheetStyle *proxy = qobject_cast<QStyleSheetStyle *>(origStyle.data()))
         proxy->deref();
 #endif
@@ -2868 +3032 @@
 void QWidget::showFullScreen()
 {
+#ifdef Q_WS_MAC
+    // If the unified toolbar is enabled, we have to disable it before going fullscreen.
+    QMainWindow *mainWindow = qobject_cast<QMainWindow*>(this);
+    if (mainWindow && mainWindow->unifiedTitleAndToolBarOnMac()) {
+        mainWindow->setUnifiedTitleAndToolBarOnMac(false);
+        QMainWindowLayout *mainLayout = qobject_cast<QMainWindowLayout*>(mainWindow->layout());
+        mainLayout->activateUnifiedToolbarAfterFullScreen = true;
+    }
+#endif // Q_WS_MAC
     ensurePolished();
 #ifdef QT3_SUPPORT
@@ -2900 +3073 @@
     setWindowState((windowState() & ~(Qt::WindowMinimized | Qt::WindowFullScreen))
                    | Qt::WindowMaximized);
+#ifdef Q_WS_MAC
+    // If the unified toolbar was enabled before going fullscreen, we have to enable it back.
+    QMainWindow *mainWindow = qobject_cast<QMainWindow*>(this);
+    if (mainWindow)
+    {
+        QMainWindowLayout *mainLayout = qobject_cast<QMainWindowLayout*>(mainWindow->layout());
+        if (mainLayout->activateUnifiedToolbarAfterFullScreen) {
+            mainWindow->setUnifiedTitleAndToolBarOnMac(true);
+            mainLayout->activateUnifiedToolbarAfterFullScreen = false;
+        }
+    }
+#endif // Q_WS_MAC
     show();
 }
@@ -2921 +3106 @@
                                      | Qt::WindowMaximized
                                      | Qt::WindowFullScreen));
+#ifdef Q_WS_MAC
+    // If the unified toolbar was enabled before going fullscreen, we have to enable it back.
+    QMainWindow *mainWindow = qobject_cast<QMainWindow*>(this);
+    if (mainWindow)
+    {
+        QMainWindowLayout *mainLayout = qobject_cast<QMainWindowLayout*>(mainWindow->layout());
+        if (mainLayout->activateUnifiedToolbarAfterFullScreen) {
+            mainWindow->setUnifiedTitleAndToolBarOnMac(true);
+            mainLayout->activateUnifiedToolbarAfterFullScreen = false;
+        }
+    }
+#endif // Q_WS_MAC
     show();
 }
@@ -4733 +4930 @@
     direction.
 
+    This method no longer affects text layout direction since Qt 4.7.
+
     \sa QApplication::layoutDirection
 */
@@ -4738 +4937 @@
 {
     Q_D(QWidget);
+
+    if (direction == Qt::LayoutDirectionAuto) {
+        unsetLayoutDirection();
+        return;
+    }
 
     setAttribute(Qt::WA_SetLayoutDirection);
@@ -4891 +5095 @@
                      const QRegion &sourceRegion, RenderFlags renderFlags)
 {
-    Q_D(QWidget);
-    if (!target) {
-        qWarning("QWidget::render: null pointer to paint device");
-        return;
-    }
-
-    const bool inRenderWithPainter = d->extra && d->extra->inRenderWithPainter;
-    QRegion paintRegion = !inRenderWithPainter ? d->prepareToRender(sourceRegion, renderFlags)
-                                               : sourceRegion;
-    if (paintRegion.isEmpty())
-        return;
-
-#ifndef Q_WS_MAC
-    QPainter *oldSharedPainter = inRenderWithPainter ? d->sharedPainter() : 0;
-
-    // Use the target's shared painter if set (typically set when doing
-    // "other->render(widget);" in the widget's paintEvent.
-    if (target->devType() == QInternal::Widget) {
-        QWidgetPrivate *targetPrivate = static_cast<QWidget *>(target)->d_func();
-        if (targetPrivate->extra && targetPrivate->extra->inRenderWithPainter) {
-            QPainter *targetPainter = targetPrivate->sharedPainter();
-            if (targetPainter && targetPainter->isActive())
-                d->setSharedPainter(targetPainter);
-        }
-    }
-#endif
-
-    // Use the target's redirected device if set and adjust offset and paint
-    // region accordingly. This is typically the case when people call render
-    // from the paintEvent.
-    QPoint offset = targetOffset;
-    offset -= paintRegion.boundingRect().topLeft();
-    QPoint redirectionOffset;
-    QPaintDevice *redirected = 0;
-
-    if (target->devType() == QInternal::Widget)
-        redirected = static_cast<QWidget *>(target)->d_func()->redirected(&redirectionOffset);
-    if (!redirected)
-        redirected = QPainter::redirected(target, &redirectionOffset);
-
-    if (redirected) {
-        target = redirected;
-        offset -= redirectionOffset;
-    }
-
-    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);
-        }
-    }
-
-    // Set backingstore flags.
-    int flags = QWidgetPrivate::DrawPaintOnScreen | QWidgetPrivate::DrawInvisible;
-    if (renderFlags & DrawWindowBackground)
-        flags |= QWidgetPrivate::DrawAsRoot;
-
-    if (renderFlags & DrawChildren)
-        flags |= QWidgetPrivate::DrawRecursive;
-    else
-        flags |= QWidgetPrivate::DontSubtractOpaqueChildren;
-
-#ifdef Q_WS_QWS
-    flags |= QWidgetPrivate::DontSetCompositionMode;
-#endif
-
-    if (target->devType() == QInternal::Printer) {
-        QPainter p(target);
-        d->render_helper(&p, targetOffset, paintRegion, renderFlags);
-        return;
-    }
-
-#ifndef Q_WS_MAC
-    // Render via backingstore.
-    d->drawWidget(target, paintRegion, offset, flags, d->sharedPainter());
-
-    // Restore shared painter.
-    if (oldSharedPainter)
-        d->setSharedPainter(oldSharedPainter);
-#else
-    // Render via backingstore (no shared painter).
-    d->drawWidget(target, paintRegion, offset, flags, 0);
-#endif
+    d_func()->render(target, targetOffset, sourceRegion, renderFlags, false);
 }
 
@@ -5334 +5455 @@
             if (paintEngine) {
                 setRedirected(pdev, -offset);
-
+#ifdef Q_WS_MAC
+                // (Alien support) Special case for Mac when redirecting: If the paint device
+                // is of the Widget type we need to set WA_WState_InPaintEvent since painting
+                // outside the paint event is not supported on QWidgets. The attributeis
+                // restored further down.
+                if (pdev->devType() == QInternal::Widget)
+                    static_cast<QWidget *>(pdev)->setAttribute(Qt::WA_WState_InPaintEvent);
+
+#endif
                 if (sharedPainter)
                     paintEngine->d_func()->systemClip = toBePainted;
@@ -5375 +5504 @@
             //restore
             if (paintEngine) {
+#ifdef Q_WS_MAC
+                if (pdev->devType() == QInternal::Widget)
+                    static_cast<QWidget *>(pdev)->setAttribute(Qt::WA_WState_InPaintEvent, false);
+#endif
                 restoreRedirected();
                 if (!sharedPainter)
@@ -5418 +5551 @@
                                 , sharedPainter, backingStore);
     }
+}
+
+void QWidgetPrivate::render(QPaintDevice *target, const QPoint &targetOffset,
+                            const QRegion &sourceRegion, QWidget::RenderFlags renderFlags,
+                            bool readyToRender)
+{
+    if (!target) {
+        qWarning("QWidget::render: null pointer to paint device");
+        return;
+    }
+
+    const bool inRenderWithPainter = extra && extra->inRenderWithPainter;
+    QRegion paintRegion = !inRenderWithPainter && !readyToRender
+                          ? prepareToRender(sourceRegion, renderFlags)
+                          : sourceRegion;
+    if (paintRegion.isEmpty())
+        return;
+
+#ifndef Q_WS_MAC
+    QPainter *oldSharedPainter = inRenderWithPainter ? sharedPainter() : 0;
+
+    // Use the target's shared painter if set (typically set when doing
+    // "other->render(widget);" in the widget's paintEvent.
+    if (target->devType() == QInternal::Widget) {
+        QWidgetPrivate *targetPrivate = static_cast<QWidget *>(target)->d_func();
+        if (targetPrivate->extra && targetPrivate->extra->inRenderWithPainter) {
+            QPainter *targetPainter = targetPrivate->sharedPainter();
+            if (targetPainter && targetPainter->isActive())
+                setSharedPainter(targetPainter);
+        }
+    }
+#endif
+
+    // Use the target's redirected device if set and adjust offset and paint
+    // region accordingly. This is typically the case when people call render
+    // from the paintEvent.
+    QPoint offset = targetOffset;
+    offset -= paintRegion.boundingRect().topLeft();
+    QPoint redirectionOffset;
+    QPaintDevice *redirected = 0;
+
+    if (target->devType() == QInternal::Widget)
+        redirected = static_cast<QWidget *>(target)->d_func()->redirected(&redirectionOffset);
+    if (!redirected)
+        redirected = QPainter::redirected(target, &redirectionOffset);
+
+    if (redirected) {
+        target = redirected;
+        offset -= redirectionOffset;
+    }
+
+    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);
+        }
+    }
+
+    // Set backingstore flags.
+    int flags = DrawPaintOnScreen | DrawInvisible;
+    if (renderFlags & QWidget::DrawWindowBackground)
+        flags |= DrawAsRoot;
+
+    if (renderFlags & QWidget::DrawChildren)
+        flags |= DrawRecursive;
+    else
+        flags |= DontSubtractOpaqueChildren;
+
+#ifdef Q_WS_QWS
+    flags |= DontSetCompositionMode;
+#endif
+
+    if (target->devType() == QInternal::Printer) {
+        QPainter p(target);
+        render_helper(&p, targetOffset, paintRegion, renderFlags);
+        return;
+    }
+
+#ifndef Q_WS_MAC
+    // Render via backingstore.
+    drawWidget(target, paintRegion, offset, flags, sharedPainter());
+
+    // Restore shared painter.
+    if (oldSharedPainter)
+        setSharedPainter(oldSharedPainter);
+#else
+    // Render via backingstore (no shared painter).
+    drawWidget(target, paintRegion, offset, flags, 0);
+#endif
 }
 
@@ -5537 +5760 @@
     }
 
-
     QRect effectRect;
 
-    if (mode == QGraphicsEffect::PadToEffectiveBoundingRect) {
+    if (mode == QGraphicsEffect::PadToEffectiveBoundingRect)
         effectRect = m_widget->graphicsEffect()->boundingRectFor(sourceRect).toAlignedRect();
-
-    } else if (mode == QGraphicsEffect::PadToTransparentBorder) {
+    else if (mode == QGraphicsEffect::PadToTransparentBorder)
         effectRect = sourceRect.adjusted(-1, -1, 1, 1).toAlignedRect();
-
-    } else {
+    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);
+    m_widget->render(&pixmap, pixmapOffset, QRegion(), QWidget::DrawChildren);
     return pixmap;
 }
@@ -6186 +6380 @@
                 }
                 if (!isHidden()) {
+#ifndef QT_NO_GRAPHICSVIEW
+                    // Update proxy state
+                    if (QWExtra *topData = window()->d_func()->extra)
+                        if (topData->proxyWidget && topData->proxyWidget->hasFocus())
+                            topData->proxyWidget->d_func()->updateProxyInputMethodAcceptanceFromWidget();
+#endif
                     // Send event to self
                     QFocusEvent event(QEvent::FocusIn, reason);
@@ -6465 +6665 @@
     QWidget *fn = first->d_func()->focus_next;
 
-    if (fn == second)
+    if (fn == second || first == second)
         return;
 
@@ -6694 +6894 @@
 QByteArray QWidget::saveGeometry() const
 {
+#ifdef QT_MAC_USE_COCOA
+    // We check if the window was maximized during this invocation. If so, we need to record the
+    // starting position as 0,0.
+    Q_D(const QWidget);
+    QRect newFramePosition = frameGeometry();
+    QRect newNormalPosition = normalGeometry();
+    if(d->topData()->wasMaximized && !(windowState() & Qt::WindowMaximized)) {
+        // Change the starting position
+        newFramePosition.moveTo(0, 0);
+        newNormalPosition.moveTo(0, 0);
+    }
+#endif // QT_MAC_USE_COCOA
     QByteArray array;
     QDataStream stream(&array, QIODevice::WriteOnly);
@@ -6703 +6915 @@
            << majorVersion
            << minorVersion
+#ifdef QT_MAC_USE_COCOA
+           << newFramePosition
+           << newNormalPosition
+#else
            << frameGeometry()
            << normalGeometry()
+#endif // QT_MAC_USE_COCOA
            << qint32(QApplication::desktop()->screenNumber(this))
            << quint8(windowState() & Qt::WindowMaximized)
@@ -7281 +7498 @@
     bool isEmbedded = false;
 #if !defined QT_NO_GRAPHICSVIEW
-    isEmbedded = q->isWindow() && nearestGraphicsProxyWidget(q->parentWidget()) != 0;
+    isEmbedded = q->isWindow() && !bypassGraphicsProxyWidget(q) && nearestGraphicsProxyWidget(q->parentWidget()) != 0;
 #else
     Q_UNUSED(isEmbedded);
@@ -7318 +7535 @@
     // hidden.
     if (wasVisible) {
-#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined (Q_WS_QWS) || defined(Q_WS_PM)
+#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined (Q_WS_QWS) || defined(Q_WS_MAC) || defined(Q_WS_PM)
         qApp->d_func()->sendSyntheticEnterLeave(q);
 #endif
@@ -7349 +7566 @@
     it. It will not be automatically shown when the parent is shown.
 
-    To check visiblity, use !isVisible() instead (notice the exclamation mark).
+    To check visibility, use !isVisible() instead (notice the exclamation mark).
 
     isHidden() implies !isVisible(), but a widget can be not visible
@@ -7450 +7667 @@
             d->show_helper();
 
-#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined (Q_WS_QWS) || defined(Q_WS_PM)
+#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined (Q_WS_QWS) || defined(Q_WS_MAC) || defined(Q_WS_PM)
             qApp->d_func()->sendSyntheticEnterLeave(this);
 #endif
@@ -7582 +7799 @@
             }
         }
-#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined (Q_WS_QWS) || defined(Q_WS_PM)
+#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined (Q_WS_QWS) || defined(Q_WS_MAC) || defined(Q_WS_PM)
         qApp->d_func()->sendSyntheticEnterLeave(widget);
 #endif
@@ -7626 +7843 @@
         QApplication::quit();
 #endif
-    // Attempt to close the application only if this widget has the
-    // WA_QuitOnClose flag set set and has a non-visible parent
-    quitOnClose = quitOnClose && (parentWidget.isNull() || !parentWidget->isVisible() || parentWidget->testAttribute(Qt::WA_DontShowOnScreen));
+    // Attempt to close the application only if this has WA_QuitOnClose set and a non-visible parent
+    quitOnClose = quitOnClose && (parentWidget.isNull() || !parentWidget->isVisible());
 
     if (quitOnClose) {
-        // If there is no non-withdrawn primary window left (except
-        // the ones without QuitOnClose or with WA_DontShowOnScreen),
-        // we emit the lastWindowClosed signal
+        /* if there is no non-withdrawn primary window left (except
+           the ones without QuitOnClose), we emit the lastWindowClosed
+           signal */
         QWidgetList list = QApplication::topLevelWidgets();
         bool lastWindowClosed = true;
         for (int i = 0; i < list.size(); ++i) {
             QWidget *w = list.at(i);
-            if ((w->isVisible() && !w->testAttribute(Qt::WA_DontShowOnScreen))
-                    && !w->parentWidget() && w->testAttribute(Qt::WA_QuitOnClose)) {
-                lastWindowClosed = false;
-                break;
-            }
+            if (!w->isVisible() || w->parentWidget() || !w->testAttribute(Qt::WA_QuitOnClose))
+                continue;
+            lastWindowClosed = false;
+            break;
         }
         if (lastWindowClosed)
@@ -8484 +8699 @@
         break;
     }
+#ifndef QT_NO_GESTURES
     case QEvent::Gesture:
         event->ignore();
         break;
+#endif
 #ifndef QT_NO_PROPERTIES
     case QEvent::DynamicPropertyChange: {
@@ -8513 +8730 @@
   This event handler can be reimplemented to handle state changes.
 
-  The state being changed in this event can be retrieved through event \a
-  event.
+  The state being changed in this event can be retrieved through the \a event
+  supplied.
 
   Change events include: QEvent::ToolBarChange,
@@ -8625 +8842 @@
         while ((w = QApplication::activePopupWidget()) && w != this){
             w->close();
-            if (QApplication::activePopupWidget() == w) // widget does not want to dissappear
+            if (QApplication::activePopupWidget() == w) // widget does not want to disappear
                 w->hide(); // hide at least
         }
@@ -9078 +9295 @@
 {
 #ifndef QT_NO_IM
-    Q_D(const QWidget);
-    return d->imHints;
+    const QWidgetPrivate *priv = d_func();
+    while (priv->inheritsInputMethodHints) {
+        priv = priv->q_func()->parentWidget()->d_func();
+        Q_ASSERT(priv);
+    }
+    return priv->imHints;
 #else //QT_NO_IM
     return 0;
@@ -9090 +9311 @@
     Q_D(QWidget);
     d->imHints = hints;
-    // Optimisation to update input context only it has already been created.
+    // Optimization to update input context only it has already been created.
     if (d->ic || qApp->d_func()->inputContext) {
         QInputContext *ic = inputContext();
@@ -9634 +9855 @@
 QWidget *QWidgetPrivate::childAt_helper(const QPoint &p, bool ignoreChildrenInDestructor) const
 {
+    if (children.isEmpty())
+        return 0;
+
+#ifdef Q_WS_MAC
     Q_Q(const QWidget);
-#ifdef Q_WS_MAC
+    // Unified tool bars on the Mac require special handling since they live outside
+    // QMainWindow's geometry(). See commit: 35667fd45ada49269a5987c235fdedfc43e92bb8
     bool includeFrame = q->isWindow() && qobject_cast<const QMainWindow *>(q)
                         && static_cast<const QMainWindow *>(q)->unifiedTitleAndToolBarOnMac();
-#endif
-
-    if (
+    if (includeFrame)
+        return childAtRecursiveHelper(p, ignoreChildrenInDestructor, includeFrame);
+#endif
+
+    if (!pointInsideRectAndMask(p))
+        return 0;
+    return childAtRecursiveHelper(p, ignoreChildrenInDestructor);
+}
+
+QWidget *QWidgetPrivate::childAtRecursiveHelper(const QPoint &p, bool ignoreChildrenInDestructor, bool includeFrame) const
+{
+#ifndef Q_WS_MAC
+    Q_UNUSED(includeFrame);
+#endif
+    for (int i = children.size() - 1; i >= 0; --i) {
+        QWidget *child = qobject_cast<QWidget *>(children.at(i));
+        if (!child || child->isWindow() || child->isHidden() || child->testAttribute(Qt::WA_TransparentForMouseEvents)
+            || (ignoreChildrenInDestructor && child->data->in_destructor)) {
+            continue;
+        }
+
+        // Map the point 'p' from parent coordinates to child coordinates.
+        QPoint childPoint = p;
 #ifdef Q_WS_MAC
-            !includeFrame &&
-#endif
-            !q->rect().contains(p))
-        return 0;
-
-    for (int i = children.size(); i > 0 ;) {
-        --i;
-        QWidget *w = qobject_cast<QWidget *>(children.at(i));
-        if (w && !w->isWindow() && !w->isHidden()
-                && (w->geometry().contains(p)
-#ifdef Q_WS_MAC
-                    || (includeFrame && w->geometry().contains(qt_mac_nativeMapFromParent(w, p)))
-#endif
-               )) {
-            if (ignoreChildrenInDestructor && w->data->in_destructor)
-                continue;
-            if (w->testAttribute(Qt::WA_TransparentForMouseEvents))
-                continue;
-            QPoint childPoint = w->mapFromParent(p);
-#ifdef Q_WS_MAC
-            if (includeFrame && !w->geometry().contains(p))
-                childPoint = qt_mac_nativeMapFromParent(w, p);
-#endif
-            if (QWidget *t = w->d_func()->childAt_helper(childPoint, ignoreChildrenInDestructor))
-                return t;
-            // if WMouseNoMask is set the widget mask is ignored, if
-            // the widget has no mask then the WMouseNoMask flag has no
-            // effect
-            if (w->testAttribute(Qt::WA_MouseNoMask) || w->mask().contains(childPoint)
-                || w->mask().isEmpty())
-                return w;
-        }
+        // 'includeFrame' is true if the child's parent is a top-level QMainWindow with an unified tool bar.
+        // An unified tool bar on the Mac lives outside QMainWindow's geometry(), so a normal
+        // QWidget::mapFromParent won't do the trick.
+        if (includeFrame && qobject_cast<QToolBar *>(child))
+            childPoint = qt_mac_nativeMapFromParent(child, p);
+        else
+#endif
+        childPoint -= child->data->crect.topLeft();
+
+        // Check if the point hits the child.
+        if (!child->d_func()->pointInsideRectAndMask(childPoint))
+            continue;
+
+        // Do the same for the child's descendants.
+        if (QWidget *w = child->d_func()->childAtRecursiveHelper(childPoint, ignoreChildrenInDestructor))
+            return w;
+
+        // We have found our target; namely the child at position 'p'.
+        return child;
     }
     return 0;
@@ -9830 +10063 @@
     bool newParent = (parent != parentWidget()) || !wasCreated || desktopWidget;
 
-#if defined(Q_WS_X11) || defined(Q_WS_WIN)
+#if defined(Q_WS_X11) || defined(Q_WS_WIN) || defined(Q_WS_MAC) || defined(Q_OS_SYMBIAN)
     if (newParent && parent && !desktopWidget) {
         if (testAttribute(Qt::WA_NativeWindow) && !qApp->testAttribute(Qt::AA_DontCreateNativeWidgetSiblings))
@@ -9852 +10085 @@
         focusWidget()->clearFocus();
 
+    QTLWExtra *oldTopExtra = window()->d_func()->maybeTopData();
+    QWidgetBackingStoreTracker *oldBsTracker = oldTopExtra ? &oldTopExtra->backingStore : 0;
+
     d->setParent_sys(parent, f);
+
+    QTLWExtra *topExtra = window()->d_func()->maybeTopData();
+    QWidgetBackingStoreTracker *bsTracker = topExtra ? &topExtra->backingStore : 0;
+    if (oldBsTracker && oldBsTracker != bsTracker)
+        oldBsTracker->unregisterWidgetSubtree(this);
+
     if (desktopWidget)
         parent = 0;
@@ -10315 +10557 @@
 #endif // QT3_SUPPORT
 
-/*!
-    Sets the attribute \a attribute on this widget if \a on is true;
-    otherwise clears the attribute.
-
-    \sa testAttribute()
-*/
-void QWidget::setAttribute(Qt::WidgetAttribute attribute, bool on)
-{
-    if (testAttribute(attribute) == on)
-        return;
-
-    Q_D(QWidget);
-    Q_ASSERT_X(sizeof(d->high_attributes)*8 >= (Qt::WA_AttributeCount - sizeof(uint)*8),
-               "QWidget::setAttribute(WidgetAttribute, bool)",
-               "QWidgetPrivate::high_attributes[] too small to contain all attributes in WidgetAttribute");
-
-#if defined(Q_WS_WIN) || defined(Q_WS_PM)
-    // ### 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();
-        if (d->noPaintOnScreen)
-            return;
-    }
-#endif
-
+ /*!
+  \internal
+
+  This just sets the corresponding attribute bit to 1 or 0
+ */
+static void setAttribute_internal(Qt::WidgetAttribute attribute, bool on, QWidgetData *data,
+                                  QWidgetPrivate *d)
+{
     if (attribute < int(8*sizeof(uint))) {
         if (on)
@@ -10354 +10578 @@
             d->high_attributes[int_off] &= ~(1<<(x-(int_off*8*sizeof(uint))));
     }
+}
+
+/*!
+    Sets the attribute \a attribute on this widget if \a on is true;
+    otherwise clears the attribute.
+
+    \sa testAttribute()
+*/
+void QWidget::setAttribute(Qt::WidgetAttribute attribute, bool on)
+{
+    if (testAttribute(attribute) == on)
+        return;
+
+    Q_D(QWidget);
+    Q_ASSERT_X(sizeof(d->high_attributes)*8 >= (Qt::WA_AttributeCount - sizeof(uint)*8),
+               "QWidget::setAttribute(WidgetAttribute, bool)",
+               "QWidgetPrivate::high_attributes[] too small to contain all attributes in WidgetAttribute");
+
+#if defined(Q_WS_WIN) || defined(Q_WS_PM)
+    // ### 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();
+        if (d->noPaintOnScreen)
+            return;
+    }
+#endif
+
+    setAttribute_internal(attribute, on, data, d);
 
     switch (attribute) {
@@ -10412 +10665 @@
         {
             // We can only have one of these set at a time
-            static const int MacSizes[] = { Qt::WA_MacNormalSize, Qt::WA_MacSmallSize,
-                                            Qt::WA_MacMiniSize, 0 };
-            for (int i = 0; MacSizes[i] != 0; ++i) {
-                if (MacSizes[i] == attribute)
-                    continue;
-                int macsize_x = MacSizes[i] - 8*sizeof(uint);
-                int macsize_int_off = macsize_x / (8*sizeof(uint));
-                d->high_attributes[macsize_int_off] &= ~(1<<(macsize_x-(macsize_int_off*8*sizeof(uint))));
+            const Qt::WidgetAttribute MacSizes[] = { Qt::WA_MacNormalSize, Qt::WA_MacSmallSize,
+                                                     Qt::WA_MacMiniSize };
+            for (int i = 0; i < 3; ++i) {
+                if (MacSizes[i] != attribute)
+                    setAttribute_internal(MacSizes[i], false, data, d);
             }
             d->macUpdateSizeAttribute();
@@ -10486 +10736 @@
     case Qt::WA_PaintOnScreen:
         d->updateIsOpaque();
-#if defined(Q_WS_WIN) || defined(Q_WS_X11)
+#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_OS_SYMBIAN)
         // Recreate the widget if it's already created as an alien widget and
         // WA_PaintOnScreen is enabled. Paint on screen widgets must have win id.
@@ -10542 +10792 @@
         d->updateIsOpaque();
         break;
+    case Qt::WA_X11DoNotAcceptFocus:
+        if (testAttribute(Qt::WA_WState_Created))
+            d->updateX11AcceptFocus();
+        break;
 #endif
     case Qt::WA_DontShowOnScreen: {
@@ -10597 +10851 @@
         break;
     case Qt::WA_AcceptTouchEvents:
-#if defined(Q_WS_WIN) || defined(Q_WS_MAC) || defined(Q_WS_S60)
+#if defined(Q_WS_WIN) || defined(Q_WS_MAC) || defined(Q_OS_SYMBIAN)
         if (on)
             d->registerTouchWindow();
 #endif
         break;
+    case Qt::WA_LockPortraitOrientation:
+    case Qt::WA_LockLandscapeOrientation:
+    case Qt::WA_AutoOrientation: {
+        const Qt::WidgetAttribute orientations[3] = {
+            Qt::WA_LockPortraitOrientation,
+            Qt::WA_LockLandscapeOrientation,
+            Qt::WA_AutoOrientation
+        };
+
+        if (on) {
+            // We can only have one of these set at a time
+            for (int i = 0; i < 3; ++i) {
+                if (orientations[i] != attribute)
+                    setAttribute_internal(orientations[i], false, data, d);
+            }
+        }
+
+#ifdef Q_WS_S60
+        CAknAppUiBase* appUi = static_cast<CAknAppUiBase*>(CEikonEnv::Static()->EikAppUi());
+        const CAknAppUiBase::TAppUiOrientation s60orientations[] = {
+            CAknAppUiBase::EAppUiOrientationPortrait,
+            CAknAppUiBase::EAppUiOrientationLandscape,
+            CAknAppUiBase::EAppUiOrientationAutomatic
+        };
+        CAknAppUiBase::TAppUiOrientation s60orientation = CAknAppUiBase::EAppUiOrientationUnspecified;
+        for (int i = 0; i < 3; ++i) {
+            if (testAttribute(orientations[i])) {
+                s60orientation = s60orientations[i];
+                break;
+            }
+        }
+        QT_TRAP_THROWING(appUi->SetOrientationL(s60orientation));
+        S60->orientationSet = true;
+#endif
+        break;
+    }
     default:
         break;
@@ -10959 +11249 @@
 #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.
+    // and optimization to update input context only it has already been created.
     if (d->ic || qApp->d_func()->inputContext) {
         QInputContext *ic = inputContext();
@@ -11785 +12075 @@
     Tells us if it there is currently a reachable widget by keypad navigation in
     a certain \a orientation.
-    If no navigation is possible, occuring key events in that \a orientation may
-    be used to interact with the value in the focussed widget, even though it
+    If no navigation is possible, occurring key events in that \a orientation may
+    be used to interact with the value in the focused widget, even though it
     currently has not the editFocus.
 
@@ -11806 +12096 @@
     navigation. If there is no QTabWidget, the horizontal key events can be used
 to
-    interact with the value in the focussed widget, even though it currently has
+    interact with the value in the focused widget, even though it currently has
     not the editFocus.
 
@@ -12006 +12296 @@
 */
 
+#ifndef QT_NO_GESTURES
 /*!
     Subscribes the widget to a given \a gesture with specific \a flags.
@@ -12029 +12320 @@
     Q_D(QWidget);
     if (d->gestureContext.remove(gesture)) {
-        QGestureManager *manager = QGestureManager::instance();
-        manager->cleanupCachedGestures(this, gesture);
-    }
-}
-
+        if (QGestureManager *manager = QGestureManager::instance())
+            manager->cleanupCachedGestures(this, gesture);
+    }
+}
+#endif // QT_NO_GESTURES
 
 /*!
@@ -12357 +12648 @@
 #endif
 
+#if QT_MAC_USE_COCOA
+void QWidgetPrivate::syncUnifiedMode() {
+    // The whole purpose of this method is to keep the unifiedToolbar in sync.
+    // That means making sure we either exchange the drawing methods or we let
+    // the toolbar know that it does not require to draw the baseline.
+    Q_Q(QWidget);
+    // This function makes sense only if this is a top level
+    if(!q->isWindow())
+        return;
+    OSWindowRef window = qt_mac_window_for(q);
+    if(changeMethods) {
+        // Ok, we are in documentMode.
+        if(originalDrawMethod)
+            qt_mac_replaceDrawRect(window, this);
+    } else {
+        if(!originalDrawMethod)
+            qt_mac_replaceDrawRectOriginal(window, this);
+    }
+}
+
+#endif // QT_MAC_USE_COCOA
+
 QT_END_NAMESPACE