Changeset 846 for trunk/src/gui/kernel

trunk

Property svn:mergeinfo changed
/branches/vendor/nokia/qt/4.7.2 (added) merged: 845
/branches/vendor/nokia/qt/current merged: 844
/branches/vendor/nokia/qt/4.6.3 removed

trunk/src/gui/kernel/kernel.pri

-              r651
+              r846
         kernel/qclipboard_s60.cpp\
         kernel/qdnd_s60.cpp \
+        kernel/qsound_s60.cpp \
+        kernel/qsoftkeymanager_s60.cpp
+        kernel/qsound_s60.cpp
     HEADERS += \
         kernel/qt_s60_p.h \
+        kernel/qeventdispatcher_s60_p.h \
+        kernel/qsoftkeymanager_s60_p.h
+        kernel/qeventdispatcher_s60_p.h
     LIBS += -lbafl -lestor
 …
     INCLUDEPATH += $$MW_LAYER_SYSTEMINCLUDE
     INCLUDEPATH += ../3rdparty/s60
+    contains(QT_CONFIG, s60) {
+        SOURCES += kernel/qsoftkeymanager_s60.cpp
+        HEADERS += kernel/qsoftkeymanager_s60_p.h
+    }
+}
 …
         OBJECTIVE_HEADERS += \
                 qcocoawindow_mac_p.h \
+                qcocoapanel_mac_p.h \
                 qcocoawindowdelegate_mac_p.h \
                 qcocoaview_mac_p.h \

trunk/src/gui/kernel/qaction.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 QActionPrivate::QActionPrivate() : group(0), enabled(1), forceDisabled(0),
                                    visible(1), forceInvisible(0), checkable(0), checked(0), separator(0), fontSet(false),
+                                   forceEnabledInSoftkeys(false), menuActionSoftkeys(false),
+                                   iconVisibleInMenu(-1),
                                    menuRole(QAction::TextHeuristicRole), softKeyRole(QAction::NoSoftKey),
                                    priority(QAction::NormalPriority), iconVisibleInMenu(-1)
+                                   priority(QAction::NormalPriority)
+{
 #ifdef QT3_SUPPORT

trunk/src/gui/kernel/qaction.h

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
     friend class QShortcutMap;
     friend class QToolButton;
+#ifdef Q_WS_MAC
+    friend void qt_mac_clear_status_text(QAction *action);
+#endif
 };

trunk/src/gui/kernel/qaction_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
     ~QActionPrivate();
+    static QActionPrivate *get(QAction *q)
+    {
+        return q->d_func();
+    }
     bool showStatusText(QWidget *w, const QString &str);
 …
     uint separator : 1;
     uint fontSet : 1;
+    //for soft keys management
+    uint forceEnabledInSoftkeys : 1;
+    uint menuActionSoftkeys : 1;
+    int iconVisibleInMenu : 3;  // Only has values -1, 0, and 1
     QAction::MenuRole menuRole;
     QAction::SoftKeyRole softKeyRole;
     QAction::Priority priority;
+    int iconVisibleInMenu : 3;  // Only has values -1, 0, and 1
     QList<QWidget *> widgets;
 #ifndef QT_NO_GRAPHICSVIEW

trunk/src/gui/kernel/qactiongroup.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qactiongroup.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qapplication.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include "qdebug.h"
 #include "private/qgraphicssystemfactory_p.h"
+#include "private/qgraphicssystem_p.h"
 #include "private/qstylesheetstyle_p.h"
 #include "private/qstyle_p.h"
 …
 #include <QtGui/qgraphicsproxywidget.h>
+#ifdef QT_GRAPHICSSYSTEM_RUNTIME
+#include "private/qgraphicssystem_runtime_p.h"
+#endif
 #include "qinputcontext.h"
 #include "qkeymapper_p.h"
 …
 #endif
 #if defined(Q_WS_X11) || defined(Q_WS_S60)
+#if defined(Q_WS_X11) || defined(Q_OS_SYMBIAN)
 #include "qinputcontextfactory.h"
 #endif
 …
 #include <stdlib.h>
+#if defined(Q_WS_X11) && !defined(QT_NO_EGL)
+#include <link.h>
+#endif
 #include "qapplication_p.h"
 …
+{
 #if defined(Q_WS_WINCE)
+    Q_INIT_RESOURCE_EXTERN(qstyle_wince)
     Q_INIT_RESOURCE(qstyle_wince);
 #elif defined(Q_OS_SYMBIAN)
+    Q_INIT_RESOURCE_EXTERN(qstyle_s60)
     Q_INIT_RESOURCE(qstyle_s60);
 #else
+    Q_INIT_RESOURCE_EXTERN(qstyle)
     Q_INIT_RESOURCE(qstyle);
 #endif
+    Q_INIT_RESOURCE_EXTERN(qmessagebox)
     Q_INIT_RESOURCE(qmessagebox);
 #if !defined(QT_NO_PRINTDIALOG)
+    Q_INIT_RESOURCE_EXTERN(qprintdialog)
     Q_INIT_RESOURCE(qprintdialog);
 #endif
 …
 QT_BEGIN_NAMESPACE
 Q_DECL_IMPORT extern void qt_call_post_routines();
+Q_CORE_EXPORT void qt_call_post_routines();
 int QApplicationPrivate::app_compile_version = 0x040000; //we don't know exactly, but it's at least 4.0.0
 …
 #endif
+#ifndef QT_NO_GESTURES
     gestureManager = 0;
     gestureWidget = 0;
+#endif // QT_NO_GESTURES
+#if defined(Q_WS_X11) || defined(Q_WS_WIN)
+    move_cursor = 0;
+    copy_cursor = 0;
+    link_cursor = 0;
+#endif
+#if defined(Q_WS_WIN)
+    ignore_cursor = 0;
+#endif
     if (!self)
 …
 QGraphicsSystem *QApplicationPrivate::graphics_system = 0; // default graphics system
 QString QApplicationPrivate::graphics_system_name;         // graphics system id - for delayed initialization
+bool QApplicationPrivate::runtime_graphics_system = false;
 Q_GLOBAL_STATIC(QMutex, applicationFontMutex)
 …
 int qt_antialiasing_threshold = -1;
 static int drag_time = 500;
+#ifndef QT_GUI_DRAG_DISTANCE
+#define QT_GUI_DRAG_DISTANCE 4
+#endif
 #ifdef Q_OS_SYMBIAN
 // The screens are a bit too small to for your thumb when using only 4 pixels drag distance.
 static int drag_distance = 8;
+static int drag_distance = 12; //XXX move to qplatformdefs.h
 #else
 static int drag_distance = 4;
+static int drag_distance = QT_GUI_DRAG_DISTANCE;
 #endif
 static Qt::LayoutDirection layout_direction = Qt::LeftToRight;
 …
 bool QApplicationPrivate::widgetCount = false;
 bool QApplicationPrivate::load_testability = false;
+QString QApplicationPrivate::qmljs_debug_arguments;
 #ifdef QT_KEYPAD_NAVIGATION
 #  ifdef Q_OS_SYMBIAN
 …
     if (!widget)
         return false;
+#if defined(Q_WS_MAC) // Fake alien behavior on the Mac :)
+    return !widget->isWindow() && widget->window()->testAttribute(Qt::WA_DontShowOnScreen);
+#elif defined(Q_WS_QWS)
+#if defined(Q_WS_QWS)
     return !widget->isWindow()
 # ifdef Q_BACKINGSTORE_SUBSURFACES
 …
         if (arg == "-qdevel" || arg == "-qdebug") {
             // obsolete argument
+        } else if (arg.indexOf("-qmljsdebugger=", 0) != -1) {
+            qmljs_debug_arguments = QString::fromLocal8Bit(arg.right(arg.length() - 15));
         } else if (arg.indexOf("-style=", 0) != -1) {
             s = QString::fromLocal8Bit(arg.right(arg.length() - 7).toLower());
 …
         \o  -graphicssystem, sets the backend to be used for on-screen widgets
             and QPixmaps. Available options are \c{raster} and \c{opengl}.
+        \o  -qmljsdebugger=, activates the QML/JS debugger with a specified port.
+            The value must be of format port:1234[,block], where block is optional
+            and will make the application wait until a debugger connects to it.
     \endlist
 …
             that is shown.
         \o  -fn or \c -font \e font, defines the application font. The font
+            should be specified using an X logical font description.
+            should be specified using an X logical font description. Note that
+            this option is ignored when Qt is built with fontconfig support enabled.
         \o  -bg or \c -background \e color, sets the default background color
             and an application palette (light and dark shades are calculated).
 …
     \endlist
+    \section1 X11 Notes
+    If QApplication fails to open the X11 display, it will terminate
+    the process. This behavior is consistent with most X11
+    applications.
     \sa arguments()
 */
 …
 { Q_D(QApplication); d->construct();  QApplicationPrivate::app_compile_version = _internal;}
+#if defined(Q_WS_X11) && !defined(QT_NO_EGL)
+static int qt_matchLibraryName(dl_phdr_info *info, size_t, void *data)
+{
+    const char *name = static_cast<const char *>(data);
+    return strstr(info->dlpi_name, name) != 0;
+}
+#endif
 /*!
 …
     qt_is_gui_used = (qt_appType != QApplication::Tty);
     process_cmdline();
+    // the environment variable has the lowest precedence of runtime graphicssystem switches
+    if (graphics_system_name.isEmpty())
+        graphics_system_name = QString::fromLocal8Bit(qgetenv("QT_GRAPHICSSYSTEM"));
+#if defined(Q_WS_X11) && !defined(QT_NO_EGL)
+    if (graphics_system_name.isEmpty()) {
+        bool linksWithMeeGoTouch = dl_iterate_phdr(qt_matchLibraryName, const_cast<char *>("libmeegotouchcore"));
+        bool linksWithMeeGoGraphicsSystemHelper = dl_iterate_phdr(qt_matchLibraryName, const_cast<char *>("libQtMeeGoGraphicsSystemHelper"));
+        if (linksWithMeeGoTouch && !linksWithMeeGoGraphicsSystemHelper) {
+            qWarning("Running non-meego graphics system enabled  MeeGo touch, forcing native graphicssystem\n");
+            graphics_system_name = QLatin1String("native");
+        }
+    }
+#endif
     // Must be called before initialize()
     qt_init(this, qt_appType
 …
     extern void qt_gui_eval_init(uint);
     qt_gui_eval_init(application_type);
+#endif
+#if defined(Q_OS_SYMBIAN) && !defined(QT_NO_SYSTEMLOCALE)
+    symbianInit();
 #endif
 …
             typedef void (*TasInitialize)(void);
             TasInitialize initFunction = (TasInitialize)testLib.resolve("qt_testability_init");
+#ifdef Q_OS_SYMBIAN
+            // resolving method by name does not work on Symbian OS so need to use ordinal
+            if(!initFunction) {
+                initFunction = (TasInitialize)testLib.resolve("1");
+            }
+#endif
             if (initFunction) {
                 initFunction();
 …
 extern void qInitDrawhelperAsm();
+extern void qInitImageConversions();
 extern int qRegisterGuiVariant();
 extern int qUnregisterGuiVariant();
 …
     // Set up which span functions should be used in raster engine...
     qInitDrawhelperAsm();
+    // and QImage conversion functions
+    qInitImageConversions();
 #ifndef QT_NO_WHEELEVENT
 …
     QApplicationPrivate::is_app_closing = true;
     QApplicationPrivate::is_app_running = false;
-    delete qt_desktopWidget;
-    qt_desktopWidget = 0;
-#ifndef QT_NO_CLIPBOARD
-    delete qt_clipboard;
-    qt_clipboard = 0;
-#endif
     delete QWidgetPrivate::mapper;
 …
+    }
+    delete qt_desktopWidget;
+    qt_desktopWidget = 0;
+#ifndef QT_NO_CLIPBOARD
+    delete qt_clipboard;
+    qt_clipboard = 0;
+#endif
+#if defined(Q_WS_X11) || defined(Q_WS_WIN)
+    delete d->move_cursor; d->move_cursor = 0;
+    delete d->copy_cursor; d->copy_cursor = 0;
+    delete d->link_cursor; d->link_cursor = 0;
+#endif
+#if defined(Q_WS_WIN)
+    delete d->ignore_cursor; d->ignore_cursor = 0;
+#endif
     delete QApplicationPrivate::app_pal;
     QApplicationPrivate::app_pal = 0;
 …
     delete QApplicationPrivate::app_icon;
     QApplicationPrivate::app_icon = 0;
+    delete QApplicationPrivate::graphics_system;
+    QApplicationPrivate::graphics_system = 0;
 #ifndef QT_NO_CURSOR
     d->cursor_list.clear();
 …
         //
         QString style;
+        if (!QApplicationPrivate::styleOverride.isEmpty())
+#ifdef QT_BUILD_INTERNAL
+        QString envStyle = QString::fromLocal8Bit(qgetenv("QT_STYLE_OVERRIDE"));
+#else
+        QString envStyle;
+#endif
+        if (!QApplicationPrivate::styleOverride.isEmpty()) {
             style = QApplicationPrivate::styleOverride;
+        else
+        } else if (!envStyle.isEmpty()) {
+            style = envStyle;
+        } else {
             style = QApplicationPrivate::desktopStyleKey();
+        }
         QStyle *&app_style = QApplicationPrivate::app_style;
 …
     \c{"raster"} and \c{"opengl"}.
+    This function call overrides both the application commandline
+    \c{-graphicssystem} switch and the configure \c{-graphicssystem} switch.
+    \warning This function must be called before the QApplication constructor
+    There are several ways to set the graphics backend, in order of decreasing
+    precedence:
+    \list
+        \o the application commandline \c{-graphicssystem} switch
+        \o QApplication::setGraphicsSystem()
+        \o the QT_GRAPHICSSYSTEM environment variable
+        \o the Qt configure \c{-graphicssystem} switch
+    \endlist
+    If the highest precedence switch sets an invalid name, the error will be
+    ignored and the default backend will be used.
+    \warning This function is only effective before the QApplication constructor
     is called.
 …
 void QApplication::setGraphicsSystem(const QString &system)
+{
+    QApplicationPrivate::graphics_system_name = system;
+#ifdef QT_GRAPHICSSYSTEM_RUNTIME
+    if (QApplicationPrivate::graphics_system_name == QLatin1String("runtime")) {
+        QRuntimeGraphicsSystem *r =
+                static_cast<QRuntimeGraphicsSystem *>(QApplicationPrivate::graphics_system);
+        r->setGraphicsSystem(system);
+    } else
+#endif
+        QApplicationPrivate::graphics_system_name = system;
+}
 …
     bool did_close = true;
     QWidget *w;
     while((w = activeModalWidget()) && did_close) {
         if(!w->isVisible())
+    while ((w = activeModalWidget()) && did_close) {
+        if (!w->isVisible() || w->data->is_closing)
             break;
         did_close = w->close();
 …
     for (int i = 0; did_close && i < list.size(); ++i) {
         w = list.at(i);
+        if (w->isVisible() && w->windowType() != Qt::Desktop) {
+        if (w->isVisible()
+            && w->windowType() != Qt::Desktop
+            && !w->data->is_closing) {
             did_close = w->close();
             list = QApplication::topLevelWidgets();
 …
                          " and Arabic) to get proper widget layout.") == QLatin1String("RTL"));
+}
+#if defined(Q_WS_MAC)
+static const char *application_menu_strings[] = {
+    QT_TRANSLATE_NOOP("MAC_APPLICATION_MENU","Services"),
+    QT_TRANSLATE_NOOP("MAC_APPLICATION_MENU","Hide %1"),
+    QT_TRANSLATE_NOOP("MAC_APPLICATION_MENU","Hide Others"),
+    QT_TRANSLATE_NOOP("MAC_APPLICATION_MENU","Show All"),
+    QT_TRANSLATE_NOOP("MAC_APPLICATION_MENU","Preferences..."),
+    QT_TRANSLATE_NOOP("MAC_APPLICATION_MENU","Quit %1"),
+    QT_TRANSLATE_NOOP("MAC_APPLICATION_MENU","About %1")
+    };
+QString qt_mac_applicationmenu_string(int type)
+{
+    QString menuString = QString::fromLatin1(application_menu_strings[type]);
+    QString translated = qApp->translate("QMenuBar", application_menu_strings[type]);
+    if (translated != menuString)
+        return translated;
+    else
+        return qApp->translate("MAC_APPLICATION_MENU",
+                               application_menu_strings[type]);
+}
+#endif
 #endif
 …
         setLayoutDirection(qt_detectRTLLanguage()?Qt::RightToLeft:Qt::LeftToRight);
 #endif
+#if defined(QT_MAC_USE_COCOA)
+        qt_mac_post_retranslateAppMenu();
+#endif
         QWidgetList list = topLevelWidgets();
         for (int i = 0; i < list.size(); ++i) {
 …
                 postEvent(w, new QEvent(QEvent::LanguageChange));
+        }
+#ifndef Q_OS_WIN
+    } else if (e->type() == QEvent::LocaleChange) {
+        // on Windows the event propagation is taken care by the
+        // WM_SETTINGCHANGE event handler.
+        QWidgetList list = topLevelWidgets();
+        for (int i = 0; i < list.size(); ++i) {
+            QWidget *w = list.at(i);
+            if (!(w->windowType() == Qt::Desktop)) {
+                if (!w->testAttribute(Qt::WA_SetLocale))
+                    w->d_func()->setLocale_helper(QLocale(), true);
+            }
+        }
+#endif
     } else if (e->type() == QEvent::Timer) {
         QTimerEvent *te = static_cast<QTimerEvent*>(e);
 …
+    }
+#ifdef QT_MAC_USE_COCOA
+    // In case the user clicked on a child window, we need to
+    // reestablish the stacking order of the window so
+    // it pops in front of other child windows in cocoa:
+    qt_cocoaStackChildWindowOnTopOfOtherChildren(window);
+#endif
     for(int i = 0; i < toBeDeactivated.size(); ++i) {
         QWidget *w = toBeDeactivated.at(i);
 …
 #elif defined(Q_WS_X11)
             qt_x11_enforce_cursor(cursorWidget, true);
 #elif defined(Q_WS_S60)
+#elif defined(Q_OS_SYMBIAN)
             qt_symbian_set_cursor(cursorWidget, true);
 #elif defined(Q_WS_PM)
 …
+}
 #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)
 /*
     This function should only be called when the widget changes visibility, i.e.
 …
 #endif // QT_NO_CURSOR
+}
 #endif // Q_WS_WIN || Q_WS_PM || Q_WS_X11
+#endif // Q_WS_WIN || Q_WS_X11 || Q_WS_MAC || Q_WS_PM
 /*!
 …
 void QApplication::setLayoutDirection(Qt::LayoutDirection direction)
+{
     if (layout_direction == direction)
+    if (layout_direction == direction || direction == Qt::LayoutDirectionAuto)
         return;
 …
+    }
+#ifndef QT_NO_GESTURES
     // walk through parents and check for gestures
     if (d->gestureManager) {
 …
+        }
+    }
+#endif // QT_NO_GESTURES
     // User input and window activation makes tooltips sleep
 …
         break;
+#ifndef QT_NO_GESTURES
     case QEvent::NativeGesture:
+    {
 …
                     for (int i = 0; i < gestures.size(); ++i) {
                         QGesture *g = gestures.at(i);
+                        if ((res && eventAccepted) || (!eventAccepted && ge.isAccepted(g))) {
+                        // Ignore res [event return value] because handling of multiple gestures
+                        // packed into a single QEvent depends on not consuming the event
+                        if (eventAccepted || ge.isAccepted(g)) {
                             // if the gesture was accepted, mark the target widget for it
                             gestureEvent->d_func()->targetWidgets[g->gestureType()] = w;
                             gestureEvent->setAccepted(g, true);
                         } else if (!eventAccepted && !ge.isAccepted(g)) {
+                        } else {
                             // if the gesture was explicitly ignored by the application,
                             // put it back so a parent can get it
 …
         break;
+    }
+#endif // QT_NO_GESTURES
     default:
         res = d->notify_helper(receiver, e);
 …
 */
+#ifndef QT_NO_IM
 // ************************************************************************
 // Input Method support
 …
     with \a inputContext.
+    Qt takes ownership of the given \a inputContext.
     \sa inputContext()
 */
 …
+{
 #ifndef QT_NO_IM
     Q_D(QApplication);
     Q_UNUSED(d);// only static members being used.
+    if (inputContext == QApplicationPrivate::inputContext)
+        return;
     if (!inputContext) {
         qWarning("QApplication::setInputContext: called with 0 input context");
         return;
+    }
+    delete d->inputContext;
+    d->inputContext = inputContext;
+    delete QApplicationPrivate::inputContext;
+    QApplicationPrivate::inputContext = inputContext;
+    QApplicationPrivate::inputContext->setParent(this);
 #endif
+}
 …
         that->d_func()->inputContext = qic;
+    }
 #elif defined(Q_WS_S60)
+#elif defined(Q_OS_SYMBIAN)
     if (!d->inputContext) {
         QApplication *that = const_cast<QApplication *>(this);
+        that->d_func()->inputContext = QInputContextFactory::create(QString::fromLatin1("coefep"), that);
+        const QStringList keys = QInputContextFactory::keys();
+        // Try hbim and coefep first, then try others.
+        if (keys.contains(QLatin1String("hbim"))) {
+            that->d_func()->inputContext = QInputContextFactory::create(QLatin1String("hbim"), that);
+        } else if (keys.contains(QLatin1String("coefep"))) {
+            that->d_func()->inputContext = QInputContextFactory::create(QLatin1String("coefep"), that);
+        } else {
+            for (int c = 0; c < keys.size() && !d->inputContext; ++c) {
+                that->d_func()->inputContext = QInputContextFactory::create(keys[c], that);
+            }
+        }
+    }
 #endif
 …
 #endif
+}
+#endif // QT_NO_IM
 //Returns the current platform used by keyBindings
 …
+}
+#ifndef QT_NO_GESTURES
 QGestureManager* QGestureManager::instance()
+{
+    QApplicationPrivate *qAppPriv = QApplicationPrivate::instance();
+    if (!qAppPriv->gestureManager)
+        qAppPriv->gestureManager = new QGestureManager(qApp);
+    return qAppPriv->gestureManager;
+    if (QApplicationPrivate *qAppPriv = QApplicationPrivate::instance()) {
+        if (!qAppPriv->gestureManager)
+            qAppPriv->gestureManager = new QGestureManager(qApp);
+        return qAppPriv->gestureManager;
+    }
+    return 0;
+}
+#endif // QT_NO_GESTURES
+// These pixmaps approximate the images in the Windows User Interface Guidelines.
+// XPM
+static const char * const move_xpm[] = {
+"11 20 3 1",
+".        c None",
+#if defined(Q_WS_WIN)
+"a        c #000000",
+"X        c #FFFFFF", // Windows cursor is traditionally white
+#else
+"a        c #FFFFFF",
+"X        c #000000", // X11 cursor is traditionally black
+#endif
+"aa.........",
+"aXa........",
+"aXXa.......",
+"aXXXa......",
+"aXXXXa.....",
+"aXXXXXa....",
+"aXXXXXXa...",
+"aXXXXXXXa..",
+"aXXXXXXXXa.",
+"aXXXXXXXXXa",
+"aXXXXXXaaaa",
+"aXXXaXXa...",
+"aXXaaXXa...",
+"aXa..aXXa..",
+"aa...aXXa..",
+"a.....aXXa.",
+"......aXXa.",
+".......aXXa",
+".......aXXa",
+"........aa."};
+#ifdef Q_WS_WIN
+/* XPM */
+static const char * const ignore_xpm[] = {
+"24 30 3 1",
+".        c None",
+"a        c #000000",
+"X        c #FFFFFF",
+"aa......................",
+"aXa.....................",
+"aXXa....................",
+"aXXXa...................",
+"aXXXXa..................",
+"aXXXXXa.................",
+"aXXXXXXa................",
+"aXXXXXXXa...............",
+"aXXXXXXXXa..............",
+"aXXXXXXXXXa.............",
+"aXXXXXXaaaa.............",
+"aXXXaXXa................",
+"aXXaaXXa................",
+"aXa..aXXa...............",
+"aa...aXXa...............",
+"a.....aXXa..............",
+"......aXXa.....XXXX.....",
+".......aXXa..XXaaaaXX...",
+".......aXXa.XaaaaaaaaX..",
+"........aa.XaaaXXXXaaaX.",
+"...........XaaaaX..XaaX.",
+"..........XaaXaaaX..XaaX",
+"..........XaaXXaaaX.XaaX",
+"..........XaaX.XaaaXXaaX",
+"..........XaaX..XaaaXaaX",
+"...........XaaX..XaaaaX.",
+"...........XaaaXXXXaaaX.",
+"............XaaaaaaaaX..",
+".............XXaaaaXX...",
+"...............XXXX....."};
+#endif
+/* XPM */
+static const char * const copy_xpm[] = {
+"24 30 3 1",
+".        c None",
+"a        c #000000",
+"X        c #FFFFFF",
+#if defined(Q_WS_WIN) // Windows cursor is traditionally white
+"aa......................",
+"aXa.....................",
+"aXXa....................",
+"aXXXa...................",
+"aXXXXa..................",
+"aXXXXXa.................",
+"aXXXXXXa................",
+"aXXXXXXXa...............",
+"aXXXXXXXXa..............",
+"aXXXXXXXXXa.............",
+"aXXXXXXaaaa.............",
+"aXXXaXXa................",
+"aXXaaXXa................",
+"aXa..aXXa...............",
+"aa...aXXa...............",
+"a.....aXXa..............",
+"......aXXa..............",
+".......aXXa.............",
+".......aXXa.............",
+"........aa...aaaaaaaaaaa",
+#else
+"XX......................",
+"XaX.....................",
+"XaaX....................",
+"XaaaX...................",
+"XaaaaX..................",
+"XaaaaaX.................",
+"XaaaaaaX................",
+"XaaaaaaaX...............",
+"XaaaaaaaaX..............",
+"XaaaaaaaaaX.............",
+"XaaaaaaXXXX.............",
+"XaaaXaaX................",
+"XaaXXaaX................",
+"XaX..XaaX...............",
+"XX...XaaX...............",
+"X.....XaaX..............",
+"......XaaX..............",
+".......XaaX.............",
+".......XaaX.............",
+"........XX...aaaaaaaaaaa",
+#endif
+".............aXXXXXXXXXa",
+".............aXXXXXXXXXa",
+".............aXXXXaXXXXa",
+".............aXXXXaXXXXa",
+".............aXXaaaaaXXa",
+".............aXXXXaXXXXa",
+".............aXXXXaXXXXa",
+".............aXXXXXXXXXa",
+".............aXXXXXXXXXa",
+".............aaaaaaaaaaa"};
+/* XPM */
+static const char * const link_xpm[] = {
+"24 30 3 1",
+".        c None",
+"a        c #000000",
+"X        c #FFFFFF",
+#if defined(Q_WS_WIN) // Windows cursor is traditionally white
+"aa......................",
+"aXa.....................",
+"aXXa....................",
+"aXXXa...................",
+"aXXXXa..................",
+"aXXXXXa.................",
+"aXXXXXXa................",
+"aXXXXXXXa...............",
+"aXXXXXXXXa..............",
+"aXXXXXXXXXa.............",
+"aXXXXXXaaaa.............",
+"aXXXaXXa................",
+"aXXaaXXa................",
+"aXa..aXXa...............",
+"aa...aXXa...............",
+"a.....aXXa..............",
+"......aXXa..............",
+".......aXXa.............",
+".......aXXa.............",
+"........aa...aaaaaaaaaaa",
+#else
+"XX......................",
+"XaX.....................",
+"XaaX....................",
+"XaaaX...................",
+"XaaaaX..................",
+"XaaaaaX.................",
+"XaaaaaaX................",
+"XaaaaaaaX...............",
+"XaaaaaaaaX..............",
+"XaaaaaaaaaX.............",
+"XaaaaaaXXXX.............",
+"XaaaXaaX................",
+"XaaXXaaX................",
+"XaX..XaaX...............",
+"XX...XaaX...............",
+"X.....XaaX..............",
+"......XaaX..............",
+".......XaaX.............",
+".......XaaX.............",
+"........XX...aaaaaaaaaaa",
+#endif
+".............aXXXXXXXXXa",
+".............aXXXaaaaXXa",
+".............aXXXXaaaXXa",
+".............aXXXaaaaXXa",
+".............aXXaaaXaXXa",
+".............aXXaaXXXXXa",
+".............aXXaXXXXXXa",
+".............aXXXaXXXXXa",
+".............aXXXXXXXXXa",
+".............aaaaaaaaaaa"};
+QPixmap QApplicationPrivate::getPixmapCursor(Qt::CursorShape cshape)
+{
+#if defined(Q_WS_X11) || defined(Q_WS_WIN)
+    if (!move_cursor) {
+        move_cursor = new QPixmap((const char **)move_xpm);
+        copy_cursor = new QPixmap((const char **)copy_xpm);
+        link_cursor = new QPixmap((const char **)link_xpm);
+#ifdef Q_WS_WIN
+        ignore_cursor = new QPixmap((const char **)ignore_xpm);
+#endif
+    }
+    switch (cshape) {
+    case Qt::DragMoveCursor:
+        return *move_cursor;
+    case Qt::DragCopyCursor:
+        return *copy_cursor;
+    case Qt::DragLinkCursor:
+        return *link_cursor;
+#ifdef Q_WS_WIN
+    case Qt::ForbiddenCursor:
+        return *ignore_cursor;
+#endif
+    default:
+        break;
+    }
+#endif
+    return QPixmap();
+}
+QString QApplicationPrivate::qmljsDebugArgumentsString()
+{
+    return qmljs_debug_arguments;
+}

trunk/src/gui/kernel/qapplication.h

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 QT_BEGIN_HEADER
 #if defined(Q_WS_S60)
+#if defined(Q_OS_SYMBIAN)
 class CApaApplication;
 #endif
 …
     enum Type { Tty, GuiClient, GuiServer };
 #ifdef Q_WS_S60
+#ifdef Q_OS_SYMBIAN
     typedef CApaApplication * (*QS60MainApplicationFactory)();
 #endif
 …
     QApplication(Display *dpy, int &argc, char **argv, Qt::HANDLE visual = 0, Qt::HANDLE cmap= 0, int = QT_VERSION);
 #endif
 #if defined(Q_WS_S60)
+#if defined(Q_OS_SYMBIAN)
     QApplication(QApplication::QS60MainApplicationFactory factory, int &argc, char **argv, int = QT_VERSION);
 #endif
 …
     virtual void saveState(QSessionManager& sm);
 #endif
+#ifndef QT_NO_IM
     void setInputContext(QInputContext *);
     QInputContext *inputContext() const;
+#endif
     static QLocale keyboardInputLocale();
 …
     QApplication(Display *dpy, int &argc, char **argv, Qt::HANDLE visual = 0, Qt::HANDLE cmap= 0);
 #endif
 #if defined(Q_WS_S60) || defined(qdoc)
+#if defined(Q_OS_SYMBIAN) || defined(qdoc)
     QApplication(QApplication::QS60MainApplicationFactory factory, int &argc, char **argv);
 #endif
 …
     friend class QGraphicsWidget;
+    friend class QGraphicsItem;
     friend class QGraphicsScene;
     friend class QGraphicsScenePrivate;
 …
     friend class QDirectPainterPrivate;
 #endif
+#ifndef QT_NO_GESTURES
     friend class QGestureManager;
+#endif
 #if defined(Q_WS_MAC) || defined(Q_WS_X11)
 …
     Q_PRIVATE_SLOT(d_func(), void _q_readRX71MultiTouchEvents())
 #endif
+#if defined(Q_OS_SYMBIAN)
+    Q_PRIVATE_SLOT(d_func(), void _q_aboutToQuit())
+#endif
 };

trunk/src/gui/kernel/qapplication_mac.mm

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 static bool qt_mac_collapse_on_dblclick = true;
 extern int qt_antialiasing_threshold; // from qapplication.cpp
+QPointer<QWidget> qt_button_down;                // widget got last button-down
+QWidget * qt_button_down;                // widget got last button-down
+QPointer<QWidget> qt_last_mouse_receiver;
 #ifndef QT_MAC_USE_COCOA
 static bool qt_button_down_in_content; // whether the button_down was in the content area.
 …
 static void qt_mac_update_child_gl_widgets(QWidget *widget)
+{
-    if (widget->isWindow())
-        return;
     // Update all OpenGL child widgets for the given widget.
     QList<QWidgetPrivate::GlWidgetInfo> &glWidgets = qt_widget_private(widget)->glWidgets;
 …
 #endif
         if (!app_proc_ae_handlerUPP) {
+        if (!app_proc_ae_handlerUPP && !QApplication::testAttribute(Qt::AA_MacPluginApplication)) {
             app_proc_ae_handlerUPP = AEEventHandlerUPP(QApplicationPrivate::globalAppleEventProcessor);
+            for(uint i = 0; i < sizeof(app_apple_events) / sizeof(QMacAppleEventTypeSpec); ++i)
+                AEInstallEventHandler(app_apple_events[i].mac_class, app_apple_events[i].mac_id,
+                        app_proc_ae_handlerUPP, SRefCon(qApp), false);
+            for(uint i = 0; i < sizeof(app_apple_events) / sizeof(QMacAppleEventTypeSpec); ++i) {
+                // Install apple event handler, but avoid overwriting an already
+                // existing handler (it means a 3rd party application has installed one):
+                SRefCon refCon = 0;
+                AEEventHandlerUPP current_handler = NULL;
+                AEGetEventHandler(app_apple_events[i].mac_class, app_apple_events[i].mac_id, &current_handler, &refCon, false);
+                if (!current_handler)
+                    AEInstallEventHandler(app_apple_events[i].mac_class, app_apple_events[i].mac_id,
+                            app_proc_ae_handlerUPP, SRefCon(qApp), false);
+            }
+        }
 …
     // Cocoa application delegate
 #ifdef QT_MAC_USE_COCOA
     NSApplication *cocoaApp = [NSApplication sharedApplication];
+    NSApplication *cocoaApp = [QNSApplication sharedApplication];
     QMacCocoaAutoReleasePool pool;
     NSObject *oldDelegate = [cocoaApp delegate];
 …
         [newDelegate setMenuLoader:qtMenuLoader];
         [qtMenuLoader release];
-        NSAppleEventManager *eventManager = [NSAppleEventManager sharedAppleEventManager];
-        [eventManager setEventHandler:newDelegate andSelector:@selector(getUrl:withReplyEvent:)
-          forEventClass:kInternetEventClass andEventID:kAEGetURL];
+    }
 #endif
 …
   QApplication cursor stack
  *****************************************************************************/
+#ifdef QT_MAC_USE_COCOA
+void QApplicationPrivate::disableUsageOfCursorRects(bool disable)
+{
+    // In Cocoa there are two competing ways of setting the cursor; either
+    // by using cursor rects (see qcocoaview_mac.mm), or by pushing/popping
+    // the cursor manually. When we use override cursors, it makes most sense
+    // to use the latter. But then we need to tell cocoa to stop using the
+    // first approach so it doesn't change the cursor back when hovering over
+    // a cursor rect:
+    QWidgetList topLevels = qApp->topLevelWidgets();
+    for (int i=0; i<topLevels.size(); ++i) {
+        if (NSWindow *window = qt_mac_window_for(topLevels.at(i)))
+            disable ? [window disableCursorRects] : [window enableCursorRects];
+    }
+}
+void QApplicationPrivate::updateOverrideCursor()
+{
+    // Sometimes Cocoa forgets that we have set a Cursor
+    // manually. In those cases, remind it again:
+    if (QCursor *override = qApp->overrideCursor())
+        [static_cast<NSCursor *>(qt_mac_nsCursorForQCursor(*override)) set];
+}
+#endif
 void QApplication::setOverrideCursor(const QCursor &cursor)
+{
 …
 #ifdef QT_MAC_USE_COCOA
     QMacCocoaAutoReleasePool pool;
+    if (qApp->d_func()->cursor_list.size() == 1)
+        qApp->d_func()->disableUsageOfCursorRects(true);
     [static_cast<NSCursor *>(qt_mac_nsCursorForQCursor(cursor)) push];
 #else
 …
     QMacCocoaAutoReleasePool pool;
     [NSCursor pop];
+    if (qApp->d_func()->cursor_list.isEmpty())
+        qApp->d_func()->disableUsageOfCursorRects(false);
 #else
     if (qApp && qApp->activeWindow()) {
 …
             // As a results of this, and to make sure we dont't receive duplicate events,
             // we try to detect when this happend by checking the 'compatibilityEvent'.
+            // Since delta is delivered as pixels rather than degrees, we need to
+            // convert from pixels to degrees in a sensible manner.
+            // It looks like 1/4 degrees per pixel behaves most native.
+            // (NB: Qt expects the unit for delta to be 8 per degree):
+            const int pixelsToDegrees = 2;
             SInt32 mdelt = 0;
             GetEventParameter(event, kEventParamMouseWheelSmoothHorizontalDelta, typeSInt32, 0,
                               sizeof(mdelt), 0, &mdelt);
             wheel_deltaX = mdelt;
+            wheel_deltaX = mdelt * pixelsToDegrees;
             mdelt = 0;
             GetEventParameter(event, kEventParamMouseWheelSmoothVerticalDelta, typeSInt32, 0,
                               sizeof(mdelt), 0, &mdelt);
             wheel_deltaY = mdelt;
+            wheel_deltaY = mdelt * pixelsToDegrees;
             GetEventParameter(event, kEventParamEventRef, typeEventRef, 0,
                               sizeof(compatibilityEvent), 0, &compatibilityEvent);
 …
             if(!handled_event) {
                 if(cmd.commandID == kHICommandQuit) {
+                    handled_event = true;
+                    HiliteMenu(0);
+                    bool handle_quit = true;
+                    if(QApplicationPrivate::modalState()) {
+                        int visible = 0;
+                        const QWidgetList tlws = QApplication::topLevelWidgets();
+                        for(int i = 0; i < tlws.size(); ++i) {
+                            if(tlws.at(i)->isVisible())
+                                ++visible;
+                    // Quitting the application is not Qt's responsibility if
+                    // used in a plugin or just embedded into a native application.
+                    // In that case, let the event pass down to the native apps event handler.
+                    if (!QApplication::testAttribute(Qt::AA_MacPluginApplication)) {
+                        handled_event = true;
+                        HiliteMenu(0);
+                        bool handle_quit = true;
+                        if(QApplicationPrivate::modalState()) {
+                            int visible = 0;
+                            const QWidgetList tlws = QApplication::topLevelWidgets();
+                            for(int i = 0; i < tlws.size(); ++i) {
+                                if(tlws.at(i)->isVisible())
+                                    ++visible;
+                            }
+                            handle_quit = (visible <= 1);
+                        }
+                        handle_quit = (visible <= 1);
+                    }
+                    if(handle_quit) {
+                        QCloseEvent ev;
+                        QApplication::sendSpontaneousEvent(app, &ev);
+                        if(ev.isAccepted())
+                            app->quit();
+                    } else {
+                        QApplication::beep();
+                        if(handle_quit) {
+                            QCloseEvent ev;
+                            QApplication::sendSpontaneousEvent(app, &ev);
+                            if(ev.isAccepted())
+                                app->quit();
+                        } else {
+                            QApplication::beep();
+                        }
+                    }
                 } else if(cmd.commandID == kHICommandSelectWindow) {
 …
 #endif
+}
+#ifdef QT_MAC_USE_COCOA
+void QApplicationPrivate::qt_initAfterNSAppStarted()
+{
+    setupAppleEvents();
+    updateOverrideCursor();
+}
+void QApplicationPrivate::setupAppleEvents()
+{
+    // This function is called from the event dispatcher when NSApplication has
+    // finished initialization, which appears to be just after [NSApplication run] has
+    // started to execute. By setting up our apple events handlers this late, we override
+    // the ones set up by NSApplication.
+    // If Qt is used as a plugin, we let the 3rd party application handle events
+    // like quit and open file events. Otherwise, if we install our own handlers, we
+    // easily end up breaking functionallity the 3rd party application depend on:
+    if (QApplication::testAttribute(Qt::AA_MacPluginApplication))
+        return;
+    QT_MANGLE_NAMESPACE(QCocoaApplicationDelegate) *newDelegate = [QT_MANGLE_NAMESPACE(QCocoaApplicationDelegate) sharedDelegate];
+    NSAppleEventManager *eventManager = [NSAppleEventManager sharedAppleEventManager];
+    [eventManager setEventHandler:newDelegate andSelector:@selector(appleEventQuit:withReplyEvent:)
+     forEventClass:kCoreEventClass andEventID:kAEQuitApplication];
+    [eventManager setEventHandler:newDelegate andSelector:@selector(getUrl:withReplyEvent:)
+      forEventClass:kInternetEventClass andEventID:kAEGetURL];
+}
+#endif
 // In Carbon this is your one stop for apple events.
 …
     QMenuBar::macUpdateMenuBar();
+    QApplicationPrivate::updateOverrideCursor();
 #else
     Q_UNUSED(widget);

trunk/src/gui/kernel/qapplication_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 class QWidget;
 class QSocketNotifier;
+#ifndef QT_NO_GESTURES
 class QGestureManager;
+#endif
 extern bool qt_is_gui_used;
 …
 typedef BOOL (WINAPI *PtrCloseTouchInputHandle)(HANDLE);
+#ifndef QT_NO_GESTURES
 typedef BOOL (WINAPI *PtrGetGestureInfo)(HANDLE, PVOID);
 typedef BOOL (WINAPI *PtrGetGestureExtraArgs)(HANDLE, UINT, PBYTE);
 …
 #endif
+#endif // QT_NO_GESTURES
 #endif // Q_WS_WIN
 …
     static QGraphicsSystem *graphics_system;
     static QString graphics_system_name;
+    static bool runtime_graphics_system;
 private:
 …
     static bool widgetCount; // Coupled with -widgetcount switch
     static bool load_testability; // Coupled with -testability switch
+    static QString qmljs_debug_arguments; // a string containing arguments for js/qml debugging.
+    static QString qmljsDebugArgumentsString(); // access string from other libraries
 #ifdef Q_WS_MAC
     static bool native_modal_dialog_active;
 …
     static OSStatus globalAppleEventProcessor(const AppleEvent *, AppleEvent *, long);
     static OSStatus tabletProximityCallback(EventHandlerCallRef, EventRef, void *);
+#ifdef QT_MAC_USE_COCOA
+    static void qt_initAfterNSAppStarted();
+    static void setupAppleEvents();
+    static void updateOverrideCursor();
+    static void disableUsageOfCursorRects(bool disable);
+#endif
     static bool qt_mac_apply_settings();
 #endif
 …
     int symbianResourceChange(const QSymbianEvent *symbianEvent);
+#endif
+#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined (Q_WS_QWS) || defined(Q_WS_PM)
+    void _q_aboutToQuit();
+#endif
+#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined (Q_WS_QWS) || defined(Q_WS_MAC) || defined(Q_WS_PM)
     void sendSyntheticEnterLeave(QWidget *widget);
 #endif
 …
 #endif
+#ifndef QT_NO_GESTURES
     QGestureManager *gestureManager;
     QWidget *gestureWidget;
+#endif
+#if defined(Q_WS_X11) || defined(Q_WS_WIN)
+    QPixmap *move_cursor;
+    QPixmap *copy_cursor;
+    QPixmap *link_cursor;
+#endif
+#if defined(Q_WS_WIN)
+    QPixmap *ignore_cursor;
+#endif
+    QPixmap getPixmapCursor(Qt::CursorShape cshape);
     QMap<int, QWeakPointer<QWidget> > widgetForTouchPointId;
 …
     bool translateTouchEvent(const MSG &msg);
+#ifndef QT_NO_GESTURES
     PtrGetGestureInfo GetGestureInfo;
     PtrGetGestureExtraArgs GetGestureExtraArgs;
 …
     PtrUpdatePanningFeedback UpdatePanningFeedback;
     PtrEndPanningFeedback EndPanningFeedback;
+#endif // QT_NO_GESTURES
 #endif
 …
 #ifdef Q_OS_SYMBIAN
     static QHash<TInt, TUint> scanCodeCache;
+    QHash<TInt, TUint> scanCodeCache;
 #endif

trunk/src/gui/kernel/qapplication_qws.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qapplication_s60.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include "private/qmenubar_p.h"
 #include "private/qsoftkeymanager_p.h"
+#ifdef QT_GRAPHICSSYSTEM_RUNTIME
+#include "private/qgraphicssystem_runtime_p.h"
+#endif
 #include "apgwgnam.h" // For CApaWindowGroupName
 #include <mdaaudiotoneplayer.h>     // For CMdaAudioToneUtility
+#if defined(Q_WS_S60)
+# if !defined(QT_NO_IM)
+#  include "qinputcontext.h"
+#  include <private/qcoefepinputcontext_p.h>
+# endif
+#if defined(Q_OS_SYMBIAN)
 # include <private/qs60mainapplication_p.h>
 # include <centralrepository.h>
 # include "qs60mainappui.h"
+# include "qinputcontext.h"
+#endif
+#if defined(Q_WS_S60)
+# if !defined(QT_NO_IM)
+#  include <private/qcoefepinputcontext_p.h>
+# endif
 #endif
 …
 #include <hal_data.h>
+#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
+#include <graphics/wstfxconst.h>
+#endif
 QT_BEGIN_NAMESPACE
+// Goom Events through Window Server
+static const int KGoomMemoryLowEvent = 0x10282DBF;
+static const int KGoomMemoryGoodEvent = 0x20026790;
 #if defined(QT_DEBUG)
 …
+{
     return qt_s60Data();
+}
+#ifdef Q_WS_S60
+void QS60Data::setStatusPaneAndButtonGroupVisibility(bool statusPaneVisible, bool buttonGroupVisible)
+{
+    bool buttonGroupVisibilityChanged = false;
+    if (CEikButtonGroupContainer *const b = buttonGroupContainer()) {
+        buttonGroupVisibilityChanged = (b->IsVisible() != buttonGroupVisible);
+        b->MakeVisible(buttonGroupVisible);
+    }
+    bool statusPaneVisibilityChanged = false;
+    if (CEikStatusPane *const s = statusPane()) {
+        statusPaneVisibilityChanged = (s->IsVisible() != statusPaneVisible);
+        s->MakeVisible(statusPaneVisible);
+    }
+    if (buttonGroupVisibilityChanged  || statusPaneVisibilityChanged) {
+        const QSize size = qt_TRect2QRect(static_cast<CEikAppUi*>(S60->appUi())->ClientRect()).size();
+        const QSize oldSize; // note that QDesktopWidget::resizeEvent ignores the QResizeEvent contents
+        QResizeEvent event(size, oldSize);
+        QApplication::instance()->sendEvent(QApplication::desktop(), &event);
+    }
+    if (buttonGroupVisibilityChanged  && !statusPaneVisibilityChanged && QApplication::activeWindow())
+        // Ensure that control rectangle is updated
+        static_cast<QSymbianControl *>(QApplication::activeWindow()->winId())->handleClientAreaChange();
+}
+#endif
+void QS60Data::controlVisibilityChanged(CCoeControl *control, bool visible)
+{
+    if (QWidgetPrivate::mapper && QWidgetPrivate::mapper->contains(control)) {
+        QWidget *const widget = QWidgetPrivate::mapper->value(control);
+        QWidget *const window = widget->window();
+        if (QTLWExtra *topData = qt_widget_private(window)->maybeTopData()) {
+            QWidgetBackingStoreTracker &backingStore = topData->backingStore;
+            if (visible) {
+                if (backingStore.data()) {
+                    backingStore.registerWidget(widget);
+                } else {
+                    backingStore.create(window);
+                    backingStore.registerWidget(widget);
+                    qt_widget_private(widget)->invalidateBuffer(widget->rect());
+                    widget->repaint();
+                }
+            } else {
+                backingStore.unregisterWidget(widget);
+                // In order to ensure that any resources used by the window surface
+                // are immediately freed, we flush the WSERV command buffer.
+                S60->wsSession().Flush();
+            }
+        }
+    }
+}
 …
-QHash<TInt, TUint> QApplicationPrivate::scanCodeCache;
 static Qt::KeyboardModifiers mapToQtModifiers(TUint s60Modifiers)
+{
 …
     if (!desktop)
+    {
         if (isWindowOwning or !qwidget->parentWidget())
+        if (isWindowOwning || !qwidget->parentWidget())
             CreateWindowL(S60->windowGroup());
         else
 …
         SetFocusing(true);
         m_longTapDetector = QLongTapTimer::NewL(this);
+        m_doubleClickTimer.invalidate();
         DrawableWindow()->SetPointerGrab(ETrue);
+    }
+#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
+    if (OwnsWindow()) {
+        TTfxWindowPurpose windowPurpose(ETfxPurposeNone);
+        switch (qwidget->windowType()) {
+        case Qt::Dialog:
+            windowPurpose = ETfxPurposeDialogWindow;
+            break;
+        case Qt::Popup:
+            windowPurpose = ETfxPurposePopupWindow;
+            break;
+        case Qt::Tool:
+            windowPurpose = ETfxPurposeToolWindow;
+            break;
+        case Qt::ToolTip:
+            windowPurpose = ETfxPurposeToolTipWindow;
+            break;
+        case Qt::SplashScreen:
+            windowPurpose = ETfxPurposeSplashScreenWindow;
+            break;
+        default:
+            windowPurpose = (isWindowOwning || !qwidget->parentWidget())
+                            ? ETfxPurposeWindow : ETfxPurposeChildWindow;
+            break;
+        }
+        Window().SetPurpose(windowPurpose);
+    }
+#endif
+}
 QSymbianControl::~QSymbianControl()
+{
+    // Ensure backing store is deleted before the top-level
+    // window is destroyed
+    qt_widget_private(qwidget)->topData()->backingStore.destroy();
     if (S60->curWin == this)
         S60->curWin = 0;
 …
+{
     QApplicationPrivate *d = QApplicationPrivate::instance();
+    QPointF screenPos = qwidget->mapToGlobal(QPoint(event->iPosition.iX, event->iPosition.iY));
     qreal pressure;
     if(d->pressureSupported
 …
     else
         pressure = qreal(1.0);
+    processTouchEvent(event->PointerNumber(), event->iType, screenPos, pressure);
+}
+#endif
+void QSymbianControl::processTouchEvent(int pointerNumber, TPointerEvent::TType type, QPointF screenPos, qreal pressure)
+{
     QRect screenGeometry = qApp->desktop()->screenGeometry(qwidget);
+    QApplicationPrivate *d = QApplicationPrivate::instance();
     QList<QTouchEvent::TouchPoint> points = d->appAllTouchPoints;
     while (points.count() <= event->PointerNumber())
+    while (points.count() <= pointerNumber)
         points.append(QTouchEvent::TouchPoint(points.count()));
 …
         QTouchEvent::TouchPoint &touchPoint = points[i];
         if (touchPoint.id() == event->PointerNumber()) {
+        if (touchPoint.id() == pointerNumber) {
             Qt::TouchPointStates state;
             switch (event->iType) {
+            switch (type) {
             case TPointerEvent::EButton1Down:
+#ifdef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER
             case TPointerEvent::EEnterHighPressure:
+#endif
                 state = Qt::TouchPointPressed;
                 break;
             case TPointerEvent::EButton1Up:
+#ifdef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER
             case TPointerEvent::EExitCloseProximity:
+#endif
                 state = Qt::TouchPointReleased;
                 break;
 …
                 break;
+            }
             if (event->PointerNumber() == 0)
+            if (pointerNumber == 0)
                 state |= Qt::TouchPointPrimary;
             touchPoint.setState(state);
-            QPointF screenPos = qwidget->mapToGlobal(QPoint(event->iPosition.iX, event->iPosition.iY));
             touchPoint.setScreenPos(screenPos);
             touchPoint.setNormalizedPos(QPointF(screenPos.x() / screenGeometry.width(),
 …
                                                 points);
+}
-#endif
 void QSymbianControl::HandlePointerEventL(const TPointerEvent& pEvent)
 …
 #endif
+//Generate single touch event for S60 5.0 (has touchscreen, does not have advanced pointers)
+#ifndef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER
+    if (S60->hasTouchscreen) {
+        processTouchEvent(0, pEvent.iType, QPointF(globalPos), 1.0);
+    }
+#endif
     sendMouseEvent(receiver, type, globalPos, button, modifiers);
+}
 …
 TKeyResponse QSymbianControl::OfferKeyEvent(const TKeyEvent& keyEvent, TEventCode type)
+{
+    switch (type) {
+    //case EEventKeyDown: // <-- Intentionally left out. See below.
+    case EEventKeyUp:
+    case EEventKey:
+    {
+        // S60 has a confusing way of delivering key events. There are three types of
+        // events: EKeyEvent, EKeyEventDown and EKeyEventUp. When a key is pressed, the
+        // two first events are generated. When releasing the key, the last one is
+        // generated.
+        // Because S60 does not generate keysyms for EKeyEventDown and EKeyEventUp events,
+        // we need to do some special tricks to map it to the Qt way. First, we completely
+        // discard EKeyEventDown events, since they are redundant. Second, since
+        // EKeyEventUp does not give us a keysym, we need to cache the keysyms from
+        // the EKeyEvent events. This is what resolveS60ScanCode does.
+        // ### hackish way to send Qt application to background when pressing right softkey
+        /*
+        if( keyEvent.iScanCode == EStdKeyDevice1 ) {
+            S60->window_group->SetOrdinalPosition(-1);
+            qApp->setActiveWindow(0);
+            return EKeyWasNotConsumed;
+        }
+        */
+        TUint s60Keysym = QApplicationPrivate::resolveS60ScanCode(keyEvent.iScanCode,
+                keyEvent.iCode);
+        int keyCode;
+        if (s60Keysym == EKeyNull){ //some key events have 0 in iCode, for them iScanCode should be used
+            keyCode = qt_keymapper_private()->mapS60ScanCodesToQt(keyEvent.iScanCode);
+        } else if (s60Keysym >= 0x20 && s60Keysym < ENonCharacterKeyBase) {
+            // Normal characters keys.
+            keyCode = s60Keysym;
+    /*
+      S60 has a confusing way of delivering key events. There are three types of
+      events: EEventKey, EEventKeyDown and EEventKeyUp. When a key is pressed,
+      EEventKeyDown is first generated, followed by EEventKey. Then, when the key is
+      released, EEventKeyUp is generated.
+      However, it is possible that only the EEventKey is generated alone, typically
+      in relation to virtual keyboards. In that case we need to take care to
+      generate both press and release events in Qt, since applications expect that.
+      We do this by having three states for each used scan code, depending on the
+      events received. See the switch below for what happens in each state
+      transition.
+    */
+    if (type != EEventKeyDown)
+        if (handleVirtualMouse(keyEvent, type) == EKeyWasConsumed)
+            return EKeyWasConsumed;
+    TKeyResponse ret = EKeyWasNotConsumed;
+#define GET_RETURN(x) (ret = ((x) == EKeyWasConsumed) ? EKeyWasConsumed : ret)
+    // This top level switch corresponds to the states, and the inner switches
+    // correspond to the transitions.
+    QS60Data::ScanCodeState &scanCodeState = S60->scanCodeStates[keyEvent.iScanCode];
+    switch (scanCodeState) {
+    case QS60Data::Unpressed:
+        switch (type) {
+        case EEventKeyDown:
+            scanCodeState = QS60Data::KeyDown;
+            break;
+        case EEventKey:
+            GET_RETURN(sendSymbianKeyEvent(keyEvent, QEvent::KeyPress));
+            GET_RETURN(sendSymbianKeyEvent(keyEvent, QEvent::KeyRelease));
+            break;
+        case EEventKeyUp:
+            // No action.
+            break;
+        }
+        break;
+    case QS60Data::KeyDown:
+        switch (type) {
+        case EEventKeyDown:
+            // This should never happen, just stay in this state to be safe.
+            break;
+        case EEventKey:
+            GET_RETURN(sendSymbianKeyEvent(keyEvent, QEvent::KeyPress));
+            scanCodeState = QS60Data::KeyDownAndKey;
+            break;
+        case EEventKeyUp:
+            scanCodeState = QS60Data::Unpressed;
+            break;
+        }
+        break;
+    case QS60Data::KeyDownAndKey:
+        switch (type) {
+        case EEventKeyDown:
+            // This should never happen, just stay in this state to be safe.
+            break;
+        case EEventKey:
+            GET_RETURN(sendSymbianKeyEvent(keyEvent, QEvent::KeyRelease));
+            GET_RETURN(sendSymbianKeyEvent(keyEvent, QEvent::KeyPress));
+            break;
+        case EEventKeyUp:
+            GET_RETURN(sendSymbianKeyEvent(keyEvent, QEvent::KeyRelease));
+            scanCodeState = QS60Data::Unpressed;
+            break;
+        }
+        break;
+    }
+    return ret;
+#undef GET_RETURN
+}
+TKeyResponse QSymbianControl::sendSymbianKeyEvent(const TKeyEvent &keyEvent, QEvent::Type type)
+{
+    // Because S60 does not generate keysyms for EKeyEventDown and EKeyEventUp
+    // events, we need to cache the keysyms from the EKeyEvent events. This is what
+    // resolveS60ScanCode does.
+    TUint s60Keysym = QApplicationPrivate::resolveS60ScanCode(keyEvent.iScanCode,
+            keyEvent.iCode);
+    int keyCode;
+    if (s60Keysym == EKeyNull){ //some key events have 0 in iCode, for them iScanCode should be used
+        keyCode = qt_keymapper_private()->mapS60ScanCodesToQt(keyEvent.iScanCode);
+    } else if (s60Keysym >= 0x20 && s60Keysym < ENonCharacterKeyBase) {
+        // Normal characters keys.
+        keyCode = s60Keysym;
+    } else {
+        // Special S60 keys.
+        keyCode = qt_keymapper_private()->mapS60KeyToQt(s60Keysym);
+    }
+    Qt::KeyboardModifiers mods = mapToQtModifiers(keyEvent.iModifiers);
+    QKeyEventEx qKeyEvent(type, keyCode, mods, qt_keymapper_private()->translateKeyEvent(keyCode, mods),
+            (keyEvent.iRepeats != 0), 1, keyEvent.iScanCode, s60Keysym, keyEvent.iModifiers);
+    QWidget *widget;
+    widget = QWidget::keyboardGrabber();
+    if (!widget) {
+        if (QApplicationPrivate::popupWidgets != 0) {
+            widget = QApplication::activePopupWidget()->focusWidget();
+            if (!widget) {
+                widget = QApplication::activePopupWidget();
+            }
         } else {
+            // Special S60 keys.
+            keyCode = qt_keymapper_private()->mapS60KeyToQt(s60Keysym);
+        }
+            widget = QApplicationPrivate::focus_widget;
+            if (!widget) {
+                widget = qwidget;
+            }
+        }
+    }
+    QEventDispatcherS60 *dispatcher;
+    // It is theoretically possible for someone to install a different event dispatcher.
+    if ((dispatcher = qobject_cast<QEventDispatcherS60 *>(widget->d_func()->threadData->eventDispatcher)) != 0) {
+        if (dispatcher->excludeUserInputEvents()) {
+            dispatcher->saveInputEvent(this, widget, new QKeyEventEx(qKeyEvent));
+            return EKeyWasConsumed;
+        }
+    }
+    return sendKeyEvent(widget, &qKeyEvent);
+}
+TKeyResponse QSymbianControl::handleVirtualMouse(const TKeyEvent& keyEvent,TEventCode type)
+{
 #ifndef QT_NO_CURSOR
+        if (S60->mouseInteractionEnabled && S60->virtualMouseRequired) {
+            //translate keys to pointer
+            if (keyCode >= Qt::Key_Left && keyCode <= Qt::Key_Down || keyCode == Qt::Key_Select) {
+                /*Explanation about virtualMouseAccel:
+                 Tapping an arrow key allows precise pixel positioning
+                 Holding an arrow key down, acceleration is applied to allow cursor
+                 to be quickly moved to another part of the screen by key repeats.
+                 */
+                if (S60->virtualMouseLastKey == keyCode) {
+                    S60->virtualMouseAccel *= 2;
+                    if (S60->virtualMouseAccel > S60->virtualMouseMaxAccel)
+                        S60->virtualMouseAccel = S60->virtualMouseMaxAccel;
+                }
+                else
+                    S60->virtualMouseAccel = 1;
+                S60->virtualMouseLastKey = keyCode;
+                QPoint pos = QCursor::pos();
+                TPointerEvent fakeEvent;
+                fakeEvent.iType = (TPointerEvent::TType)(-1);
+                TInt x = pos.x();
+                TInt y = pos.y();
+                if (type == EEventKeyUp) {
+                    if (keyCode == Qt::Key_Select &&
+                        (S60->virtualMousePressedKeys & QS60Data::Select))
+    if (S60->mouseInteractionEnabled && S60->virtualMouseRequired) {
+        //translate keys to pointer
+        if ((keyEvent.iScanCode >= EStdKeyLeftArrow && keyEvent.iScanCode <= EStdKeyDownArrow) ||
+                (keyEvent.iScanCode >= EStdKeyDevice10 && keyEvent.iScanCode <= EStdKeyDevice13) ||
+                keyEvent.iScanCode == EStdKeyDevice3) {
+            QPoint pos = QCursor::pos();
+            TPointerEvent fakeEvent;
+            fakeEvent.iType = (TPointerEvent::TType)(-1);
+            fakeEvent.iModifiers = keyEvent.iModifiers;
+            TInt x = pos.x();
+            TInt y = pos.y();
+            if (type == EEventKeyUp) {
+                S60->virtualMouseAccelTimeout.start();
+                switch (keyEvent.iScanCode) {
+                case EStdKeyLeftArrow:
+                    S60->virtualMousePressedKeys &= ~QS60Data::Left;
+                    break;
+                case EStdKeyRightArrow:
+                    S60->virtualMousePressedKeys &= ~QS60Data::Right;
+                    break;
+                case EStdKeyUpArrow:
+                    S60->virtualMousePressedKeys &= ~QS60Data::Up;
+                    break;
+                case EStdKeyDownArrow:
+                    S60->virtualMousePressedKeys &= ~QS60Data::Down;
+                    break;
+                // diagonal keys (named aliases don't exist in 3.1 SDK)
+                case EStdKeyDevice10:
+                    S60->virtualMousePressedKeys &= ~QS60Data::LeftUp;
+                    break;
+                case EStdKeyDevice11:
+                    S60->virtualMousePressedKeys &= ~QS60Data::RightUp;
+                    break;
+                case EStdKeyDevice12:
+                    S60->virtualMousePressedKeys &= ~QS60Data::RightDown;
+                    break;
+                case EStdKeyDevice13:
+                    S60->virtualMousePressedKeys &= ~QS60Data::LeftDown;
+                    break;
+                case EStdKeyDevice3: //select
+                    if (S60->virtualMousePressedKeys & QS60Data::Select)
                         fakeEvent.iType = TPointerEvent::EButton1Up;
+                    S60->virtualMouseAccel = 1;
+                    S60->virtualMouseLastKey = 0;
+                    switch (keyCode) {
+                    case Qt::Key_Left:
+                        S60->virtualMousePressedKeys &= ~QS60Data::Left;
+                        break;
+                    case Qt::Key_Right:
+                        S60->virtualMousePressedKeys &= ~QS60Data::Right;
+                        break;
+                    case Qt::Key_Up:
+                        S60->virtualMousePressedKeys &= ~QS60Data::Up;
+                        break;
+                    case Qt::Key_Down:
+                        S60->virtualMousePressedKeys &= ~QS60Data::Down;
+                        break;
+                    case Qt::Key_Select:
+                        S60->virtualMousePressedKeys &= ~QS60Data::Select;
+                        break;
+                    }
+                }
+                else if (type == EEventKey) {
+                    switch (keyCode) {
+                    case Qt::Key_Left:
+                        S60->virtualMousePressedKeys |= QS60Data::Left;
+                        x -= S60->virtualMouseAccel;
+                        fakeEvent.iType = TPointerEvent::EMove;
+                        break;
+                    case Qt::Key_Right:
+                        S60->virtualMousePressedKeys |= QS60Data::Right;
+                        x += S60->virtualMouseAccel;
+                        fakeEvent.iType = TPointerEvent::EMove;
+                        break;
+                    case Qt::Key_Up:
+                        S60->virtualMousePressedKeys |= QS60Data::Up;
+                        y -= S60->virtualMouseAccel;
+                        fakeEvent.iType = TPointerEvent::EMove;
+                        break;
+                    case Qt::Key_Down:
+                        S60->virtualMousePressedKeys |= QS60Data::Down;
+                        y += S60->virtualMouseAccel;
+                        fakeEvent.iType = TPointerEvent::EMove;
+                        break;
+                    case Qt::Key_Select:
+                        // Platform bug. If you start pressing several keys simultaneously (for
+                        // example for drag'n'drop), Symbian starts producing spurious up and
+                        // down messages for some keys. Therefore, make sure we have a clean slate
+                        // of pressed keys before starting a new button press.
+                        if (S60->virtualMousePressedKeys & QS60Data::Select) {
+                            return EKeyWasConsumed;
+                        } else {
+                            S60->virtualMousePressedKeys |= QS60Data::Select;
+                            fakeEvent.iType = TPointerEvent::EButton1Down;
+                        }
+                        break;
+                    }
+                }
+                //clip to screen size (window server allows a sprite hotspot to be outside the screen)
+                if (x < 0)
+                    x = 0;
+                else if (x >= S60->screenWidthInPixels)
+                    x = S60->screenWidthInPixels - 1;
+                if (y < 0)
+                    y = 0;
+                else if (y >= S60->screenHeightInPixels)
+                    y = S60->screenHeightInPixels - 1;
+                TPoint epos(x, y);
+                TPoint cpos = epos - PositionRelativeToScreen();
+                fakeEvent.iModifiers = keyEvent.iModifiers;
+                fakeEvent.iPosition = cpos;
+                fakeEvent.iParentPosition = epos;
+                if(fakeEvent.iType != -1)
+                    HandlePointerEvent(fakeEvent);
+                return EKeyWasConsumed;
+            }
+            else {
+                S60->virtualMouseLastKey = keyCode;
+                S60->virtualMouseAccel = 1;
+            }
+        }
+#endif
+        Qt::KeyboardModifiers mods = mapToQtModifiers(keyEvent.iModifiers);
+        QKeyEventEx qKeyEvent(type == EEventKeyUp ? QEvent::KeyRelease : QEvent::KeyPress, keyCode,
+                mods, qt_keymapper_private()->translateKeyEvent(keyCode, mods),
+                (keyEvent.iRepeats != 0), 1, keyEvent.iScanCode, s60Keysym, keyEvent.iModifiers);
+//        WId wid = reinterpret_cast<RWindowGroup *>(keyEvent.Handle())->Child();
+//        if (!wid)
+//             Could happen if window isn't shown yet.
+//            return EKeyWasNotConsumed;
+        QWidget *widget;
+        widget = QWidget::keyboardGrabber();
+        if (!widget) {
+            if (QApplicationPrivate::popupWidgets != 0) {
+                widget = QApplication::activePopupWidget()->focusWidget();
+                if (!widget) {
+                    widget = QApplication::activePopupWidget();
+                }
+            } else {
+                widget = QApplicationPrivate::focus_widget;
+                if (!widget) {
+                    widget = qwidget;
+                    S60->virtualMousePressedKeys &= ~QS60Data::Select;
+                    break;
+                }
+            }
+        }
+        QEventDispatcherS60 *dispatcher;
+        // It is theoretically possible for someone to install a different event dispatcher.
+        if ((dispatcher = qobject_cast<QEventDispatcherS60 *>(widget->d_func()->threadData->eventDispatcher)) != 0) {
+            if (dispatcher->excludeUserInputEvents()) {
+                dispatcher->saveInputEvent(this, widget, new QKeyEventEx(qKeyEvent));
+                return EKeyWasConsumed;
+            else if (type == EEventKey) {
+                int dx = 0;
+                int dy = 0;
+                if (keyEvent.iScanCode != EStdKeyDevice3) {
+                    m_doubleClickTimer.invalidate();
+                    //reset mouse accelleration after a short time with no moves
+                    const int maxTimeBetweenKeyEventsMs = 500;
+                    if (S60->virtualMouseAccelTimeout.isValid() &&
+                            S60->virtualMouseAccelTimeout.hasExpired(maxTimeBetweenKeyEventsMs)) {
+                        S60->virtualMouseAccelDX = 0;
+                        S60->virtualMouseAccelDY = 0;
+                    }
+                    S60->virtualMouseAccelTimeout.invalidate();
+                }
+                switch (keyEvent.iScanCode) {
+                case EStdKeyLeftArrow:
+                    S60->virtualMousePressedKeys |= QS60Data::Left;
+                    dx = -1;
+                    fakeEvent.iType = TPointerEvent::EMove;
+                    break;
+                case EStdKeyRightArrow:
+                    S60->virtualMousePressedKeys |= QS60Data::Right;
+                    dx = 1;
+                    fakeEvent.iType = TPointerEvent::EMove;
+                    break;
+                case EStdKeyUpArrow:
+                    S60->virtualMousePressedKeys |= QS60Data::Up;
+                    dy = -1;
+                    fakeEvent.iType = TPointerEvent::EMove;
+                    break;
+                case EStdKeyDownArrow:
+                    S60->virtualMousePressedKeys |= QS60Data::Down;
+                    dy = 1;
+                    fakeEvent.iType = TPointerEvent::EMove;
+                    break;
+                case EStdKeyDevice10:
+                    S60->virtualMousePressedKeys |= QS60Data::LeftUp;
+                    dx = -1;
+                    dy = -1;
+                    fakeEvent.iType = TPointerEvent::EMove;
+                    break;
+                case EStdKeyDevice11:
+                    S60->virtualMousePressedKeys |= QS60Data::RightUp;
+                    dx = 1;
+                    dy = -1;
+                    fakeEvent.iType = TPointerEvent::EMove;
+                    break;
+                case EStdKeyDevice12:
+                    S60->virtualMousePressedKeys |= QS60Data::RightDown;
+                    dx = 1;
+                    dy = 1;
+                    fakeEvent.iType = TPointerEvent::EMove;
+                    break;
+                case EStdKeyDevice13:
+                    S60->virtualMousePressedKeys |= QS60Data::LeftDown;
+                    dx = -1;
+                    dy = 1;
+                    fakeEvent.iType = TPointerEvent::EMove;
+                    break;
+                case EStdKeyDevice3:
+                    // Platform bug. If you start pressing several keys simultaneously (for
+                    // example for drag'n'drop), Symbian starts producing spurious up and
+                    // down messages for some keys. Therefore, make sure we have a clean slate
+                    // of pressed keys before starting a new button press.
+                    if (S60->virtualMousePressedKeys & QS60Data::Select) {
+                        return EKeyWasConsumed;
+                    } else {
+                        S60->virtualMousePressedKeys |= QS60Data::Select;
+                        fakeEvent.iType = TPointerEvent::EButton1Down;
+                        if (m_doubleClickTimer.isValid()
+                                && !m_doubleClickTimer.hasExpired(QApplication::doubleClickInterval())) {
+                            fakeEvent.iModifiers |= EModifierDoubleClick;
+                            m_doubleClickTimer.invalidate();
+                        } else {
+                            m_doubleClickTimer.start();
+                        }
+                    }
+                    break;
+                }
+                if (dx) {
+                    int cdx = S60->virtualMouseAccelDX;
+                    //reset accel on change of sign, else double accel
+                    if (dx * cdx <= 0)
+                        cdx = dx;
+                    else
+                        cdx *= 4;
+                    //cap accelleration
+                    if (dx * cdx > S60->virtualMouseMaxAccel)
+                        cdx = dx * S60->virtualMouseMaxAccel;
+                    //move mouse position
+                    x += cdx;
+                    S60->virtualMouseAccelDX = cdx;
+                }
+                if (dy) {
+                    int cdy = S60->virtualMouseAccelDY;
+                    if (dy * cdy <= 0)
+                        cdy = dy;
+                    else
+                        cdy *= 4;
+                    if (dy * cdy > S60->virtualMouseMaxAccel)
+                        cdy = dy * S60->virtualMouseMaxAccel;
+                    y += cdy;
+                    S60->virtualMouseAccelDY = cdy;
+                }
+            }
+        }
+        return sendKeyEvent(widget, &qKeyEvent);
+    }
+    }
+            //clip to screen size (window server allows a sprite hotspot to be outside the screen)
+            if (x < 0)
+                x = 0;
+            else if (x >= S60->screenWidthInPixels)
+                x = S60->screenWidthInPixels - 1;
+            if (y < 0)
+                y = 0;
+            else if (y >= S60->screenHeightInPixels)
+                y = S60->screenHeightInPixels - 1;
+            TPoint epos(x, y);
+            TPoint cpos = epos - PositionRelativeToScreen();
+            fakeEvent.iPosition = cpos;
+            fakeEvent.iParentPosition = epos;
+            if(fakeEvent.iType != -1)
+                HandlePointerEvent(fakeEvent);
+            return EKeyWasConsumed;
+        }
+    }
+#endif
     return EKeyWasNotConsumed;
+}
 …
             return EKeyWasConsumed;
+    }
 #endif // !defined(QT_NO_IM) && defined(Q_WS_S60)
+#endif // !defined(QT_NO_IM) && defined(Q_OS_SYMBIAN)
     if (widget && qt_sendSpontaneousEvent(widget, keyEvent))
 …
     if (!topExtra->inExpose) {
         topExtra->inExpose = true;
+        if (!qwidget->isWindow()) {
+            // If we get here, then it means we have a native child window
+            // Since no content should ever be painted to these windows, we
+            // erase them with a transparent brush when they get an expose.
+            CWindowGc &gc = SystemGc();
+            gc.SetBrushColor(TRgb(0, 0, 0, 0));
+            gc.Clear(controlRect);
+        }
         QRect exposeRect = qt_TRect2QRect(controlRect);
         qwidget->d_func()->syncBackingStore(exposeRect);
 …
     if (engine->type() == QPaintEngine::Raster) {
+        QS60WindowSurface *s60Surface = static_cast<QS60WindowSurface *>(qwidget->windowSurface());
+        QS60WindowSurface *s60Surface;
+#ifdef QT_GRAPHICSSYSTEM_RUNTIME
+        if (QApplicationPrivate::runtime_graphics_system) {
+            QRuntimeWindowSurface *rtSurface =
+                    static_cast<QRuntimeWindowSurface*>(qwidget->windowSurface());
+            s60Surface = static_cast<QS60WindowSurface *>(rtSurface->m_windowSurface.data());
+        } else
+#endif
+            s60Surface = static_cast<QS60WindowSurface *>(qwidget->windowSurface());
         CFbsBitmap *bitmap = s60Surface->symbianBitmap();
         CWindowGc &gc = SystemGc();
+        switch(qwidget->d_func()->extraData()->nativePaintMode) {
+        QWExtra::NativePaintMode nativePaintMode = qwidget->d_func()->extraData()->nativePaintMode;
+        if(qwidget->d_func()->paintOnScreen())
+            nativePaintMode = QWExtra::Disable;
+        switch(nativePaintMode) {
         case QWExtra::Disable:
             // Do nothing
             break;
         case QWExtra::Blit:
             if (qwidget->d_func()->isOpaque)
 …
             gc.BitBlt(controlRect.iTl, bitmap, backingStoreRect);
             break;
         case QWExtra::ZeroFill:
+            if (Window().DisplayMode() == EColor16MA) {
+            if (Window().DisplayMode() == EColor16MA
+                || Window().DisplayMode() == Q_SYMBIAN_ECOLOR16MAP) {
                 gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
                 gc.SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);
 …
             };
             break;
         default:
             Q_ASSERT(false);
 …
                 tlwExtra->inTopLevelResize = false;
         } else {
+            QResizeEvent *e = new QResizeEvent(newSize, oldSize);
+            QApplication::postEvent(qwidget, e);
+            if (!qwidget->testAttribute(Qt::WA_PendingResizeEvent)) {
+                QResizeEvent *e = new QResizeEvent(newSize, oldSize);
+                QApplication::postEvent(qwidget, e);
+            }
+        }
+    }
 …
 #ifdef Q_WS_S60
         // If widget is fullscreen/minimized, hide status pane and button container otherwise show them.
+        CEikStatusPane *statusPane = S60->statusPane();
+        CEikButtonGroupContainer *buttonGroup = S60->buttonGroupContainer();
+        TBool visible = !(qwidget->windowState() & (Qt::WindowFullScreen | Qt::WindowMinimized));
+        if (statusPane)
+            statusPane->MakeVisible(visible);
+        if (buttonGroup) {
+            // Visibility
+            const TBool isFullscreen = qwidget->windowState() & Qt::WindowFullScreen;
+            const TBool cbaVisibilityHint = qwidget->windowFlags() & Qt::WindowSoftkeysVisibleHint;
+            buttonGroup->MakeVisible(visible || (isFullscreen && cbaVisibilityHint));
+        QWidget *const window = qwidget->window();
+        if (!window->parentWidget()) { // Only top level native windows have control over cba/status pane
+            const bool decorationsVisible = !(window->windowState() & (Qt::WindowFullScreen | Qt::WindowMinimized));
+            const bool statusPaneVisibility = decorationsVisible;
+            const bool isFullscreen = window->windowState() & Qt::WindowFullScreen;
+            const bool cbaVisibilityHint = window->windowFlags() & Qt::WindowSoftkeysVisibleHint;
+            const bool buttonGroupVisibility = (decorationsVisible || (isFullscreen && cbaVisibilityHint));
+            S60->setStatusPaneAndButtonGroupVisibility(statusPaneVisibility, buttonGroupVisibility);
+        }
 #endif
     } else if (QApplication::activeWindow() == qwidget->window()) {
+        if (CCoeEnv::Static()->AppUi()->IsDisplayingMenuOrDialog() || S60->menuBeingConstructed) {
+            QWidget *fw = QApplication::focusWidget();
+            if (fw) {
+                QFocusEvent event(QEvent::FocusOut, Qt::PopupFocusReason);
+                QCoreApplication::sendEvent(fw, &event);
+        bool focusedControlFound = false;
+        WId winId = 0;
+        for (QWidget *w = qwidget->parentWidget(); w && (winId = w->internalWinId()); w = w->parentWidget()) {
+            if (winId->IsFocused() && winId->IsVisible()) {
+                focusedControlFound = true;
+                break;
+            } else if (w->isWindow())
+                break;
+        }
+        if (!focusedControlFound) {
+            if (CCoeEnv::Static()->AppUi()->IsDisplayingMenuOrDialog() || S60->menuBeingConstructed) {
+                QWidget *fw = QApplication::focusWidget();
+                if (fw) {
+                    QFocusEvent event(QEvent::FocusOut, Qt::PopupFocusReason);
+                    QCoreApplication::sendEvent(fw, &event);
+                }
+                m_symbianPopupIsOpen = true;
+                return;
+            }
+            m_symbianPopupIsOpen = true;
+            return;
+        }
+        QApplication::setActiveWindow(0);
+            QApplication::setActiveWindow(0);
+        }
+    }
     // else { We don't touch the active window unless we were explicitly activated or deactivated }
 …
+    {
         handleClientAreaChange();
+        // Send resize event to trigger desktopwidget workAreaResized signal
+        QResizeEvent e(qt_desktopWidget->size(), qt_desktopWidget->size());
+        QApplication::sendEvent(qt_desktopWidget, &e);
         break;
+    }
 …
     // the top of the stack may randomly be assigned focus by Symbian, for example
     // when creating new windows (specifically in CCoeAppUi::HandleStackChanged()).
+    // Close any popups.
+    CEikonEnv::Static()->EikAppUi()->StopDisplayingMenuBar();
     if (focus) {
         S60->appUi()->RemoveFromStack(this);
 …
+}
+bool QSymbianControl::isControlActive()
+{
+    return IsActivated() ? true : false;
+}
 /*!
     \typedef QApplication::QS60MainApplicationFactory
 …
         TTrapHandler *origTrapHandler = User::TrapHandler();
         // The S60 framework has not been initalized. We need to do it.
+        // The S60 framework has not been initialized. We need to do it.
         TApaApplicationFactory factory(S60->s60ApplicationFactory ?
                 S60->s60ApplicationFactory : newS60Application);
 …
         // After this construction, CEikonEnv will be available from CEikonEnv::Static().
         // (much like our qApp).
         CEikonEnv* coe = new CEikonEnv;
+        QtEikonEnv* coe = new QtEikonEnv;
         //not using QT_TRAP_THROWING, because coe owns the cleanupstack so it can't be pushed there.
         if(err == KErrNone)
 …
+        }
+    }
+#endif
+    delete repository;
+    repository = 0;
+#endif
+#ifdef QT_KEYPAD_NAVIGATION
     if (touch) {
         QApplicationPrivate::navigationMode = Qt::NavigationModeNone;
 …
         QApplicationPrivate::navigationMode = Qt::NavigationModeKeypadDirectional;
+    }
+#endif
 #ifndef QT_NO_CURSOR
 …
     QApplicationPrivate::setSystemFont(systemFont);
+#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
+    QObject::connect(qApp, SIGNAL(aboutToQuit()), qApp, SLOT(_q_aboutToQuit()));
+#endif
 /*
  ### Commented out for now as parameter handling not needed in SOS(yet). Code below will break testlib with -o flag
 …
     // Register WId with the metatype system.  This is to enable
     // QWidgetPrivate::create_sys to used delayed slot invokation in order
+    // QWidgetPrivate::create_sys to used delayed slot invocation in order
     // to destroy WId objects during reparenting.
     qRegisterMetaType<WId>("WId");
+}
+extern void qt_cleanup_symbianFontDatabase(); // qfontdatabase_s60.cpp
 /*****************************************************************************
 …
+    }
     QFontCache::cleanup(); // Has to happen now, since QFontEngineS60 has FBS handles
+    QPixmapCache::clear(); // Has to happen now, since QS60PixmapData has FBS handles
+    qt_cleanup_symbianFontDatabase();
 // S60 structure and window server session are freed in eventdispatcher destructor as they are needed there
 …
     S60->wsSession().SetPointerCursorMode(EPointerCursorNone);
+#ifdef Q_WS_S60
+    // Clear CBA
+    CEikonEnv::Static()->AppUiFactory()->SwapButtonGroup(0);
+    delete S60->buttonGroupContainer();
+    S60->setButtonGroupContainer(0);
+#endif
     if (S60->qtOwnsS60Environment) {
         // Restore the S60 framework trap handler. See qt_init().
 …
 void QApplicationPrivate::enterModal_sys(QWidget *widget)
+{
+#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
+    S60->wsSession().SendEffectCommand(ETfxCmdAppModalModeEnter);
+#endif
     if (widget) {
         static_cast<QSymbianControl *>(widget->effectiveWinId())->FadeBehindPopup(ETrue);
 …
 void QApplicationPrivate::leaveModal_sys(QWidget *widget)
+{
+#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
+    S60->wsSession().SendEffectCommand(ETfxCmdAppModalModeExit);
+#endif
     if (widget) {
         static_cast<QSymbianControl *>(widget->effectiveWinId())->FadeBehindPopup(EFalse);
 …
                 return 1;
             const TWsVisibilityChangedEvent *visChangedEvent = event->VisibilityChanged();
+            QWidget *w = QWidgetPrivate::mapper->value(control);
+            if (!w->d_func()->maybeTopData())
+                break;
+            if (visChangedEvent->iFlags & TWsVisibilityChangedEvent::ENotVisible) {
+                delete w->d_func()->topData()->backingStore;
+                w->d_func()->topData()->backingStore = 0;
+                // In order to ensure that any resources used by the window surface
+                // are immediately freed, we flush the WSERV command buffer.
+                S60->wsSession().Flush();
+            } else if ((visChangedEvent->iFlags & TWsVisibilityChangedEvent::EPartiallyVisible)
+                       && !w->d_func()->maybeBackingStore()) {
+                w->d_func()->topData()->backingStore = new QWidgetBackingStore(w);
+                w->d_func()->invalidateBuffer(w->rect());
+                w->repaint();
+            }
+            if (visChangedEvent->iFlags & TWsVisibilityChangedEvent::ENotVisible)
+                S60->controlVisibilityChanged(control, false);
+            else if (visChangedEvent->iFlags & TWsVisibilityChangedEvent::EPartiallyVisible)
+                S60->controlVisibilityChanged(control, true);
             return 1;
+        }
 …
+        }
 #endif
+#ifdef QT_SOFTKEYS_ENABLED
+        QSoftKeyManager::updateSoftKeys();
+#endif
         break;
     case EEventFocusLost:
 …
 #endif
         break;
+    case KGoomMemoryLowEvent:
+#ifdef QT_DEBUG
+        qDebug() << "QApplicationPrivate::symbianProcessWsEvent - KGoomMemoryLowEvent";
+#endif
+        if (callSymbianEventFilters(symbianEvent))
+            return 1;
+#ifdef QT_GRAPHICSSYSTEM_RUNTIME
+        if(QApplicationPrivate::runtime_graphics_system) {
+            bool switchToSwRendering(false);
+            foreach (QWidget *w, QApplication::topLevelWidgets()) {
+                if(w->d_func()->topData()->backingStore) {
+                    switchToSwRendering = true;
+                    break;
+                }
+            }
+            if (switchToSwRendering) {
+                QRuntimeGraphicsSystem *gs =
+                   static_cast<QRuntimeGraphicsSystem*>(QApplicationPrivate::graphics_system);
+                gs->setGraphicsSystem(QLatin1String("raster"));
+            }
+        }
+#endif
+        break;
+    case KGoomMemoryGoodEvent:
+#ifdef QT_DEBUG
+        qDebug() << "QApplicationPrivate::symbianProcessWsEvent - KGoomMemoryGoodEvent";
+#endif
+        if (callSymbianEventFilters(symbianEvent))
+            return 1;
+#ifdef QT_GRAPHICSSYSTEM_RUNTIME
+        if(QApplicationPrivate::runtime_graphics_system) {
+            QRuntimeGraphicsSystem *gs =
+                   static_cast<QRuntimeGraphicsSystem*>(QApplicationPrivate::graphics_system);
+            gs->setGraphicsSystem(QLatin1String("openvg"));
+        }
+#endif
+        break;
+#ifdef Q_SYMBIAN_SUPPORTS_SURFACES
+    case EEventUser:
+        {
+            // GOOM is looking for candidates to kill so indicate that we are
+            // capable of cleaning up by handling this event
+            TInt32 *data = reinterpret_cast<TInt32 *>(event->EventData());
+            if (data[0] == EApaSystemEventShutdown && data[1] == KGoomMemoryLowEvent)
+                return 1;
+        }
+        break;
+#endif
     default:
         break;
 …
         break;
     default:
+#ifdef Q_WS_S60
         bool handled = QSoftKeyManager::handleCommand(command);
         if (handled)
             ret = 1;
-#ifdef Q_WS_S60
         else
             ret = QMenuBarPrivate::symbianCommands(command);
 …
 TUint QApplicationPrivate::resolveS60ScanCode(TInt scanCode, TUint keysym)
+{
+    if (!scanCode)
+        return keysym;
+    QApplicationPrivate *d = QApplicationPrivate::instance();
     if (keysym) {
         // If keysym is specified, cache it.
         scanCodeCache.insert(scanCode, keysym);
+        d->scanCodeCache.insert(scanCode, keysym);
         return keysym;
     } else {
         // If not, retrieve the cached version.
         return scanCodeCache[scanCode];
+        return d->scanCodeCache[scanCode];
+    }
+}
 …
     if (HAL::Get(HALData::EPointer3DMaxPressure, maxTouchPressure) != KErrNone)
         maxTouchPressure = KMaxTInt;
+#else
+    pressureSupported = 0;
+    maxTouchPressure = KMaxTInt;
 #endif
+}
 …
 #endif // QT_NO_CURSOR
+void QApplicationPrivate::_q_aboutToQuit()
+{
+#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
+    // Send the shutdown tfx command
+    S60->wsSession().SendEffectCommand(ETfxCmdAppShutDown);
+#endif
+}
+QS60ThreadLocalData::QS60ThreadLocalData()
+{
+    CCoeEnv *env = CCoeEnv::Static();
+    if (env) {
+        //if this is the UI thread, share objects owned by CONE
+        usingCONEinstances = true;
+        wsSession = env->WsSession();
+        screenDevice = env->ScreenDevice();
+    }
+    else {
+        usingCONEinstances = false;
+        qt_symbian_throwIfError(wsSession.Connect(qt_s60GetRFs()));
+        screenDevice = new CWsScreenDevice(wsSession);
+        screenDevice->Construct();
+    }
+}
+QS60ThreadLocalData::~QS60ThreadLocalData()
+{
+    if (!usingCONEinstances) {
+        delete screenDevice;
+        wsSession.Close();
+    }
+}
 QT_END_NAMESPACE

trunk/src/gui/kernel/qapplication_win.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include <tpcshell.h>
 #ifdef QT_WINCE_GESTURES
+#ifndef QT_NO_GESTURES
 #include <gesture.h>
+#endif
 #endif
 #endif
 …
 #include "qpointer.h"
 #include "qhash.h"
-#include "qlibrary.h"
 #include "qmetaobject.h"
 #include "qmime.h"
 …
 #include "qtooltip.h"
 #include "qt_windows.h"
+#include "qscrollbar.h"
 #if defined(QT_NON_COMMERCIAL)
 #include "qnc_win.h"
 …
 #include <private/qkeymapper_p.h>
 #include <private/qlocale_p.h>
+#include <private/qsystemlibrary_p.h>
 #include "qevent_p.h"
 …
 #  include <winable.h>
 #endif
-#include "private/qwinnativepangesturerecognizer_win_p.h"
 #ifndef WM_TOUCH
 …
 #endif
+#ifndef QT_NO_GESTURES
 typedef DWORD (API *AygRecognizeGesture)(SHRGINFO*);
 static AygRecognizeGesture ptrRecognizeGesture = 0;
 …
     if (!aygResolved) {
         aygResolved = true;
         QLibrary ayglib(QLatin1String("aygshell"));
+        QSystemLibrary ayglib(QLatin1String("aygshell"));
         if (!ayglib.load())
             return;
 …
+    }
+}
+#endif // QT_NO_GESTURES
 #endif
 …
 #endif
 extern "C" LRESULT CALLBACK QtWndProc(HWND, UINT, WPARAM, LPARAM);
+extern "C" LRESULT QT_WIN_CALLBACK QtWndProc(HWND, UINT, WPARAM, LPARAM);
 class QETWidget : public QWidget                // event translator widget
 …
     bool        translateCloseEvent(const MSG &msg);
     bool        translateTabletEvent(const MSG &msg, PACKET *localPacketBuf, int numPackets);
+#ifndef QT_NO_GESTURES
     bool        translateGestureEvent(const MSG &msg, const GESTUREINFO &gi);
+#endif
     void        repolishStyle(QStyle &style);
     inline void showChildren(bool spontaneous) { d_func()->showChildren(spontaneous); }
 …
+}
+static void qt_set_windows_updateScrollBar(QWidget *widget)
+{
+    QList<QObject*> children = widget->children();
+    for (int i = 0; i < children.size(); ++i) {
+        QObject *o = children.at(i);
+        if(!o->isWidgetType())
+            continue;
+        if (QWidget *w = static_cast<QWidget *>(o))
+            qt_set_windows_updateScrollBar(w);
+    }
+#ifndef QT_NO_SCROLLBAR
+    if (qobject_cast<QScrollBar*>(widget))
+        widget->updateGeometry();
+#endif
+}
 /*****************************************************************************
   qt_init() - initializes Qt for Windows
 …
 #ifndef Q_OS_WINCE
     ptrUpdateLayeredWindowIndirect =
         (PtrUpdateLayeredWindowIndirect) QLibrary::resolve(QLatin1String("user32"),
+        (PtrUpdateLayeredWindowIndirect) QSystemLibrary::resolve(QLatin1String("user32"),
                                                            "UpdateLayeredWindowIndirect");
     ptrUpdateLayeredWindow =
         (PtrUpdateLayeredWindow) QLibrary::resolve(QLatin1String("user32"),
+        (PtrUpdateLayeredWindow) QSystemLibrary::resolve(QLatin1String("user32"),
                                                    "UpdateLayeredWindow");
 …
     // Notify Vista and Windows 7 that we support highter DPI settings
     ptrSetProcessDPIAware = (PtrSetProcessDPIAware)
         QLibrary::resolve(QLatin1String("user32"), "SetProcessDPIAware");
+        QSystemLibrary::resolve(QLatin1String("user32"), "SetProcessDPIAware");
     if (ptrSetProcessDPIAware)
         ptrSetProcessDPIAware();
 #endif
+#ifndef QT_NO_GESTURES
     priv->GetGestureInfo = 0;
     priv->GetGestureExtraArgs = 0;
 …
   #if !defined(QT_NO_NATIVE_GESTURES)
     priv->GetGestureInfo =
             (PtrGetGestureInfo)QLibrary::resolve(QLatin1String("user32"),
+            (PtrGetGestureInfo)QSystemLibrary::resolve(QLatin1String("user32"),
                                                  "GetGestureInfo");
     priv->GetGestureExtraArgs =
             (PtrGetGestureExtraArgs)QLibrary::resolve(QLatin1String("user32"),
+            (PtrGetGestureExtraArgs)QSystemLibrary::resolve(QLatin1String("user32"),
                                                       "GetGestureExtraArgs");
     priv->CloseGestureInfoHandle =
             (PtrCloseGestureInfoHandle)QLibrary::resolve(QLatin1String("user32"),
+            (PtrCloseGestureInfoHandle)QSystemLibrary::resolve(QLatin1String("user32"),
                                                          "CloseGestureInfoHandle");
     priv->SetGestureConfig =
             (PtrSetGestureConfig)QLibrary::resolve(QLatin1String("user32"),
+            (PtrSetGestureConfig)QSystemLibrary::resolve(QLatin1String("user32"),
                                                    "SetGestureConfig");
     priv->GetGestureConfig =
             (PtrGetGestureConfig)QLibrary::resolve(QLatin1String("user32"),
+            (PtrGetGestureConfig)QSystemLibrary::resolve(QLatin1String("user32"),
                                                    "GetGestureConfig");
   #endif // QT_NO_NATIVE_GESTURES
+    QSystemLibrary libTheme(QLatin1String("uxtheme"));
     priv->BeginPanningFeedback =
+            (PtrBeginPanningFeedback)QLibrary::resolve(QLatin1String("uxtheme"),
+                                                       "BeginPanningFeedback");
+            (PtrBeginPanningFeedback)libTheme.resolve("BeginPanningFeedback");
     priv->UpdatePanningFeedback =
+            (PtrUpdatePanningFeedback)QLibrary::resolve(QLatin1String("uxtheme"),
+                                                        "UpdatePanningFeedback");
+            (PtrUpdatePanningFeedback)libTheme.resolve("UpdatePanningFeedback");
     priv->EndPanningFeedback =
         (PtrEndPanningFeedback)QLibrary::resolve(QLatin1String("uxtheme"),
+                                                   "EndPanningFeedback");
 #endif
+        (PtrEndPanningFeedback)libTheme.resolve("EndPanningFeedback");
+#endif
+#endif // QT_NO_GESTURES
+}
 …
         cname = QLatin1String("QGLWidget");
         style = CS_DBLCLKS;
+#ifndef Q_WS_WINCE
+        style |= CS_OWNDC;
+#endif
         icon  = true;
     } else if (flags & Qt::MSWindowsOwnDC) {
 …
+}
+extern "C"
+LRESULT CALLBACK QtWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+extern "C" LRESULT QT_WIN_CALLBACK QtWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
     bool result = true;
 …
     switch (message) {
 #ifndef Q_WS_WINCE
+#ifndef QT_NO_SESSIONMANAGER
     case WM_QUERYENDSESSION: {
         if (sm_smActive) // bogus message from windows
 …
         RETURN(0);
+    }
+#endif
     case WM_DISPLAYCHANGE:
         if (QApplication::type() == QApplication::Tty)
 …
 #ifdef Q_WS_WINCE
         // CE SIP hide/show
         if (wParam == SPI_SETSIPINFO) {
+        if (qt_desktopWidget && wParam == SPI_SETSIPINFO) {
             QResizeEvent re(QSize(0, 0), QSize(0, 0)); // Calculated by QDesktopWidget
             QApplication::sendEvent(qt_desktopWidget, &re);
 …
     case WM_RBUTTONDOWN:
     case WM_XBUTTONDOWN:
+    case WM_LBUTTONDBLCLK:
+    case WM_RBUTTONDBLCLK:
+    case WM_MBUTTONDBLCLK:
+    case WM_XBUTTONDBLCLK:
         if (qt_win_ignoreNextMouseReleaseEvent)
             qt_win_ignoreNextMouseReleaseEvent = false;
 …
                         shrg.dwFlags = SHRG_RETURNCMD | SHRG_NOANIMATION;
                         resolveAygLibs();
+#ifndef QT_NO_GESTURES
                         if (ptrRecognizeGesture && (ptrRecognizeGesture(&shrg) == GN_CONTEXTMENU)) {
                             if (QApplication::activePopupWidget())
 …
                             result = qt_sendSpontaneousEvent(alienWidget, &e);
+                        }
+#endif // QT_NO_GESTURES
+                    }
+                }
 …
                     if (!widget->testAttribute(Qt::WA_SetLocale))
                         widget->dptr()->setLocale_helper(QLocale(), true);
+                    QEvent e(QEvent::LocaleChange);
+                    QApplication::sendEvent(qApp, &e);
+                }
+            }
 …
+                }
+            }
+            else if (msg.wParam == SPI_SETNONCLIENTMETRICS) {
+                widget = (QETWidget*)QWidget::find(hwnd);
+                if (widget && !widget->parentWidget()) {
+                    qt_set_windows_updateScrollBar(widget);
+                    QEvent e(QEvent::LayoutRequest);
+                    QApplication::sendEvent(widget, &e);
+                }
+        }
             break;
 …
             break;
+#ifndef QT_NO_CONTEXTMENU
             case WM_CONTEXTMENU:
+            {
 …
             break;
 #endif
+#endif
         case WM_IME_STARTCOMPOSITION:
 …
+            {
                 // Ignoring all requests while starting up
                 if (QApplication::startingUp() || QApplication::closingDown() || (DWORD)lParam != OBJID_CLIENT) {
+                if (QApplication::startingUp() || QApplication::closingDown() || (LONG)lParam != OBJID_CLIENT) {
                     result = false;
                     break;
 …
                     oleaccChecked = true;
 #if !defined(Q_OS_WINCE)
                     ptrLresultFromObject = (PtrLresultFromObject)QLibrary::resolve(QLatin1String("oleacc.dll"), "LresultFromObject");
+                    ptrLresultFromObject = (PtrLresultFromObject)QSystemLibrary::resolve(QLatin1String("oleacc"), "LresultFromObject");
 #endif
+                }
 …
                 QApplication::postEvent(widget, new QEvent(QEvent::OkRequest));
             if (CancelCommand)
                 QApplication::postEvent(widget, new QEvent(QEvent::Close));
+                widget->showMinimized();
             else
 #ifndef QT_NO_MENUBAR
 …
             result = false;
             break;
+#ifndef QT_NO_GESTURES
 #if !defined(Q_WS_WINCE) || defined(QT_WINCE_GESTURES)
         case WM_GESTURE: {
 …
+        }
 #endif // !defined(Q_WS_WINCE) || defined(QT_WINCE_GESTURES)
+#endif // QT_NO_GESTURES
+#ifndef QT_NO_CURSOR
+        case WM_SETCURSOR: {
+            QCursor *ovr = QApplication::overrideCursor();
+            if (ovr) {
+                SetCursor(ovr->handle());
+                RETURN(TRUE);
+            }
+            result = false;
+            break;
+        }
+#endif
         default:
             result = false;                        // event was not processed
 …
                 msgPtr->lParam = mouseMsg.lParam;
                 msgPtr->wParam = mouseMsg.wParam;
+                msgPtr->pt = mouseMsg.pt;
+                // Extract the x,y coordinates from the lParam as we do in the WndProc
+                msgPtr->pt.x = GET_X_LPARAM(mouseMsg.lParam);
+                msgPtr->pt.y = GET_Y_LPARAM(mouseMsg.lParam);
+                ClientToScreen(msg.hwnd, &(msgPtr->pt));
                 // Remove the mouse move message
                 PeekMessage(&mouseMsg, msg.hwnd, WM_MOUSEMOVE,
 …
+        }
+    }
+#ifndef Q_OS_WINCE
+    static bool trackMouseEventLookup = false;
+    typedef BOOL (WINAPI *PtrTrackMouseEvent)(LPTRACKMOUSEEVENT);
+    static PtrTrackMouseEvent ptrTrackMouseEvent = 0;
+#endif
     state  = translateButtonState(msg.wParam, type, button); // button state
     const QPoint widgetPos = mapFromGlobal(QPoint(msg.pt.x, msg.pt.y));
 …
             if (curWin != 0) {
-                static bool trackMouseEventLookup = false;
-                typedef BOOL (WINAPI *PtrTrackMouseEvent)(LPTRACKMOUSEEVENT);
-                static PtrTrackMouseEvent ptrTrackMouseEvent = 0;
                 if (!trackMouseEventLookup) {
                     trackMouseEventLookup = true;
                     ptrTrackMouseEvent = (PtrTrackMouseEvent)QLibrary::resolve(QLatin1String("comctl32"), "_TrackMouseEvent");
+                    ptrTrackMouseEvent = (PtrTrackMouseEvent)QSystemLibrary::resolve(QLatin1String("comctl32"), "_TrackMouseEvent");
+                }
                 if (ptrTrackMouseEvent && !qApp->d_func()->inPopupMode()) {
 …
+        }
+#ifndef Q_OS_WINCE
+        if (type == QEvent::MouseButtonPress
+            && QApplication::activePopupWidget() != activePopupWidget
+            && ptrTrackMouseEvent
+            && curWin) {
+            // Since curWin is already the window we clicked on,
+            // we have to setup the mouse tracking here.
+            TRACKMOUSEEVENT tme;
+            tme.cbSize = sizeof(TRACKMOUSEEVENT);
+            tme.dwFlags = 0x00000002;    // TME_LEAVE
+            tme.hwndTrack = curWin;      // Track on window receiving msgs
+            tme.dwHoverTime = (DWORD)-1; // HOVER_DEFAULT
+            ptrTrackMouseEvent(&tme);
+        }
+#endif
         if (type == QEvent::MouseButtonPress
             && QApplication::activePopupWidget() != activePopupWidget
             && replayPopupMouseEvent) {
             // the popup dissappeared. Replay the event
+            // the popup disappeared. Replay the event
             QWidget* w = QApplication::widgetAt(gpos.x, gpos.y);
             if (w && !QApplicationPrivate::isBlockedByModal(w)) {
 …
 #endif // QT_NO_TABLETEVENT
 // Update the "dynamic" informations of a cursor device (pen, airbrush, etc).
+// Update the "dynamic" information of a cursor device (pen, airbrush, etc).
 // The dynamic information is the information of QTabletDeviceData that can change
 // in time (eraser or pen if a device is turned around).
 …
         return;
     QLibrary library(QLatin1String("wintab32"));
+    QSystemLibrary library(QLatin1String("wintab32"));
     if (library.load()) {
         ptrWTInfo = (PtrWTInfo)library.resolve("WTInfoW");
 …
+}
+#ifndef QT_NO_GESTURES
 bool QETWidget::translateGestureEvent(const MSG &, const GESTUREINFO &gi)
+{
 …
     return true;
+}
+#endif // QT_NO_GESTURES
 void  QApplication::setCursorFlashTime(int msecs)
 …
 void QApplicationPrivate::initializeMultitouch_sys()
+{
+    static const IID QT_IID_IInkTablets = {0x112086D9, 0x7779, 0x4535, {0xA6, 0x99, 0x86, 0x2B, 0x43, 0xAC, 0x18, 0x63} };
+    static const IID QT_IID_IInkTablet2 = {0x90c91ad2, 0xfa36, 0x49d6, {0x95, 0x16, 0xce, 0x8d, 0x57, 0x0f, 0x6f, 0x85} };
+    static const CLSID QT_CLSID_InkTablets = {0x6E4FCB12, 0x510A, 0x4d40, {0x93, 0x04, 0x1D, 0xA1, 0x0A, 0xE9, 0x14, 0x7C} };
+    IInkTablets *iInkTablets = 0;
+    HRESULT hr = CoCreateInstance(QT_CLSID_InkTablets, NULL, CLSCTX_ALL, QT_IID_IInkTablets, (void**)&iInkTablets);
+    if (SUCCEEDED(hr)) {
+        long count = 0;
+        iInkTablets->get_Count(&count);
+        for (long i = 0; i < count; ++i) {
+            IInkTablet *iInkTablet = 0;
+            hr = iInkTablets->Item(i, &iInkTablet);
+            if (FAILED(hr))
+                continue;
+            IInkTablet2 *iInkTablet2 = 0;
+            hr = iInkTablet->QueryInterface(QT_IID_IInkTablet2, (void**)&iInkTablet2);
+            iInkTablet->Release();
+            if (FAILED(hr))
+                continue;
+            TabletDeviceKind kind;
+            hr = iInkTablet2->get_DeviceKind(&kind);
+            iInkTablet2->Release();
+            if (FAILED(hr))
+                continue;
+            if (kind == TDK_Touch) {
+                QApplicationPrivate::HasTouchSupport = true;
+                break;
+            }
+        }
+        iInkTablets->Release();
+    }
+    QLibrary library(QLatin1String("user32"));
+    if (QSysInfo::windowsVersion() >= QSysInfo::WV_WINDOWS7) {
+        static const int QT_SM_DIGITIZER = 94;
+        int value = GetSystemMetrics(QT_SM_DIGITIZER);
+        static const int QT_NID_INTEGRATED_TOUCH = 0x01;
+        static const int QT_NID_EXTERNAL_TOUCH   = 0x02;
+        static const int QT_NID_MULTI_INPUT      = 0x40;
+        QApplicationPrivate::HasTouchSupport =
+                value & (QT_NID_INTEGRATED_TOUCH | QT_NID_EXTERNAL_TOUCH | QT_NID_MULTI_INPUT);
+    }
+    QSystemLibrary library(QLatin1String("user32"));
     // MinGW (g++ 3.4.5) accepts only C casts.
     RegisterTouchWindow = (PtrRegisterTouchWindow)(library.resolve("RegisterTouchWindow"));

trunk/src/gui/kernel/qapplication_x11.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include "qvarlengtharray.h"
 #include "qdebug.h"
-#include <private/qunicodetables_p.h>
 #include <private/qcrashhandler_p.h>
 #include <private/qcolor_p.h>
 …
     "DTWM_IS_RUNNING\0"
-    "KDE_FULL_SESSION\0"
-    "KWIN_RUNNING\0"
-    "KWM_RUNNING\0"
-    "GNOME_BACKGROUND_PROPERTIES\0"
     "ENLIGHTENMENT_DESKTOP\0"
+    "_DT_SAVE_MODE\0"
     "_SGI_DESKS_MANAGER\0"
 …
     "_NET_SYSTEM_TRAY_VISUAL\0"
+    "_NET_ACTIVE_WINDOW\0"
     // Property formats
     "COMPOUND_TEXT\0"
 …
 #endif
+typedef bool(*QX11FilterFunction)(XEvent *event);
+Q_GLOBAL_STATIC(QList<QX11FilterFunction>, x11Filters)
+Q_GUI_EXPORT void qt_installX11EventFilter(QX11FilterFunction func)
+{
+    Q_ASSERT(func);
+    if (QList<QX11FilterFunction> *list = x11Filters())
+        list->append(func);
+}
+Q_GUI_EXPORT void qt_removeX11EventFilter(QX11FilterFunction func)
+{
+    Q_ASSERT(func);
+    if (QList<QX11FilterFunction> *list = x11Filters())
+        list->removeOne(func);
+}
 static bool qt_x11EventFilter(XEvent* ev)
+{
 …
     if (qApp->filterEvent(ev, &unused))
         return true;
+    if (const QList<QX11FilterFunction> *list = x11Filters()) {
+        for (QList<QX11FilterFunction>::const_iterator it = list->constBegin(); it != list->constEnd(); ++it) {
+            if ((*it)(ev))
+                return true;
+        }
+    }
     return qApp->x11EventFilter(ev);
+}
 …
 static int qt_x_errhandler(Display *dpy, XErrorEvent *err)
+{
+    if (X11->display != dpy) {
+        // only handle X errors for our display
+        return 0;
+    }
     switch (err->error_code) {
     case BadAtom:
 …
                 || err->resourceid == ATOM(_NET_SUPPORTED)
                 || err->resourceid == ATOM(_NET_SUPPORTING_WM_CHECK)
-                || err->resourceid == ATOM(KDE_FULL_SESSION)
-                || err->resourceid == ATOM(KWIN_RUNNING)
                 || err->resourceid == ATOM(XdndProxy)
                 || err->resourceid == ATOM(XdndAware))) {
 …
+        }
         if (X11->ignore_badwindow)
-            return 0;
-        break;
-    case BadMatch:
-        if (err->request_code == 42 /* X_SetInputFocus */)
             return 0;
         break;
 …
         else if (err->request_code == X11->mitshm_major)
             extensionName = "MIT-SHM";
+#ifndef QT_NO_XKB
+        else if(err->request_code == X11->xkb_major)
+            extensionName = "XKEYBOARD";
+#endif
         char minor_str[256];
 …
     X11->xinput_eventbase = 0;
     X11->xinput_errorbase = 0;
+    X11->use_xkb = false;
+    X11->xkb_major = 0;
+    X11->xkb_eventbase = 0;
+    X11->xkb_errorbase = 0;
     // MIT-SHM
 …
 #endif // QT_NO_XINPUT
+#ifndef QT_NO_XKB
+        int xkblibMajor = XkbMajorVersion;
+        int xkblibMinor = XkbMinorVersion;
+        X11->use_xkb = XkbQueryExtension(X11->display,
+                                         &X11->xkb_major,
+                                         &X11->xkb_eventbase,
+                                         &X11->xkb_errorbase,
+                                         &xkblibMajor,
+                                         &xkblibMinor);
+        if (X11->use_xkb) {
+            // If XKB is detected, set the GrabsUseXKBState option so input method
+            // compositions continue to work (ie. deadkeys)
+            unsigned int state = XkbPCF_GrabsUseXKBStateMask;
+            (void) XkbSetPerClientControls(X11->display, state, &state);
+            // select for group change events
+            XkbSelectEventDetails(X11->display,
+                                  XkbUseCoreKbd,
+                                  XkbStateNotify,
+                                  XkbAllStateComponentsMask,
+                                  XkbGroupStateMask);
+            // current group state is queried when creating the keymapper, no need to do it here
+        }
+#endif
 #if !defined(QT_NO_FONTCONFIG)
         int dpi = 0;
 …
         for (int s = 0; s < ScreenCount(X11->display); ++s) {
             int subpixel = FC_RGBA_UNKNOWN;
 #if RENDER_MAJOR > 0 || RENDER_MINOR >= 6
+#if !defined(QT_NO_XRENDER) && (RENDER_MAJOR > 0 || RENDER_MINOR >= 6)
             if (X11->use_xrender) {
                 int rsp = XRenderQuerySubpixelOrder(X11->display, s);
 …
         QKeyMapper::changeKeyboard();
-#ifndef QT_NO_XKB
-        if (qt_keymapper_private()->useXKB) {
-            // If XKB is detected, set the GrabsUseXKBState option so input method
-            // compositions continue to work (ie. deadkeys)
-            unsigned int state = XkbPCF_GrabsUseXKBStateMask;
-            (void) XkbSetPerClientControls(X11->display, state, &state);
+        }
-#endif // QT_NO_XKB
         // Misc. initialization
 #if 0 //disabled for now..
 …
         X11->desktopVersion = 0;
+        // See if the current window manager is using the freedesktop.org spec to give its name
+        Window windowManagerWindow = XNone;
+        Atom typeReturned;
+        int formatReturned;
+        unsigned long nitemsReturned;
+        unsigned long unused;
+        unsigned char *data = 0;
+        if (XGetWindowProperty(QX11Info::display(), QX11Info::appRootWindow(),
+                           ATOM(_NET_SUPPORTING_WM_CHECK),
+, 1024, False, XA_WINDOW, &typeReturned,
+                           &formatReturned, &nitemsReturned, &unused, &data)
+              == Success) {
+            if (typeReturned == XA_WINDOW && formatReturned == 32)
+                windowManagerWindow = *((Window*) data);
+            if (data)
+        Atom type;
+        int format;
+        unsigned long length, after;
+        uchar *data = 0;
+        int rc;
+        do {
+            if (!qgetenv("KDE_FULL_SESSION").isEmpty()) {
+                X11->desktopEnvironment = DE_KDE;
+                X11->desktopVersion = qgetenv("KDE_SESSION_VERSION").toInt();
+                break;
+            }
+            if (qgetenv("DESKTOP_SESSION") == "gnome") {
+                X11->desktopEnvironment = DE_GNOME;
+                break;
+            }
+            // GNOME_DESKTOP_SESSION_ID is deprecated for some reason, but still check it
+            if (!qgetenv("GNOME_DESKTOP_SESSION_ID").isEmpty()) {
+                X11->desktopEnvironment = DE_GNOME;
+                break;
+            }
+            rc = XGetWindowProperty(X11->display, QX11Info::appRootWindow(), ATOM(_DT_SAVE_MODE),
+, 2, False, XA_STRING, &type, &format, &length,
+                                    &after, &data);
+            if (rc == Success && length) {
+                if (!strcmp(reinterpret_cast<char *>(data), "xfce4")) {
+                    // Pretend that xfce4 is gnome, as it uses the same libraries.
+                    // The detection above is stolen from xdg-open.
+                    X11->desktopEnvironment = DE_GNOME;
+                    break;
+                }
+                // We got the property but it wasn't xfce4. Free data before it gets overwritten.
                 XFree(data);
+            if (windowManagerWindow != XNone) {
+                QString wmName;
+                Atom utf8atom = ATOM(UTF8_STRING);
+                if (XGetWindowProperty(QX11Info::display(), windowManagerWindow, ATOM(_NET_WM_NAME),
+, 1024, False, utf8atom, &typeReturned,
+                                       &formatReturned, &nitemsReturned, &unused, &data)
+                    == Success) {
+                    if (typeReturned == utf8atom && formatReturned == 8)
+                        wmName = QString::fromUtf8((const char*)data);
+                    if (data)
+                        XFree(data);
+                    if (wmName == QLatin1String("KWin"))
+                        X11->desktopEnvironment = DE_KDE;
+                    if (wmName == QLatin1String("Metacity"))
+                        X11->desktopEnvironment = DE_GNOME;
+                }
+            }
+        }
+        // Running a different/newer/older window manager?  Try some other things
+        if (X11->desktopEnvironment == DE_UNKNOWN){
+            Atom type;
+            int format;
+            unsigned long length, after;
+            uchar *data = 0;
+            QString session = QString::fromLocal8Bit(qgetenv("DESKTOP_SESSION"));
+            if (session == QLatin1String("kde")) {
+                X11->desktopEnvironment = DE_KDE;
+            } else if (session == QLatin1String("gnome") || session == QLatin1String("xfce")) {
+                X11->desktopEnvironment = DE_GNOME;
+            } else if (XGetWindowProperty(X11->display, QX11Info::appRootWindow(), ATOM(DTWM_IS_RUNNING),
+, 1, False, AnyPropertyType, &type, &format, &length,
+                                   &after, &data) == Success && length) {
+                data = 0;
+            }
+            rc = XGetWindowProperty(X11->display, QX11Info::appRootWindow(), ATOM(DTWM_IS_RUNNING),
+, 1, False, AnyPropertyType, &type, &format, &length,
+                                    &after, &data);
+            if (rc == Success && length) {
                 // DTWM is running, meaning most likely CDE is running...
                 X11->desktopEnvironment = DE_CDE;
+            } else if (XGetWindowProperty(X11->display, QX11Info::appRootWindow(),
+                                          ATOM(GNOME_BACKGROUND_PROPERTIES), 0, 1, False, AnyPropertyType,
+                                          &type, &format, &length, &after, &data) == Success && length) {
+                X11->desktopEnvironment = DE_GNOME;
+            } else if (!qgetenv("GNOME_DESKTOP_SESSION_ID").isEmpty()) {
+                X11->desktopEnvironment = DE_GNOME;
+            } else if ((XGetWindowProperty(X11->display, QX11Info::appRootWindow(), ATOM(KDE_FULL_SESSION),
+, 1, False, AnyPropertyType, &type, &format, &length, &after, &data) == Success
+                        && length)
+                       || (XGetWindowProperty(X11->display, QX11Info::appRootWindow(), ATOM(KWIN_RUNNING),
+, 1, False, AnyPropertyType, &type, &format, &length,
+                                              &after, &data) == Success
+                           && length)
+                       || (XGetWindowProperty(X11->display, QX11Info::appRootWindow(), ATOM(KWM_RUNNING),
+, 1, False, AnyPropertyType, &type, &format, &length,
+                                              &after, &data) == Success && length)) {
+                X11->desktopEnvironment = DE_KDE;
+            } else if (XGetWindowProperty(X11->display, QX11Info::appRootWindow(), ATOM(_SGI_DESKS_MANAGER),
+, 1, False, XA_WINDOW, &type, &format, &length, &after, &data) == Success
+                       && length) {
+                break;
+            }
+            rc = XGetWindowProperty(X11->display, QX11Info::appRootWindow(),
+                                    ATOM(_SGI_DESKS_MANAGER), 0, 1, False, XA_WINDOW,
+                                    &type, &format, &length, &after, &data);
+            if (rc == Success && length) {
                 X11->desktopEnvironment = DE_4DWM;
+            }
+            if (data)
+                XFree((char *)data);
+        }
+        if (X11->desktopEnvironment == DE_KDE)
+            X11->desktopVersion = QString::fromLocal8Bit(qgetenv("KDE_SESSION_VERSION")).toInt();
+                break;
+            }
+            if (XGetWindowProperty(X11->display, QX11Info::appRootWindow(),
+                               ATOM(_NET_SUPPORTING_WM_CHECK),
+, 1024, False, XA_WINDOW, &type,
+                               &format, &length, &after, &data) == Success) {
+                if (type == XA_WINDOW && format == 32) {
+                    Window windowManagerWindow = *((Window*) data);
+                    XFree(data);
+                    data = 0;
+                    if (windowManagerWindow != XNone) {
+                        Atom utf8atom = ATOM(UTF8_STRING);
+                        if (XGetWindowProperty(QX11Info::display(), windowManagerWindow, ATOM(_NET_WM_NAME),
+, 1024, False, utf8atom, &type,
+                                               &format, &length, &after, &data) == Success) {
+                            if (type == utf8atom && format == 8) {
+                                if (qstrcmp((const char *)data, "MCompositor") == 0)
+                                    X11->desktopEnvironment = DE_MEEGO_COMPOSITOR;
+                            }
+                        }
+                    }
+                }
+            }
+        } while(0);
+        if (data)
+            XFree((char *)data);
 #if !defined(QT_NO_STYLE_GTK)
 …
                     X11->time = event->xclient.data.l[1];
                 QWidget *amw = activeModalWidget();
+                if (amw && amw->testAttribute(Qt::WA_X11DoNotAcceptFocus))
+                    amw = 0;
                 if (amw && !QApplicationPrivate::tryModalHelper(widget, 0)) {
                     QWidget *p = amw->parentWidget();
 …
         return 0;
+    }
+#ifndef QT_NO_XKB
+    else if (X11->use_xkb && event->type == X11->xkb_eventbase) {
+        XkbAnyEvent *xkbevent = (XkbAnyEvent *) event;
+        switch (xkbevent->xkb_type) {
+        case XkbStateNotify:
+            {
+                XkbStateNotifyEvent *xkbstateevent = (XkbStateNotifyEvent *) xkbevent;
+                if ((xkbstateevent->changed & XkbGroupStateMask) != 0) {
+                    qt_keymapper_private()->xkb_currentGroup = xkbstateevent->group;
+                    QKeyMapper::changeKeyboard();
+                }
+                break;
+            }
+        default:
+            break;
+        }
+    }
+#endif
     if (!widget) {                                // don't know this windows
 …
     case MapNotify:                                // window shown
         if (widget->isWindow()) {
+            // if we got a MapNotify when we were not waiting for it, it most
+            // likely means the user has already asked to hide the window before
+            // it ever being shown, so we try to withdraw a window after sending
+            // the QShowEvent.
+            bool pendingHide = widget->testAttribute(Qt::WA_WState_ExplicitShowHide) && widget->testAttribute(Qt::WA_WState_Hidden);
             widget->d_func()->topData()->waitingForMapNotify = 0;
 …
+                }
+            }
+            if (pendingHide) // hide the window
+                XWithdrawWindow(X11->display, widget->internalWinId(), widget->x11Info().screen());
+        }
         break;
 …
                 QWidget *newparent = QWidget::find(event->xreparent.parent);
                 if (! newparent || (newparent->windowType() == Qt::Desktop)) {
                     // we dont' know about the new parent (or we've been
+                    // we don't know about the new parent (or we've been
                     // reparented to root), perhaps a window manager
                     // has been (re)started?  reset the focus model to unknown
 …
         if (isVisible() && data->crect.size() != oldSize) {
             Q_ASSERT(d->extra->topextra);
             QWidgetBackingStore *bs = d->extra->topextra->backingStore;
+            QWidgetBackingStore *bs = d->extra->topextra->backingStore.data();
             const bool hasStaticContents = bs && bs->hasStaticContents();
             // If we have a backing store with static contents, we have to disable the top-level

trunk/src/gui/kernel/qboxlayout.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qboxlayout.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qclipboard.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
     store or retrieve the clipboard contents in response to timer or
     non-user-input events.
+    \i Since there is no standard way to copy and paste files between
+    applications on X11, various MIME types and conventions are currently
+    in use. For instance, Nautilus expects files to be supplied with a
+    \c{x-special/gnome-copied-files} MIME type with data beginning with
+    the cut/copy action, a newline character, and the URL of the file.
     \endlist

trunk/src/gui/kernel/qclipboard.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qclipboard_mac.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #ifdef DEBUG_PASTEBOARD
     if(fromGlobal)
         qDebug("Pasteboard: Syncronize!");
+        qDebug("Pasteboard: Synchronize!");
 #endif
     return fromGlobal;

trunk/src/gui/kernel/qclipboard_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qclipboard_qws.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qclipboard_s60.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include "qevent.h"
 #include "private/qcore_symbian_p.h"
+#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
+#include "txtclipboard.h"
+#endif
+#include "txtetext.h"
 #include <QtDebug>
 …
 QT_BEGIN_NAMESPACE
-//###  Mime Type mapping to UIDs
 const TUid KQtCbDataStream = {0x2001B2DD};
+const TInt KPlainTextBegin = 0;
 class QClipboardData
 …
         HBufC* stringData = TPtrC(reinterpret_cast<const TUint16*>((*iter).utf16())).AllocLC();
         QByteArray ba = aData->data((*iter));
-        qDebug() << "copy to clipboard mime: " << *iter << " data: " << ba;
         // mime type
         aStream << TCardinality(stringData->Size());
 …
         CleanupStack::PopAndDestroy(stringData);
+    }
+}
+void writeToSymbianStoreLX(const QMimeData* aData, CClipboard* clipboard)
+{
+    // This function both leaves and throws exceptions. There must be no destructor
+    // dependencies between cleanup styles, and no cleanup stack dependencies on stacked objects.
+    if (aData->hasText()) {
+        CPlainText* text = CPlainText::NewL();
+        CleanupStack::PushL(text);
+        TPtrC textPtr(qt_QString2TPtrC(aData->text()));
+        text->InsertL(KPlainTextBegin, textPtr);
+        text->CopyToStoreL(clipboard->Store(), clipboard->StreamDictionary(),
+                           KPlainTextBegin, textPtr.Length());
+        CleanupStack::PopAndDestroy(text);
+    }
+}
+void readSymbianStoreLX(QMimeData* aData, CClipboard* clipboard)
+{
+    // This function both leaves and throws exceptions. There must be no destructor
+    // dependencies between cleanup styles, and no cleanup stack dependencies on stacked objects.
+    CPlainText* text = CPlainText::NewL();
+    CleanupStack::PushL(text);
+    TInt dataLength = text->PasteFromStoreL(clipboard->Store(), clipboard->StreamDictionary(),
+                                            KPlainTextBegin);
+    if (dataLength == 0) {
+        User::Leave(KErrNotFound);
+    }
+    HBufC* hBuf = HBufC::NewL(dataLength);
+    TPtr buf = hBuf->Des();
+    text->Extract(buf, KPlainTextBegin, dataLength);
+    QString string = qt_TDesC2QString(buf);
+    CleanupStack::PopAndDestroy(text);
+    aData->setText(string);
+}
 …
         aStream.ReadL(reinterpret_cast<uchar*>(ba.data_ptr()->data),dataSize);
         ba.data_ptr()->size = dataSize;
-        qDebug() << "paste from clipboard mime: " << mimeType << " data: " << ba;
         aData->setData(mimeType,ba);
+    }
 …
     if (mode != Clipboard) return 0;
     QClipboardData *d = clipboardData();
+    bool dataExists(false);
     if (d)
+    {
 …
             CClipboard* cb = CClipboard::NewForReadingLC(fs);
             Q_ASSERT(cb);
+            //stream for qt
             RStoreReadStream stream;
             TStreamId stid = (cb->StreamDictionary()).At(KQtCbDataStream);
+            stream.OpenLC(cb->Store(),stid);
+            QT_TRYCATCH_LEAVING(readFromStreamLX(d->source(),stream));
+            CleanupStack::PopAndDestroy(2,cb);
+            return d->source();
+            if (stid != 0) {
+                stream.OpenLC(cb->Store(),stid);
+                QT_TRYCATCH_LEAVING(readFromStreamLX(d->source(),stream));
+                CleanupStack::PopAndDestroy(&stream);
+                dataExists = true;
+            }
+            else {
+                //symbian clipboard
+                RStoreReadStream symbianStream;
+                TStreamId symbianStId = (cb->StreamDictionary()).At(KClipboardUidTypePlainText);
+                if (symbianStId != 0) {
+                    symbianStream.OpenLC(cb->Store(), symbianStId);
+                    QT_TRYCATCH_LEAVING(readSymbianStoreLX(d->source(), cb));
+                    CleanupStack::PopAndDestroy(&symbianStream);
+                    dataExists = true;
+                }
+            }
+            CleanupStack::PopAndDestroy(cb);
         });
         if (err != KErrNone){
 …
+        }
+        if (dataExists) {
+            return d->source();
+        }
+    }
     return 0;
 …
             RFs fs = qt_s60GetRFs();
             CClipboard* cb = CClipboard::NewForWritingLC(fs);
+            //stream for qt
             RStoreWriteStream  stream;
             TStreamId stid = stream.CreateLC(cb->Store());
 …
             (cb->StreamDictionary()).AssignL(KQtCbDataStream,stid);
             cb->CommitL();
+            CleanupStack::PopAndDestroy(2,cb);
+            //stream for symbian
+            RStoreWriteStream symbianStream;
+            TStreamId symbianStId = symbianStream.CreateLC(cb->Store());
+            QT_TRYCATCH_LEAVING(writeToSymbianStoreLX(src, cb));
+            (cb->StreamDictionary()).AssignL(KClipboardUidTypePlainText, symbianStId);
+            cb->CommitL();
+            CleanupStack::PopAndDestroy(3,cb);
         });
         if (err != KErrNone){

trunk/src/gui/kernel/qclipboard_win.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
         clipBoardViewer->createWinId();
         clipBoardViewer->setObjectName(QLatin1String("internal clipboard owner"));
         // We dont need this internal widget to appear in QApplication::topLevelWidgets()
+        // We don't need this internal widget to appear in QApplication::topLevelWidgets()
         if (QWidgetPrivate::allWidgets)
             QWidgetPrivate::allWidgets->remove(clipBoardViewer);

trunk/src/gui/kernel/qclipboard_x11.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include "qdesktopwidget.h"
 #include "qbitmap.h"
-#include "qdatetime.h"
 #include "qiodevice.h"
 #include "qbuffer.h"
 …
 #include "qx11info_x11.h"
 #include "qimagewriter.h"
+#include "qelapsedtimer.h"
 #include "qvariant.h"
 #include "qdnd_p.h"
 …
     requestor->createWinId();
     requestor->setObjectName(QLatin1String("internal clipboard requestor"));
     // We dont need this internal widgets to appear in QApplication::topLevelWidgets()
+    // We don't need this internal widgets to appear in QApplication::topLevelWidgets()
     if (QWidgetPrivate::allWidgets) {
         QWidgetPrivate::allWidgets->remove(owner);
 …
         if (data.timestamp == CurrentTime) {
             setupOwner();
+            int dummy = 0;
+            // We need this value just for completeness, we don't use it.
+            long dummy = 0;
             Window ownerId = owner->internalWinId();
             XChangeProperty(X11->display, ownerId,
 …
 bool QX11Data::clipboardWaitForEvent(Window win, int type, XEvent *event, int timeout)
+{
+    QTime started = QTime::currentTime();
+    QTime now = started;
+    QElapsedTimer started;
+    started.start();
+    QElapsedTimer now = started;
     if (QAbstractEventDispatcher::instance()->inherits("QtMotif")
 …
             usleep(50000);
+            now = QTime::currentTime();
+            if (started > now)                        // crossed midnight
+                started = now;
+            now.start();
             QEventLoop::ProcessEventsFlags flags(QEventLoop::ExcludeUserInputEvents
 …
                 qApp->x11ProcessEvent(&e);
+            now = QTime::currentTime();
+            if ( started > now )                        // crossed midnight
+                started = now;
+            now.start();
             XFlush(X11->display);
 …
 bool QX11Data::clipboardReadProperty(Window win, Atom property, bool deleteProperty,
                                      QByteArray *buffer, int *size, Atom *type, int *format, bool nullterm)
+                                     QByteArray *buffer, int *size, Atom *type, int *format)
+{
     int           maxsize = maxSelectionIncr(display);
 …
+    }
     int newSize = proplen + (nullterm ? 1 : 0);
+    int newSize = proplen;
     buffer->resize(newSize);
 …
     VDEBUG("QClipboard: read_property(): buffer resized to %d", buffer->size());
     if (ok) {
+    if (ok && newSize) {
         // could allocate buffer
 …
             textprop.encoding = *type;
             textprop.format = *format;
             textprop.nitems = length;
+            textprop.nitems = buffer_offset;
             textprop.value = (unsigned char *) buffer->data();
 …
             if (XmbTextPropertyToTextList(display, &textprop, &list_ret,
                          &count) == Success && count && list_ret) {
                 offset = strlen(list_ret[0]);
                 buffer->resize(offset + (nullterm ? 1 : 0));
+                offset = buffer_offset = strlen(list_ret[0]);
+                buffer->resize(offset);
                 memcpy(buffer->data(), list_ret[0], offset);
+            }
             if (list_ret) XFreeStringList(list_ret);
+        }
-        // zero-terminate (for text)
-        if (nullterm)
-            buffer->data()[buffer_offset] = '\0';
+    }
 …
              event.xproperty.state != PropertyNewValue)
             continue;
         if (X11->clipboardReadProperty(win, property, true, &tmp_buf, &length, 0, 0, false)) {
+        if (X11->clipboardReadProperty(win, property, true, &tmp_buf, &length, 0, 0)) {
             if (length == 0) {                // no more data, we're done
                 if (nullterm) {
 …
     requestor = new QWidget(0);
     requestor->setObjectName(QLatin1String("internal clipboard requestor"));
     // We dont need this internal widget to appear in QApplication::topLevelWidgets()
+    // We don't need this internal widget to appear in QApplication::topLevelWidgets()
     if (QWidgetPrivate::allWidgets)
         QWidgetPrivate::allWidgets->remove(requestor);
 …
             (void)new QClipboardINCRTransaction(window, property, atomFormat, dataFormat, data, increment);
             return ATOM(INCR);
+            return property;
+        }
 …
                 if (req->property == XNone
                     || !X11->clipboardReadProperty(req->requestor, req->property, false, &multi_data,
 , &multi_type, &multi_format, 0)
+, &multi_type, &multi_format)
                     || multi_format != 32) {
                     // MULTIPLE property not formatted correctly
 …
     XSelectInput(dpy, win, PropertyChangeMask);
     if (X11->clipboardReadProperty(win, ATOM(_QT_SELECTION), true, &buf, 0, &type, 0, false)) {
+    if (X11->clipboardReadProperty(win, ATOM(_QT_SELECTION), true, &buf, 0, &type, 0)) {
         if (type == ATOM(INCR)) {
             int nbytes = buf.size() >= 4 ? *((int*)buf.data()) : 0;
 …
 #endif
     if (!owner || (selectionOwner && selectionOwner != owner->internalWinId()) ||
         (!selectionOwner && d->timestamp != CurrentTime && d->timestamp < timestamp))
+        (!selectionOwner && (d->timestamp == CurrentTime || d->timestamp < timestamp)))
         return qt_check_selection_sentinel();
     return false;
 …
 #endif
     if (!owner || (clipboardOwner && clipboardOwner != owner->internalWinId()) ||
         (!clipboardOwner && d->timestamp != CurrentTime && d->timestamp < timestamp))
+        (!clipboardOwner && (d->timestamp == CurrentTime || d->timestamp < timestamp)))
         return qt_check_clipboard_sentinel();
     return false;

trunk/src/gui/kernel/qcocoaapplication_mac.mm

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include <private/qt_cocoa_helpers_mac_p.h>
+QT_USE_NAMESPACE
 @implementation NSApplication (QT_MANGLE_NAMESPACE(QApplicationIntegration))
 …
+}
+- (void)qt_sendPostedMessage:(NSEvent *)event
+{
+    // WARNING: data1 and data2 is truncated to from 64-bit to 32-bit on OS 10.5!
+    // That is why we need to split the address in two parts:
+    quint64 lower = [event data1];
+    quint64 upper = [event data2];
+    QCocoaPostMessageArgs *args = reinterpret_cast<QCocoaPostMessageArgs *>(lower | (upper << 32));
+    [args->target performSelector:args->selector];
+    delete args;
+}
+- (BOOL)qt_sendEvent:(NSEvent *)event
+{
+    if ([event type] == NSApplicationDefined) {
+        switch ([event subtype]) {
+            case QtCocoaEventSubTypePostMessage:
+                [NSApp qt_sendPostedMessage:event];
+                return true;
+            default:
+                break;
+        }
+    }
+    return false;
+}
 @end
+@implementation QNSApplication
+// WARNING: If Qt did not create NSApplication (this can e.g.
+// happend if Qt is used as a plugin from a 3rd-party cocoa
+// application), QNSApplication::sendEvent will never be called.
+// SO DO NOT RELY ON THIS FUNCTION BEING AVAILABLE.
+// Plugin developers that _do_ control the NSApplication sub-class
+// implementation of the 3rd-party application can call qt_sendEvent
+// from the sub-class event handler (like we do here) to work around
+// any issues.
+- (void)sendEvent:(NSEvent *)event
+{
+    if (![self qt_sendEvent:event])
+        [super sendEvent:event];
+}
+@end
 #endif

trunk/src/gui/kernel/qcocoaapplication_mac_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 - (QT_MANGLE_NAMESPACE(QCocoaMenuLoader) *)QT_MANGLE_NAMESPACE(qt_qcocoamenuLoader);
 - (int)QT_MANGLE_NAMESPACE(qt_validModesForFontPanel):(NSFontPanel *)fontPanel;
+- (void)qt_sendPostedMessage:(NSEvent *)event;
+- (BOOL)qt_sendEvent:(NSEvent *)event;
 @end
+@interface QNSApplication : NSApplication {
+}
+@end
 #endif

trunk/src/gui/kernel/qcocoaapplicationdelegate_mac.mm

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 // This function will only be called when NSApp is actually running. Before
 // that, the kAEQuitApplication apple event will be sendt to
+// that, the kAEQuitApplication Apple event will be sent to
 // QApplicationPrivate::globalAppleEventProcessor in qapplication_mac.mm
 - (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender
 …
         // INVARIANT: No event loop is executing. This probably
         // means that Qt is used as a plugin, or as a part of a native
         // Cocoa application. In any case it should be fine to
+        // Cocoa application. In any case it should be fine to
         // terminate now:
         return NSTerminateNow;
+    } else {
+        // Prevent Cocoa from terminating the application, since this simply
+        // exits the program whithout allowing QApplication::exec() to return.
+        // The call to QApplication::quit() above will instead quit the
+        // application from the Qt side.
+        return NSTerminateCancel;
+    }
+    }
+    return NSTerminateCancel;
+}
 …
+}
+- (void)appleEventQuit:(NSAppleEventDescriptor *)event withReplyEvent:(NSAppleEventDescriptor *)replyEvent
+{
+    Q_UNUSED(event);
+    Q_UNUSED(replyEvent);
+    [NSApp terminate:self];
+}
+- (void)qtDispatcherToQAction:(id)sender
+{
+    [[NSApp QT_MANGLE_NAMESPACE(qt_qcocoamenuLoader)] qtDispatcherToQAction:sender];
+}
 @end
 #endif

trunk/src/gui/kernel/qcocoaapplicationdelegate_mac_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qcocoamenuloader_mac.mm

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include <private/qapplication_p.h>
 #include <private/qt_mac_p.h>
+#include <private/qmenubar_p.h>
 #include <qmenubar.h>
+#include <private/qt_cocoa_helpers_mac_p.h>
 QT_FORWARD_DECLARE_CLASS(QCFString)
 QT_FORWARD_DECLARE_CLASS(QString)
+#ifndef QT_NO_TRANSLATION
+    QT_BEGIN_NAMESPACE
+    extern QString qt_mac_applicationmenu_string(int type);
+    QT_END_NAMESPACE
+#endif
 QT_USE_NAMESPACE
 …
 - (void)awakeFromNib
+{
+    servicesItem = [[appMenu itemWithTitle:@"Services"] retain];
+    hideAllOthersItem = [[appMenu itemWithTitle:@"Hide Others"] retain];
+    showAllItem = [[appMenu itemWithTitle:@"Show All"] retain];
     // Get the names in the nib to match the app name set by Qt.
     NSString *appName = reinterpret_cast<const NSString*>(QCFString::toCFStringRef(qAppName()));
 …
+{
     // The application menu is the menu in the menu bar that contains the
     // 'Quit' item. When changing menu bar (e.g when swithing between
+    // 'Quit' item. When changing menu bar (e.g when switching between
     // windows with different menu bars), we never recreate this menu, but
     // instead pull it out the current menu bar and place into the new one:
 …
 - (void)dealloc
+{
+    [servicesItem release];
+    [hideAllOthersItem release];
+    [showAllItem release];
     [lastAppSpecificItem release];
     [theMenu release];
 …
+{
     [NSApp hide:sender];
+}
+- (void)qtUpdateMenubar
+{
+    QMenuBarPrivate::macUpdateMenuBarImmediatly();
+}
+- (void)qtTranslateApplicationMenu
+{
+#ifndef QT_NO_TRANSLATION
+    [servicesItem setTitle: qt_mac_QStringToNSString(qt_mac_applicationmenu_string(0))];
+    [hideItem setTitle: qt_mac_QStringToNSString(qt_mac_applicationmenu_string(1).arg(qAppName()))];
+    [hideAllOthersItem setTitle: qt_mac_QStringToNSString(qt_mac_applicationmenu_string(2))];
+    [showAllItem setTitle: qt_mac_QStringToNSString(qt_mac_applicationmenu_string(3))];
+    [preferencesItem setTitle: qt_mac_QStringToNSString(qt_mac_applicationmenu_string(4))];
+    [quitItem setTitle: qt_mac_QStringToNSString(qt_mac_applicationmenu_string(5).arg(qAppName()))];
+    [aboutItem setTitle: qt_mac_QStringToNSString(qt_mac_applicationmenu_string(6).arg(qAppName()))];
+#endif
+}
 …
+    }
+}
+ - (void)orderFrontCharacterPalette:(id)sender
+ {
+     [NSApp orderFrontCharacterPalette:sender];
+ }
 @end
 #endif // QT_MAC_USE_COCOA

trunk/src/gui/kernel/qcocoamenuloader_mac_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
     IBOutlet NSMenuItem *hideItem;
     NSMenuItem *lastAppSpecificItem;
+    NSMenuItem *servicesItem;
+    NSMenuItem *hideAllOthersItem;
+    NSMenuItem *showAllItem;
+}
 - (void)ensureAppMenuInMenu:(NSMenu *)menu;
 …
 - (IBAction)hide:(id)sender;
 - (IBAction)qtDispatcherToQAction:(id)sender;
+- (void)qtUpdateMenubar;
+- (void)orderFrontCharacterPalette:(id)sender;
 @end

trunk/src/gui/kernel/qcocoapanel_mac.mm

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #import <private/qcocoaview_mac_p.h>
 #import <private/qcocoawindowcustomthemeframe_mac_p.h>
+#import <private/qcocoaapplication_mac_p.h>
 #include <private/qapplication_p.h>
 #include <private/qbackingstore_p.h>

trunk/src/gui/kernel/qcocoapanel_mac_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #import <Cocoa/Cocoa.h>
+QT_FORWARD_DECLARE_CLASS(QStringList);
 @interface QT_MANGLE_NAMESPACE(QCocoaPanel) : NSPanel {
     bool leftButtonIsRightButton;
+    QStringList *currentCustomDragTypes;
+}
 + (Class)frameViewClassForStyleMask:(NSUInteger)styleMask;
+- (void)registerDragTypes;
 @end
 #endif

trunk/src/gui/kernel/qcocoasharedwindowmethods_mac_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 extern Qt::MouseButton cocoaButton2QtButton(NSInteger buttonNum); // qcocoaview.mm
 extern QPointer<QWidget> qt_button_down; //qapplication_mac.cpp
+extern const QStringList& qEnabledDraggedTypes(); // qmime_mac.cpp
+extern void qt_event_request_window_change(QWidget *); // qapplication_mac.mm
+extern void qt_mac_send_posted_gl_updates(QWidget *widget); // qapplication_mac.mm
+Q_GLOBAL_STATIC(QPointer<QWidget>, currentDragTarget);
 QT_END_NAMESPACE
+- (id)initWithContentRect:(NSRect)contentRect
+    styleMask:(NSUInteger)windowStyle
+    backing:(NSBackingStoreType)bufferingType
+    defer:(BOOL)deferCreation
+{
+    self = [super initWithContentRect:contentRect styleMask:windowStyle
+        backing:bufferingType defer:deferCreation];
+    if (self) {
+        currentCustomDragTypes = 0;
+    }
+    return self;
+}
+- (void)dealloc
+{
+    delete currentCustomDragTypes;
+    [super dealloc];
+}
 - (BOOL)canBecomeKeyWindow
+{
     QWidget *widget = [self QT_MANGLE_NAMESPACE(qt_qwidget)];
+    if (!widget)
+        return NO; // This should happen only for qt_root_win
     bool isToolTip = (widget->windowType() == Qt::ToolTip);
 …
+}
+- (BOOL)canBecomeMainWindow
+{
+    QWidget *widget = [self QT_MANGLE_NAMESPACE(qt_qwidget)];
+    if (!widget)
+        return NO; // This should happen only for qt_root_win
+    bool isToolTip = (widget->windowType() == Qt::ToolTip);
+    bool isPopup = (widget->windowType() == Qt::Popup);
+    bool isTool = (widget->windowType() == Qt::Tool);
+    return !(isPopup || isToolTip || isTool);
+}
+- (void)becomeMainWindow
+{
+    [super becomeMainWindow];
+    // Cocoa sometimes tell a hidden window to become the
+    // main window (and as such, show it). This can e.g
+    // happend when the application gets activated. If
+    // this is the case, we tell it to hide again:
+    if (![self isVisible])
+        [self orderOut:self];
+}
 - (void)toggleToolbarShown:(id)sender
+{
 …
+}
-/*
-    The methods keyDown, keyUp, and flagsChanged... These really shouldn't ever
-    get hit. We automatically say we can be first responder if we are a window.
-    So, the handling should get handled by the view. This is here more as a
-    last resort (i.e., this is code that can potentially be removed).
- */
-- (void)keyDown:(NSEvent *)theEvent
+{
-    bool keyOK = qt_dispatchKeyEvent(theEvent, [self QT_MANGLE_NAMESPACE(qt_qwidget)]);
-    if (!keyOK)
-        [super keyDown:theEvent];
+}
-- (void)keyUp:(NSEvent *)theEvent
+{
-    bool keyOK = qt_dispatchKeyEvent(theEvent, [self QT_MANGLE_NAMESPACE(qt_qwidget)]);
-    if (!keyOK)
-        [super keyUp:theEvent];
+}
 - (void)flagsChanged:(NSEvent *)theEvent
+{
 …
+}
+- (void)qtDispatcherToQAction:(id)sender
+{
+    // If this window is modal, the menu bar will be modally shaddowed.
+    // In that case, since the window will be in the first responder chain,
+    // we can still catch the trigger here and forward it to the menu bar.
+    // This is needed as a single modal dialog on Qt should be able to access
+    // the application menu (e.g. quit).
+    [[NSApp QT_MANGLE_NAMESPACE(qt_qcocoamenuLoader)] qtDispatcherToQAction:sender];
+}
+- (void)terminate:(id)sender
+{
+    // This function is called from the quit item in the menubar when this window
+    // is in the first responder chain (see also qtDispatcherToQAction above)
+    [NSApp terminate:sender];
+}
 - (void)sendEvent:(NSEvent *)event
+{
+    if ([event type] == NSApplicationDefined) {
+        switch ([event subtype]) {
+            case QtCocoaEventSubTypePostMessage:
+                [NSApp qt_sendPostedMessage:event];
+                return;
+            default:
+                break;
+        }
+        return;
+    }
     QWidget *widget = [[QT_MANGLE_NAMESPACE(QCocoaWindowDelegate) sharedDelegate] qt_qwidgetForWindow:self];
     // Cocoa can hold onto the window after we've disavowed its knowledge. So,
     // if we get sent an event afterwards just have it go through the super's
 …
     // sometimes need to redirect mouse events to the popup.
     QWidget *popup = qAppInstance()->activePopupWidget();
     if (popup) {
+    if (popup && popup != widget) {
         switch([event type])
+        {
 …
             handled = qt_mac_handleMouseEvent(view, event, QEvent::MouseButtonPress, mouseButton);
             // Don't call super here. This prevents us from getting the mouseUp event,
             // which we need to send even if the mouseDown event was not accepted.
+            // which we need to send even if the mouseDown event was not accepted.
             // (this is standard Qt behavior.)
             break;
 …
+}
+- (void)setInitialFirstResponder:(NSView *)view
+{
+    // This method is called the first time the window is placed on screen and
+    // is the earliest point in time we can connect OpenGL contexts to NSViews.
+    QWidget *qwidget = [[QT_MANGLE_NAMESPACE(QCocoaWindowDelegate) sharedDelegate] qt_qwidgetForWindow:self];
+    if (qwidget) {
+        qt_event_request_window_change(qwidget);
+        qt_mac_send_posted_gl_updates(qwidget);
+    }
+    [super setInitialFirstResponder:view];
+}
 - (BOOL)makeFirstResponder:(NSResponder *)responder
+{
 …
+}
+-(void)registerDragTypes
+{
+    // Calling registerForDraggedTypes below is slow, so only do
+    // it once for each window, or when the custom types change.
+    QMacCocoaAutoReleasePool pool;
+    const QStringList& customTypes = qEnabledDraggedTypes();
+    if (currentCustomDragTypes == 0 || *currentCustomDragTypes != customTypes) {
+        if (currentCustomDragTypes == 0)
+            currentCustomDragTypes = new QStringList();
+        *currentCustomDragTypes = customTypes;
+        const NSString* mimeTypeGeneric = @"com.trolltech.qt.MimeTypeName";
+        NSMutableArray *supportedTypes = [NSMutableArray arrayWithObjects:NSColorPboardType,
+                       NSFilenamesPboardType, NSStringPboardType,
+                       NSFilenamesPboardType, NSPostScriptPboardType, NSTIFFPboardType,
+                       NSRTFPboardType, NSTabularTextPboardType, NSFontPboardType,
+                       NSRulerPboardType, NSFileContentsPboardType, NSColorPboardType,
+                       NSRTFDPboardType, NSHTMLPboardType, NSPICTPboardType,
+                       NSURLPboardType, NSPDFPboardType, NSVCardPboardType,
+                       NSFilesPromisePboardType, NSInkTextPboardType,
+                       NSMultipleTextSelectionPboardType, mimeTypeGeneric, nil];
+        // Add custom types supported by the application.
+        for (int i = 0; i < customTypes.size(); i++) {
+           [supportedTypes addObject:reinterpret_cast<const NSString *>(QCFString::toCFStringRef(customTypes[i]))];
+        }
+        [self registerForDraggedTypes:supportedTypes];
+    }
+}
+- (QWidget *)dragTargetHitTest:(id <NSDraggingInfo>)sender
+{
+    // Do a hittest to find the NSView under the
+    // mouse, and return the corresponding QWidget:
+    NSPoint windowPoint = [sender draggingLocation];
+    NSView *candidateView = [[self contentView] hitTest:windowPoint];
+    if (![candidateView isKindOfClass:[QT_MANGLE_NAMESPACE(QCocoaView) class]])
+        return 0;
+    return [static_cast<QT_MANGLE_NAMESPACE(QCocoaView) *>(candidateView) qt_qwidget];
+}
+- (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender
+{
+    // The user dragged something into the window. Send a draggingEntered message
+    // to the QWidget under the mouse. As the drag moves over the window, and over
+    // different widgets, we will handle enter and leave events from within
+    // draggingUpdated below. The reason why we handle this ourselves rather than
+    // subscribing for drag events directly in QCocoaView is that calling
+    // registerForDraggedTypes on the views will severly degrade initialization time
+    // for an application that uses a lot of drag subscribing widgets.
+    QWidget *target = [self dragTargetHitTest:sender];
+    if (!target)
+        return [super draggingEntered:sender];
+    if (target->testAttribute(Qt::WA_DropSiteRegistered) == false)
+        return NSDragOperationNone;
+    *currentDragTarget() = target;
+    return [reinterpret_cast<NSView *>((*currentDragTarget())->winId()) draggingEntered:sender];
+ }
+- (NSDragOperation)draggingUpdated:(id < NSDraggingInfo >)sender
+{
+    QWidget *target = [self dragTargetHitTest:sender];
+    if (!target)
+        return [super draggingUpdated:sender];
+    if (target == *currentDragTarget()) {
+        // The drag continues to move over the widget that we have sendt
+        // a draggingEntered message to. So just update the view:
+        return [reinterpret_cast<NSView *>((*currentDragTarget())->winId()) draggingUpdated:sender];
+    } else {
+        // The widget under the mouse has changed.
+        // So we need to fake enter/leave events:
+        if (*currentDragTarget())
+            [reinterpret_cast<NSView *>((*currentDragTarget())->winId()) draggingExited:sender];
+        if (target->testAttribute(Qt::WA_DropSiteRegistered) == false) {
+            *currentDragTarget() = 0;
+            return NSDragOperationNone;
+        }
+        *currentDragTarget() = target;
+        return [reinterpret_cast<NSView *>((*currentDragTarget())->winId()) draggingEntered:sender];
+    }
+}
+- (void)draggingExited:(id < NSDraggingInfo >)sender
+{
+    QWidget *target = [self dragTargetHitTest:sender];
+    if (!target)
+        return [super draggingExited:sender];
+    if (*currentDragTarget()) {
+        [reinterpret_cast<NSView *>((*currentDragTarget())->winId()) draggingExited:sender];
+        *currentDragTarget() = 0;
+    }
+}
+- (BOOL)performDragOperation:(id < NSDraggingInfo >)sender
+{
+    QWidget *target = [self dragTargetHitTest:sender];
+    if (!target)
+        return [super performDragOperation:sender];
+    BOOL dropResult = NO;
+    if (*currentDragTarget()) {
+        dropResult = [reinterpret_cast<NSView *>((*currentDragTarget())->winId()) performDragOperation:sender];
+        *currentDragTarget() = 0;
+    }
+    return dropResult;
+}
 - (void)displayIfNeeded
+{
 …
+}
+// This is a hack and it should be removed once we find the real cause for
+// the painting problems.
+// We have a static variable that signals if we have been called before or not.
+static bool firstDrawingInvocation = true;
+// The method below exists only as a workaround to draw/not draw the baseline
+// in the title bar. This is to support unifiedToolbar look.
+// This method is very special. To begin with, it is a
+// method that will get called only if we enable documentMode.
+// Furthermore, it won't get called as a normal method, we swap
+// this method with the normal implementation of drawRect in
+// _NSThemeFrame. When this method is active, its mission is to
+// first call the original drawRect implementation so the widget
+// gets proper painting. After that, it needs to detect if there
+// is a toolbar or not, in order to decide how to handle the unified
+// look. The distinction is important since the presence and
+// visibility of a toolbar change the way we enter into unified mode.
+// When there is a toolbar and that toolbar is visible, the problem
+// is as simple as to tell the toolbar not to draw its baseline.
+// However when there is not toolbar or the toolbar is not visible,
+// we need to draw a line on top of the baseline, because the baseline
+// in that case will belong to the title. For this case we need to draw
+// a line on top of the baseline.
+// As usual, there is a special case. When we first are called, we might
+// need to repaint ourselves one more time. We only need that if we
+// didn't get the activation, i.e. when we are launched via the command
+// line. And this only if the toolbar is visible from the beginning,
+// so we have a special flag that signals if we need to repaint or not.
+- (void)drawRectSpecial:(NSRect)rect
+{
+    // Call the original drawing method.
+    [self drawRectOriginal:rect];
+    NSWindow *window = [self window];
+    NSToolbar *toolbar = [window toolbar];
+    if(!toolbar) {
+        // There is no toolbar, we have to draw a line on top of the line drawn by Cocoa.
+        macDrawRectOnTop((void *)window);
+    } else {
+        if([toolbar isVisible]) {
+            // We tell Cocoa to avoid drawing the line at the end.
+            if(firstDrawingInvocation) {
+                firstDrawingInvocation = false;
+                macSyncDrawingOnFirstInvocation((void *)window);
+            } else
+                [toolbar setShowsBaselineSeparator:NO];
+        } else {
+            // There is a toolbar but it is not visible so
+            // we have to draw a line on top of the line drawn by Cocoa.
+            macDrawRectOnTop((void *)window);
+        }
+    }
+}

trunk/src/gui/kernel/qcocoaview_mac.mm

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 extern bool qt_sendSpontaneousEvent(QObject *, QEvent *); // qapplication.cpp
 extern OSViewRef qt_mac_nativeview_for(const QWidget *w); // qwidget_mac.mm
-extern const QStringList& qEnabledDraggedTypes(); // qmime_mac.cpp
 extern QPointer<QWidget> qt_mouseover; //qapplication_mac.mm
 extern QPointer<QWidget> qt_button_down; //qapplication_mac.cpp
+Qt::MouseButton cocoaButton2QtButton(NSInteger buttonNum)
+{
+    if (buttonNum == 0)
+        return Qt::LeftButton;
+    if (buttonNum == 1)
+        return Qt::RightButton;
+    if (buttonNum == 2)
+        return Qt::MidButton;
+    if (buttonNum == 3)
+        return Qt::XButton1;
+    if (buttonNum == 4)
+        return Qt::XButton2;
+    return Qt::NoButton;
+}
+extern Qt::MouseButton cocoaButton2QtButton(NSInteger buttonNum);
 struct dndenum_mapper
 …
+}
+#ifdef ALIEN_DEBUG
+static int qCocoaViewCount = 0;
+#endif
 @implementation QT_MANGLE_NAMESPACE(QCocoaView)
 …
         [self finishInitWithQWidget:widget widgetPrivate:widgetprivate];
+    }
+    [self setFocusRingType:NSFocusRingTypeNone];
     composingText = new QString();
+#ifdef ALIEN_DEBUG
+    ++qCocoaViewCount;
+    qDebug() << "init: qCocoaViewCount is" << qCocoaViewCount;
+#endif
     composing = false;
     sendKeyEvents = true;
-    currentCustomTypes = 0;
     [self setHidden:YES];
     return self;
 …
+}
--(void)registerDragTypes
+{
-    QMacCocoaAutoReleasePool pool;
-    // Calling registerForDraggedTypes is slow, so only do it once for each widget
-    // or when the custom types change.
-    const QStringList& customTypes = qEnabledDraggedTypes();
-    if (currentCustomTypes == 0 || *currentCustomTypes != customTypes) {
-        if (currentCustomTypes == 0)
-            currentCustomTypes = new QStringList();
-        *currentCustomTypes = customTypes;
-        const NSString* mimeTypeGeneric = @"com.trolltech.qt.MimeTypeName";
-        NSMutableArray *supportedTypes = [NSMutableArray arrayWithObjects:NSColorPboardType,
-                                   NSFilenamesPboardType, NSStringPboardType,
-                                   NSFilenamesPboardType, NSPostScriptPboardType, NSTIFFPboardType,
-                                   NSRTFPboardType, NSTabularTextPboardType, NSFontPboardType,
-                                   NSRulerPboardType, NSFileContentsPboardType, NSColorPboardType,
-                                   NSRTFDPboardType, NSHTMLPboardType, NSPICTPboardType,
-                                   NSURLPboardType, NSPDFPboardType, NSVCardPboardType,
-                                   NSFilesPromisePboardType, NSInkTextPboardType,
-                                   NSMultipleTextSelectionPboardType, mimeTypeGeneric, nil];
-        // Add custom types supported by the application.
-        for (int i = 0; i < customTypes.size(); i++) {
-           [supportedTypes addObject:reinterpret_cast<const NSString *>(QCFString::toCFStringRef(customTypes[i]))];
+        }
-        [self registerForDraggedTypes:supportedTypes];
+    }
+}
 - (void)resetCursorRects
+{
+    // [NSView addCursorRect] is slow, so bail out early if we can:
+    if (NSIsEmptyRect([self visibleRect]))
+        return;
     QWidget *cursorWidget = qwidget;
 …
     QRegion mask = qt_widget_private(cursorWidget)->extra->mask;
     NSCursor *nscursor = static_cast<NSCursor *>(qt_mac_nsCursorForQCursor(cursorWidget->cursor()));
+    if (mask.isEmpty()) {
+    // The mask could have the WA_MouseNoMask attribute set and that means that we have to ignore the mask.
+    if (mask.isEmpty() || cursorWidget->testAttribute(Qt::WA_MouseNoMask)) {
         [self addCursorRect:[qt_mac_nativeview_for(cursorWidget) visibleRect] cursor:nscursor];
     } else {
 …
+}
+- (void)changeDraggingCursor:(NSDragOperation)newOperation
+{
+    static SEL action = nil;
+    static bool operationSupported = false;
+    if (action == nil) {
+        action = NSSelectorFromString(@"operationNotAllowedCursor");
+        if ([NSCursor respondsToSelector:action]) {
+            operationSupported = true;
+        }
+    }
+    if (operationSupported) {
+        NSCursor *notAllowedCursor = [NSCursor performSelector:action];
+        bool isNotAllowedCursor = ([NSCursor currentCursor] == notAllowedCursor);
+        if (newOperation == NSDragOperationNone && !isNotAllowedCursor) {
+            [notAllowedCursor push];
+        } else if (newOperation != NSDragOperationNone && isNotAllowedCursor) {
+            [notAllowedCursor pop];
+        }
+    }
+}
 - (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender
+{
     if (qwidget->testAttribute(Qt::WA_DropSiteRegistered) == false)
         return NSDragOperationNone;
+    // NB: This function is called from QCoocaWindow/QCocoaPanel rather than directly
+    // from Cocoa. They modify the drag target, and might fake enter/leave events.
     NSPoint windowPoint = [sender draggingLocation];
-    if (qwidget->testAttribute(Qt::WA_TransparentForMouseEvents)) {
-        // pass the drag enter event to the view underneath.
-        NSView *candidateView = [[[self window] contentView] hitTest:windowPoint];
-        if (candidateView && candidateView != self)
-            return [candidateView draggingEntered:sender];
+    }
     dragEnterSequence = [sender draggingSequenceNumber];
     [self addDropData:sender];
 …
         // widget is not interested in this drag, so ignore this drop data.
         [self removeDropData];
+        [self changeDraggingCursor:NSDragOperationNone];
         return NSDragOperationNone;
     } else {
 …
+        }
         QT_PREPEND_NAMESPACE(qt_mac_copy_answer_rect)(qDMEvent);
+        [self changeDraggingCursor:nsActions];
         return nsActions;
+    }
 …
 - (NSDragOperation)draggingUpdated:(id < NSDraggingInfo >)sender
+{
+    // NB: This function is called from QCoocaWindow/QCocoaPanel rather than directly
+    // from Cocoa. They modify the drag target, and might fake enter/leave events.
     NSPoint windowPoint = [sender draggingLocation];
-    if (qwidget->testAttribute(Qt::WA_TransparentForMouseEvents)) {
-        // pass the drag move event to the view underneath.
-        NSView *candidateView = [[[self window] contentView] hitTest:windowPoint];
-        if (candidateView && candidateView != self)
-            return [candidateView draggingUpdated:sender];
+    }
     // in cases like QFocusFrame, the view under the mouse might
     // not have received the drag enter. Generate a synthetic
 …
         [self draggingEntered:sender];
     // drag enter event was rejected, so ignore the move event.
+    if (dropData == 0)
+    if (dropData == 0) {
+        [self changeDraggingCursor:NSDragOperationNone];
         return NSDragOperationNone;
+    }
     // return last value, if we are still in the answerRect.
     NSPoint globalPoint = [[sender draggingDestinationWindow] convertBaseToScreen:windowPoint];
 …
     QPoint posDrag(localPoint.x, localPoint.y);
     if (qt_mac_mouse_inside_answer_rect(posDrag)
+        && QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec.lastOperation) == nsActions)
+        return QT_PREPEND_NAMESPACE(qt_mac_mapDropActions)(QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec.lastAction));
+        && QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec.lastOperation) == nsActions) {
+        NSDragOperation operation = QT_PREPEND_NAMESPACE(qt_mac_mapDropActions)(QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec.lastAction));
+        [self changeDraggingCursor:operation];
+        return operation;
+    }
     // send drag move event to the widget
     QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec.lastOperation) = nsActions;
 …
         mimeData = QDragManager::self()->dragPrivate()->data;
     QDragMoveEvent qDMEvent(posDrag, qtAllowed, mimeData, QApplication::mouseButtons(), modifiers);
+    qDMEvent.setDropAction(QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec).lastAction);
+    if (QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec).lastAction != Qt::IgnoreAction
+        && QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec).buttons == qDMEvent.mouseButtons()
+        && QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec).modifiers == qDMEvent.keyboardModifiers())
+        qDMEvent.setDropAction(QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec).lastAction);
     qDMEvent.accept();
     QApplication::sendEvent(qwidget, &qDMEvent);
 …
+    }
     qt_mac_copy_answer_rect(qDMEvent);
+    [self changeDraggingCursor:operation];
     return operation;
+}
 …
 - (void)draggingExited:(id < NSDraggingInfo >)sender
+{
+    // NB: This function is called from QCoocaWindow/QCocoaPanel rather than directly
+    // from Cocoa. They modify the drag target, and might fake enter/leave events.
+    Q_UNUSED(sender);
     dragEnterSequence = -1;
-    if (qwidget->testAttribute(Qt::WA_TransparentForMouseEvents)) {
-        // try sending the leave event to the last view which accepted drag enter.
-        DnDParams *dndParams = [QT_MANGLE_NAMESPACE(QCocoaView) currentMouseEvent];
-        NSView *candidateView = [[[self window] contentView] hitTest:dndParams->activeDragEnterPos];
-        if (candidateView && candidateView != self)
-            return [candidateView draggingExited:sender];
+    }
     // drag enter event was rejected, so ignore the move event.
     if (dropData) {
 …
         [self removeDropData];
+    }
+    [self changeDraggingCursor:NSDragOperationEvery];
+}
 - (BOOL)performDragOperation:(id <NSDraggingInfo>)sender
+{
+    // NB: This function is called from QCoocaWindow/QCocoaPanel rather than directly
+    // from Cocoa. They modify the drag target, and might fake enter/leave events.
     NSPoint windowPoint = [sender draggingLocation];
     dragEnterSequence = -1;
-    if (qwidget->testAttribute(Qt::WA_TransparentForMouseEvents)) {
-        // pass the drop event to the view underneath.
-        NSView *candidateView = [[[self window] contentView] hitTest:windowPoint];
-        if (candidateView && candidateView != self)
-            return [candidateView performDragOperation:sender];
+    }
     [self addDropData:sender];
 …
     delete composingText;
     [[NSNotificationCenter defaultCenter] removeObserver:self];
+    delete currentCustomTypes;
+    [self unregisterDraggedTypes];
+#ifdef ALIEN_DEBUG
+    --qCocoaViewCount;
+    qDebug() << "qCocoaViewCount is" << qCocoaViewCount;
+#endif
     [super dealloc];
+}
 …
 - (BOOL)isOpaque;
+{
+    if (!qwidgetprivate)
+        return [super isOpaque];
     return qwidgetprivate->isOpaque;
+}
 …
+}
+- (BOOL) preservesContentDuringLiveResize;
+// We preserve the content of the view if WA_StaticContents is defined.
+//
+// More info in the Cocoa documentation:
+// http://developer.apple.com/mac/library/documentation/cocoa/conceptual/CocoaViewsGuide/Optimizing/Optimizing.html
+- (BOOL) preservesContentDuringLiveResize
+{
     return qwidget->testAttribute(Qt::WA_StaticContents);
 …
     // Make sure the opengl context is updated on resize.
     if (qwidgetprivate->isGLWidget) {
+    if (qwidgetprivate && qwidgetprivate->isGLWidget) {
         qwidgetprivate->needWindowChange = true;
         QEvent event(QEvent::MacGLWindowChange);
 …
+}
+// We catch the 'setNeedsDisplay:' message in order to avoid a useless full repaint.
+// During the resize, the top of the widget is repainted, probably because of the
+// change of coordinate space (Quartz vs Qt). This is then followed by this message:
+// -[NSView _setNeedsDisplayIfTopLeftChanged]
+// which force a full repaint by sending the message 'setNeedsDisplay:'.
+// That is what we are preventing here.
+- (void)setNeedsDisplay:(BOOL)flag {
+    if (![self inLiveResize] || !(qwidget->testAttribute(Qt::WA_StaticContents))) {
+        [super setNeedsDisplay:flag];
+    }
+}
 - (void)drawRect:(NSRect)aRect
+{
+    if (!qwidget)
+        return;
     if (QApplicationPrivate::graphicsSystem() != 0) {
         if (QWidgetBackingStore *bs = qwidgetprivate->maybeBackingStore()) {
+        if (qwidgetprivate->maybeBackingStore()) {
             // Drawing is handled on the window level
+            // See qcocoasharedwindowmethods_mac_p.
+            return;
+            // See qcocoasharedwindowmethods_mac_p.h
+            if (!qwidget->testAttribute(Qt::WA_PaintOnScreen))
+                return;
+        }
+    }
 …
         const QRect qrect = QRect(aRect.origin.x, aRect.origin.y, aRect.size.width, aRect.size.height);
+        QRegion qrgn(qrect);
+        QRegion qrgn;
+        const NSRect *rects;
+        NSInteger count;
+        [self getRectsBeingDrawn:&rects count:&count];
+        for (int i = 0; i < count; ++i) {
+            QRect tmpRect = QRect(rects[i].origin.x, rects[i].origin.y, rects[i].size.width, rects[i].size.height);
+            qrgn += tmpRect;
+        }
         if (!qwidget->isWindow() && !qobject_cast<QAbstractScrollArea *>(qwidget->parent())) {
 …
+        }
+        // Check for alien widgets, use qwidgetPrivate->drawWidget() to draw the widget if this
+        // is the case. This makes sure child widgets are drawn as well, Cocoa does not know about
+        // those and wont send them drawRect calls.
+        if (qwidget->testAttribute(Qt::WA_NativeWindow) && qt_widget_private(qwidget)->hasAlienChildren == false) {
         if (engine && !qwidget->testAttribute(Qt::WA_NoSystemBackground)
             && (qwidget->isWindow() || qwidget->autoFillBackground())
 …
 #endif
         qt_sendSpontaneousEvent(qwidget, &e);
+        } else {
+           qwidget->setAttribute(Qt::WA_WState_InPaintEvent, false); // QWidgetPrivate::drawWidget sets this
+           QWidgetPrivate *qwidgetPrivate = qt_widget_private(qwidget);
+           qwidgetPrivate->drawWidget(qwidget, qrgn, QPoint(), QWidgetPrivate::DrawAsRoot | QWidgetPrivate::DrawPaintOnScreen | QWidgetPrivate::DrawRecursive, 0);
+        }
         if (!redirectionOffset.isNull())
             QPainter::restoreRedirected(qwidget);
 …
 - (BOOL)acceptsFirstMouse:(NSEvent *)theEvent
+{
+    if (!qwidget)
+        return NO;
     Q_UNUSED(theEvent);
     return !qwidget->testAttribute(Qt::WA_MacNoClickThrough);
 …
 - (NSView *)hitTest:(NSPoint)aPoint
+{
+    if (!qwidget)
+        return [super hitTest:aPoint];
     if (qwidget->testAttribute(Qt::WA_TransparentForMouseEvents))
         return nil; // You cannot hit a transparent for mouse event widget.
 …
 - (void)updateTrackingAreas
+{
+    if (!qwidget)
+        return;
+    // [NSView addTrackingArea] is slow, so bail out early if we can:
+    if (NSIsEmptyRect([self visibleRect]))
+        return;
     QMacCocoaAutoReleasePool pool;
     if (NSArray *trackingArray = [self trackingAreas]) {
 …
 - (void)mouseEntered:(NSEvent *)event
+{
+    if (!qwidget)
+        return;
     if (qwidgetprivate->data.in_destructor)
         return;
+    QEvent enterEvent(QEvent::Enter);
+    NSPoint windowPoint = [event locationInWindow];
+    NSPoint globalPoint = [[event window] convertBaseToScreen:windowPoint];
+    NSPoint viewPoint = [self convertPoint:windowPoint fromView:nil];
     if (!qAppInstance()->activeModalWidget() || QApplicationPrivate::tryModalHelper(qwidget, 0)) {
+        QEvent enterEvent(QEvent::Enter);
+        NSPoint windowPoint = [event locationInWindow];
+        NSPoint globalPoint = [[event window] convertBaseToScreen:windowPoint];
+        NSPoint viewPoint = [self convertPoint:windowPoint fromView:nil];
         QApplication::sendEvent(qwidget, &enterEvent);
         qt_mouseover = qwidget;
         // Update cursor and dispatch hover events.
+        // Update cursor icon:
         qt_mac_update_cursor_at_global_pos(flipPoint(globalPoint).toPoint());
+        if (qwidget->testAttribute(Qt::WA_Hover) &&
+            (!qAppInstance()->activePopupWidget() || qAppInstance()->activePopupWidget() == qwidget->window())) {
+            QHoverEvent he(QEvent::HoverEnter, QPoint(viewPoint.x, viewPoint.y), QPoint(-1, -1));
+            QApplicationPrivate::instance()->notify_helper(qwidget, &he);
+        // Send mouse move and hover events as well:
+        if (!qAppInstance()->activePopupWidget() || qAppInstance()->activePopupWidget() == qwidget->window()) {
+            // This mouse move event should be sendt, even when mouse
+            // tracking is switched off (to trigger tooltips):
+            NSEvent *mouseEvent = [NSEvent mouseEventWithType:NSMouseMoved
+                location:windowPoint modifierFlags:[event modifierFlags] timestamp:[event timestamp]
+                windowNumber:[event windowNumber] context:[event context] eventNumber:[event eventNumber]
+                clickCount:0 pressure:0];
+            qt_mac_handleMouseEvent(self, mouseEvent, QEvent::MouseMove, Qt::NoButton);
+            if (qwidget->testAttribute(Qt::WA_Hover)) {
+                QHoverEvent he(QEvent::HoverEnter, QPoint(viewPoint.x, viewPoint.y), QPoint(-1, -1));
+                QApplicationPrivate::instance()->notify_helper(qwidget, &he);
+            }
+        }
+    }
 …
 - (void)mouseExited:(NSEvent *)event
+{
+    if (!qwidget)
+        return;
     QEvent leaveEvent(QEvent::Leave);
     NSPoint globalPoint = [[event window] convertBaseToScreen:[event locationInWindow]];
 …
 - (void)flagsChanged:(NSEvent *)theEvent
+{
+    if (!qwidget)
+        return;
     QWidget *widgetToGetKey = qwidget;
 …
 - (void)mouseMoved:(NSEvent *)theEvent
+{
+    if (!qwidget)
+        return;
     // We always enable mouse tracking for all QCocoaView-s. In cases where we have
     // child views, we will receive mouseMoved for both parent & the child (if
 …
         // Since deviceDelta is delivered as pixels rather than degrees, we need to
         // convert from pixels to degrees in a sensible manner.
+        // It looks like four degrees per pixel behaves most native.
+        // Qt expects the unit for delta to be 1/8 of a degree:
+        deltaX = [theEvent deviceDeltaX];
+        deltaY = [theEvent deviceDeltaY];
+        deltaZ = [theEvent deviceDeltaZ];
+        // It looks like 1/4 degrees per pixel behaves most native.
+        // (NB: Qt expects the unit for delta to be 8 per degree):
+        const int pixelsToDegrees = 2; // 8 * 1/4
+        deltaX = [theEvent deviceDeltaX] * pixelsToDegrees;
+        deltaY = [theEvent deviceDeltaY] * pixelsToDegrees;
+        deltaZ = [theEvent deviceDeltaZ] * pixelsToDegrees;
     } else {
         // carbonEventKind == kEventMouseWheelMoved
 …
+    }
 #endif //QT_NO_WHEELEVENT
-    if (!wheelOK) {
-        return [super scrollWheel:theEvent];
+    }
+}
 …
         return;
+#ifndef QT_NO_GESTURES
     QNativeGestureEvent qNGEvent;
     qNGEvent.gestureType = QNativeGestureEvent::Zoom;
 …
     qNGEvent.percentage = [event magnification];
     qt_sendSpontaneousEvent(qwidget, &qNGEvent);
+#endif // QT_NO_GESTURES
+}
 …
         return;
+#ifndef QT_NO_GESTURES
     QNativeGestureEvent qNGEvent;
     qNGEvent.gestureType = QNativeGestureEvent::Rotate;
 …
     qNGEvent.percentage = -[event rotation];
     qt_sendSpontaneousEvent(qwidget, &qNGEvent);
+#endif // QT_NO_GESTURES
+}
 …
         return;
+#ifndef QT_NO_GESTURES
     QNativeGestureEvent qNGEvent;
     qNGEvent.gestureType = QNativeGestureEvent::Swipe;
 …
         qNGEvent.angle = 270.0f;
     qt_sendSpontaneousEvent(qwidget, &qNGEvent);
+#endif // QT_NO_GESTURES
+}
 …
         return;
+#ifndef QT_NO_GESTURES
     QNativeGestureEvent qNGEvent;
     qNGEvent.gestureType = QNativeGestureEvent::GestureBegin;
 …
     qNGEvent.position = flipPoint(p).toPoint();
     qt_sendSpontaneousEvent(qwidget, &qNGEvent);
+#endif // QT_NO_GESTURES
+}
 …
         return;
+#ifndef QT_NO_GESTURES
     QNativeGestureEvent qNGEvent;
     qNGEvent.gestureType = QNativeGestureEvent::GestureEnd;
 …
     qNGEvent.position = flipPoint(p).toPoint();
     qt_sendSpontaneousEvent(qwidget, &qNGEvent);
+#endif // QT_NO_GESTURES
+}
 …
+{
     Q_UNUSED(note);
+    if (!qwidget)
+        return;
     if (qwidget->isWindow())
         return;
 …
     QMacCocoaAutoReleasePool pool;
     [super setEnabled:flag];
     if (qwidget->isEnabled() != flag)
+    if (qwidget && qwidget->isEnabled() != flag)
         qwidget->setEnabled(flag);
+}
 …
 - (BOOL)acceptsFirstResponder
+{
+    if (qwidget->isWindow())
+    if (!qwidget)
+        return NO;
+    // disabled widget shouldn't get focus even if it's a window.
+    // hence disabled windows will not get any key or mouse events.
+    if (!qwidget->isEnabled())
+        return NO;
+    // Before accepting the focus for a window, we check that
+    // the focusWidget (if any) is not contained in the same window.
+    if (qwidget->isWindow() && !qt_widget_private(qwidget)->topData()->embedded
+        && (!qApp->focusWidget() || qApp->focusWidget()->window() != qwidget)) {
         return YES;  // Always do it, so that windows can accept key press events.
+    }
     return qwidget->focusPolicy() != Qt::NoFocus;
+}
 …
 - (BOOL)resignFirstResponder
+{
+    if (!qwidget)
+        return NO;
     // Seems like the following test only triggers if this
     // view is inside a QMacNativeWidget:
     if (qwidget == QApplication::focusWidget())
+        QApplicationPrivate::setFocusWidget(0, Qt::OtherFocusReason);
+        qwidget->clearFocus();
+    return YES;
+}
+- (BOOL)becomeFirstResponder
+{
+    // see the comment in the acceptsFirstResponder - if the window "stole" focus
+    // let it become the responder, but don't tell Qt
+    if (qwidget && qt_widget_private(qwidget->window())->topData()->embedded
+        && !QApplication::focusWidget() && qwidget->focusPolicy() != Qt::NoFocus)
+        qwidget->setFocus(Qt::OtherFocusReason);
     return YES;
+}
 …
+}
+- (void) qt_clearQWidget
+{
+    qwidget = 0;
+    qwidgetprivate = 0;
+}
 - (BOOL)qt_leftButtonIsRightButton
+{
 …
     if (sendKeyEvents && !composing) {
         bool keyOK = qt_dispatchKeyEvent(theEvent, widgetToGetKey);
+        if (!keyOK && !sendToPopup)
+            [super keyDown:theEvent];
+        if (!keyOK && !sendToPopup) {
+            // find the first responder that is not created by Qt and forward
+            // the event to it (for example if Qt widget is embedded into native).
+            QWidget *toplevel = qwidget->window();
+            if (toplevel && qt_widget_private(toplevel)->topData()->embedded) {
+                if (NSResponder *w = [qt_mac_nativeview_for(toplevel) superview])
+                    [w keyDown:theEvent];
+            }
+        }
+    }
+}
 …
     if (sendKeyEvents) {
         bool keyOK = qt_dispatchKeyEvent(theEvent, qwidget);
+        if (!keyOK)
+            [super keyUp:theEvent];
+        if (!keyOK) {
+            QWidget *toplevel = qwidget->window();
+            if (toplevel && qt_widget_private(toplevel)->topData()->embedded) {
+                if (NSResponder *w = [qt_mac_nativeview_for(toplevel) superview])
+                    [w keyUp:theEvent];
+            }
+        }
+    }
+}
 …
 - (void)viewWillMoveToWindow:(NSWindow *)window
+{
+    if (qwidget == 0)
+        return;
     if (qwidget->windowFlags() & Qt::MSWindowsOwnDC
           && (window != [self window])) { // OpenGL Widget
-        // Create a stupid ClearDrawable Event
         QEvent event(QEvent::MacGLClearDrawable);
         qApp->sendEvent(qwidget, &event);
 …
 - (void)viewDidMoveToWindow
+{
+    if (qwidget == 0)
+        return;
     if (qwidget->windowFlags() & Qt::MSWindowsOwnDC && [self window]) {
         // call update paint event
 …
 - (NSArray*) validAttributesForMarkedText
+{
+    if (qwidget == 0)
+        return nil;
     if (!qwidget->testAttribute(Qt::WA_InputMethodEnabled))
         return nil;  // Not sure if that's correct, but it's saves a malloc.
 …
     [dndParams.view release];
     [image release];
+    dragPrivate()->executed_action = Qt::IgnoreAction;
+    if (dragPrivate())
+        dragPrivate()->executed_action = Qt::IgnoreAction;
     object = 0;
     Qt::DropAction performedAction(qt_mac_mapNSDragOperation(qMacDnDParams()->performedAction));
 …
+        }
+    }
+    o->setMimeData(0);
+    o->deleteLater();
     return performedAction;
+}

trunk/src/gui/kernel/qcocoaview_mac_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
     bool sendKeyEvents;
     QString *composingText;
-    QStringList *currentCustomTypes;
     NSInteger dragEnterSequence;
+}
 …
 - (void)draggingExited:(id < NSDraggingInfo >)sender;
 - (BOOL)performDragOperation:(id <NSDraggingInfo>)sender;
-- (void)registerDragTypes;
 - (void)removeDropData;
 - (void)addDropData:(id <NSDraggingInfo>)sender;
 …
 - (BOOL)isComposing;
 - (QWidget *)qt_qwidget;
+- (void) qt_clearQWidget;
 - (BOOL)qt_leftButtonIsRightButton;
 - (void)qt_setLeftButtonIsRightButton:(BOOL)isSwapped;
+- (void)changeDraggingCursor:(NSDragOperation)newOperation;
 + (DnDParams*)currentMouseEvent;

trunk/src/gui/kernel/qcocoawindow_mac.mm

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #import <private/qt_cocoa_helpers_mac_p.h>
 #import <private/qcocoawindowcustomthemeframe_mac_p.h>
+#import <private/qcocoaapplication_mac_p.h>
 #include <QtGui/QWidget>

trunk/src/gui/kernel/qcocoawindow_mac_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 @interface QT_MANGLE_NAMESPACE(QCocoaWindow) : NSWindow {
     bool leftButtonIsRightButton;
+    QStringList *currentCustomDragTypes;
+}
 + (Class)frameViewClassForStyleMask:(NSUInteger)styleMask;
+- (void)registerDragTypes;
 @end
 #endif

trunk/src/gui/kernel/qcocoawindowcustomthemeframe_mac.mm

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qcocoawindowcustomthemeframe_mac_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qcocoawindowdelegate_mac.mm

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
                                                    & ~Qt::WindowMaximized));
         qt_sendSpontaneousEvent(qwidget, &e);
+    } else {
+        widgetData->window_state = widgetData->window_state & ~Qt::WindowMaximized;
+        QWindowStateChangeEvent e(Qt::WindowStates(widgetData->window_state
+                                                   | Qt::WindowMaximized));
+        qt_sendSpontaneousEvent(qwidget, &e);
+    }
     NSRect rect = [[window contentView] frame];
 …
     QWidget *qwidget = m_windowHash->value([notification object]);
     Q_ASSERT(qwidget);
-    if (qwidget->isActiveWindow())
-        return;  // Widget is already active, no need to go through re-activation.
     onApplicationWindowChangedActivation(qwidget, true);
+}
 …
     QWidget *qwidget = m_windowHash->value([notification object]);
     Q_ASSERT(qwidget);
-    if (qwidget->isActiveWindow())
-        return;  // Widget is already active, no need to go through re-activation
     onApplicationWindowChangedActivation(qwidget, true);
+}
 …
     // saving the current window geometry before the window is maximized
     QWidget *qwidget = m_windowHash->value(window);
+    if (qwidget->isWindow() && !(qwidget->windowState() & Qt::WindowMaximized)) {
+        QWidgetPrivate *widgetPrivate = qt_widget_private(qwidget);
+        widgetPrivate->topData()->normalGeometry = qwidget->geometry();
+    QWidgetPrivate *widgetPrivate = qt_widget_private(qwidget);
+    if (qwidget->isWindow()) {
+        if(qwidget->windowState() & Qt::WindowMaximized) {
+            // Restoring
+            widgetPrivate->topData()->wasMaximized = false;
+        } else {
+            // Maximizing
+            widgetPrivate->topData()->normalGeometry = qwidget->geometry();
+            // If the window was maximized we need to update the coordinates since now it will start at 0,0.
+            // We do this in a special field that is only used when not restoring but manually resizing the window.
+            // Since the coordinates are fixed we just set a boolean flag.
+            widgetPrivate->topData()->wasMaximized = true;
+        }
+    }
     return YES;
 …
     return NO;
+}
+- (void)syncContentViewFrame: (NSNotification *)notification
+{
+    NSView *cView = [notification object];
+    if (cView) {
+        NSWindow *window = [cView window];
+        QWidget *qwidget = m_windowHash->value(window);
+        if (qwidget) {
+            QWidgetData *widgetData = qt_qwidget_data(qwidget);
+            NSRect rect = [cView frame];
+            const QSize newSize(rect.size.width, rect.size.height);
+            const QSize &oldSize = widgetData->crect.size();
+            if (newSize != oldSize) {
+                [self syncSizeForWidget:qwidget toSize:newSize fromSize:oldSize];
+            }
+        }
+    }
+}
 @end
 #endif// QT_MAC_USE_COCOA

trunk/src/gui/kernel/qcocoawindowdelegate_mac_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
         window:(NSWindow *)window withNewSize:(NSSize)proposedSize;
 - (QWidget *)qt_qwidgetForWindow:(NSWindow *)window;
+- (void)syncContentViewFrame: (NSNotification *)notification;
 @end
 #endif

trunk/src/gui/kernel/qcursor.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
          \o \inlineimage      cursor-closedhand.png
          \o Qt::ClosedHandCursor \o \c closedhand
+    \row \o
+         \o Qt::DragMoveCursor      \o \c dnd-move or \c move
+         \o
+         \o Qt::DragCopyCursor      \o \c dnd-copy or \c copy
+    \row \o
+         \o Qt::DragLinkCursor      \o \c dnd-link or \c link
     \endtable
 …
     Writes the \a cursor to the \a stream.
     \sa {Format of the QDataStream operators}
+    \sa {Serializing Qt Data Types}
 */
 …
     Reads the \a cursor from the \a stream.
     \sa {Format of the QDataStream operators}
+    \sa {Serializing Qt Data Types}
 */

trunk/src/gui/kernel/qcursor.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qcursor_mac.mm

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
     c->handle(); //force the cursor to get loaded, if it's not
+    if(1 || currentCursor != c->d) {
+        if(currentCursor && currentCursor->type == QCursorData::TYPE_ThemeCursor
+                && currentCursor->curs.tc.anim)
+            currentCursor->curs.tc.anim->stop();
+        QMacCocoaAutoReleasePool pool;
+        if(c->d->type == QCursorData::TYPE_ImageCursor) {
+            [static_cast<NSCursor *>(c->d->curs.cp.nscursor) set];
+        } else if(c->d->type == QCursorData::TYPE_ThemeCursor) {
+#ifdef QT_MAC_USE_COCOA
+            if (c->d->curs.cp.nscursor == 0)
+                [[NSCursor arrowCursor] set];
+            [static_cast<NSCursor *>(c->d->curs.cp.nscursor) set];
+#else
+            if(SetAnimatedThemeCursor(c->d->curs.tc.curs, 0) == themeBadCursorIndexErr) {
+                SetThemeCursor(c->d->curs.tc.curs);
+            } else {
+                if(!c->d->curs.tc.anim)
+                    c->d->curs.tc.anim = new QMacAnimateCursor;
+                c->d->curs.tc.anim->start(c->d->curs.tc.curs);
+            }
+#endif
+    if(currentCursor && currentCursor->type == QCursorData::TYPE_ThemeCursor
+            && currentCursor->curs.tc.anim)
+        currentCursor->curs.tc.anim->stop();
+    if(c->d->type == QCursorData::TYPE_ImageCursor) {
+        [static_cast<NSCursor *>(c->d->curs.cp.nscursor) set];
+    } else if(c->d->type == QCursorData::TYPE_ThemeCursor) {
+        if(SetAnimatedThemeCursor(c->d->curs.tc.curs, 0) == themeBadCursorIndexErr) {
+            SetThemeCursor(c->d->curs.tc.curs);
+        } else {
+            if(!c->d->curs.tc.anim)
+                c->d->curs.tc.anim = new QMacAnimateCursor;
+            c->d->curs.tc.anim->start(c->d->curs.tc.curs);
+        }
+    }
 …
 void QCursor::setPos(int x, int y)
+{
+#ifdef QT_MAC_USE_COCOA
+    CGPoint pos;
+    pos.x = x;
+    pos.y = y;
+    CGEventRef e = CGEventCreateMouseEvent(0, kCGEventMouseMoved, pos, 0);
+    CGEventPost(kCGHIDEventTap, e);
+    CFRelease(e);
+#else
     CGWarpMouseCursorPosition(CGPointMake(x, y));
 …
         qt_sendSpontaneousEvent(widget, &me);
+    }
+#endif
+}
 …
         curs.cp.nscursor = [NSCursor closedHandCursor];
         break;
+    case Qt::DragCopyCursor:
+        type = QCursorData::TYPE_ThemeCursor;
+        curs.cp.nscursor = [NSCursor dragCopyCursor];
+        break;
+    case Qt::DragMoveCursor:
+        type = QCursorData::TYPE_ThemeCursor;
+        curs.cp.nscursor = [NSCursor arrowCursor];
+        break;
+    case Qt::DragLinkCursor:
+        type = QCursorData::TYPE_ThemeCursor;
+        curs.cp.nscursor = [NSCursor dragLinkCursor];
+        break;
 #define QT_USE_APPROXIMATE_CURSORS
 #ifdef QT_USE_APPROXIMATE_CURSORS
 …
         curs.tc.curs = kThemeClosedHandCursor;
         break;
+    case Qt::DragMoveCursor:
+        type = QCursorData::TYPE_ThemeCursor;
+        curs.tc.curs = kThemeArrowCursor;
+        break;
+    case Qt::DragCopyCursor:
+        type = QCursorData::TYPE_ThemeCursor;
+        curs.tc.curs = kThemeCopyArrowCursor;
+        break;
+    case Qt::DragLinkCursor:
+        type = QCursorData::TYPE_ThemeCursor;
+        curs.tc.curs = kThemeAliasArrowCursor;
+        break;
 #define QT_USE_APPROXIMATE_CURSORS
 #ifdef QT_USE_APPROXIMATE_CURSORS

trunk/src/gui/kernel/qcursor_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qcursor_qws.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qcursor_s60.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include <coecntrl.h>
 #include <qcursor.h>
 #include <qt_s60_p.h>
+#include <private/qt_s60_p.h>
 #include <qbitmap.h>
 #include <w32std.h>
 …
         RWsPointerCursor *pcurs = reinterpret_cast<RWsPointerCursor *> (handle);
         node.SetCustomPointerCursor(*pcurs);
+    }
+    } else
 #ifdef Q_SYMBIAN_HAS_SYSTEM_CURSORS
     else {
+    {
         TInt shape = qt_symbian_translate_cursor_shape(cursor.shape());
         node.SetPointerCursor(shape);

trunk/src/gui/kernel/qcursor_win.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include <qimage.h>
 #include <qt_windows.h>
+#include <private/qapplication_p.h>
 QT_BEGIN_NAMESPACE
 …
         return;
+    }
+    case Qt::DragCopyCursor:
+    case Qt::DragMoveCursor:
+    case Qt::DragLinkCursor: {
+        QPixmap pixmap = QApplicationPrivate::instance()->getPixmapCursor(cshape);
+        hcurs = create32BitCursor(pixmap, hx, hy);
+    }
     default:
         qWarning("QCursor::update: Invalid cursor shape %d", cshape);

trunk/src/gui/kernel/qcursor_x11.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 ****************************************************************************/
+#include <qdebug.h>
 #include <qdatastream.h>
 #include <private/qcursor_p.h>
 #include <private/qt_x11_p.h>
+#include <private/qapplication_p.h>
 #include <qbitmap.h>
 #include <qcursor.h>
 …
 #include "qx11info_x11.h"
+#include <private/qpixmap_x11_p.h>
 QT_BEGIN_NAMESPACE
 …
         "left_ptr_watch",
         "openhand",
+        "closedhand"
+        "closedhand",
+        "copy",
+        "move",
+        "link"
     };
 #ifndef QT_NO_XCURSOR
+    if (X11->ptrXcursorLibraryLoadCursor)
+        hcurs = X11->ptrXcursorLibraryLoadCursor(dpy, cursorNames[cshape]);
+    if (X11->ptrXcursorLibraryLoadCursor) {
+        // special case for non-standard dnd-* cursors
+        switch (cshape) {
+        case Qt::DragCopyCursor:
+            hcurs = X11->ptrXcursorLibraryLoadCursor(dpy, "dnd-copy");
+            break;
+        case Qt::DragMoveCursor:
+            hcurs = X11->ptrXcursorLibraryLoadCursor(dpy, "dnd-move");
+            break;
+        case Qt::DragLinkCursor:
+            hcurs = X11->ptrXcursorLibraryLoadCursor(dpy, "dnd-link");
+            break;
+        default:
+            break;
+        }
+        if (!hcurs)
+            hcurs = X11->ptrXcursorLibraryLoadCursor(dpy, cursorNames[cshape]);
+    }
     if (hcurs)
         return;
 #endif // QT_NO_XCURSOR
     static const char cur_blank_bits[] = {
+    static const uchar cur_blank_bits[] = {
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 …
 #ifndef QT_USE_APPROXIMATE_CURSORS
     static const char cur_ver_bits[] = {
+    static const uchar cur_ver_bits[] = {
 x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0xc0, 0x03, 0xe0, 0x07, 0xf0, 0x0f,
 x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0xf0, 0x0f,
 xe0, 0x07, 0xc0, 0x03, 0x80, 0x01, 0x00, 0x00 };
     static const char mcur_ver_bits[] = {
+    static const uchar mcur_ver_bits[] = {
 x00, 0x00, 0x80, 0x03, 0xc0, 0x07, 0xe0, 0x0f, 0xf0, 0x1f, 0xf8, 0x3f,
 xfc, 0x7f, 0xc0, 0x07, 0xc0, 0x07, 0xc0, 0x07, 0xfc, 0x7f, 0xf8, 0x3f,
 xf0, 0x1f, 0xe0, 0x0f, 0xc0, 0x07, 0x80, 0x03 };
     static const char cur_hor_bits[] = {
+    static const uchar cur_hor_bits[] = {
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x08, 0x30, 0x18,
 x38, 0x38, 0xfc, 0x7f, 0xfc, 0x7f, 0x38, 0x38, 0x30, 0x18, 0x20, 0x08,
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
     static const char mcur_hor_bits[] = {
+    static const uchar mcur_hor_bits[] = {
 x00, 0x00, 0x00, 0x00, 0x40, 0x04, 0x60, 0x0c, 0x70, 0x1c, 0x78, 0x3c,
 xfc, 0x7f, 0xfe, 0xff, 0xfe, 0xff, 0xfe, 0xff, 0xfc, 0x7f, 0x78, 0x3c,
 x70, 0x1c, 0x60, 0x0c, 0x40, 0x04, 0x00, 0x00 };
     static const char cur_bdiag_bits[] = {
+    static const uchar cur_bdiag_bits[] = {
 x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x3e, 0x00, 0x3c, 0x00, 0x3e,
 x00, 0x37, 0x88, 0x23, 0xd8, 0x01, 0xf8, 0x00, 0x78, 0x00, 0xf8, 0x00,
 xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
     static const char mcur_bdiag_bits[] = {
+    static const uchar mcur_bdiag_bits[] = {
 x00, 0x00, 0xc0, 0x7f, 0x80, 0x7f, 0x00, 0x7f, 0x00, 0x7e, 0x04, 0x7f,
 x8c, 0x7f, 0xdc, 0x77, 0xfc, 0x63, 0xfc, 0x41, 0xfc, 0x00, 0xfc, 0x01,
 xfc, 0x03, 0xfc, 0x07, 0x00, 0x00, 0x00, 0x00 };
     static const char cur_fdiag_bits[] = {
+    static const uchar cur_fdiag_bits[] = {
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0xf8, 0x00, 0x78, 0x00,
 xf8, 0x00, 0xd8, 0x01, 0x88, 0x23, 0x00, 0x37, 0x00, 0x3e, 0x00, 0x3c,
 x00, 0x3e, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00 };
     static const char mcur_fdiag_bits[] = {
+    static const uchar mcur_fdiag_bits[] = {
 x00, 0x00, 0x00, 0x00, 0xfc, 0x07, 0xfc, 0x03, 0xfc, 0x01, 0xfc, 0x00,
 xfc, 0x41, 0xfc, 0x63, 0xdc, 0x77, 0x8c, 0x7f, 0x04, 0x7f, 0x00, 0x7e,
 x00, 0x7f, 0x80, 0x7f, 0xc0, 0x7f, 0x00, 0x00 };
     static const char *cursor_bits16[] = {
+    static const uchar *cursor_bits16[] = {
         cur_ver_bits, mcur_ver_bits, cur_hor_bits, mcur_hor_bits,
         cur_bdiag_bits, mcur_bdiag_bits, cur_fdiag_bits, mcur_fdiag_bits,
 , 0, cur_blank_bits, cur_blank_bits };
     static const char vsplit_bits[] = {
+    static const uchar vsplit_bits[] = {
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 …
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
     static const char vsplitm_bits[] = {
+    static const uchar vsplitm_bits[] = {
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,
 …
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
     static const char hsplit_bits[] = {
+    static const uchar hsplit_bits[] = {
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 …
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
     static const char hsplitm_bits[] = {
+    static const uchar hsplitm_bits[] = {
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 …
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
     static const char whatsthis_bits[] = {
+    static const uchar whatsthis_bits[] = {
 x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05, 0xf0, 0x07, 0x00,
 x09, 0x18, 0x0e, 0x00, 0x11, 0x1c, 0x0e, 0x00, 0x21, 0x1c, 0x0e, 0x00,
 …
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, };
     static const char whatsthism_bits[] = {
+    static const uchar whatsthism_bits[] = {
 x01, 0x00, 0x00, 0x00, 0x03, 0xf0, 0x07, 0x00, 0x07, 0xf8, 0x0f, 0x00,
 x0f, 0xfc, 0x1f, 0x00, 0x1f, 0x3e, 0x1f, 0x00, 0x3f, 0x3e, 0x1f, 0x00,
 …
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, };
     static const char busy_bits[] = {
+    static const uchar busy_bits[] = {
 x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
 x09, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
 …
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
     static const char busym_bits[] = {
+    static const uchar busym_bits[] = {
 x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
 x0f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00,
 …
 x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
     static const char * const cursor_bits32[] = {
+    static const uchar * const cursor_bits32[] = {
         vsplit_bits, vsplitm_bits, hsplit_bits, hsplitm_bits,
 , 0, 0, 0, whatsthis_bits, whatsthism_bits, busy_bits, busym_bits
     };
     static const char forbidden_bits[] = {
+    static const uchar forbidden_bits[] = {
 x00,0x00,0x00,0x80,0x1f,0x00,0xe0,0x7f,0x00,0xf0,0xf0,0x00,0x38,0xc0,0x01,
 x7c,0x80,0x03,0xec,0x00,0x03,0xce,0x01,0x07,0x86,0x03,0x06,0x06,0x07,0x06,
 …
 x38,0xc0,0x01,0xf0,0xe0,0x00,0xe0,0x7f,0x00,0x80,0x1f,0x00,0x00,0x00,0x00 };
     static const char forbiddenm_bits[] = {
+    static const uchar forbiddenm_bits[] = {
 x80,0x1f,0x00,0xe0,0x7f,0x00,0xf0,0xff,0x00,0xf8,0xff,0x01,0xfc,0xf0,0x03,
 xfe,0xc0,0x07,0xfe,0x81,0x07,0xff,0x83,0x0f,0xcf,0x07,0x0f,0x8f,0x0f,0x0f,
 …
 xfc,0xe0,0x03,0xf8,0xff,0x01,0xf0,0xff,0x00,0xe0,0x7f,0x00,0x80,0x1f,0x00};
     static const char openhand_bits[] = {
+    static const uchar openhand_bits[] = {
 x80,0x01,0x58,0x0e,0x64,0x12,0x64,0x52,0x48,0xb2,0x48,0x92,
 x16,0x90,0x19,0x80,0x11,0x40,0x02,0x40,0x04,0x40,0x04,0x20,
 x08,0x20,0x10,0x10,0x20,0x10,0x00,0x00};
     static const char openhandm_bits[] = {
+    static const uchar openhandm_bits[] = {
 x80,0x01,0xd8,0x0f,0xfc,0x1f,0xfc,0x5f,0xf8,0xff,0xf8,0xff,
 xf6,0xff,0xff,0xff,0xff,0x7f,0xfe,0x7f,0xfc,0x7f,0xfc,0x3f,
 xf8,0x3f,0xf0,0x1f,0xe0,0x1f,0x00,0x00};
     static const char closedhand_bits[] = {
+    static const uchar closedhand_bits[] = {
 x00,0x00,0x00,0x00,0x00,0x00,0xb0,0x0d,0x48,0x32,0x08,0x50,
 x10,0x40,0x18,0x40,0x04,0x40,0x04,0x20,0x08,0x20,0x10,0x10,
 x20,0x10,0x20,0x10,0x00,0x00,0x00,0x00};
     static const char closedhandm_bits[] = {
+    static const uchar closedhandm_bits[] = {
 x00,0x00,0x00,0x00,0x00,0x00,0xb0,0x0d,0xf8,0x3f,0xf8,0x7f,
 xf0,0x7f,0xf8,0x7f,0xfc,0x7f,0xfc,0x3f,0xf8,0x3f,0xf0,0x1f,
 xe0,0x1f,0xe0,0x1f,0x00,0x00,0x00,0x00};
     static const char * const cursor_bits20[] = {
+    static const uchar * const cursor_bits20[] = {
         forbidden_bits, forbiddenm_bits
     };
 …
         fg.blue  = 0;
         int i = (cshape - Qt::SizeVerCursor) * 2;
         pm  = XCreateBitmapFromData(dpy, rootwin, cursor_bits16[i], 16, 16);
         pmm = XCreateBitmapFromData(dpy, rootwin, cursor_bits16[i + 1], 16, 16);
+        pm  = XCreateBitmapFromData(dpy, rootwin, reinterpret_cast<const char*>(cursor_bits16[i]), 16, 16);
+        pmm = XCreateBitmapFromData(dpy, rootwin, reinterpret_cast<const char*>(cursor_bits16[i + 1]), 16, 16);
         hcurs = XCreatePixmapCursor(dpy, pm, pmm, &fg, &bg, 8, 8);
     } else if ((cshape >= Qt::SplitVCursor && cshape <= Qt::SplitHCursor)
 …
         fg.blue  = 0;
         int i = (cshape - Qt::SplitVCursor) * 2;
         pm  = XCreateBitmapFromData(dpy, rootwin, cursor_bits32[i], 32, 32);
         pmm = XCreateBitmapFromData(dpy, rootwin, cursor_bits32[i + 1], 32, 32);
+        pm  = XCreateBitmapFromData(dpy, rootwin, reinterpret_cast<const char *>(cursor_bits32[i]), 32, 32);
+        pmm = XCreateBitmapFromData(dpy, rootwin, reinterpret_cast<const char *>(cursor_bits32[i + 1]), 32, 32);
         int hs = (cshape == Qt::PointingHandCursor || cshape == Qt::WhatsThisCursor
                   || cshape == Qt::BusyCursor) ? 0 : 16;
 …
         fg.blue  = 0;
         int i = (cshape - Qt::ForbiddenCursor) * 2;
         pm  = XCreateBitmapFromData(dpy, rootwin, cursor_bits20[i], 20, 20);
         pmm = XCreateBitmapFromData(dpy, rootwin, cursor_bits20[i + 1], 20, 20);
+        pm  = XCreateBitmapFromData(dpy, rootwin, reinterpret_cast<const char *>(cursor_bits20[i]), 20, 20);
+        pmm = XCreateBitmapFromData(dpy, rootwin, reinterpret_cast<const char *>(cursor_bits20[i + 1]), 20, 20);
         hcurs = XCreatePixmapCursor(dpy, pm, pmm, &fg, &bg, 10, 10);
     } else if (cshape == Qt::OpenHandCursor || cshape == Qt::ClosedHandCursor) {
 …
         fg.blue  = 0;
         bool open = cshape == Qt::OpenHandCursor;
+        pm  = XCreateBitmapFromData(dpy, rootwin, open ? openhand_bits : closedhand_bits, 16, 16);
+        pmm = XCreateBitmapFromData(dpy, rootwin, open ? openhandm_bits : closedhandm_bits, 16, 16);
+        pm  = XCreateBitmapFromData(dpy, rootwin, reinterpret_cast<const char *>(open ? openhand_bits : closedhand_bits), 16, 16);
+        pmm = XCreateBitmapFromData(dpy, rootwin, reinterpret_cast<const char *>(open ? openhandm_bits : closedhandm_bits), 16, 16);
+        hcurs = XCreatePixmapCursor(dpy, pm, pmm, &fg, &bg, 8, 8);
+    } else if (cshape == Qt::DragCopyCursor || cshape == Qt::DragMoveCursor
+               || cshape == Qt::DragLinkCursor) {
+        XColor bg, fg;
+        bg.red   = 255 << 8;
+        bg.green = 255 << 8;
+        bg.blue  = 255 << 8;
+        fg.red   = 0;
+        fg.green = 0;
+        fg.blue  = 0;
+        QImage image = QApplicationPrivate::instance()->getPixmapCursor(cshape).toImage();
+        pm = QX11PixmapData::createBitmapFromImage(image);
+        pmm = QX11PixmapData::createBitmapFromImage(image.createAlphaMask().convertToFormat(QImage::Format_MonoLSB));
         hcurs = XCreatePixmapCursor(dpy, pm, pmm, &fg, &bg, 8, 8);
+    }
 …
         sh = XC_watch;
         break;
+    case Qt::DragCopyCursor:
+        sh = XC_tcross;
+        break;
+    case Qt::DragLinkCursor:
+        sh = XC_center_ptr;
+        break;
+    case Qt::DragMoveCursor:
+        sh = XC_top_left_arrow;
+        break;
 #endif /* QT_USE_APPROXIMATE_CURSORS */
     default:

trunk/src/gui/kernel/qdesktopwidget.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qdesktopwidget.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qdesktopwidget.qdoc

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 ** This file is part of the documentation of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
+** $QT_BEGIN_LICENSE:FDL$
 ** Commercial Usage
 ** Licensees holding valid Qt Commercial licenses may use this file in
 ** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+** Software or, alternatively, in accordance with the terms contained in a
+** written agreement between you and Nokia.
+**
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of this
+** file.
 **
 ** If you have questions regarding the use of this file, please contact

trunk/src/gui/kernel/qdesktopwidget_mac.mm

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qdesktopwidget_mac_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qdesktopwidget_qws.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qdesktopwidget_s60.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
     rects->resize(QDesktopWidgetPrivate::screenCount);
     workrects->resize(QDesktopWidgetPrivate::screenCount);
+    (*rects)[0].setRect(0, 0, S60->screenWidthInPixels, S60->screenHeightInPixels);
+    QRect wr = qt_TRect2QRect(static_cast<CEikAppUi*>(S60->appUi())->ClientRect());
+    (*workrects)[0].setRect(wr.x(), wr.y(), wr.width(), wr.height());
+}
 …
+}
+const QRect QDesktopWidget::availableGeometry(int /* screen */) const
+{
+    TRect clientRect = static_cast<CEikAppUi*>(S60->appUi())->ClientRect();
+    return qt_TRect2QRect(clientRect);
+}
+const QRect QDesktopWidget::screenGeometry(int /* screen */) const
+const QRect QDesktopWidget::availableGeometry(int screen) const
+{
     Q_D(const QDesktopWidget);
+    return QRect(0, 0, S60->screenWidthInPixels, S60->screenHeightInPixels);
+    }
+    if (screen < 0 || screen >= d->screenCount)
+        screen = d->primaryScreen;
+    return d->workrects->at(screen);
+}
+const QRect QDesktopWidget::screenGeometry(int screen) const
+{
+    Q_D(const QDesktopWidget);
+    if (screen < 0 || screen >= d->screenCount)
+        screen = d->primaryScreen;
+    return d->rects->at(screen);
+}
 int QDesktopWidget::screenNumber(const QWidget * /* widget */) const

trunk/src/gui/kernel/qdesktopwidget_win.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include "qt_windows.h"
 #include "qapplication_p.h"
 #include "qlibrary.h"
+#include <private/qsystemlibrary_p.h>
 #include <qvector.h>
 #include <limits.h>
 …
     typedef BOOL (WINAPI *InfoFunc)(HMONITOR, MONITORINFO*);
     typedef BOOL (CALLBACK *EnumProc)(HMONITOR, HDC, LPRECT, LPARAM);
+    typedef BOOL (QT_WIN_CALLBACK *EnumProc)(HMONITOR, HDC, LPRECT, LPARAM);
     typedef BOOL (WINAPI *EnumFunc)(HDC, LPCRECT, EnumProc, LPARAM);
 …
 BOOL CALLBACK enumCallback(HMONITOR hMonitor, HDC, LPRECT, LPARAM)
+BOOL QT_WIN_CALLBACK enumCallback(HMONITOR hMonitor, HDC, LPRECT, LPARAM)
+{
     QDesktopWidgetPrivate::screenCount++;
 …
 #ifndef Q_OS_WINCE
     QLibrary user32Lib(QLatin1String("user32"));
+    QSystemLibrary user32Lib(QLatin1String("user32"));
     if (user32Lib.load()) {
         enumDisplayMonitors = (EnumFunc)user32Lib.resolve("EnumDisplayMonitors");
 …
     getMonitorInfo = 0;
 #else
     QLibrary coreLib(QLatin1String("coredll"));
+    QSystemLibrary coreLib(QLatin1String("coredll"));
     if (coreLib.load()) {
         // CE >= 4.0 case

trunk/src/gui/kernel/qdesktopwidget_x11.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qdnd.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include <ctype.h>
+#include <private/qapplication_p.h>
 #ifndef QT_NO_DRAGANDDROP
 QT_BEGIN_NAMESPACE
-// These pixmaps approximate the images in the Windows User Interface Guidelines.
-// XPM
-static const char * const move_xpm[] = {
-"11 20 3 1",
-".        c None",
-#if defined(Q_WS_WIN)
-"a        c #000000",
-"X        c #FFFFFF", // Windows cursor is traditionally white
-#else
-"a        c #FFFFFF",
-"X        c #000000", // X11 cursor is traditionally black
-#endif
-"aa.........",
-"aXa........",
-"aXXa.......",
-"aXXXa......",
-"aXXXXa.....",
-"aXXXXXa....",
-"aXXXXXXa...",
-"aXXXXXXXa..",
-"aXXXXXXXXa.",
-"aXXXXXXXXXa",
-"aXXXXXXaaaa",
-"aXXXaXXa...",
-"aXXaaXXa...",
-"aXa..aXXa..",
-"aa...aXXa..",
-"a.....aXXa.",
-"......aXXa.",
-".......aXXa",
-".......aXXa",
-"........aa."};
-#if defined(Q_WS_WIN) || defined(Q_WS_PM)
-/* XPM */
-static const char * const ignore_xpm[] = {
-"24 30 3 1",
-".        c None",
-#if defined(Q_WS_WIN)
-"a        c #000000",
-"X        c #FFFFFF", // Windows cursor is traditionally white
-#else
-"a        c #FFFFFF",
-"X        c #000000", // OS/2 cursor is traditionally black
-#endif
-"aa......................",
-"aXa.....................",
-"aXXa....................",
-"aXXXa...................",
-"aXXXXa..................",
-"aXXXXXa.................",
-"aXXXXXXa................",
-"aXXXXXXXa...............",
-"aXXXXXXXXa..............",
-"aXXXXXXXXXa.............",
-"aXXXXXXaaaa.............",
-"aXXXaXXa................",
-"aXXaaXXa................",
-"aXa..aXXa...............",
-"aa...aXXa...............",
-"a.....aXXa..............",
-"......aXXa.....XXXX.....",
-".......aXXa..XXaaaaXX...",
-".......aXXa.XaaaaaaaaX..",
-"........aa.XaaaXXXXaaaX.",
-"...........XaaaaX..XaaX.",
-"..........XaaXaaaX..XaaX",
-"..........XaaXXaaaX.XaaX",
-"..........XaaX.XaaaXXaaX",
-"..........XaaX..XaaaXaaX",
-"...........XaaX..XaaaaX.",
-"...........XaaaXXXXaaaX.",
-"............XaaaaaaaaX..",
-".............XXaaaaXX...",
-"...............XXXX....."};
-#endif
-/* XPM */
-static const char * const copy_xpm[] = {
-"24 30 3 1",
-".        c None",
-"a        c #000000",
-"X        c #FFFFFF",
-#if defined(Q_WS_WIN) // Windows cursor is traditionally white
-"aa......................",
-"aXa.....................",
-"aXXa....................",
-"aXXXa...................",
-"aXXXXa..................",
-"aXXXXXa.................",
-"aXXXXXXa................",
-"aXXXXXXXa...............",
-"aXXXXXXXXa..............",
-"aXXXXXXXXXa.............",
-"aXXXXXXaaaa.............",
-"aXXXaXXa................",
-"aXXaaXXa................",
-"aXa..aXXa...............",
-"aa...aXXa...............",
-"a.....aXXa..............",
-"......aXXa..............",
-".......aXXa.............",
-".......aXXa.............",
-"........aa...aaaaaaaaaaa",
-#else
-"XX......................",
-"XaX.....................",
-"XaaX....................",
-"XaaaX...................",
-"XaaaaX..................",
-"XaaaaaX.................",
-"XaaaaaaX................",
-"XaaaaaaaX...............",
-"XaaaaaaaaX..............",
-"XaaaaaaaaaX.............",
-"XaaaaaaXXXX.............",
-"XaaaXaaX................",
-"XaaXXaaX................",
-"XaX..XaaX...............",
-"XX...XaaX...............",
-"X.....XaaX..............",
-"......XaaX..............",
-".......XaaX.............",
-".......XaaX.............",
-"........XX...aaaaaaaaaaa",
-#endif
-".............aXXXXXXXXXa",
-".............aXXXXXXXXXa",
-".............aXXXXaXXXXa",
-".............aXXXXaXXXXa",
-".............aXXaaaaaXXa",
-".............aXXXXaXXXXa",
-".............aXXXXaXXXXa",
-".............aXXXXXXXXXa",
-".............aXXXXXXXXXa",
-".............aaaaaaaaaaa"};
-/* XPM */
-static const char * const link_xpm[] = {
-"24 30 3 1",
-".        c None",
-"a        c #000000",
-"X        c #FFFFFF",
-#if defined(Q_WS_WIN) // Windows cursor is traditionally white
-"aa......................",
-"aXa.....................",
-"aXXa....................",
-"aXXXa...................",
-"aXXXXa..................",
-"aXXXXXa.................",
-"aXXXXXXa................",
-"aXXXXXXXa...............",
-"aXXXXXXXXa..............",
-"aXXXXXXXXXa.............",
-"aXXXXXXaaaa.............",
-"aXXXaXXa................",
-"aXXaaXXa................",
-"aXa..aXXa...............",
-"aa...aXXa...............",
-"a.....aXXa..............",
-"......aXXa..............",
-".......aXXa.............",
-".......aXXa.............",
-"........aa...aaaaaaaaaaa",
-#else
-"XX......................",
-"XaX.....................",
-"XaaX....................",
-"XaaaX...................",
-"XaaaaX..................",
-"XaaaaaX.................",
-"XaaaaaaX................",
-"XaaaaaaaX...............",
-"XaaaaaaaaX..............",
-"XaaaaaaaaaX.............",
-"XaaaaaaXXXX.............",
-"XaaaXaaX................",
-"XaaXXaaX................",
-"XaX..XaaX...............",
-"XX...XaaX...............",
-"X.....XaaX..............",
-"......XaaX..............",
-".......XaaX.............",
-".......XaaX.............",
-"........XX...aaaaaaaaaaa",
-#endif
-".............aXXXXXXXXXa",
-".............aXXXaaaaXXa",
-".............aXXXXaaaXXa",
-".............aXXXaaaaXXa",
-".............aXXaaaXaXXa",
-".............aXXaaXXXXXa",
-".............aXXaXXXXXXa",
-".............aXXXaXXXXXa",
-".............aXXXXXXXXXa",
-".............aaaaaaaaaaa"};
 #ifndef QT_NO_DRAGANDDROP
 …
     Q_ASSERT(!instance);
-#if defined(Q_WS_WIN) || defined(Q_WS_PM)
-    n_cursor = 4;
-#else
-    n_cursor = 3;
-#endif
 #ifdef Q_WS_QWS
     currentActionForOverrideCursor = Qt::IgnoreAction;
-#endif
-    pm_cursor = new QPixmap[n_cursor];
-    pm_cursor[0] = QPixmap((const char **)move_xpm);
-    pm_cursor[1] = QPixmap((const char **)copy_xpm);
-    pm_cursor[2] = QPixmap((const char **)link_xpm);
-#if defined(Q_WS_WIN) || defined(Q_WS_PM)
-    pm_cursor[3] = QPixmap((const char **)ignore_xpm);
 #endif
     object = 0;
 …
 #endif
     instance = 0;
-    delete [] pm_cursor;
     delete dropData;
+}
 …
         return d->customCursors[action];
     else if (action == Qt::MoveAction)
         return pm_cursor[0];
+        return QApplicationPrivate::instance()->getPixmapCursor(Qt::DragMoveCursor);
     else if (action == Qt::CopyAction)
         return pm_cursor[1];
+        return QApplicationPrivate::instance()->getPixmapCursor(Qt::DragCopyCursor);
     else if (action == Qt::LinkAction)
         return pm_cursor[2];
+        return QApplicationPrivate::instance()->getPixmapCursor(Qt::DragLinkCursor);
 #ifdef Q_WS_WIN
     else if (action == Qt::IgnoreAction)
         return pm_cursor[3];
+        return QApplicationPrivate::instance()->getPixmapCursor(Qt::ForbiddenCursor);
 #endif
     return QPixmap();

trunk/src/gui/kernel/qdnd_mac.mm

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
             if (atleastOne){
                 DisposeDrag(dragRef);
+                o->setMimeData(0);
+                o->deleteLater();
                 return action;
+            }
 …
         GetDragDropAction(dragRef, &ret);
         DisposeDrag(dragRef); //cleanup
+        o->setMimeData(0);
+        o->deleteLater();
         return qt_mac_dnd_map_mac_default_action(ret);
+    }

trunk/src/gui/kernel/qdnd_p.h

-              r786
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 private:
-    QPixmap *pm_cursor;
-    int n_cursor;
 #ifdef Q_WS_QWS
     Qt::DropAction currentActionForOverrideCursor;

trunk/src/gui/kernel/qdnd_qws.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
     switch(e->type()) {
+        case QEvent::ShortcutOverride:
+            // prevent accelerators from firing while dragging
+            e->accept();
+            return true;
         case QEvent::KeyPress:

trunk/src/gui/kernel/qdnd_s60.cpp

r769	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qdnd_win.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 //                    IDropSource Methods
 //---------------------------------------------------------------------
 STDMETHODIMP
+QT_ENSURE_STACK_ALIGNED_FOR_SSE STDMETHODIMP
 QOleDropSource::QueryContinueDrag(BOOL fEscapePressed, DWORD grfKeyState)
+{
 …
     if (fEscapePressed) {
         return ResultFromScode(DRAGDROP_S_CANCEL);
+    } else if (!(grfKeyState & (MK_LBUTTON|MK_MBUTTON|MK_RBUTTON))) {
+    } else if ((GetAsyncKeyState(VK_LBUTTON) == 0)
+        && (GetAsyncKeyState(VK_MBUTTON) == 0)
+        && (GetAsyncKeyState(VK_RBUTTON) == 0))    {
+        // grfKeyState is broken on CE & some Windows XP versions,
+        // therefore we need to check the state manually
         return ResultFromScode(DRAGDROP_S_DROP);
     } else {
+#if defined(Q_OS_WINCE)
+        // grfKeyState is broken on CE, therefore need to check
+        // the state manually
+        if ((GetAsyncKeyState(VK_LBUTTON) == 0) &&
+            (GetAsyncKeyState(VK_MBUTTON) == 0) &&
+            (GetAsyncKeyState(VK_RBUTTON) == 0)) {
+            return ResultFromScode(DRAGDROP_S_DROP);
+        }
+#else
+#if !defined(Q_OS_WINCE)
         if (currentButtons == Qt::NoButton) {
             currentButtons = keystate_to_mousebutton(grfKeyState);
 …
+}
 STDMETHODIMP
+QT_ENSURE_STACK_ALIGNED_FOR_SSE STDMETHODIMP
 QOleDropSource::GiveFeedback(DWORD dwEffect)
+{
 …
 //---------------------------------------------------------------------
 STDMETHODIMP
+QT_ENSURE_STACK_ALIGNED_FOR_SSE STDMETHODIMP
 QOleDropTarget::DragEnter(LPDATAOBJECT pDataObj, DWORD grfKeyState, POINTL pt, LPDWORD pdwEffect)
+{
 …
+}
 STDMETHODIMP
+QT_ENSURE_STACK_ALIGNED_FOR_SSE STDMETHODIMP
 QOleDropTarget::DragOver(DWORD grfKeyState, POINTL pt, LPDWORD pdwEffect)
+{
 …
+}
 STDMETHODIMP
+QT_ENSURE_STACK_ALIGNED_FOR_SSE STDMETHODIMP
 QOleDropTarget::DragLeave()
+{
 …
 #define KEY_STATE_BUTTON_MASK (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)
 STDMETHODIMP
+QT_ENSURE_STACK_ALIGNED_FOR_SSE STDMETHODIMP
 QOleDropTarget::Drop(LPDATAOBJECT /*pDataObj*/, DWORD grfKeyState, POINTL pt, LPDWORD pdwEffect)
+{

trunk/src/gui/kernel/qdnd_x11.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include "qdesktopwidget.h"
 #include "qevent.h"
-#include "qdatetime.h"
 #include "qiodevice.h"
 #include "qpointer.h"
 #include "qcursor.h"
+#include "qelapsedtimer.h"
 #include "qvariant.h"
 #include "qvector.h"
 …
 #include "qdnd_p.h"
+#include "qapplication_p.h"
 #include "qt_x11_p.h"
 #include "qx11info_x11.h"
 …
+}
+// TODO: remove and use QApplication::currentKeyboardModifiers() in Qt 4.8.
+static Qt::KeyboardModifiers currentKeyboardModifiers()
+{
+    Window root;
+    Window child;
+    int root_x, root_y, win_x, win_y;
+    uint keybstate;
+    for (int i = 0; i < ScreenCount(X11->display); ++i) {
+        if (XQueryPointer(X11->display, QX11Info::appRootWindow(i), &root, &child,
+                          &root_x, &root_y, &win_x, &win_y, &keybstate))
+            return X11->translateModifiers(keybstate & 0x00ff);
+    }
+    return 0;
+}
 void QX11Data::xdndHandleDrop(QWidget *, const XEvent * xe, bool passive)
 …
         if (!dropData)
             dropData = (manager->object) ? manager->dragPrivate()->data : manager->dropData;
+        // Drop coming from another app? Update keyboard modifiers.
+        if (!qt_xdnd_dragging) {
+            QApplicationPrivate::modifier_buttons = currentKeyboardModifiers();
+        }
         QDropEvent de(qt_xdnd_current_position, possible_actions, dropData,
 …
+    }
+    if (e->type() == QEvent::ShortcutOverride) {
+        // prevent accelerators from firing while dragging
+        e->accept();
+        return true;
+    }
     if (e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease) {
         QKeyEvent *ke = ((QKeyEvent*)e);
 …
 #ifndef QT_NO_CURSOR
         noDropCursor = new QCursor(Qt::ForbiddenCursor);
         moveCursor = new QCursor(dragCursor(Qt::MoveAction), 0,0);
         copyCursor = new QCursor(dragCursor(Qt::CopyAction), 0,0);
         linkCursor = new QCursor(dragCursor(Qt::LinkAction), 0,0);
+        moveCursor = new QCursor(Qt::DragMoveCursor);
+        copyCursor = new QCursor(Qt::DragCopyCursor);
+        linkCursor = new QCursor(Qt::DragLinkCursor);
 #endif
+    }
 …
         Atom type;
         if (X11->clipboardReadProperty(tw->effectiveWinId(), ATOM(XdndSelection), true, &result, 0, &type, 0, false)) {
+        if (X11->clipboardReadProperty(tw->effectiveWinId(), ATOM(XdndSelection), true, &result, 0, &type, 0)) {
             if (type == ATOM(INCR)) {
                 int nbytes = result.size() >= 4 ? *((int*)result.data()) : 0;
 …
         QApplication::flush();
         QTime started = QTime::currentTime();
         QTime now = started;
+        QElapsedTimer timer;
+        timer.start();
         do {
             XEvent event;
             if (XCheckTypedEvent(X11->display, ClientMessage, &event))
                 qApp->x11ProcessEvent(&event);
-            now = QTime::currentTime();
-            if (started > now) // crossed midnight
-                started = now;
             // sleep 50 ms, so we don't use up CPU cycles all the time.
 …
             usleep_tv.tv_usec = 50000;
             select(0, 0, 0, 0, &usleep_tv);
         } while (object && started.msecsTo(now) < 1000);
+        } while (object && timer.hasExpired(1000));
+    }

trunk/src/gui/kernel/qdrag.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
     loop. Other events are still delivered to the application while
     the operation is performed. On Windows, the Qt event loop is
+    blocked while during the operation.
+    blocked during the operation. However, QDrag::exec() on
+        Windows causes processEvents() to be called frequently to keep the GUI responsive.
+        If any loops or operations are called while a drag operation is active, it will block the drag operation.
 */

trunk/src/gui/kernel/qdrag.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qevent.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
   Z-axis, pass zero here.
   The \a tangentialPressure paramater contins the tangential pressure of an air
+  The \a tangentialPressure parameter contins the tangential pressure of an air
   brush. If the device does not support tangential pressure, pass 0 here.
 …
         dbg.nospace() << "QChildEvent(" << n << ", " << (static_cast<const QChildEvent*>(e))->child();
         return dbg.space();
+#ifndef QT_NO_GESTURES
     case QEvent::Gesture:
         n = "Gesture";
         break;
+#endif
     default:
         dbg.nospace() << "QEvent(" << (const void *)e << ", type = " << e->type() << ')';
 …
     \since 4.6
     \ingroup events
     \ingroup multitouch
+    \ingroup touch
     \section1 Enabling Touch Events
 …
     Similarly to QMouseEvent, Qt automatically grabs each touch point on the first press inside a
     widget, and the widget will receive all updates for the touch point until it is released.
     Note that it is possible for a widget to receive events for multiple touch points, and that
+    Note that it is possible for a widget to receive events for numerous touch points, and that
     multiple widgets may be receiving touch events at the same time.
 …
     \i As mentioned above, enabling touch events means multiple widgets can be receiving touch
     events simultaneously. Combined with the default QWidget::event() handling for QTouchEvents,
     this gives you great flexibility in designing multi-touch user interfaces. Be aware of the
+    this gives you great flexibility in designing touch user interfaces. Be aware of the
     implications. For example, it is possible that the user is moving a QSlider with one finger and
     pressing a QPushButton with another. The signals emitted by these widgets will be
 …
     \i QTouchEvents are not affected by a \l{QWidget::grabMouse()}{mouse grab} or an
     \l{QApplication::activePopupWidget()}{active pop-up widget}. The behavior of QTouchEvents is
     undefined when opening a pop-up or grabbing the mouse while there are multiple active touch
+    undefined when opening a pop-up or grabbing the mouse while there are more than one active touch
     points.
 …
+}
+#ifndef QT_NO_GESTURES
 /*!
     \class QGestureEvent
 …
     QGestureEvent::accept() for each of them, or an event filter consumes the
     event.
+    \section1 Further Reading
+    For an overview of gesture handling in Qt and information on using gestures
+    in your applications, see the \l{Gestures Programming} document.
     \sa QGesture, QGestureRecognizer,
 …
 #endif
+#endif // QT_NO_GESTURES
 QT_END_NAMESPACE

trunk/src/gui/kernel/qevent.h

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 class QAction;
+#ifndef QT_NO_GESTURES
 class QGesture;
+#endif
 class Q_GUI_EXPORT QInputEvent : public QEvent
 …
 };
+#ifndef QT_NO_GESTURES
 class QGesture;
 class QGestureEventPrivate;
 …
     friend class QGestureManager;
 };
+#endif // QT_NO_GESTURES
 QT_END_NAMESPACE

trunk/src/gui/kernel/qevent_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 };
+#ifndef QT_NO_GESTURES
 class QNativeGestureEvent : public QEvent
+{
 …
     QMap<Qt::GestureType, QWidget *> targetWidgets;
 };
+#endif // QT_NO_GESTURES
 class QFileOpenEventPrivate

trunk/src/gui/kernel/qeventdispatcher_glib_qws.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qeventdispatcher_glib_qws_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qeventdispatcher_mac.mm

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #ifndef QT_NO_THREAD
 #  include "qmutex.h"
+#endif
 QT_BEGIN_NAMESPACE
 QT_USE_NAMESPACE
-#endif
 /*****************************************************************************
 …
         case NSOtherMouseUp:
         case NSOtherMouseDragged:
+#ifndef QT_NO_GESTURES
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
         case NSEventTypeGesture: // touch events
 …
         case NSEventTypeEndGesture:
 #endif
+#endif // QT_NO_GESTURES
             result    = true;
         break;
 …
     Q_D(QEventDispatcherMac);
     d->interrupt = false;
+#ifdef QT_MAC_USE_COCOA
+    bool interruptLater = false;
+    QtMacInterruptDispatcherHelp::cancelInterruptLater();
+#endif
     // In case we end up recursing while we now process events, make sure
     // that we send remaining posted Qt events before this call returns:
 …
         NSEvent* event = 0;
+        // If Qt is used as a plugin, or just added into a native cocoa
+        // application, we should not run or stop NSApplication;
+        // This will be done from outside Qt.
+        // And if processEvents is called manually (rather than from QEventLoop), we
+        // cannot enter a tight loop and block the call, but instead return after one flush:
+        bool canExec_3rdParty = d->nsAppRunCalledByQt || ![NSApp isRunning];
+        bool canExec_Qt = flags & QEventLoop::DialogExec || flags & QEventLoop::EventLoopExec;
+        // First, send all previously excluded input events, if any:
+        if (!(flags & QEventLoop::ExcludeUserInputEvents)) {
+            while (!d->queuedUserInputEvents.isEmpty()) {
+                event = static_cast<NSEvent *>(d->queuedUserInputEvents.takeFirst());
+                if (!filterEvent(event)) {
+                    qt_mac_send_event(flags, event, 0);
+                    retVal = true;
+                }
+                [event release];
+            }
+        }
+        // If Qt is used as a plugin, or as an extension in a native cocoa
+        // application, we should not run or stop NSApplication; This will be
+        // done from the application itself. And if processEvents is called
+        // manually (rather than from a QEventLoop), we cannot enter a tight
+        // loop and block this call, but instead we need to return after one flush:
+        const bool canExec_3rdParty = d->nsAppRunCalledByQt || ![NSApp isRunning];
+        const bool canExec_Qt = flags & QEventLoop::DialogExec || flags & QEventLoop::EventLoopExec;
         if (canExec_Qt && canExec_3rdParty) {
             // We can use exec-mode, meaning that we can stay in a tight loop until
+            // interrupted. This is mostly an optimization, but it also allow us
+            // to use [NSApp run], which is the recommended way of running applications
+            // in cocoa. [NSApp run] should be called at least once for any cocoa app.
+            // interrupted. This is mostly an optimization, but it allow us to use
+            // [NSApp run], which is the normal code path for cocoa applications.
             if (NSModalSession session = d->currentModalSession()) {
                 QBoolBlocker execGuard(d->currentExecIsNSAppRun, false);
                 while ([NSApp runModalSession:session] == NSRunContinuesResponse && !d->interrupt)
                     qt_mac_waitForMoreModalSessionEvents();
                 if (!d->interrupt && session == d->currentModalSessionCached) {
                     // INVARIANT: Someone called e.g. [NSApp stopModal:] from outside the event
+                    // Someone called [NSApp stopModal:] from outside the event
                     // dispatcher (e.g to stop a native dialog). But that call wrongly stopped
                     // 'session' as well. As a result, we need to restart all internal sessions:
 …
+            }
             retVal = true;
         } else do {
             // INVARIANT: We cannot block the thread (and run in a tight loop).
+        } else {
+            // We cannot block the thread (and run in a tight loop).
             // Instead we will process all current pending events and return.
+            bool mustRelease = false;
+            if (!(flags & QEventLoop::ExcludeUserInputEvents) && !d->queuedUserInputEvents.isEmpty()) {
+                // Process a pending user input event
+                mustRelease = true;
+                event = static_cast<NSEvent *>(d->queuedUserInputEvents.takeFirst());
+            } else {
+                if (NSModalSession session = d->currentModalSession()) {
+                    if (flags & QEventLoop::WaitForMoreEvents)
+                        qt_mac_waitForMoreModalSessionEvents();
+                    NSInteger status = [NSApp runModalSession:session];
+                    if (status != NSRunContinuesResponse && session == d->currentModalSessionCached) {
+                        // INVARIANT: Someone called e.g. [NSApp stopModal:] from outside the event
+                        // dispatcher (e.g to stop a native dialog). But that call wrongly stopped
+                        // 'session' as well. As a result, we need to restart all internal sessions:
+                        d->temporarilyStopAllModalSessions();
+                    }
+                    retVal = true;
+                    break;
+                } else {
+                    event = [NSApp nextEventMatchingMask:NSAnyEventMask
+                        untilDate:nil
+                        inMode:NSDefaultRunLoopMode
+                        dequeue: YES];
+                    if (event != nil) {
+                        if (flags & QEventLoop::ExcludeUserInputEvents) {
+                            if (IsMouseOrKeyEvent(event)) {
+                                // retain event here?
+                                [event retain];
+                                d->queuedUserInputEvents.append(event);
+                                continue;
+                            }
+            d->ensureNSAppInitialized();
+            if (NSModalSession session = d->currentModalSession()) {
+                if (flags & QEventLoop::WaitForMoreEvents)
+                    qt_mac_waitForMoreModalSessionEvents();
+                NSInteger status = [NSApp runModalSession:session];
+                if (status != NSRunContinuesResponse && session == d->currentModalSessionCached) {
+                    // INVARIANT: Someone called [NSApp stopModal:] from outside the event
+                    // dispatcher (e.g to stop a native dialog). But that call wrongly stopped
+                    // 'session' as well. As a result, we need to restart all internal sessions:
+                    d->temporarilyStopAllModalSessions();
+                }
+                retVal = true;
+            } else do {
+                event = [NSApp nextEventMatchingMask:NSAnyEventMask
+                    untilDate:nil
+                    inMode:NSDefaultRunLoopMode
+                    dequeue: YES];
+                if (event) {
+                    if (flags & QEventLoop::ExcludeUserInputEvents) {
+                        if (IsMouseOrKeyEvent(event)) {
+                            [event retain];
+                            d->queuedUserInputEvents.append(event);
+                            continue;
+                        }
+                    }
+                    if (!filterEvent(event) && qt_mac_send_event(flags, event, 0))
+                        retVal = true;
+                }
+            }
+            if (event) {
                 if (!filterEvent(event) && qt_mac_send_event(flags, event, 0))
                     retVal = true;
                 if (mustRelease)
                     [event release];
+            }
         } while(!d->interrupt && event != nil);
+            } while (!d->interrupt && event != nil);
+            // Since the window that holds modality might have changed while processing
+            // events, we we need to interrupt when we return back the previous process
+            // event recursion to ensure that we spin the correct modal session.
+            // We do the interruptLater at the end of the function to ensure that we don't
+            // disturb the 'wait for more events' below (as deleteLater will post an event):
+            interruptLater = true;
+        }
 #else
         do {
 …
+    }
+    // If we're interrupted, we need to interrupt the _current_
+    // recursion as well to check if it is  still supposed to be
+    // executing. This way we wind down the stack until we land
+    // on a recursion that again calls processEvents (typically
+    // from QEventLoop), and set interrupt to false:
+    if (d->interrupt)
+        interrupt();
 #ifdef QT_MAC_USE_COCOA
+    // In case we _now_ process events using [NSApp run], we need to stop it to
+    // ensure that:
+    //    1. the QEventLoop that called us is still executing, or
+    //    2. we have a modal session that needs to be spun instead.
+    // In case this is a plain call to processEvents (perhaps from a loop)
+    // from the application (rather than from a QEventLoop), we delay the
+    // interrupting until we/ actually enter a lower loop level (hence the
+    // deffered delete of the object below):
+    QtMacInterruptDispatcherHelp::interruptLater();
+#endif
+    if (d->interrupt) {
+        // We should continue to leave all recursion to processEvents until
+        // processEvents is called again (e.g. from a QEventLoop that
+        // was not yet told to quit:
+        interrupt();
+    }
+    if (interruptLater)
+        QtMacInterruptDispatcherHelp::interruptLater();
+#endif
     return retVal;
 …
 MacTimerHash QEventDispatcherMacPrivate::macTimerHash;
 bool QEventDispatcherMacPrivate::blockSendPostedEvents = false;
+bool QEventDispatcherMacPrivate::interrupt = false;
 #ifdef QT_MAC_USE_COCOA
 …
 bool QEventDispatcherMacPrivate::currentExecIsNSAppRun = false;
 bool QEventDispatcherMacPrivate::nsAppRunCalledByQt = false;
+bool QEventDispatcherMacPrivate::cleanupModalSessionsNeeded = false;
 NSModalSession QEventDispatcherMacPrivate::currentModalSessionCached = 0;
+int QEventDispatcherMacPrivate::activeModalSessionCount()
+{
+    // Returns the number of modal sessions created
+    // (and not just pushed onto the stack, pending to be created)
+    int count = 0;
+    for (int i=cocoaModalSessionStack.size()-1; i>=0; --i) {
+        QCocoaModalSessionInfo &info = cocoaModalSessionStack[i];
+        if (info.session)
+            ++count;
+    }
+    return count;
+void QEventDispatcherMacPrivate::ensureNSAppInitialized()
+{
+    // Some elements in Cocoa require NSApplication to be running before
+    // they get fully initialized, in particular the menu bar. This
+    // function is intended for cases where a dialog is told to execute before
+    // QApplication::exec is called, or the application spins the events loop
+    // manually rather than calling QApplication:exec.
+    // The function makes sure that NSApplication starts running, but stops
+    // it again as soon as the send posted events callback is called. That way
+    // we let Cocoa finish the initialization it seems to need. We'll only
+    // apply this trick at most once for any application, and we avoid doing it
+    // for the common case where main just starts QApplication::exec.
+    if (nsAppRunCalledByQt || [NSApp isRunning])
+        return;
+    nsAppRunCalledByQt = true;
+    QBoolBlocker block1(interrupt, true);
+    QBoolBlocker block2(currentExecIsNSAppRun, true);
+    [NSApp run];
+}
 void QEventDispatcherMacPrivate::temporarilyStopAllModalSessions()
+{
+    // Stop all created modal session, and as such, make then
+    // pending again. The next call to currentModalSession will
+    // recreate the session on top again:
+    // Flush, and Stop, all created modal session, and as
+    // such, make them pending again. The next call to
+    // currentModalSession will recreate them again. The
+    // reason to stop all session like this is that otherwise
+    // a call [NSApp stop] would not stop NSApp, but rather
+    // the current modal session. So if we need to stop NSApp
+    // we need to stop all the modal session first. To avoid changing
+    // the stacking order of the windows while doing so, we put
+    // up a block that is used in QCocoaWindow and QCocoaPanel:
     int stackSize = cocoaModalSessionStack.size();
     for (int i=stackSize-1; i>=0; --i) {
+    for (int i=0; i<stackSize; ++i) {
         QCocoaModalSessionInfo &info = cocoaModalSessionStack[i];
         if (info.session) {
 …
     if (cocoaModalSessionStack.isEmpty())
         return 0;
-    // Since this code will end up calling our Qt event handler
-    // (also from beginModalSessionForWindow), we need to block
-    // that to avoid side effects of events beeing delivered:
-    QBoolBlocker block(blockSendPostedEvents, true);
-    if (![NSApp isRunning]) {
-        // Sadly, we need to introduce this little event flush
-        // to stop dialogs from blinking/poping in front if a
-        // modal session restart was needed:
-        while (NSEvent *event = [NSApp nextEventMatchingMask:0
-                untilDate:nil
-                inMode:NSDefaultRunLoopMode
-                dequeue: YES]) {
-            qt_mac_send_event(0, event, 0);
+        }
+    }
     int sessionCount = cocoaModalSessionStack.size();
 …
             if (!window)
                 continue;
+            ensureNSAppInitialized();
+            QBoolBlocker block1(blockSendPostedEvents, true);
+            info.nswindow = window;
+            [(NSWindow*) info.nswindow retain];
+            int levelBeforeEnterModal = [window level];
             info.session = [NSApp beginModalSessionForWindow:window];
+            // Make sure we don't stack the window lower that it was before
+            // entering modal, in case it e.g. had the stays-on-top flag set:
+            if (levelBeforeEnterModal > [window level])
+                [window setLevel:levelBeforeEnterModal];
+        }
         currentModalSessionCached = info.session;
+    }
+        cleanupModalSessionsNeeded = false;
+    }
     return currentModalSessionCached;
+}
 …
         if (window && [window isKindOfClass:[NSPanel class]]) {
             [static_cast<NSPanel *>(window) setWorksWhenModal:worksWhenModal];
             if (worksWhenModal && dialogs[i]->isVisible()){
+            if (worksWhenModal && [window isVisible]){
                 [window orderFront:window];
+            }
 …
     // active. And make the dialog children of
     // the previous modal dialog unactive again:
+    QMacCocoaAutoReleasePool pool;
     int size = cocoaModalSessionStack.size();
     if (size > 0){
 …
+}
+void QEventDispatcherMacPrivate::cleanupModalSessions()
+{
+    // Go through the list of modal sessions, and end those
+    // that no longer has a widget assosiated; no widget means
+    // the the session has logically ended. The reason we wait like
+    // this to actually end the sessions for real (rather than at the
+    // point they were marked as stopped), is that ending a session
+    // when no other session runs below it on the stack will make cocoa
+    // drop some events on the floor.
+    QMacCocoaAutoReleasePool pool;
+    int stackSize = cocoaModalSessionStack.size();
+    for (int i=stackSize-1; i>=0; --i) {
+        QCocoaModalSessionInfo &info = cocoaModalSessionStack[i];
+        if (info.widget) {
+            // This session has a widget, and is therefore not marked
+            // as stopped. So just make it current. There might still be other
+            // stopped sessions on the stack, but those will be stopped on
+            // a later "cleanup" call.
+            currentModalSessionCached = info.session;
+            break;
+        }
+        cocoaModalSessionStack.remove(i);
+        currentModalSessionCached = 0;
+        if (info.session) {
+            [NSApp endModalSession:info.session];
+            [(NSWindow *)info.nswindow release];
+        }
+    }
+    updateChildrenWorksWhenModal();
+    cleanupModalSessionsNeeded = false;
+}
 void QEventDispatcherMacPrivate::beginModalSession(QWidget *widget)
+{
 …
     // currentModalSession). A QCocoaModalSessionInfo is considered pending to be stopped if
     // the widget pointer is zero, and the session pointer is non-zero (it will be fully
     // stopped in endModalSession().
     QCocoaModalSessionInfo info = {widget, 0};
+    // stopped in cleanupModalSessions()).
+    QCocoaModalSessionInfo info = {widget, 0, 0};
     cocoaModalSessionStack.push(info);
     updateChildrenWorksWhenModal();
 …
     for (int i=stackSize-1; i>=0; --i) {
         QCocoaModalSessionInfo &info = cocoaModalSessionStack[i];
         if (info.widget == widget)
+        if (info.widget == widget) {
             info.widget = 0;
+    }
+    // Now we stop, and remove, all sessions marked as pending
+    // to be stopped on _top_ of the stack, if any:
+    bool needToInterruptEventDispatcher = false;
+    bool needToUpdateChildrenWorksWhenModal = false;
+    for (int i=stackSize-1; i>=0; --i) {
+        QCocoaModalSessionInfo &info = cocoaModalSessionStack[i];
+        if (info.widget)
+            break;
+        cocoaModalSessionStack.remove(i);
+        needToUpdateChildrenWorksWhenModal = true;
+        currentModalSessionCached = 0;
+        if (info.session) {
+            [NSApp endModalSession:info.session];
+            needToInterruptEventDispatcher = true;
+        }
+    }
+    if (needToUpdateChildrenWorksWhenModal)
+        updateChildrenWorksWhenModal();
+    if (needToInterruptEventDispatcher)
+        QEventDispatcherMac::instance()->interrupt();
+            if (i == stackSize-1) {
+                // The top sessions ended. Interrupt the event dispatcher
+                // to start spinning the correct session immidiatly:
+                currentModalSessionCached = 0;
+                cleanupModalSessionsNeeded = true;
+                QEventDispatcherMac::instance()->interrupt();
+            }
+        }
+    }
+}
 …
 QEventDispatcherMacPrivate::QEventDispatcherMacPrivate()
-    : interrupt(false)
+{
+}
 …
 inline static void processPostedEvents(QEventDispatcherMacPrivate *const d, const bool blockSendPostedEvents)
+{
+    if (blockSendPostedEvents || d->interrupt) {
+    if (blockSendPostedEvents) {
+        // We're told to not send posted events (because the event dispatcher
+        // is currently working on setting up the correct session to run). But
+        // we still need to make sure that we don't fall asleep until pending events
+        // are sendt, so we just signal this need, and return:
         CFRunLoopSourceSignal(d->postedEventsSource);
+    } else {
+        if (!d->threadData->canWait || (d->serialNumber != d->lastSerial)) {
+            d->lastSerial = d->serialNumber;
+            QApplicationPrivate::sendPostedEvents(0, 0, d->threadData);
+        }
+        return;
+    }
+#ifdef QT_MAC_USE_COCOA
+    if (d->cleanupModalSessionsNeeded)
+        d->cleanupModalSessions();
+#endif
+    if (d->interrupt) {
+#ifdef QT_MAC_USE_COCOA
+        if (d->currentExecIsNSAppRun) {
+            // The event dispatcher has been interrupted. But since
+            // [NSApplication run] is running the event loop, we
+            // delayed stopping it until now (to let cocoa process
+            // pending cocoa events first).
+            if (d->currentModalSessionCached)
+                d->temporarilyStopAllModalSessions();
+            [NSApp stop:NSApp];
+            d->cancelWaitForMoreEvents();
+        }
+#endif
+        return;
+    }
+    if (!d->threadData->canWait || (d->serialNumber != d->lastSerial)) {
+        d->lastSerial = d->serialNumber;
+        QApplicationPrivate::sendPostedEvents(0, 0, d->threadData);
+    }
+}
 …
     Q_UNUSED(ref);
     Q_UNUSED(activity);
+#ifdef QT_MAC_USE_COCOA
+    QApplicationPrivate::qt_initAfterNSAppStarted();
+#endif
     processPostedEvents(static_cast<QEventDispatcherMacPrivate *>(info), blockSendPostedEvents);
+}
 …
     processPostedEvents(static_cast<QEventDispatcherMacPrivate *>(info), blockSendPostedEvents);
+}
+#ifdef QT_MAC_USE_COCOA
+void QEventDispatcherMacPrivate::cancelWaitForMoreEvents()
+{
+    // In case the event dispatcher is waiting for more
+    // events somewhere, we post a dummy event to wake it up:
+    QMacCocoaAutoReleasePool pool;
+    [NSApp postEvent:[NSEvent otherEventWithType:NSApplicationDefined location:NSZeroPoint
+        modifierFlags:0 timestamp:0. windowNumber:0 context:0
+        subtype:QtCocoaEventSubTypeWakeup data1:0 data2:0] atStart:NO];
+}
+#endif
 void QEventDispatcherMac::interrupt()
 …
     CFRunLoopStop(mainRunLoop());
 #else
+    QMacCocoaAutoReleasePool pool;
+    // In case we wait for more events inside
+    // processEvents (or NSApp run), post a dummy to wake it up:
+    static const short NSAppShouldStopForQt = SHRT_MAX;
+    [NSApp postEvent:[NSEvent otherEventWithType:NSApplicationDefined location:NSZeroPoint
+        modifierFlags:0 timestamp:0. windowNumber:0 context:0
+        subtype:NSAppShouldStopForQt data1:0 data2:0] atStart:NO];
+    if (d->activeModalSessionCount() == 0) {
+        // We should only stop NSApp if we actually started it (and
+        // not some 3rd party application, e.g. if we are a plugin).
+        if (d->nsAppRunCalledByQt)
+            [NSApp stop:NSApp];
+    }
+    // We do nothing more here than setting d->interrupt = true, and
+    // poke the event loop if it is sleeping. Actually stopping
+    // NSApp, or the current modal session, is done inside the send
+    // posted events callback. We do this to ensure that all current pending
+    // cocoa events gets delivered before we stop. Otherwise, if we now stop
+    // the last event loop recursion, cocoa will just drop pending posted
+    // events on the floor before we get a chance to reestablish a new session.
+    d->cancelWaitForMoreEvents();
 #endif
+}
 …
+}
-/////////////////////////////////////////////////////////////////////////////
 #ifdef QT_MAC_USE_COCOA
 …
 QtMacInterruptDispatcherHelp::QtMacInterruptDispatcherHelp() : cancelled(false)
+{
+    // This is the whole point of encapsulation this code
+    // inside a class; we can make the code (inside destructor)
+    // execute on lower loop level:
+    // The whole point of this class is that we enable a way to interrupt
+    // the event dispatcher when returning back to a lower recursion level
+    // than where interruptLater was called. This is needed to detect if
+    // [NSApp run] should still be running at the recursion level it is at.
+    // Since the interrupt is canceled if processEvents is called before
+    // this object gets deleted, we also avoid interrupting unnecessary.
     deleteLater();
+}
 …
     if (cancelled)
         return;
     instance = 0;
-    if (QEventDispatcherMacPrivate::currentExecIsNSAppRun) {
-        int activeCount = QEventDispatcherMacPrivate::activeModalSessionCount();
-        if (activeCount > 0) {
-            // The problem we now have hit: [NSApp stop] will not stop NSApp
-            // if a session is active; it will stop the session instead.
-            // So to stop NSApp, we need to temporarily stop all the
-            // sessions, then stop NSApp, then restart the session on top again.
-            // We need to do this to ensure that we're not stuck inside
-            // [NSApp run] when we really should be running a modal session:
-            QEventDispatcherMacPrivate::temporarilyStopAllModalSessions();
+        }
+    }
-    // Always interrupt once more in case the modal session stack changed
-    // while processEvents was called manually from within the application:
     QEventDispatcherMac::instance()->interrupt();
+}
+void QtMacInterruptDispatcherHelp::interruptLater() {
+    if (instance) {
+        instance->cancelled = true;
+        delete instance;
+    }
+void QtMacInterruptDispatcherHelp::cancelInterruptLater()
+{
+    if (!instance)
+        return;
+    instance->cancelled = true;
+    delete instance;
+    instance = 0;
+}
+void QtMacInterruptDispatcherHelp::interruptLater()
+{
+    cancelInterruptLater();
     instance = new QtMacInterruptDispatcherHelp;
+}
 …
 QT_END_NAMESPACE

trunk/src/gui/kernel/qeventdispatcher_mac_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
     QPointer<QWidget> widget;
     NSModalSession session;
+    void *nswindow;
 } QCocoaModalSessionInfo;
 #endif
 …
     static bool currentExecIsNSAppRun;
     static bool nsAppRunCalledByQt;
+    static bool cleanupModalSessionsNeeded;
     static NSModalSession currentModalSessionCached;
+    static NSModalSession currentModalSession();
     static void updateChildrenWorksWhenModal();
-    static NSModalSession currentModalSession();
-    static int activeModalSessionCount();
     static void temporarilyStopAllModalSessions();
     static void beginModalSession(QWidget *widget);
     static void endModalSession(QWidget *widget);
+    static void cancelWaitForMoreEvents();
+    static void cleanupModalSessions();
+    static void ensureNSAppInitialized();
 #endif
 …
     QAtomicInt serialNumber;
     int lastSerial;
     bool interrupt;
+    static bool interrupt;
 private:
     static Boolean postedEventSourceEqualCallback(const void *info1, const void *info2);
 …
     public:
     static void interruptLater();
+    static void cancelInterruptLater();
 };
 #endif

trunk/src/gui/kernel/qeventdispatcher_qws.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qeventdispatcher_qws_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qeventdispatcher_s60.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 QT_BEGIN_NAMESPACE
+QtEikonEnv::QtEikonEnv()
+    : m_lastIterationCount(0)
+    , m_savedStatusCode(KRequestPending)
+    , m_hasAlreadyRun(false)
+{
+}
+QtEikonEnv::~QtEikonEnv()
+{
+}
+void QtEikonEnv::RunL()
+{
+    QEventDispatcherS60 *dispatcher = qobject_cast<QEventDispatcherS60 *>(QAbstractEventDispatcher::instance());
+    if (!dispatcher) {
+        CEikonEnv::RunL();
+        return;
+    }
+    if (m_lastIterationCount != dispatcher->iterationCount()) {
+        m_hasAlreadyRun = false;
+        m_lastIterationCount = dispatcher->iterationCount();
+    }
+    if (m_hasAlreadyRun) {
+        // Fool the active scheduler into believing we are still waiting for events.
+        // The window server thinks we are not, however.
+        m_savedStatusCode = iStatus.Int();
+        iStatus = KRequestPending;
+        SetActive();
+        dispatcher->queueDeferredActiveObjectsCompletion();
+    } else {
+        m_hasAlreadyRun = true;
+        CEikonEnv::RunL();
+    }
+}
+void QtEikonEnv::DoCancel()
+{
+    complete();
+    CEikonEnv::DoCancel();
+}
+void QtEikonEnv::complete()
+{
+    if (m_hasAlreadyRun) {
+        if (m_savedStatusCode != KRequestPending) {
+            TRequestStatus *status = &iStatus;
+            QEventDispatcherSymbian::RequestComplete(status, m_savedStatusCode);
+            m_savedStatusCode = KRequestPending;
+        }
+        m_hasAlreadyRun = false;
+    }
+}
 QEventDispatcherS60::QEventDispatcherS60(QObject *parent)
 …
+}
+// reimpl
+void QEventDispatcherS60::reactivateDeferredActiveObjects()
+{
+    if (S60->qtOwnsS60Environment) {
+        static_cast<QtEikonEnv *>(CCoeEnv::Static())->complete();
+    }
+    QEventDispatcherSymbian::reactivateDeferredActiveObjects();
+}
 QT_END_NAMESPACE

trunk/src/gui/kernel/qeventdispatcher_s60_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include "qt_s60_p.h"
+#include <eikenv.h>
 QT_BEGIN_NAMESPACE
+class QEventDispatcherS60;
+class QtEikonEnv : public CEikonEnv
+{
+public:
+    QtEikonEnv();
+    ~QtEikonEnv();
+    // from CActive.
+    void RunL();
+    void DoCancel();
+    void complete();
+private:
+    // Workaround for a BC break from S60 3.2 -> 5.0, where the CEikonEnv override was removed.
+    // To avoid linking to that when we build against 3.2, define an empty body here.
+    // Reserved_*() have been verified to be empty in the S60 code.
+    void Reserved_1() {}
+    void Reserved_2() {}
+private:
+    int m_lastIterationCount;
+    TInt m_savedStatusCode;
+    bool m_hasAlreadyRun;
+};
 class Q_GUI_EXPORT QEventDispatcherS60 : public QEventDispatcherSymbian
 …
     void saveInputEvent(QSymbianControl *control, QWidget *widget, QInputEvent *event);
+    void reactivateDeferredActiveObjects();
 private:

trunk/src/gui/kernel/qeventdispatcher_x11.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qeventdispatcher_x11_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qformlayout.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qformlayout.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qgesture.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include "qgesture.h"
 #include "private/qgesture_p.h"
+#include "private/qstandardgestures_p.h"
+#ifndef QT_NO_GESTURES
 QT_BEGIN_NAMESPACE
 …
     the QGestureRecognizer object that is registered with the application; see
     QGestureRecognizer::registerRecognizer().
+    For an overview of gesture handling in Qt and information on using gestures
+    in your applications, see the \l{Gestures Programming} document.
     \section1 Gesture Properties
 …
     \image pangesture.png
+    \sa {Gestures Programming}, QPinchGesture, QSwipeGesture
+    For an overview of gesture handling in Qt and information on using gestures
+    in your applications, see the \l{Gestures Programming} document.
+    \sa QPinchGesture, QSwipeGesture
 */
 …
 /*!
     \property QPanGesture::acceleration
+    \brief the acceleration in the motion of the touch point for this gesture
+*/
+/*!
+    \property QPanGesture::horizontalVelocity
+    \brief the horizontal component of the motion of the touch point for this
+    gesture
+    \since 4.7.1
+    \internal
+    \sa verticalVelocity, acceleration
+*/
+/*!
+    \property QPanGesture::verticalVelocity
+    \brief the vertical component of the motion of the touch point for this
+    gesture
+    \since 4.7.1
+    \internal
+    \sa horizontalVelocity, acceleration
 */
 …
     \since 4.6
     \brief The QPinchGesture class describes a pinch gesture made my the user.
     \ingroup multitouch
+    \ingroup touch
     \ingroup gestures
     A pinch gesture is a form of multitouch user input in which the user typically
+    A pinch gesture is a form of touch user input in which the user typically
     touches two points on the input device with a thumb and finger, before moving
     them closer together or further apart to change the scale factor, zoom, or level
     of detail of the user interface.
+    For an overview of gesture handling in Qt and information on using gestures
+    in your applications, see the \l{Gestures Programming} document.
     \image pinchgesture.png
 …
     of QPinchGesture in the Qt::GestureUpdated state.
     \sa {Gestures Programming}, QPanGesture, QSwipeGesture
+    \sa QPanGesture, QSwipeGesture
 */
 …
     The scale factor measures the scale factor associated with the distance
     between two of the user's inputs on a multitouch device.
+    between two of the user's inputs on a touch device.
     \sa totalScaleFactor, lastScaleFactor
 …
     \image swipegesture.png
+    \sa {Gestures Programming}, QPanGesture, QPinchGesture
+    For an overview of gesture handling in Qt and information on using gestures
+    in your applications, see the \l{Gestures Programming} document.
+    \sa QPanGesture, QPinchGesture
 */
 …
     swipe angle describes the angle between the direction of motion and the
     x-axis as defined using the standard widget
     \l{The Coordinate System}{coordinate system}.
+    \l{Coordinate System}{coordinate system}.
     \sa horizontalDirection, verticalDirection
+*/
+/*!
+    \property QSwipeGesture::velocity
+    \since 4.7.1
+    \internal
 */
 …
     \ingroup gestures
+    \sa {Gestures Programming}, QPanGesture, QPinchGesture
+    For an overview of gesture handling in Qt and information on using gestures
+    in your applications, see the \l{Gestures Programming} document.
+    \sa QPanGesture, QPinchGesture
 */
 …
     \ingroup gestures
+    \sa {Gestures Programming}, QPanGesture, QPinchGesture
+    For an overview of gesture handling in Qt and information on using gestures
+    in your applications, see the \l{Gestures Programming} document.
+    \sa QPanGesture, QPinchGesture
 */
 …
+}
+/*!
+    Set the timeout, in milliseconds, before the gesture triggers.
+    The recognizer will detect a touch down and and if \a msecs
+    later the touch is still down, it will trigger the QTapAndHoldGesture.
+    The default value is 700 milliseconds.
+*/
+// static
+void QTapAndHoldGesture::setTimeout(int msecs)
+{
+    QTapAndHoldGesturePrivate::Timeout = msecs;
+}
+/*!
+    Gets the timeout, in milliseconds, before the gesture triggers.
+    The recognizer will detect a touch down and and if timeout()
+    later the touch is still down, it will trigger the QTapAndHoldGesture.
+    The default value is 700 milliseconds.
+*/
+// static
+int QTapAndHoldGesture::timeout()
+{
+    return QTapAndHoldGesturePrivate::Timeout;
+}
+int QTapAndHoldGesturePrivate::Timeout = 700; // in ms
 QT_END_NAMESPACE
+#include <moc_qgesture.cpp>
+#endif // QT_NO_GESTURES

trunk/src/gui/kernel/qgesture.h

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include <QtCore/qmetatype.h>
+#ifndef QT_NO_GESTURES
 QT_BEGIN_HEADER
 Q_DECLARE_METATYPE(Qt::GestureState)
+Q_DECLARE_METATYPE(Qt::GestureType)
 QT_BEGIN_NAMESPACE
 …
     Q_PROPERTY(QPointF delta READ delta STORED false)
     Q_PROPERTY(qreal acceleration READ acceleration WRITE setAcceleration)
+    Q_PRIVATE_PROPERTY(QPanGesture::d_func(), qreal horizontalVelocity READ horizontalVelocity WRITE setHorizontalVelocity)
+    Q_PRIVATE_PROPERTY(QPanGesture::d_func(), qreal verticalVelocity READ verticalVelocity WRITE setVerticalVelocity)
 public:
 …
     Q_OBJECT
     Q_DECLARE_PRIVATE(QPinchGesture)
+    Q_FLAGS(ChangeFlags ChangeFlag)
 public:
 …
 };
+Q_DECLARE_OPERATORS_FOR_FLAGS(QPinchGesture::ChangeFlags)
 QT_END_NAMESPACE
 …
     Q_PROPERTY(SwipeDirection verticalDirection READ verticalDirection STORED false)
     Q_PROPERTY(qreal swipeAngle READ swipeAngle WRITE setSwipeAngle)
+    Q_PRIVATE_PROPERTY(QSwipeGesture::d_func(), qreal velocity READ velocity WRITE setVelocity)
 public:
 …
     void setPosition(const QPointF &pos);
+    static void setTimeout(int msecs);
+    static int timeout();
     friend class QTapAndHoldGestureRecognizer;
 };
 …
 QT_END_HEADER
+#endif // QT_NO_GESTURES
 #endif // QGESTURE_H

trunk/src/gui/kernel/qgesture_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include "qrect.h"
 #include "qpoint.h"
-#include "qdatetime.h"
 #include "qgesture.h"
+#include "qelapsedtimer.h"
 #include "private/qobject_p.h"
+#ifndef QT_NO_GESTURES
 QT_BEGIN_NAMESPACE
 …
         : gestureType(Qt::CustomGesture), state(Qt::NoGesture),
           isHotSpotSet(false), gestureCancelPolicy(0)
+    {
+    }
 …
     Qt::GestureState state;
     QPointF hotSpot;
+    QPointF sceneHotSpot;
     uint isHotSpotSet : 1;
     uint gestureCancelPolicy : 2;
 …
 public:
     QPanGesturePrivate()
         : acceleration(0)
+        : acceleration(0), xVelocity(0), yVelocity(0)
+    {
+    }
+    qreal horizontalVelocity() const { return xVelocity; }
+    void setHorizontalVelocity(qreal value) { xVelocity = value; }
+    qreal verticalVelocity() const { return yVelocity; }
+    void setVerticalVelocity(qreal value) { yVelocity = value; }
     QPointF lastOffset;
 …
     QPoint startPosition;
     qreal acceleration;
+    qreal xVelocity;
+    qreal yVelocity;
 };
 …
     QPinchGesturePrivate()
         : totalChangeFlags(0), changeFlags(0),
           totalScaleFactor(0), lastScaleFactor(0), scaleFactor(0),
+          totalScaleFactor(1), lastScaleFactor(1), scaleFactor(1),
           totalRotationAngle(0), lastRotationAngle(0), rotationAngle(0),
           isNewSequence(true)
 …
           verticalDirection(QSwipeGesture::NoDirection),
           swipeAngle(0),
           started(false), speed(0)
+          started(false), velocityValue(0)
+    {
+    }
+    qreal velocity() const { return velocityValue; }
+    void setVelocity(qreal value) { velocityValue = value; }
     QSwipeGesture::SwipeDirection horizontalDirection;
 …
     QPoint lastPositions[3];
     bool started;
     qreal speed;
     QTime time;
+    qreal velocityValue;
+    QElapsedTimer time;
 };
 …
     QPointF position;
     int timerId;
+    static int Timeout;
 };
 QT_END_NAMESPACE
+#endif // QT_NO_GESTURES
 #endif // QGESTURE_P_H

trunk/src/gui/kernel/qgesturemanager.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #endif
+#ifndef QT_NO_GESTURES
 QT_BEGIN_NAMESPACE
 QGestureManager::QGestureManager(QObject *parent)
     : QObject(parent), state(NotGesture), m_lastCustomGestureId(0)
+    : QObject(parent), state(NotGesture), m_lastCustomGestureId(Qt::CustomGesture)
+{
     qRegisterMetaType<Qt::GestureState>();
 …
         // generate a new custom gesture id
         ++m_lastCustomGestureId;
         type = Qt::GestureType(Qt::CustomGesture + m_lastCustomGestureId);
+        type = Qt::GestureType(m_lastCustomGestureId);
+    }
     m_recognizers.insertMulti(type, recognizer);
 …
+{
     QList<QGestureRecognizer *> list = m_recognizers.values(type);
+    m_recognizers.remove(type);
+    while (QGestureRecognizer *recognizer = m_recognizers.take(type)) {
+        if (!m_obsoleteGestures.contains(recognizer)) {
+            // inserting even an empty QSet will cause the recognizer to be deleted on destruction of the manager
+            m_obsoleteGestures.insert(recognizer, QSet<QGesture *>());
+        }
+    }
     foreach (QGesture *g, m_gestureToRecognizer.keys()) {
         QGestureRecognizer *recognizer = m_gestureToRecognizer.value(g);
         if (list.contains(recognizer)) {
             m_deletedRecognizers.insert(g, recognizer);
+            m_gestureToRecognizer.remove(g);
+        }
+    }
+    foreach (QGestureRecognizer *recognizer, list) {
+        QList<QGesture *> obsoleteGestures;
+        QMap<ObjectGesture, QList<QGesture *> >::Iterator iter = m_objectGestures.begin();
+        while (iter != m_objectGestures.end()) {
+            ObjectGesture objectGesture = iter.key();
+            if (objectGesture.gesture == type)
+                obsoleteGestures << iter.value();
+            ++iter;
+        }
+        m_obsoleteGestures.insert(recognizer, obsoleteGestures);
+        }
+    }
+    QMap<ObjectGesture, QList<QGesture *> >::const_iterator iter = m_objectGestures.begin();
+    while (iter != m_objectGestures.end()) {
+        ObjectGesture objectGesture = iter.key();
+        if (objectGesture.gesture == type) {
+            foreach (QGesture *g, iter.value()) {
+                if (QGestureRecognizer *recognizer = m_gestureToRecognizer.value(g)) {
+                    m_gestureToRecognizer.remove(g);
+                    m_obsoleteGestures[recognizer].insert(g);
+                }
+            }
+        }
+        ++iter;
+    }
+}
 …
     while (iter != m_objectGestures.end()) {
         ObjectGesture objectGesture = iter.key();
+        if (objectGesture.gesture == type && target == objectGesture.object.data()) {
+            qDeleteAll(iter.value());
+        if (objectGesture.gesture == type && target == objectGesture.object) {
+            QSet<QGesture *> gestures = iter.value().toSet();
+            for (QHash<QGestureRecognizer *, QSet<QGesture *> >::iterator
+                 it = m_obsoleteGestures.begin(), e = m_obsoleteGestures.end(); it != e; ++it) {
+                it.value() -= gestures;
+            }
+            foreach (QGesture *g, gestures) {
+                m_deletedRecognizers.remove(g);
+                m_gestureToRecognizer.remove(g);
+                m_maybeGestures.remove(g);
+                m_activeGestures.remove(g);
+                m_gestureOwners.remove(g);
+                m_gestureTargets.remove(g);
+                m_gesturesToDelete.insert(g);
+            }
             iter = m_objectGestures.erase(iter);
         } else {
 …
 QGesture *QGestureManager::getState(QObject *object, QGestureRecognizer *recognizer, Qt::GestureType type)
+{
     // if the widget is being deleted we should be carefull and not to
     // create a new state, as it will create QWeakPointer which doesnt work
+    // if the widget is being deleted we should be careful not to
+    // create a new state, as it will create QWeakPointer which doesn't work
     // from the destructor.
     if (object->isWidgetType()) {
 …
     } else {
         Q_ASSERT(qobject_cast<QGraphicsObject *>(object));
+        QGraphicsObject *graphicsObject = static_cast<QGraphicsObject *>(object);
+        if (graphicsObject->QGraphicsItem::d_func()->inDestructor)
+            return 0;
 #endif
+    }
 …
     QSet<QGesture *> activeToMaybeGestures = m_activeGestures & newMaybeGestures;
+    // check if a maybe gesture switched to canceled - reset it but don't send an event
+    QSet<QGesture *> maybeToCanceledGestures = m_maybeGestures & notGestures;
     // check if a running gesture switched back to not gesture state,
     // i.e. were canceled
     QSet<QGesture *> canceledGestures = m_activeGestures & notGestures;
+    // start timers for new gestures in maybe state
+    foreach (QGesture *state, newMaybeGestures) {
+        QBasicTimer &timer = m_maybeGestures[state];
+        if (!timer.isActive())
+            timer.start(3000, this);
+    }
+    // kill timers for gestures that were in maybe state
+    // new gestures in maybe state
+    m_maybeGestures += newMaybeGestures;
+    // gestures that were in maybe state
     QSet<QGesture *> notMaybeGestures = (startedGestures | triggeredGestures
                                          | finishedGestures | canceledGestures
                                          | notGestures);
+    foreach(QGesture *gesture, notMaybeGestures) {
+        QHash<QGesture *, QBasicTimer>::iterator it =
+                m_maybeGestures.find(gesture);
+        if (it != m_maybeGestures.end()) {
+            it.value().stop();
+            m_maybeGestures.erase(it);
+        }
+    }
+    m_maybeGestures -= notMaybeGestures;
     Q_ASSERT((startedGestures & finishedGestures).isEmpty());
 …
         DEBUG() << "QGestureManager::filterEventThroughContexts:"
                 << "\n\tactiveGestures:" << m_activeGestures
                 << "\n\tmaybeGestures:" << m_maybeGestures.keys()
+                << "\n\tmaybeGestures:" << m_maybeGestures
                 << "\n\tstarted:" << startedGestures
                 << "\n\ttriggered:" << triggeredGestures
                 << "\n\tfinished:" << finishedGestures
+                << "\n\tcanceled:" << canceledGestures;
+                << "\n\tcanceled:" << canceledGestures
+                << "\n\tmaybe-canceled:" << maybeToCanceledGestures;
+    }
 …
     // reset gestures that ended
     QSet<QGesture *> endedGestures =
             finishedGestures + canceledGestures + undeliveredGestures;
+            finishedGestures + canceledGestures + undeliveredGestures + maybeToCanceledGestures;
     foreach (QGesture *gesture, endedGestures) {
         recycle(gesture);
         m_gestureTargets.remove(gesture);
+    }
+    //Clean up the Gestures
+    qDeleteAll(m_gesturesToDelete);
+    m_gesturesToDelete.clear();
     return ret;
+}
 …
+{
     QGestureRecognizer *recognizer = m_deletedRecognizers.value(gesture);
+    Q_ASSERT(recognizer);
+    if(!recognizer) //The Gesture is removed while in the even loop, so the recognizers for this gestures was removed
+        return;
     m_deletedRecognizers.remove(gesture);
     if (m_deletedRecognizers.keys(recognizer).isEmpty()) {
 …
                 // guess the target widget using the hotspot of the gesture
                 QPoint pt = gesture->hotSpot().toPoint();
+                if (QWidget *w = qApp->topLevelAt(pt)) {
+                    target = w->childAt(w->mapFromGlobal(pt));
+                if (QWidget *topLevel = qApp->topLevelAt(pt)) {
+                    QWidget *child = topLevel->childAt(topLevel->mapFromGlobal(pt));
+                    target = child ? child : topLevel;
+                }
             } else {
 …
+}
-void QGestureManager::timerEvent(QTimerEvent *event)
+{
-    QHash<QGesture *, QBasicTimer>::iterator it = m_maybeGestures.begin(),
-                                             e = m_maybeGestures.end();
-    for (; it != e; ) {
-        QBasicTimer &timer = it.value();
-        Q_ASSERT(timer.isActive());
-        if (timer.timerId() == event->timerId()) {
-            timer.stop();
-            QGesture *gesture = it.key();
-            it = m_maybeGestures.erase(it);
-            DEBUG() << "QGestureManager::timerEvent: gesture stopped due to timeout:"
-                    << gesture;
-            recycle(gesture);
-        } else {
-            ++it;
+        }
+    }
+}
 void QGestureManager::recycle(QGesture *gesture)
+{
 …
         gesture->setGestureCancelPolicy(QGesture::CancelNone);
         recognizer->reset(gesture);
+        m_activeGestures.remove(gesture);
     } else {
         cleanupGesturesForRemovedRecognizer(gesture);
 …
 QT_END_NAMESPACE
+#endif // QT_NO_GESTURES
 #include "moc_qgesturemanager_p.cpp"

trunk/src/gui/kernel/qgesturemanager_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include "qgesturerecognizer.h"
+#ifndef QT_NO_GESTURES
 QT_BEGIN_NAMESPACE
 …
 protected:
-    void timerEvent(QTimerEvent *event);
     bool filterEventThroughContexts(const QMultiMap<QObject *, Qt::GestureType> &contexts,
                                     QEvent *event);
 …
     QSet<QGesture *> m_activeGestures;
     QHash<QGesture *, QBasicTimer> m_maybeGestures;
+    QSet<QGesture *> m_maybeGestures;
     enum State {
 …
         MaybeGesture // this means timers are up and waiting for some
                      // more events, and input events are handled by
                      // gesture recognizer explicitely
+                     // gesture recognizer explicitly
     } state;
     struct ObjectGesture
+    {
         QWeakPointer<QObject> object;
+        QObject* object;
         Qt::GestureType gesture;
 …
         inline bool operator<(const ObjectGesture &rhs) const
+        {
             if (object.data() < rhs.object.data())
+            if (object < rhs.object)
                 return true;
             if (object == rhs.object)
 …
     int m_lastCustomGestureId;
     QHash<QGestureRecognizer *, QList<QGesture *> > m_obsoleteGestures;
+    QHash<QGestureRecognizer *, QSet<QGesture *> > m_obsoleteGestures;
     QHash<QGesture *, QGestureRecognizer *> m_deletedRecognizers;
+    QSet<QGesture *> m_gesturesToDelete;
     void cleanupGesturesForRemovedRecognizer(QGesture *gesture);
 …
 QT_END_NAMESPACE
+#endif // QT_NO_GESTURES
 #endif // QGESTUREMANAGER_P_H

trunk/src/gui/kernel/qgesturerecognizer.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include "private/qgesturemanager_p.h"
+#ifndef QT_NO_GESTURES
 QT_BEGIN_NAMESPACE
 …
    need to use this class directly. Instances will be created behind the scenes by the
    framework.
+   For an overview of gesture handling in Qt and information on using gestures
+   in your applications, see the \l{Gestures Programming} document.
    \section1 Recognizing Gestures
 …
     Reimplement this function to create a custom QGesture-derived gesture
     object if necessary.
+    The application takes ownership of the created gesture object.
 */
 QGesture *QGestureRecognizer::create(QObject *target)
 …
         d->state = Qt::NoGesture;
         d->hotSpot = QPointF();
+        d->sceneHotSpot = QPointF();
         d->isHotSpotSet = false;
+    }
 …
 QT_END_NAMESPACE
+#endif // QT_NO_GESTURES

trunk/src/gui/kernel/qgesturerecognizer.h

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include <QtCore/qglobal.h>
 #include <QtCore/qnamespace.h>
+#ifndef QT_NO_GESTURES
 QT_BEGIN_HEADER
 …
 QT_END_HEADER
+#endif // QT_NO_GESTURES
 #endif // QGESTURERECOGNIZER_H

trunk/src/gui/kernel/qgridlayout.cpp

r769	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qgridlayout.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qguieventdispatcher_glib.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
+}
+void QGuiEventDispatcherGlib::flush()
+{
+    XFlush(X11->display);
+}
 QT_END_NAMESPACE

trunk/src/gui/kernel/qguieventdispatcher_glib_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
     void startingUp();
+    void flush();
 };

trunk/src/gui/kernel/qguifunctions_wince.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #endif
+#ifndef SHDB_HIDE
+#define SHDB_HIDE 0x0002
+#endif
 #ifndef SHFS_SHOWTASKBAR
 #define SHFS_SHOWTASKBAR 0x0001
 …
 typedef BOOL (*AygFullScreen)(HWND, DWORD);
 typedef BOOL (*AygSHSipInfo)(UINT, UINT, PVOID, UINT);
+typedef BOOL (*AygSHDoneButton)(HWND, DWORD);
 static AygInitDialog ptrAygInitDialog = 0;
 static AygFullScreen ptrAygFullScreen = 0;
 static AygSHSipInfo  ptrAygSHSipInfo  = 0;
+static AygSHDoneButton ptrAygSHDoneButton = 0;
 static bool aygResolved = false;
 …
         ptrAygFullScreen = (AygFullScreen) ayglib.resolve("SHFullScreen");
         ptrAygSHSipInfo  = (AygSHSipInfo)  ayglib.resolve("SHSipInfo");
+    }
+}
+struct DIBINFO : public BITMAPINFO
+{
+    RGBQUAD arColors[255];
+    operator LPBITMAPINFO() { return (LPBITMAPINFO) this; }
+    operator LPBITMAPINFOHEADER() { return &bmiHeader; }
+    RGBQUAD* ColorTable() { return bmiColors; }
+};
+        ptrAygSHDoneButton = (AygSHDoneButton) ayglib.resolve("SHDoneButton");
+    }
+}
 int qt_wince_GetDIBits(HDC /*hdc*/ , HBITMAP hSourceBitmap, uint, uint, LPVOID lpvBits, LPBITMAPINFO, uint)
 …
         if (widget->windowFlags() & Qt::WindowOkButtonHint)
             shidi.dwFlags |= SHIDIF_DONEBUTTON;
+        if (!(widget->windowFlags() & (Qt::WindowCancelButtonHint | Qt::WindowOkButtonHint)))
+            shidi.dwFlags |= SHIDIF_CANCELBUTTON;
         resolveAygLibs();
         if (ptrAygInitDialog)
 …
         MoveWindow(hwnd, r.top, r.left, r.right - r.left, r.bottom - r.top, true);
         SetWindowLong(hwnd, GWL_EXSTYLE, GetWindowLong (hwnd, GWL_EXSTYLE) | WS_EX_NODRAG);
+    }
+}
+void qt_wince_unmaximize(QWidget *widget)
+{
+    if (ptrAygSHDoneButton && qt_wince_is_mobile()
+        && !(widget->windowFlags() & (Qt::WindowCancelButtonHint | Qt::WindowOkButtonHint)))
+    {
+        // Hide the [X] button, we've added in qt_wince_maximize.
+        ptrAygSHDoneButton(widget->winId(), SHDB_HIDE);
+    }
+}

trunk/src/gui/kernel/qguifunctions_wince.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qguiplatformplugin.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
     if (!plugin)
+    {
 #if !defined(QT_NO_LIBRARY) && !defined(QT_NO_SETTINGS)
+#ifndef QT_NO_LIBRARY
         QString key = QString::fromLocal8Bit(qgetenv("QT_PLATFORM_PLUGIN"));
 …
+}
 /* return an aditional default palette  (only work on X11) */
+/* return an additional default palette  (only work on X11) */
 QPalette QGuiPlatformPlugin::palette()
+{

trunk/src/gui/kernel/qguiplatformplugin_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qguivariant.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qkde.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qkde_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qkeymapper.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qkeymapper_mac.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 };
+static qt_mac_enum_mapper qt_mac_private_unicode[] = {
+    { 0xF700, QT_MAC_MAP_ENUM(Qt::Key_Up) },            //NSUpArrowFunctionKey
+    { 0xF701, QT_MAC_MAP_ENUM(Qt::Key_Down) },          //NSDownArrowFunctionKey
+    { 0xF702, QT_MAC_MAP_ENUM(Qt::Key_Left) },          //NSLeftArrowFunctionKey
+    { 0xF703, QT_MAC_MAP_ENUM(Qt::Key_Right) },         //NSRightArrowFunctionKey
+    { 0xF727, QT_MAC_MAP_ENUM(Qt::Key_Insert) },        //NSInsertFunctionKey
+    { 0xF728, QT_MAC_MAP_ENUM(Qt::Key_Delete) },        //NSDeleteFunctionKey
+    { 0xF729, QT_MAC_MAP_ENUM(Qt::Key_Home) },          //NSHomeFunctionKey
+    { 0xF72B, QT_MAC_MAP_ENUM(Qt::Key_End) },           //NSEndFunctionKey
+    { 0xF72C, QT_MAC_MAP_ENUM(Qt::Key_PageUp) },        //NSPageUpFunctionKey
+    { 0xF72D, QT_MAC_MAP_ENUM(Qt::Key_PageDown) },      //NSPageDownFunctionKey
+    { 0xF72F, QT_MAC_MAP_ENUM(Qt::Key_ScrollLock) },    //NSScrollLockFunctionKey
+    { 0xF730, QT_MAC_MAP_ENUM(Qt::Key_Pause) },         //NSPauseFunctionKey
+    { 0xF731, QT_MAC_MAP_ENUM(Qt::Key_SysReq) },        //NSSysReqFunctionKey
+    { 0xF735, QT_MAC_MAP_ENUM(Qt::Key_Menu) },          //NSMenuFunctionKey
+    { 0xF738, QT_MAC_MAP_ENUM(Qt::Key_Print) },         //NSPrintFunctionKey
+    { 0xF73A, QT_MAC_MAP_ENUM(Qt::Key_Clear) },         //NSClearDisplayFunctionKey
+    { 0xF73D, QT_MAC_MAP_ENUM(Qt::Key_Insert) },        //NSInsertCharFunctionKey
+    { 0xF73E, QT_MAC_MAP_ENUM(Qt::Key_Delete) },        //NSDeleteCharFunctionKey
+    { 0xF741, QT_MAC_MAP_ENUM(Qt::Key_Select) },        //NSSelectFunctionKey
+    { 0xF742, QT_MAC_MAP_ENUM(Qt::Key_Execute) },       //NSExecuteFunctionKey
+    { 0xF746, QT_MAC_MAP_ENUM(Qt::Key_Help) },          //NSHelpFunctionKey
+    { 0xF747, QT_MAC_MAP_ENUM(Qt::Key_Mode_switch) },   //NSModeSwitchFunctionKey
+    {   0,    QT_MAC_MAP_ENUM(0) }
+};
 static int qt_mac_get_key(int modif, const QChar &key, int virtualKey)
+{
 …
             return qt_mac_keyvkey_symbols[i].qt_code;
+        }
+    }
+    // check if they belong to key codes in private unicode range
+    if (key >= 0xf700 && key <= 0xf747) {
+        if (key >= 0xf704 && key <= 0xf726) {
+            return Qt::Key_F1 + (key.unicode() - 0xf704) ;
+        }
+        for (int i = 0; qt_mac_private_unicode[i].qt_code; i++) {
+            if (qt_mac_private_unicode[i].mac_code == key) {
+                return qt_mac_private_unicode[i].qt_code;
+            }
+        }
+    }
 …
     if (iso639Code) {
         keyboardInputLocale = QLocale(QCFString::toQString(iso639Code));
+        QString monday = keyboardInputLocale.dayName(1);
+        bool rtl = false;
+        for (int i = 0; i < monday.length(); ++i) {
+            switch (monday.at(i).direction()) {
+            default:
+                break;
+            case QChar::DirR:
+            case QChar::DirAL:
+            case QChar::DirRLE:
+            case QChar::DirRLO:
+                rtl = true;
+                break;
+            }
+            if (rtl)
+                break;
+        }
+        keyboardInputDirection = rtl ? Qt::RightToLeft : Qt::LeftToRight;
+        keyboardInputDirection = keyboardInputLocale.textDirection();
     } else {
         keyboardInputLocale = QLocale::c();
 …
+    }
+    if (qApp->inputContext() && qApp->inputContext()->isComposing()) {
+    QInputContext *currentContext = qApp->inputContext();
+    if (currentContext && currentContext->isComposing()) {
         if (ekind == kEventRawKeyDown) {
             QMacInputContext *context = qobject_cast<QMacInputContext*>(qApp->inputContext());
+            QMacInputContext *context = qobject_cast<QMacInputContext*>(currentContext);
             if (context)
                 context->setLastKeydownEvent(event);
 …
         return false;
+    }
+    // Once we process the key down , we don't need to send the saved event again from
+    // kEventTextInputUnicodeForKeyEvent, so clear it.
+    if (currentContext && ekind == kEventRawKeyDown) {
+        QMacInputContext *context = qobject_cast<QMacInputContext*>(currentContext);
+        if (context)
+            context->setLastKeydownEvent(0);
+    }
     //get modifiers
     Qt::KeyboardModifiers modifiers;
 …
         return handled_event;
     QString text(ourChar);
     /* This is actually wrong - but unfortunatly it is the best that can be
+    /* This is actually wrong - but unfortunately it is the best that can be
        done for now because of the Control/Meta mapping problems */
     if (modifiers & (Qt::ControlModifier | Qt::MetaModifier)
 …
         GetEventParameter(event, kEventParamKeyModifiers, typeUInt32, 0,
                           sizeof(macModifiers), 0, &macModifiers);
+#ifdef QT_MAC_USE_COCOA
+        // The unicode characters in the range 0xF700-0xF747 are reserved
+        // by Mac OS X for transient use as keyboard function keys. We
+        // wont send 'text' for such key events. This is done to match
+        // behavior on other platforms.
+        unsigned int *unicodeKey = (unsigned int*)info;
+        if (*unicodeKey >= 0xf700 && *unicodeKey <= 0xf747)
+            text = QString();
+        bool isAccepted;
+#endif
         handled_event = QKeyMapper::sendKeyEvent(widget, grab,
                                                  (ekind == kEventRawKeyUp) ? QEvent::KeyRelease : QEvent::KeyPress,
 …
                                                  macScanCode, macVirtualKey, macModifiers
 #ifdef QT_MAC_USE_COCOA
                                                  ,static_cast<bool *>(info)
+                                                 ,&isAccepted
 #endif
                                                  );
+#ifdef QT_MAC_USE_COCOA
+        *unicodeKey = (unsigned int)isAccepted;
+#endif
+    }
     return handled_event;
 …
 void
+QKeyMapperPrivate::updateKeyMap(EventHandlerCallRef, EventRef event, void *)
+QKeyMapperPrivate::updateKeyMap(EventHandlerCallRef, EventRef event, void *
+#if defined(QT_MAC_USE_COCOA)
+                                unicodeKey // unicode character from NSEvent (modifiers applied)
+#endif
+                                )
+{
     UInt32 macVirtualKey = 0;
 …
                 keyLayout[macVirtualKey]->qtKey[i] = qtkey;
+            }
+#ifndef Q_WS_MAC32
+            else {
+                const QChar unicode(*((UniChar *)unicodeKey));
+                int qtkey = qt_mac_get_key(keyModifier, unicode, macVirtualKey);
+                if (qtkey == Qt::Key_unknown)
+                    qtkey = unicode.unicode();
+                keyLayout[macVirtualKey]->qtKey[i] = qtkey;
+            }
+#endif
 #ifdef Q_WS_MAC32
         } else {

trunk/src/gui/kernel/qkeymapper_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
                            bool grab);
     bool useXKB;
+    int xkb_currentGroup;
     QXCoreDesc coreDesc;

trunk/src/gui/kernel/qkeymapper_qws.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
+{
     keyboardInputLocale = QLocale::system();
     keyboardInputDirection = Qt::RightToLeft;
+    keyboardInputDirection = keyboardInputLocale.textDirection();
+}

trunk/src/gui/kernel/qkeymapper_s60.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
     {EKeyDevice1, EStdKeyDevice1, Key_Context2}, // Found by manual testing.
     {EKeyDevice3, EStdKeyDevice3, Key_Select},
+//    {EKeyDevice7, EStdKeyDevice7, Key_Camera},  //not supported by qt yet
+    {EKeyDevice7, EStdKeyDevice7, Key_Camera},
     {EKeyApplication0, EStdKeyApplication0, Key_Menu}, // Found by manual testing.
     {EKeyApplication1, EStdKeyApplication1, Key_Launch1}, // Found by manual testing.
 …
     {EKeyApplicationE, EStdKeyApplicationE, Key_LaunchE},
     {EKeyApplicationF, EStdKeyApplicationF, Key_LaunchF},
+//    {EKeyApplication19, EStdKeyApplication19, Key_CameraFocus},  //not supported by qt yet
+    {EKeyApplication19, EStdKeyApplication19, Key_CameraFocus},
     {EKeyYes, EStdKeyYes, Key_Yes},
     {EKeyNo, EStdKeyNo, Key_No},

trunk/src/gui/kernel/qkeymapper_win.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 // Implemented elsewhere
 extern "C" LRESULT CALLBACK QtWndProc(HWND, UINT, WPARAM, LPARAM);
+extern "C" LRESULT QT_WIN_CALLBACK QtWndProc(HWND, UINT, WPARAM, LPARAM);
 extern Q_CORE_EXPORT QLocale qt_localeFromLCID(LCID id);
 …
      * returns a DWORD. */
     LCID newLCID = MAKELCID((DWORD)GetKeyboardLayout(0), SORT_DEFAULT);
+    LCID newLCID = MAKELCID((quintptr)GetKeyboardLayout(0), SORT_DEFAULT);
 //    keyboardInputLocale = qt_localeFromLCID(newLCID);

trunk/src/gui/kernel/qkeymapper_x11.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include <ctype.h>
-QT_BEGIN_NAMESPACE
-#ifndef QT_NO_XKB
-// bring in the auto-generated xkbLayoutData
-#include "qkeymapper_x11_p.cpp"
 #ifdef QT_LINUXBASE
 // LSB's IsKeypadKey define is wrong - see
 …
 #endif
+static void getLocaleAndDirection(QLocale *locale,
+                                  Qt::LayoutDirection *direction,
+                                  const QByteArray &layoutName,
+                                  const QByteArray &variantName)
+QT_BEGIN_NAMESPACE
+#ifndef QT_NO_XKB
+// bring in the auto-generated xkbLayoutData
+#include "qkeymapper_x11_p.cpp"
+QLocale q_getKeyboardLocale(const QByteArray &layoutName, const QByteArray &variantName)
+{
     int i = 0;
     while (xkbLayoutData[i].layout != 0) {
+        if (layoutName == xkbLayoutData[i].layout && variantName == xkbLayoutData[i].variant) {
+            *locale = QLocale(xkbLayoutData[i].language, xkbLayoutData[i].country);
+            *direction = xkbLayoutData[i].direction;
+            return;
+        }
+        if (layoutName == xkbLayoutData[i].layout && variantName == xkbLayoutData[i].variant)
+            return QLocale(xkbLayoutData[i].language, xkbLayoutData[i].country);
         ++i;
+    }
+    *locale = QLocale::c();
+    *direction = Qt::LeftToRight;
+    return QLocale::c();
+}
 #endif // QT_NO_XKB
 // from qapplication_x11.cpp
 …
 QKeyMapperPrivate::QKeyMapperPrivate()
     : keyboardInputDirection(Qt::LeftToRight), useXKB(false)
+    : keyboardInputDirection(Qt::LeftToRight), xkb_currentGroup(0)
+{
     memset(&coreDesc, 0, sizeof(coreDesc));
 #ifndef QT_NO_XKB
+    int opcode = -1;
+    int xkbEventBase = -1;
+    int xkbErrorBase = -1;
+    int xkblibMajor = XkbMajorVersion;
+    int xkblibMinor = XkbMinorVersion;
+    if (XkbQueryExtension(X11->display, &opcode, &xkbEventBase, &xkbErrorBase, &xkblibMajor, &xkblibMinor))
+        useXKB = true;
+#endif
+#if 0
+    qDebug() << "useXKB =" << useXKB;
+    if (X11->use_xkb) {
+        // get the current group
+        XkbStateRec xkbState;
+        if (XkbGetState(X11->display, XkbUseCoreKbd, &xkbState) == Success)
+            xkb_currentGroup = xkbState.group;
+    }
 #endif
+}
 …
+{
 #ifndef QT_NO_XKB
     if (useXKB)
+    if (X11->use_xkb)
         return possibleKeysXKB(event);
 #endif
 …
+{
 #ifndef QT_NO_XKB
     if (useXKB) {
+    if (X11->use_xkb) {
         // try to determine the layout name and input direction by reading the _XKB_RULES_NAMES property off
         // the root window
 …
             } while (p < end);
+            layoutName = QByteArray::fromRawData(names[2], qstrlen(names[2]));
+            variantName = QByteArray::fromRawData(names[3], qstrlen(names[3]));
+            // the layout names and variants are saved in the _XKB_RULES_NAMES property as a comma separated list
+            QList<QByteArray> layoutNames = QByteArray::fromRawData(names[2], qstrlen(names[2])).split(',');
+            if (uint(xkb_currentGroup) < uint(layoutNames.count()))
+                layoutName = layoutNames.at(xkb_currentGroup);
+            QList<QByteArray> variantNames = QByteArray::fromRawData(names[3], qstrlen(names[3])).split(',');
+            if (uint(xkb_currentGroup) < uint(variantNames.count()))
+                variantName = variantNames.at(xkb_currentGroup);
+        }
 …
         //     qWarning("Qt: unable to determine keyboard layout, please talk to qt-bugs@trolltech.com"); ?
+        getLocaleAndDirection(&keyboardInputLocale,
+                              &keyboardInputDirection,
+                              layoutName,
+                              variantName);
+        keyboardInputLocale = q_getKeyboardLocale(layoutName, variantName);
+        keyboardInputDirection = keyboardInputLocale.textDirection();
 #if 0
 …
                  << keyboardInputDirection;
 #endif
         if (data)
             XFree(data);
 …
     // look at the modifier mapping, and get the correct masks for alt, meta, super, hyper, and mode_switch
 #ifndef QT_NO_XKB
     if (useXKB) {
+    if (X11->use_xkb) {
         XkbDescPtr xkbDesc = XkbGetMap(X11->display, XkbAllClientInfoMask, XkbUseCoreKbd);
         for (int i = xkbDesc->min_key_code; i < xkbDesc->max_key_code; ++i) {
 …
     XF86XK_LaunchC,             Qt::Key_LaunchE,
     XF86XK_LaunchD,             Qt::Key_LaunchF,
+    XF86XK_LaunchE,             Qt::Key_LaunchG,
+    XF86XK_LaunchF,             Qt::Key_LaunchH,
     // Qtopia keys

trunk/src/gui/kernel/qkeymapper_x11_p.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
     { "is", "nodeadkeys", Qt::LeftToRight, QLocale::Icelandic, QLocale::Iceland },
     // name = il, description = Israel
     { "il", "", Qt::LeftToRight, QLocale::Hebrew, QLocale::Israel },
+    { "il", "", Qt::RightToLeft, QLocale::Hebrew, QLocale::Israel },
     // name = il:lyx, description = Israel
     { "il", "lyx", Qt::LeftToRight, QLocale::Hebrew, QLocale::Israel },
+    { "il", "lyx", Qt::RightToLeft, QLocale::Hebrew, QLocale::Israel },
     // name = il:si1452, description = Israel
     { "il", "si1452", Qt::LeftToRight, QLocale::Hebrew, QLocale::Israel },
+    { "il", "si1452", Qt::RightToLeft, QLocale::Hebrew, QLocale::Israel },
     // name = il:phonetic, description = Israel
     { "il", "phonetic", Qt::LeftToRight, QLocale::Hebrew, QLocale::Israel },
+    { "il", "phonetic", Qt::RightToLeft, QLocale::Hebrew, QLocale::Israel },
     // name = it, description = Italy
     { "it", "", Qt::LeftToRight, QLocale::Italian, QLocale::Italy },
 …
     { "ch", "fr_sundeadkeys", Qt::LeftToRight, QLocale::French, QLocale::Switzerland },
     // name = sy, description = Syria
     { "sy", "", Qt::RightToLeft, QLocale::Arabic, QLocale::SyrianArabRepublic },
+    { "sy", "", Qt::RightToLeft, QLocale::Syriac, QLocale::SyrianArabRepublic },
     // name = sy:syc, description = Syria
     { "sy", "syc", Qt::RightToLeft, QLocale::Arabic, QLocale::SyrianArabRepublic },
+    { "sy", "syc", Qt::RightToLeft, QLocale::Syriac, QLocale::SyrianArabRepublic },
     // name = sy:syc_phonetic, description = Syria
     { "sy", "syc_phonetic", Qt::RightToLeft, QLocale::Arabic, QLocale::SyrianArabRepublic },
+    { "sy", "syc_phonetic", Qt::RightToLeft, QLocale::Syriac, QLocale::SyrianArabRepublic },
     // name = tj, description = Tajikistan
     { "tj", "", Qt::LeftToRight, QLocale::Tajik, QLocale::Tajikistan },

trunk/src/gui/kernel/qkeysequence.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
     const char* name;
 } keyname[] = {
+    //: This and all following "incomprehensible" strings in QShortcut context
+    //: are key names. Please use the localized names appearing on actual
+    //: keyboards or whatever is commonly used.
     { Qt::Key_Space,        QT_TRANSLATE_NOOP("QShortcut", "Space") },
     { Qt::Key_Escape,       QT_TRANSLATE_NOOP("QShortcut", "Esc") },
 …
     { Qt::Key_MediaNext,                  QT_TRANSLATE_NOOP("QShortcut", "Media Next") },
     { Qt::Key_MediaRecord,                QT_TRANSLATE_NOOP("QShortcut", "Media Record") },
+    //: Media player pause button
+    { Qt::Key_MediaPause,                 QT_TRANSLATE_NOOP("QShortcut", "Media Pause") },
+    //: Media player button to toggle between playing and paused
+    { Qt::Key_MediaTogglePlayPause,       QT_TRANSLATE_NOOP("QShortcut", "Toggle Media Play/Pause") },
     { Qt::Key_HomePage,                   QT_TRANSLATE_NOOP("QShortcut", "Home Page") },
     { Qt::Key_Favorites,                  QT_TRANSLATE_NOOP("QShortcut", "Favorites") },
 …
     // --------------------------------------------------------------
     // Device keys
+    { Qt::Key_Context1,     QT_TRANSLATE_NOOP("QShortcut", "Context1") },
+    { Qt::Key_Context2,     QT_TRANSLATE_NOOP("QShortcut", "Context2") },
+    { Qt::Key_Context3,     QT_TRANSLATE_NOOP("QShortcut", "Context3") },
+    { Qt::Key_Context4,     QT_TRANSLATE_NOOP("QShortcut", "Context4") },
+    { Qt::Key_Call,         QT_TRANSLATE_NOOP("QShortcut", "Call") },
+    { Qt::Key_Hangup,       QT_TRANSLATE_NOOP("QShortcut", "Hangup") },
+    { Qt::Key_Flip,         QT_TRANSLATE_NOOP("QShortcut", "Flip") },
+    { Qt::Key_Context1,         QT_TRANSLATE_NOOP("QShortcut", "Context1") },
+    { Qt::Key_Context2,         QT_TRANSLATE_NOOP("QShortcut", "Context2") },
+    { Qt::Key_Context3,         QT_TRANSLATE_NOOP("QShortcut", "Context3") },
+    { Qt::Key_Context4,         QT_TRANSLATE_NOOP("QShortcut", "Context4") },
+    //: Button to start a call (note: a separate button is used to end the call)
+    { Qt::Key_Call,             QT_TRANSLATE_NOOP("QShortcut", "Call") },
+    //: Button to end a call (note: a separate button is used to start the call)
+    { Qt::Key_Hangup,           QT_TRANSLATE_NOOP("QShortcut", "Hangup") },
+    //: Button that will hang up if we're in call, or make a call if we're not.
+    { Qt::Key_ToggleCallHangup, QT_TRANSLATE_NOOP("QShortcut", "Toggle Call/Hangup") },
+    { Qt::Key_Flip,             QT_TRANSLATE_NOOP("QShortcut", "Flip") },
+    //: Button to trigger voice dialing
+    { Qt::Key_VoiceDial,        QT_TRANSLATE_NOOP("QShortcut", "Voice Dial") },
+    //: Button to redial the last number called
+    { Qt::Key_LastNumberRedial, QT_TRANSLATE_NOOP("QShortcut", "Last Number Redial") },
+    //: Button to trigger the camera shutter (take a picture)
+    { Qt::Key_Camera,           QT_TRANSLATE_NOOP("QShortcut", "Camera Shutter") },
+    //: Button to focus the camera
+    { Qt::Key_CameraFocus,      QT_TRANSLATE_NOOP("QShortcut", "Camera Focus") },
+    // --------------------------------------------------------------
+    // Japanese keyboard support
+    { Qt::Key_Kanji,            QT_TRANSLATE_NOOP("QShortcut", "Kanji") },
+    { Qt::Key_Muhenkan,         QT_TRANSLATE_NOOP("QShortcut", "Muhenkan") },
+    { Qt::Key_Henkan,           QT_TRANSLATE_NOOP("QShortcut", "Henkan") },
+    { Qt::Key_Romaji,           QT_TRANSLATE_NOOP("QShortcut", "Romaji") },
+    { Qt::Key_Hiragana,         QT_TRANSLATE_NOOP("QShortcut", "Hiragana") },
+    { Qt::Key_Katakana,         QT_TRANSLATE_NOOP("QShortcut", "Katakana") },
+    { Qt::Key_Hiragana_Katakana,QT_TRANSLATE_NOOP("QShortcut", "Hiragana Katakana") },
+    { Qt::Key_Zenkaku,          QT_TRANSLATE_NOOP("QShortcut", "Zenkaku") },
+    { Qt::Key_Hankaku,          QT_TRANSLATE_NOOP("QShortcut", "Hankaku") },
+    { Qt::Key_Zenkaku_Hankaku,  QT_TRANSLATE_NOOP("QShortcut", "Zenkaku Hankaku") },
+    { Qt::Key_Touroku,          QT_TRANSLATE_NOOP("QShortcut", "Touroku") },
+    { Qt::Key_Massyo,           QT_TRANSLATE_NOOP("QShortcut", "Massyo") },
+    { Qt::Key_Kana_Lock,        QT_TRANSLATE_NOOP("QShortcut", "Kana Lock") },
+    { Qt::Key_Kana_Shift,       QT_TRANSLATE_NOOP("QShortcut", "Kana Shift") },
+    { Qt::Key_Eisu_Shift,       QT_TRANSLATE_NOOP("QShortcut", "Eisu Shift") },
+    { Qt::Key_Eisu_toggle,      QT_TRANSLATE_NOOP("QShortcut", "Eisu toggle") },
+    { Qt::Key_Codeinput,        QT_TRANSLATE_NOOP("QShortcut", "Code input") },
+    { Qt::Key_MultipleCandidate,QT_TRANSLATE_NOOP("QShortcut", "Multiple Candidate") },
+    { Qt::Key_PreviousCandidate,QT_TRANSLATE_NOOP("QShortcut", "Previous Candidate") },
+    // --------------------------------------------------------------
+    // Korean keyboard support
+    { Qt::Key_Hangul,          QT_TRANSLATE_NOOP("QShortcut", "Hangul") },
+    { Qt::Key_Hangul_Start,    QT_TRANSLATE_NOOP("QShortcut", "Hangul Start") },
+    { Qt::Key_Hangul_End,      QT_TRANSLATE_NOOP("QShortcut", "Hangul End") },
+    { Qt::Key_Hangul_Hanja,    QT_TRANSLATE_NOOP("QShortcut", "Hangul Hanja") },
+    { Qt::Key_Hangul_Jamo,     QT_TRANSLATE_NOOP("QShortcut", "Hangul Jamo") },
+    { Qt::Key_Hangul_Romaja,   QT_TRANSLATE_NOOP("QShortcut", "Hangul Romaja") },
+    { Qt::Key_Hangul_Jeonja,   QT_TRANSLATE_NOOP("QShortcut", "Hangul Jeonja") },
+    { Qt::Key_Hangul_Banja,    QT_TRANSLATE_NOOP("QShortcut", "Hangul Banja") },
+    { Qt::Key_Hangul_PreHanja, QT_TRANSLATE_NOOP("QShortcut", "Hangul PreHanja") },
+    { Qt::Key_Hangul_PostHanja,QT_TRANSLATE_NOOP("QShortcut", "Hangul PostHanja") },
+    { Qt::Key_Hangul_Special,  QT_TRANSLATE_NOOP("QShortcut", "Hangul Special") },
     { 0, 0 }
 …
     {QKeySequence::PreviousChild,           1,          Qt::CTRL | Qt::SHIFT | Qt::Key_Backtab, QApplicationPrivate::KB_Win | QApplicationPrivate::KB_X11},
     {QKeySequence::PreviousChild,           0,          Qt::CTRL | Qt::SHIFT | Qt::Key_Backtab, QApplicationPrivate::KB_Mac },//different priority from above
+    {QKeySequence::Paste,                   0,          Qt::CTRL | Qt::SHIFT | Qt::Key_Insert,  QApplicationPrivate::KB_X11},
     {QKeySequence::SelectStartOfDocument,   0,          Qt::CTRL | Qt::SHIFT | Qt::Key_Home,    QApplicationPrivate::KB_Win | QApplicationPrivate::KB_X11 | QApplicationPrivate::KB_S60},
     {QKeySequence::SelectEndOfDocument,     0,          Qt::CTRL | Qt::SHIFT | Qt::Key_End,     QApplicationPrivate::KB_Win | QApplicationPrivate::KB_X11 | QApplicationPrivate::KB_S60},
 …
     commas, e.g. "Alt+X,Ctrl+S,Q".
+    \a key should be in NativeText format.
     This constructor is typically used with \link QObject::tr() tr
     \endlink(), so that shortcut keys can be replaced in
 …
     d = new QKeySequencePrivate();
     assign(key);
+}
+/*!
+    \since 4.x
+    Creates a key sequence from the \a key string based on \a format.
+*/
+QKeySequence::QKeySequence(const QString &key, QKeySequence::SequenceFormat format)
+{
+    d = new QKeySequencePrivate();
+    assign(key, format);
+}
 …
                     found = true;
                 } else {
                     qWarning("QKeySequence::mnemonic: \"%s\" contains multiple occurences of '&'", qPrintable(text));
+                    qWarning("QKeySequence::mnemonic: \"%s\" contains multiple occurrences of '&'", qPrintable(text));
 #endif
+                }
 …
     comma; for example, "Alt+X,Ctrl+S,Z". The return value is the
     number of key codes added.
+    \a keys should be in NativeText format.
 */
 int QKeySequence::assign(const QString &ks)
+{
+    return assign(ks, NativeText);
+}
+/*!
+    \fn int QKeySequence::assign(const QString &keys, QKeySequence::SequenceFormat format)
+    \since 4.x
+    Adds the given \a keys to the key sequence (based on \a format).
+    \a keys may contain up to four key codes, provided they are
+    separated by a comma; for example, "Alt+X,Ctrl+S,Z". The return
+    value is the number of key codes added.
+*/
+int QKeySequence::assign(const QString &ks, QKeySequence::SequenceFormat format)
+{
     QString keyseq = ks;
 …
         part = keyseq.left(-1 == p ? keyseq.length() : p - diff);
         keyseq = keyseq.right(-1 == p ? 0 : keyseq.length() - (p + 1));
         d->key[n] = decodeString(part);
+        d->key[n] = QKeySequencePrivate::decodeString(part, format);
         ++n;
+    }
 …
 QKeySequence QKeySequence::fromString(const QString &str, SequenceFormat format)
+{
+    QStringList sl = str.split(QLatin1String(", "));
+    int keys[4] = {0, 0, 0, 0};
+    int total = qMin(sl.count(), 4);
+    for (int i = 0; i < total; ++i)
+        keys[i] = QKeySequencePrivate::decodeString(sl[i], format);
+    return QKeySequence(keys[0], keys[1], keys[2], keys[3]);
+    return QKeySequence(str, format);
+}

trunk/src/gui/kernel/qkeysequence.h

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
      };
+    enum SequenceFormat {
+        NativeText,
+        PortableText
+    };
     QKeySequence();
     QKeySequence(const QString &key);
+    QKeySequence(const QString &key, SequenceFormat format);
     QKeySequence(int k1, int k2 = 0, int k3 = 0, int k4 = 0);
     QKeySequence(const QKeySequence &ks);
 …
         , Identical = ExactMatch
 #endif
-    };
-    enum SequenceFormat {
-        NativeText,
-        PortableText
     };
 …
     static QString encodeString(int key);
     int assign(const QString &str);
+    int assign(const QString &str, SequenceFormat format);
     void setKey(int key, int index);

trunk/src/gui/kernel/qkeysequence_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qlayout.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qlayout.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qlayout_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qlayoutengine.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qlayoutengine_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qlayoutitem.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qlayoutitem.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qmacdefines_mac.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qmacgesturerecognizer_mac.mm

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include "qwidget.h"
 #include "qdebug.h"
+#ifndef QT_NO_GESTURES
 QT_BEGIN_NAMESPACE
 …
 QT_END_NAMESPACE
+#endif // QT_NO_GESTURES

trunk/src/gui/kernel/qmacgesturerecognizer_mac_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include "qgesturerecognizer.h"
+#ifndef QT_NO_GESTURES
 QT_BEGIN_NAMESPACE
 …
 QT_END_NAMESPACE
+#endif // QT_NO_GESTURES
 #endif // QMACSWIPEGESTURERECOGNIZER_MAC_P_H

trunk/src/gui/kernel/qmime.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qmime.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qmime_mac.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
     \i public.file-url - converts to "text/uri-list"
     \i public.tiff - converts to "application/x-qt-image"
+    \i public.vcard - converts to "text/plain"
     \i com.apple.traditional-mac-plain-text - converts to "text/plain"
     \i com.apple.pict - converts to "application/x-qt-image"
 …
+}
+class QMacPasteboardMimeVCard : public QMacPasteboardMime
+{
+public:
+    QMacPasteboardMimeVCard() : QMacPasteboardMime(MIME_ALL){ }
+    QString convertorName();
+    QString flavorFor(const QString &mime);
+    QString mimeFor(QString flav);
+    bool canConvert(const QString &mime, QString flav);
+    QVariant convertToMime(const QString &mime, QList<QByteArray> data, QString flav);
+    QList<QByteArray> convertFromMime(const QString &mime, QVariant data, QString flav);
+};
+QString QMacPasteboardMimeVCard::convertorName()
+{
+    return QString("VCard");
+}
+bool QMacPasteboardMimeVCard::canConvert(const QString &mime, QString flav)
+{
+    return mimeFor(flav) == mime;
+}
+QString QMacPasteboardMimeVCard::flavorFor(const QString &mime)
+{
+    if(mime.startsWith(QLatin1String("text/plain")))
+        return QLatin1String("public.vcard");
+    return QString();
+}
+QString QMacPasteboardMimeVCard::mimeFor(QString flav)
+{
+    if (flav == QLatin1String("public.vcard"))
+        return QLatin1String("text/plain");
+    return QString();
+}
+QVariant QMacPasteboardMimeVCard::convertToMime(const QString &mime, QList<QByteArray> data, QString)
+{
+    QByteArray cards;
+    if (mime == QLatin1String("text/plain")) {
+        for (int i=0; i<data.size(); ++i)
+            cards += data[i];
+    }
+    return QVariant(cards);
+}
+QList<QByteArray> QMacPasteboardMimeVCard::convertFromMime(const QString &mime, QVariant data, QString)
+{
+    QList<QByteArray> ret;
+    if (mime == QLatin1String("text/plain"))
+        ret.append(data.toString().toUtf8());
+    return ret;
+}
 #ifdef QT3_SUPPORT
 class QMacPasteboardMimeQt3Any : public QMacPasteboardMime {
 …
         new QMacPasteboardMimeUrl;
         new QMacPasteboardMimeTypeName;
+        new QMacPasteboardMimeVCard;
         //make sure our "non-standard" types are always last! --Sam
         new QMacPasteboardMimeAny;

trunk/src/gui/kernel/qmime_win.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
         s.setByteOrder(QDataStream::LittleEndian);// Intel byte order ####
         if (cf == CF_DIB) {
+            if (img.format() > QImage::Format_ARGB32)
+                img = img.convertToFormat(QImage::Format_RGB32);
             if (qt_write_dib(s, img))
                 return setData(ba, pmedium);

trunk/src/gui/kernel/qmotifdnd_x11.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
                                      unsigned char protocol_style)
+{
+    DndReceiverProp receiver_prop ;
+    DndReceiverProp receiver_prop;
+    // squelch potential valgrind errors about uninitialized reads
+    memset(&receiver_prop, 0, sizeof(receiver_prop));
     receiver_prop.byte_order = DndByteOrder() ;
 …
         Atom type;
         if (X11->clipboardReadProperty(tw->internalWinId(), Dnd_selection, true, &result, 0, &type, 0, false)) {
+        if (X11->clipboardReadProperty(tw->internalWinId(), Dnd_selection, true, &result, 0, &type, 0)) {
+        }
+    }

trunk/src/gui/kernel/qmultitouch_mac.mm

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qmultitouch_mac_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qnsframeview_mac_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qnsthemeframe_mac_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 - (char)shouldBeTreatedAsInkEvent:fp8;
 - (char)_shouldBeTreatedAsInkEventInInactiveWindow:fp8;
+- hitTest:(struct _NSPoint)fp8;
+//- hitTest:(struct _NSPoint)fp8; // collides with hittest in qcocoasharedwindowmethods_mac_p.h
 - (NSRect)_leftGroupRect;
 - (NSRect)_rightGroupRect;

trunk/src/gui/kernel/qnstitledframe_mac_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qole_win.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qpalette.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
     \fn void QPalette::setColor(ColorGroup group, ColorRole role, const QColor &color)
     Sets the brush in the specified color \a group, used for the given
+    Sets the color in the specified color \a group, used for the given
     color \a role, to the specified solid \a color.
 …
     Returns true (slowly) if this palette is different from \a p;
     otherwise returns false (usually quickly).
+    \note The current ColorGroup is not taken into account when
+    comparing palettes
+    \sa operator==()
 */
 …
     Returns true (usually quickly) if this palette is equal to \a p;
     otherwise returns false (slowly).
+    \note The current ColorGroup is not taken into account when
+    comparing palettes
+    \sa operator!=()
 */
 bool QPalette::operator==(const QPalette &p) const

trunk/src/gui/kernel/qpalette.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qsessionmanager.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qsessionmanager_qws.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qshortcut.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qshortcut.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qshortcutmap.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qshortcutmap_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qsizepolicy.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qsizepolicy.qdoc

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 ** This file is part of the documentation of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
+** $QT_BEGIN_LICENSE:FDL$
 ** Commercial Usage
 ** Licensees holding valid Qt Commercial licenses may use this file in
 ** accordance with the Qt Commercial License Agreement provided with the
 ** Software or, alternatively, in accordance with the terms contained in
 ** a written agreement between you and Nokia.
+** Software or, alternatively, in accordance with the terms contained in a
+** written agreement between you and Nokia.
 **
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of this
+** file.
 **
 ** If you have questions regarding the use of this file, please contact

trunk/src/gui/kernel/qsoftkeymanager.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include "qbitmap.h"
 #include "private/qsoftkeymanager_p.h"
 #include "private/qobject_p.h"
+#include "private/qaction_p.h"
 #include "private/qsoftkeymanager_common_p.h"
 …
     switch (standardKey) {
     case MenuSoftKey: // FALL-THROUGH
         action->setProperty(MENU_ACTION_PROPERTY, QVariant(true)); // TODO: can be refactored away to use _q_action_menubar
+        QActionPrivate::get(action)->menuActionSoftkeys = true;
     case OkSoftKey:
     case SelectSoftKey:
 …
 void QSoftKeyManager::updateSoftKeys()
+{
+    QSoftKeyManager::instance()->d_func()->pendingUpdate = true;
     QEvent *event = new QEvent(QEvent::UpdateSoftKeys);
     QApplication::postEvent(QSoftKeyManager::instance(), event);
 …
     d->updateSoftKeys_sys();
+    d->pendingUpdate = false;
     return true;
+}
 …
 void QSoftKeyManager::setForceEnabledInSoftkeys(QAction *action)
+{
     action->setProperty(FORCE_ENABLED_PROPERTY, QVariant(true));
+    QActionPrivate::get(action)->forceEnabledInSoftkeys = true;
+}
 bool QSoftKeyManager::isForceEnabledInSofkeys(QAction *action)
+{
+    bool ret = false;
+    QVariant property = action->property(FORCE_ENABLED_PROPERTY);
+    if (property.isValid() && property.toBool())
+        ret = true;
+    return ret;
+    return QActionPrivate::get(action)->forceEnabledInSoftkeys;
+}
 …
 bool QSoftKeyManager::handleCommand(int command)
+{
+    if (QSoftKeyManager::instance()->d_func()->pendingUpdate)
+        (void)QSoftKeyManager::instance()->handleUpdateSoftKeys();
     return static_cast<QSoftKeyManagerPrivateS60*>(QSoftKeyManager::instance()->d_func())->handleCommand(command);
+}

trunk/src/gui/kernel/qsoftkeymanager_common_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
     QMultiHash<int, QAction*> requestedSoftKeyActions;
     QWidget *initialSoftKeySource;
+    bool pendingUpdate;
 };

trunk/src/gui/kernel/qsoftkeymanager_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 class QSoftKeyManagerPrivate;
-const char MENU_ACTION_PROPERTY[] = "_q_menuAction";
-const char FORCE_ENABLED_PROPERTY[] = "_q_forceEnabledInSoftkeys";
 class Q_AUTOTEST_EXPORT QSoftKeyManager : public QObject
+{

trunk/src/gui/kernel/qsoftkeymanager_s60.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include "private/qt_s60_p.h"
 #include "private/qmenu_p.h"
+#include "private/qaction_p.h"
 #include "private/qsoftkeymanager_p.h"
 #include "private/qsoftkeymanager_s60_p.h"
 …
             CEikImage* myimage = new (ELeave) CEikImage;
             myimage->SetPicture( nBitmap, nMask ); // nBitmap and nMask ownership transfered
+            myimage->SetPicture( nBitmap, nMask ); // nBitmap and nMask ownership transferred
             EikSoftkeyImage::SetImage(cba, *myimage, left); // Takes myimage ownership
 …
     QAction *action = realSoftKeyActions.value(command);
     if (action) {
         QVariant property = action->property(MENU_ACTION_PROPERTY);
         if (property.isValid() && property.toBool()) {
+        bool property = QActionPrivate::get(action)->menuActionSoftkeys;
+        if (property) {
             QT_TRAP_THROWING(tryDisplayMenuBarL());
         } else if (action->menu()) {
 …
                     QMenu *menu = menuAction->menu();
                     if(menu)
                         menuBar->addMenu(action->menu());
+                        menuBar->addMenu(menu);
                     else
                         menuBar->addAction(menuAction);

trunk/src/gui/kernel/qsoftkeymanager_s60_p.h

r769	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qsound.cpp

r769	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qsound.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qsound_mac.mm

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 QT_USE_NAMESPACE
 @interface QMacSoundDelegate : NSObject<NSSoundDelegate> {
+@interface QT_MANGLE_NAMESPACE(QMacSoundDelegate) : NSObject<NSSoundDelegate> {
     QSound *qSound; // may be null.
     QAuServerMac* server;
 …
 @end
 @implementation QMacSoundDelegate
+@implementation QT_MANGLE_NAMESPACE(QMacSoundDelegate)
 -(id)initWithQSound:(QSound*)s:(QAuServerMac*)serv {
     self = [super init];
 …
     NSString *nsFileName = const_cast<NSString *>(reinterpret_cast<const NSString *>(QCFString::toCFStringRef(fileName)));
     NSSound * const nsSound = [[NSSound alloc] initWithContentsOfFile: nsFileName byReference:YES];
     QMacSoundDelegate * const delegate = [[QMacSoundDelegate alloc] initWithQSound:qSound:this];
+    QT_MANGLE_NAMESPACE(QMacSoundDelegate) * const delegate = [[QT_MANGLE_NAMESPACE(QMacSoundDelegate) alloc] initWithQSound:qSound:this];
     [nsSound setDelegate:delegate];
     [nsFileName release];

trunk/src/gui/kernel/qsound_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qsound_qws.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qsound_s60.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
         // We don't have a way to inform about errors -> just decrement loops
         // in order that QSound::isFinished will return true;
         while (decLoop(sound)) {}
+        while (decLoop(sound) > 0) {}
         if (staticPlayingSounds.removeAll(sound))
             delete sound;

trunk/src/gui/kernel/qsound_win.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qsound_x11.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qstackedlayout.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qstackedlayout.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qstandardgestures.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include "qwidget.h"
 #include "qabstractscrollarea.h"
+#include <qgraphicssceneevent.h>
 #include "qdebug.h"
+#ifndef QT_NO_GESTURES
 QT_BEGIN_NAMESPACE
 …
             if (d->offset.x() > 10  || d->offset.y() > 10 ||
                 d->offset.x() < -10 || d->offset.y() < -10) {
+                q->setHotSpot(p1.startScreenPos());
                 result = QGestureRecognizer::TriggerGesture;
             } else {
 …
             d->isHotSpotSet = true;
+            QPointF centerPoint = (p1.screenPos() + p2.screenPos()) / 2.0;
             if (d->isNewSequence) {
                 d->startPosition[0] = p1.screenPos();
                 d->startPosition[1] = p2.screenPos();
+            }
+            QLineF line(p1.screenPos(), p2.screenPos());
+            QLineF tmp(line);
+            tmp.setLength(line.length() / 2.);
+            QPointF centerPoint = tmp.p2();
+            d->lastCenterPoint = d->centerPoint;
+                d->lastCenterPoint = centerPoint;
+            } else {
+                d->lastCenterPoint = d->centerPoint;
+            }
             d->centerPoint = centerPoint;
             d->changeFlags |= QPinchGesture::CenterPointChanged;
-            const qreal scaleFactor =
-                    QLineF(p1.screenPos(), p2.screenPos()).length()
-                    / QLineF(d->startPosition[0],  d->startPosition[1]).length();
             if (d->isNewSequence) {
+                d->lastScaleFactor = scaleFactor;
+                d->scaleFactor = 1.0;
+                d->lastScaleFactor = 1.0;
             } else {
                 d->lastScaleFactor = d->scaleFactor;
+            }
+            d->scaleFactor = scaleFactor;
+            d->totalScaleFactor += d->scaleFactor - d->lastScaleFactor;
+                QLineF line(p1.screenPos(), p2.screenPos());
+                QLineF lastLine(p1.lastScreenPos(),  p2.lastScreenPos());
+                d->scaleFactor = line.length() / lastLine.length();
+            }
+            d->totalScaleFactor = d->totalScaleFactor * d->scaleFactor;
             d->changeFlags |= QPinchGesture::ScaleFactorChanged;
 …
             const qreal rotationAngle = startAngle - angle;
             if (d->isNewSequence)
                 d->lastRotationAngle = rotationAngle;
+                d->lastRotationAngle = 0.0;
             else
                 d->lastRotationAngle = d->rotationAngle;
 …
     d->startCenterPoint = d->lastCenterPoint = d->centerPoint = QPointF();
     d->totalScaleFactor = d->lastScaleFactor = d->scaleFactor = 0;
+    d->totalScaleFactor = d->lastScaleFactor = d->scaleFactor = 1;
     d->totalRotationAngle = d->lastRotationAngle = d->rotationAngle = 0;
 …
     switch (event->type()) {
     case QEvent::TouchBegin: {
         d->speed = 1;
         d->time = QTime::currentTime();
+        d->velocityValue = 1;
+        d->time.start();
         d->started = true;
         result = QGestureRecognizer::MayBeGesture;
 …
             const int distance = xDistance >= yDistance ? xDistance : yDistance;
             int elapsedTime = d->time.msecsTo(QTime::currentTime());
+            int elapsedTime = d->time.restart();
             if (!elapsedTime)
                 elapsedTime = 1;
+            d->speed = 0.9 * d->speed + distance / elapsedTime;
+            d->time = QTime::currentTime();
+            d->velocityValue = 0.9 * d->velocityValue + distance / elapsedTime;
             d->swipeAngle = QLineF(p1.startScreenPos(), p1.screenPos()).angle();
 …
     d->lastPositions[0] = d->lastPositions[1] = d->lastPositions[2] = QPoint();
     d->started = false;
     d->speed = 0;
     d->time = QTime();
+    d->velocityValue = 0;
+    d->time.invalidate();
     QGestureRecognizer::reset(state);
 …
     case QEvent::TouchBegin: {
         d->position = ev->touchPoints().at(0).pos();
+        q->setHotSpot(ev->touchPoints().at(0).screenPos());
         result = QGestureRecognizer::TriggerGesture;
         break;
 …
         q->killTimer(d->timerId);
         d->timerId = 0;
         return QGestureRecognizer::Ignore | QGestureRecognizer::ConsumeEventHint;
+        return QGestureRecognizer::FinishGesture | QGestureRecognizer::ConsumeEventHint;
+    }
     const QTouchEvent *ev = static_cast<const QTouchEvent *>(event);
+    QGestureRecognizer::Result result = QGestureRecognizer::CancelGesture;
+    enum { TimerInterval = 2000 };
+    const QMouseEvent *me = static_cast<const QMouseEvent *>(event);
+#ifndef QT_NO_GRAPHICSVIEW
+    const QGraphicsSceneMouseEvent *gsme = static_cast<const QGraphicsSceneMouseEvent *>(event);
+#endif
     enum { TapRadius = 40 };
     switch (event->type()) {
+    case QEvent::TouchBegin:
+        d->position = ev->touchPoints().at(0).pos();
+#ifndef QT_NO_GRAPHICSVIEW
+    case QEvent::GraphicsSceneMousePress:
+        d->position = gsme->screenPos();
+        q->setHotSpot(d->position);
         if (d->timerId)
             q->killTimer(d->timerId);
+        d->timerId = q->startTimer(TimerInterval);
+        result = QGestureRecognizer::TriggerGesture;
+        break;
+        d->timerId = q->startTimer(QTapAndHoldGesturePrivate::Timeout);
+        return QGestureRecognizer::MayBeGesture; // we don't show a sign of life until the timeout
+#endif
+    case QEvent::MouseButtonPress:
+        d->position = me->globalPos();
+        q->setHotSpot(d->position);
+        if (d->timerId)
+            q->killTimer(d->timerId);
+        d->timerId = q->startTimer(QTapAndHoldGesturePrivate::Timeout);
+        return QGestureRecognizer::MayBeGesture; // we don't show a sign of life until the timeout
+    case QEvent::TouchBegin:
+        d->position = ev->touchPoints().at(0).startScreenPos();
+        q->setHotSpot(d->position);
+        if (d->timerId)
+            q->killTimer(d->timerId);
+        d->timerId = q->startTimer(QTapAndHoldGesturePrivate::Timeout);
+        return QGestureRecognizer::MayBeGesture; // we don't show a sign of life until the timeout
+#ifndef QT_NO_GRAPHICSVIEW
+    case QEvent::GraphicsSceneMouseRelease:
+#endif
+    case QEvent::MouseButtonRelease:
     case QEvent::TouchEnd:
+        if (d->timerId)
+            result = QGestureRecognizer::CancelGesture;
+        else
+            result = QGestureRecognizer::FinishGesture;
+        break;
+        return QGestureRecognizer::CancelGesture; // get out of the MayBeGesture state
     case QEvent::TouchUpdate:
         if (q->state() != Qt::NoGesture && ev->touchPoints().size() == 1) {
+        if (d->timerId && ev->touchPoints().size() == 1) {
             QTouchEvent::TouchPoint p = ev->touchPoints().at(0);
             QPoint delta = p.pos().toPoint() - p.startPos().toPoint();
             if (delta.manhattanLength() <= TapRadius)
+                result = QGestureRecognizer::TriggerGesture;
+        }
+        break;
+    case QEvent::MouseButtonPress:
+    case QEvent::MouseMove:
+    case QEvent::MouseButtonRelease:
+        result = QGestureRecognizer::Ignore;
+        break;
+                return QGestureRecognizer::MayBeGesture;
+        }
+        return QGestureRecognizer::CancelGesture;
+    case QEvent::MouseMove: {
+        QPoint delta = me->globalPos() - d->position.toPoint();
+        if (d->timerId && delta.manhattanLength() <= TapRadius)
+            return QGestureRecognizer::MayBeGesture;
+        return QGestureRecognizer::CancelGesture;
+    }
+#ifndef QT_NO_GRAPHICSVIEW
+    case QEvent::GraphicsSceneMouseMove: {
+        QPoint delta = gsme->screenPos() - d->position.toPoint();
+        if (d->timerId && delta.manhattanLength() <= TapRadius)
+            return QGestureRecognizer::MayBeGesture;
+        return QGestureRecognizer::CancelGesture;
+    }
+#endif
     default:
+        result = QGestureRecognizer::Ignore;
+        break;
+    }
+    return result;
+        return QGestureRecognizer::Ignore;
+    }
+}
 …
 QT_END_NAMESPACE
+#endif // QT_NO_GESTURES

trunk/src/gui/kernel/qstandardgestures_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include "private/qgesture_p.h"
+#ifndef QT_NO_GESTURES
 QT_BEGIN_NAMESPACE
 …
 QT_END_NAMESPACE
+#endif // QT_NO_GESTURES
 #endif // QSTANDARDGESTURES_P_H

trunk/src/gui/kernel/qt_cocoa_helpers_mac.mm

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include <private/qt_mac_p.h>
 #include <private/qapplication_p.h>
+#include <private/qcocoaapplication_mac_p.h>
 #include <private/qcocoawindow_mac_p.h>
 #include <private/qcocoaview_mac_p.h>
 …
 extern bool qt_sendSpontaneousEvent(QObject *receiver, QEvent *event); // qapplication.cpp;
-extern Qt::MouseButton cocoaButton2QtButton(NSInteger buttonNum); // qcocoaview.mm
 extern QWidget * mac_mouse_grabber;
 extern QPointer<QWidget> qt_button_down; //qapplication_mac.cpp
+extern QWidget *qt_button_down; //qapplication_mac.cpp
 void macWindowFade(void * /*OSWindowRef*/ window, float durationSeconds)
 …
+    }
 #else
+    qt_widget_private(const_cast<QWidget *>(widget))->updateFrameStrut();
     ShowHideWindowToolbar(wnd, show, false);
 #endif
 …
 #ifdef QT_MAC_USE_COCOA
+// Clears the QWidget pointer that each QCocoaView holds.
+void qt_mac_clearCocoaViewQWidgetPointers(QWidget *widget)
+{
+    QT_MANGLE_NAMESPACE(QCocoaView) *cocoaView = reinterpret_cast<QT_MANGLE_NAMESPACE(QCocoaView) *>(qt_mac_nativeview_for(widget));
+    if (cocoaView && [cocoaView respondsToSelector:@selector(qt_qwidget)]) {
+        [cocoaView qt_clearQWidget];
+    }
+}
 void qt_dispatchTabletProximityEvent(void * /*NSEvent * */ tabletEvent)
+{
 …
     QKeyEventEx ke(cocoaEvent2QtEvent([event type]), qtKey, keyMods, text, [event isARepeat], qMax(1, keyLength),
                    macScanCode, [event keyCode], [event modifierFlags]);
+    qt_sendSpontaneousEvent(widgetToGetEvent, &ke);
+    return ke.isAccepted();
+}
+#endif
+    return qt_sendSpontaneousEvent(widgetToGetEvent, &ke) && ke.isAccepted();
+}
+#endif
+Qt::MouseButton cocoaButton2QtButton(NSInteger buttonNum)
+{
+    if (buttonNum == 0)
+        return Qt::LeftButton;
+    if (buttonNum == 1)
+        return Qt::RightButton;
+    if (buttonNum == 2)
+        return Qt::MidButton;
+    if (buttonNum == 3)
+        return Qt::XButton1;
+    if (buttonNum == 4)
+        return Qt::XButton2;
+    return Qt::NoButton;
+}
 // Helper to share code between QCocoaWindow and QCocoaView
 …
     EventRef key_event = static_cast<EventRef>(const_cast<void *>([event eventRef]));
     Q_ASSERT(key_event);
+    unsigned int info = 0;
     if ([event type] == NSKeyDown) {
+        qt_keymapper_private()->updateKeyMap(0, key_event, 0);
+    }
+        NSString *characters = [event characters];
+        if ([characters length]) {
+            unichar value = [characters characterAtIndex:0];
+            qt_keymapper_private()->updateKeyMap(0, key_event, (void *)&value);
+            info = value;
+        }
+    }
+    // Redirect keys to alien widgets.
+    if (widgetToGetEvent->testAttribute(Qt::WA_NativeWindow) == false) {
+        widgetToGetEvent = qApp->focusWidget();
+    }
     if (widgetToGetEvent == 0)
         return false;
 …
     if (mustUseCocoaKeyEvent())
         return qt_dispatchKeyEventWithCocoa(keyEvent, widgetToGetEvent);
+    bool isAccepted;
+    qt_keymapper_private()->translateKeyEvent(widgetToGetEvent, 0, key_event, &isAccepted, true);
+    return isAccepted;
+    bool consumed = qt_keymapper_private()->translateKeyEvent(widgetToGetEvent, 0, key_event, &info, true);
+    return consumed && (info != 0);
 #endif
+}
 …
+    }
+    QMouseEvent qme(eventType, qlocalPoint, qglobalPoint, button, button, keyMods);
+    Qt::MouseButtons buttons = 0;
+    {
+        UInt32 mac_buttons;
+        if (GetEventParameter((EventRef)[event eventRef], kEventParamMouseChord, typeUInt32, 0,
+                              sizeof(mac_buttons), 0, &mac_buttons) == noErr)
+            buttons = qt_mac_get_buttons(mac_buttons);
+    }
+    QMouseEvent qme(eventType, qlocalPoint, qglobalPoint, button, buttons, keyMods);
     qt_sendSpontaneousEvent(widgetToGetEvent, &qme);
 …
+        }
     } else {
         extern QPointer<QWidget> qt_button_down; //qapplication_mac.cpp
+        extern QWidget * qt_button_down; //qapplication_mac.cpp
         QPoint pos;
         widgetToGetMouse = QApplicationPrivate::pickMouseReceiver(qwidget, qglobalPoint,
 …
     NSPoint localPoint = [tmpView convertPoint:windowPoint fromView:nil];
+    QPoint qlocalPoint(localPoint.x, localPoint.y);
+    QPoint qlocalPoint = QPoint(localPoint.x, localPoint.y);
+    // Search for alien child widgets (either on this qwidget or on the popup)
+    if (widgetToGetMouse->testAttribute(Qt::WA_NativeWindow) == false || qt_widget_private(widgetToGetMouse)->hasAlienChildren) {
+        QPoint qScreenPoint = flipPoint(globalPoint).toPoint();
+#ifdef ALIEN_DEBUG
+        qDebug() << "alien mouse event" << qScreenPoint << possibleAlien;
+#endif
+        QWidget *possibleAlien =  widgetToGetMouse->childAt(qlocalPoint);
+        if (possibleAlien) {
+            qlocalPoint = possibleAlien->mapFromGlobal(widgetToGetMouse->mapToGlobal(qlocalPoint));
+            widgetToGetMouse = possibleAlien;
+        }
+    }
     EventRef carbonEvent = static_cast<EventRef>(const_cast<void *>([theEvent eventRef]));
 …
     NSInteger clickCount = [theEvent clickCount];
     Qt::MouseButtons buttons = 0;
+    static Qt::MouseButton previousButton = Qt::NoButton;
+    {
         UInt32 mac_buttons;
 …
         Q_ASSERT(clickCount > 0);
 #endif
         if (clickCount % 2 == 0)
+        if (clickCount % 2 == 0 && (previousButton == Qt::NoButton || previousButton == button))
             eventType = QEvent::MouseButtonDblClick;
         if (button == Qt::LeftButton && (keyMods & Qt::MetaModifier)) {
 …
             [theView qt_setLeftButtonIsRightButton: false];
+        }
+        qt_button_down = 0;
         break;
+    }
     [QT_MANGLE_NAMESPACE(QCocoaView) currentMouseEvent]->localPoint = localPoint;
     QMouseEvent qme(eventType, qlocalPoint, qglobalPoint, button, buttons, keyMods);
+    qt_sendSpontaneousEvent(widgetToGetMouse, &qme);
+#ifdef ALIEN_DEBUG
+    qDebug() << "sending mouse event to" << widgetToGetMouse;
+#endif
+    extern QWidget *qt_button_down;
+    extern QPointer<QWidget> qt_last_mouse_receiver;
+    if (qwidget->testAttribute(Qt::WA_NativeWindow) && qt_widget_private(qwidget)->hasAlienChildren == false)
+        qt_sendSpontaneousEvent(widgetToGetMouse, &qme);
+    else
+        QApplicationPrivate::sendMouseEvent(widgetToGetMouse, &qme, widgetToGetMouse, qwidget, &qt_button_down,
+                                            qt_last_mouse_receiver);
     if (eventType == QEvent::MouseButtonPress && button == Qt::RightButton) {
         QContextMenuEvent qcme(QContextMenuEvent::Mouse, qlocalPoint, qglobalPoint, keyMods);
         qt_sendSpontaneousEvent(widgetToGetMouse, &qcme);
+    }
+    previousButton = button;
     return true;
 #endif
 …
+}
+#if QT_MAC_USE_COCOA
+void qt_mac_replaceDrawRect(void * /*OSWindowRef */window, QWidgetPrivate *widget)
+{
+    QMacCocoaAutoReleasePool pool;
+    OSWindowRef theWindow = static_cast<OSWindowRef>(window);
+    if(!theWindow)
+        return;
+    id theClass = [[[theWindow contentView] superview] class];
+    // What we do here is basically to add a new selector to NSThemeFrame called
+    // "drawRectOriginal:" which will contain the original implementation of
+    // "drawRect:". After that we get the new implementation from QCocoaWindow
+    // and exchange them. The new implementation is called drawRectSpecial.
+    // We cannot just add the method because it might have been added before and since
+    // we cannot remove a method once it has been added we need to ask QCocoaWindow if
+    // we did the swap or not.
+    if(!widget->drawRectOriginalAdded) {
+        Method m2 = class_getInstanceMethod(theClass, @selector(drawRect:));
+        if(!m2) {
+            // This case is pretty extreme, no drawRect means no drawing!
+            return;
+        }
+        class_addMethod(theClass, @selector(drawRectOriginal:), method_getImplementation(m2), method_getTypeEncoding(m2));
+        widget->drawRectOriginalAdded = true;
+    }
+    if(widget->originalDrawMethod) {
+        Method m0 = class_getInstanceMethod([theWindow class], @selector(drawRectSpecial:));
+        if(!m0) {
+            // Ok, this means the methods were never swapped. Just ignore
+            return;
+        }
+        Method m1 = class_getInstanceMethod(theClass, @selector(drawRect:));
+        if(!m1) {
+            // Ok, this means the methods were never swapped. Just ignore
+            return;
+        }
+        // We have the original method here. Proceed and swap the methods.
+        method_exchangeImplementations(m1, m0);
+        widget->originalDrawMethod = false;
+        [window display];
+    }
+}
+void qt_mac_replaceDrawRectOriginal(void * /*OSWindowRef */window, QWidgetPrivate *widget)
+{
+    QMacCocoaAutoReleasePool pool;
+    OSWindowRef theWindow = static_cast<OSWindowRef>(window);
+    id theClass = [[[theWindow contentView] superview] class];
+    // Now we need to revert the methods to their original state.
+    // We cannot remove the method, so we just keep track of it in QCocoaWindow.
+    Method m0 = class_getInstanceMethod([theWindow class], @selector(drawRectSpecial:));
+    if(!m0) {
+        // Ok, this means the methods were never swapped. Just ignore
+        return;
+    }
+    Method m1 = class_getInstanceMethod(theClass, @selector(drawRect:));
+    if(!m1) {
+        // Ok, this means the methods were never swapped. Just ignore
+        return;
+    }
+    method_exchangeImplementations(m1, m0);
+    widget->originalDrawMethod = true;
+    [window display];
+}
+#endif // QT_MAC_USE_COCOA
 void qt_mac_showBaseLineSeparator(void * /*OSWindowRef */window, bool show)
+{
+    if(!window)
+        return;
 #if QT_MAC_USE_COCOA
     QMacCocoaAutoReleasePool pool;
     OSWindowRef theWindow = static_cast<OSWindowRef>(window);
     NSToolbar *macToolbar = [theWindow toolbar];
+    if (macToolbar)
+        [macToolbar setShowsBaselineSeparator: show];
+#endif
+    [macToolbar setShowsBaselineSeparator:show];
+#endif // QT_MAC_USE_COCOA
+}
 …
     [static_cast<NSCursor *>(qt_mac_nsCursorForQCursor(cursor)) set];
+}
+//  WARNING: If Qt did not create NSApplication (e.g. in case it is
+//  used as a plugin), and at the same time, there is no window on
+//  screen (or the window that the event is sendt to becomes hidden etc
+//  before the event gets delivered), the message will not be performed.
+bool qt_cocoaPostMessage(id target, SEL selector)
+{
+    if (!target)
+        return false;
+    NSInteger windowNumber = 0;
+    if (![NSApp isMemberOfClass:[QNSApplication class]]) {
+        // INVARIANT: Cocoa is not using our NSApplication subclass. That means
+        // we don't control the main event handler either. So target the event
+        // for one of the windows on screen:
+        NSWindow *nswin = [NSApp mainWindow];
+        if (!nswin) {
+            nswin = [NSApp keyWindow];
+            if (!nswin)
+                return false;
+        }
+        windowNumber = [nswin windowNumber];
+    }
+    // WARNING: data1 and data2 is truncated to from 64-bit to 32-bit on OS 10.5!
+    // That is why we need to split the address in two parts:
+    QCocoaPostMessageArgs *args = new QCocoaPostMessageArgs(target, selector);
+    quint32 lower = quintptr(args);
+    quint32 upper = quintptr(args) >> 32;
+    NSEvent *e = [NSEvent otherEventWithType:NSApplicationDefined
+        location:NSZeroPoint modifierFlags:0 timestamp:0 windowNumber:windowNumber
+        context:nil subtype:QtCocoaEventSubTypePostMessage data1:lower data2:upper];
+    [NSApp postEvent:e atStart:NO];
+    return true;
+}
 #endif
 …
+}
+void qt_mac_post_retranslateAppMenu()
+{
+#ifdef QT_MAC_USE_COCOA
+    QMacCocoaAutoReleasePool pool;
+    qt_cocoaPostMessage([NSApp QT_MANGLE_NAMESPACE(qt_qcocoamenuLoader)], @selector(qtTranslateApplicationMenu));
+#endif
+}
+#ifdef QT_MAC_USE_COCOA
+// This method implements the magic for the drawRectSpecial method.
+// We draw a line at the upper edge of the content view in order to
+// override the title baseline.
+void macDrawRectOnTop(void * /*OSWindowRef */window)
+{
+    OSWindowRef theWindow = static_cast<OSWindowRef>(window);
+    NSView *contentView = [theWindow contentView];
+    if(!contentView)
+        return;
+    // Get coordinates of the content view
+    NSRect contentRect = [contentView frame];
+    // Draw a line on top of the already drawn line.
+    // We need to check if we are active or not to use the proper color.
+    if([window isKeyWindow] || [window isMainWindow]) {
+        [[NSColor colorWithCalibratedRed:1.0 green:1.0 blue:1.0 alpha:1.0] set];
+    } else {
+        [[NSColor colorWithCalibratedRed:1.0 green:1.0 blue:1.0 alpha:1.0] set];
+    }
+    NSPoint origin = NSMakePoint(0, contentRect.size.height);
+    NSPoint end = NSMakePoint(contentRect.size.width, contentRect.size.height);
+    [NSBezierPath strokeLineFromPoint:origin toPoint:end];
+}
+// This method will (or at least should) get called only once.
+// Its mission is to find out if we are active or not. If we are active
+// we assume that we were launched via finder, otherwise we assume
+// we were called from the command line. The distinction is important,
+// since in the first case we don't need to trigger a paintEvent, while
+// in the second case we do.
+void macSyncDrawingOnFirstInvocation(void * /*OSWindowRef */window)
+{
+    OSWindowRef theWindow = static_cast<OSWindowRef>(window);
+    NSApplication *application = [NSApplication sharedApplication];
+    NSToolbar *toolbar = [window toolbar];
+    if([application isActive]) {
+        // Launched from finder
+        [toolbar setShowsBaselineSeparator:NO];
+    } else {
+        // Launched from commandline
+        [toolbar setVisible:false];
+        [toolbar setShowsBaselineSeparator:NO];
+        [toolbar setVisible:true];
+        [theWindow display];
+    }
+}
+void qt_cocoaStackChildWindowOnTopOfOtherChildren(QWidget *childWidget)
+{
+    if (!childWidget)
+        return;
+    QWidget *parent = childWidget->parentWidget();
+    if (childWidget->isWindow() && parent) {
+        if ([[qt_mac_window_for(parent) childWindows] containsObject:qt_mac_window_for(childWidget)]) {
+            QWidgetPrivate *d = qt_widget_private(childWidget);
+            d->setSubWindowStacking(false);
+            d->setSubWindowStacking(true);
+        }
+    }
+}
+#endif // QT_MAC_USE_COCOA
 QT_END_NAMESPACE

trunk/src/gui/kernel/qt_cocoa_helpers_mac_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 **
 ****************************************************************************/
+#ifndef QT_COCOA_HELPERS_MAC_P_H
+#define QT_COCOA_HELPERS_MAC_P_H
 //
 …
 QT_BEGIN_NAMESPACE
+enum {
+    QtCocoaEventSubTypeWakeup       = SHRT_MAX,
+    QtCocoaEventSubTypePostMessage  = SHRT_MAX-1
+};
 Qt::MouseButtons qt_mac_get_buttons(int buttons);
 Qt::MouseButton qt_mac_get_button(EventMouseButton button);
 …
 void macSendToolbarChangeEvent(QWidget *widget);
 void qt_mac_updateContentBorderMetricts(void * /*OSWindowRef */window, const ::HIContentBorderMetrics &metrics);
+void qt_mac_replaceDrawRect(void * /*OSWindowRef */window, QWidgetPrivate *widget);
+void qt_mac_replaceDrawRectOriginal(void * /*OSWindowRef */window, QWidgetPrivate *widget);
 void qt_mac_showBaseLineSeparator(void * /*OSWindowRef */window, bool show);
 void * /*NSImage */qt_mac_create_nsimage(const QPixmap &pm);
 …
 bool qt_dispatchKeyEventWithCocoa(void * /*NSEvent * */ keyEvent, QWidget *widgetToGetEvent);
 void qt_cocoaChangeOverrideCursor(const QCursor &cursor);
+// These methods exists only for supporting unified mode.
+void macDrawRectOnTop(void * /*OSWindowRef */ window);
+void macSyncDrawingOnFirstInvocation(void * /*OSWindowRef */window);
+void qt_cocoaStackChildWindowOnTopOfOtherChildren(QWidget *widget);
 #endif
 void qt_mac_menu_collapseSeparators(void * /*NSMenu */ menu, bool collapse);
 …
 inline NSString *qt_mac_QStringToNSString(const QString &qstr)
 { return [reinterpret_cast<const NSString *>(QCFString::toCFStringRef(qstr)) autorelease]; }
+#endif
+#ifdef QT_MAC_USE_COCOA
+class QCocoaPostMessageArgs {
+public:
+    id target;
+    SEL selector;
+    QCocoaPostMessageArgs(id target, SEL selector) : target(target), selector(selector)
+    {
+        [target retain];
+    }
+    ~QCocoaPostMessageArgs()
+    {
+        [target release];
+    }
+};
+bool qt_cocoaPostMessage(id target, SEL selector);
+#endif
+#endif
+void qt_mac_post_retranslateAppMenu();
 QT_END_NAMESPACE
+#endif // QT_COCOA_HELPERS_MAC_P_H

trunk/src/gui/kernel/qt_gui_pch.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qt_mac.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qt_mac_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #ifdef __OBJC__
 #include <Cocoa/Cocoa.h>
+#ifdef QT_MAC_USE_COCOA
+#include <objc/runtime.h>
+#endif // QT_MAC_USE_COCOA
 #endif

trunk/src/gui/kernel/qt_s60_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include "qpointer.h"
 #include "qapplication.h"
+#include "qelapsedtimer.h"
+#include "QtCore/qthreadstorage.h"
 #include <w32std.h>
 #include <coecntrl.h>
 …
 #define Q_SYMBIAN_ECOLOR16MAP TDisplayMode(13)
+class Q_AUTOTEST_EXPORT QS60ThreadLocalData
+{
+public:
+    QS60ThreadLocalData();
+    ~QS60ThreadLocalData();
+    bool usingCONEinstances;
+    RWsSession wsSession;
+    CWsScreenDevice *screenDevice;
+};
 class QS60Data
+{
 public:
     QS60Data();
+    QThreadStorage<QS60ThreadLocalData *> tls;
     TUid uid;
     int screenDepth;
 …
     int defaultDpiY;
     WId curWin;
-    int virtualMouseLastKey;
     enum PressedKeys {
         Select = 0x1,
 …
         Down = 0x4,
         Left = 0x8,
+        Up = 0x10
+        Up = 0x10,
+        LeftUp = 0x20,
+        RightUp = 0x40,
+        RightDown = 0x80,
+        LeftDown = 0x100
     };
     int virtualMousePressedKeys; // of the above type, but avoids casting problems
+    int virtualMouseAccel;
+    int virtualMouseAccelDX;
+    int virtualMouseAccelDY;
+    QElapsedTimer virtualMouseAccelTimeout;
     int virtualMouseMaxAccel;
 #ifndef Q_SYMBIAN_FIXED_POINTER_CURSORS
 …
     int avkonComponentsSupportTransparency : 1;
     int menuBeingConstructed : 1;
+    int orientationSet : 1;
     QApplication::QS60MainApplicationFactory s60ApplicationFactory; // typedef'ed pointer type
+    static CEikButtonGroupContainer *cba;
+    enum ScanCodeState {
+        Unpressed,
+        KeyDown,
+        KeyDownAndKey
+    };
+    QHash<TInt, ScanCodeState> scanCodeStates;
     static inline void updateScreenSize();
     static inline RWsSession& wsSession();
+    inline RWsSession& wsSession();
     static inline RWindowGroup& windowGroup();
     static inline CWsScreenDevice* screenDevice();
+    inline CWsScreenDevice* screenDevice();
     static inline CCoeAppUi* appUi();
     static inline CEikMenuBar* menuBar();
 …
     static inline CAknContextPane* contextPane();
     static inline CEikButtonGroupContainer* buttonGroupContainer();
+    static inline void setButtonGroupContainer(CEikButtonGroupContainer* newCba);
+    static void setStatusPaneAndButtonGroupVisibility(bool statusPaneVisible, bool buttonGroupVisible);
+#endif
+    static void controlVisibilityChanged(CCoeControl *control, bool visible);
+#ifdef Q_OS_SYMBIAN
     TTrapHandler *s60InstalledTrapHandler;
 #endif
 };
 QS60Data* qGlobalS60Data();
+Q_AUTOTEST_EXPORT QS60Data* qGlobalS60Data();
 #define S60 qGlobalS60Data()
 …
     void setFocusSafely(bool focus);
+    bool isControlActive();
 #ifdef Q_WS_S60
     void FadeBehindPopup(bool fade){ popupFader.FadeBehindPopup( this, this, fade); }
 …
     CCoeControl* FadedComponent(TInt /*aIndex*/) {return this;}
 #else
     #warning No fallback implementation for QSymbianControl::FadeBehindPopup
+    // #warning No fallback implementation for QSymbianControl::FadeBehindPopup
     void FadeBehindPopup(bool /*fade*/){ }
 #endif
 …
     void HandlePointerEvent(const TPointerEvent& aPointerEvent);
     TKeyResponse OfferKeyEvent(const TKeyEvent& aKeyEvent,TEventCode aType);
+    TKeyResponse sendSymbianKeyEvent(const TKeyEvent &keyEvent, QEvent::Type type);
     TKeyResponse sendKeyEvent(QWidget *widget, QKeyEvent *keyEvent);
+    TKeyResponse handleVirtualMouse(const TKeyEvent& keyEvent,TEventCode type);
     bool sendMouseEvent(QWidget *widget, QMouseEvent *mEvent);
     void sendMouseEvent(
 …
             Qt::MouseButton button,
             Qt::KeyboardModifiers modifiers);
+    void processTouchEvent(int pointerNumber, TPointerEvent::TType type, QPointF screenPos, qreal pressure);
     void HandleLongTapEventL( const TPoint& aPenEventLocation, const TPoint& aPenEventScreenLocation );
 #ifdef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER
     void translateAdvancedPointerEvent(const TAdvancedPointerEvent *event);
 #endif
+public:
     void handleClientAreaChange();
 …
     QWidget *qwidget;
     QLongTapTimer* m_longTapDetector;
+    QElapsedTimer m_doubleClickTimer;
     bool m_ignoreFocusChanged : 1;
     bool m_symbianPopupIsOpen : 1;
 …
 inline QS60Data::QS60Data()
+{
+    memclr(this, sizeof(QS60Data)); //zero init data
+: uid(TUid::Null()),
+  screenDepth(0),
+  screenWidthInPixels(0),
+  screenHeightInPixels(0),
+  screenWidthInTwips(0),
+  screenHeightInTwips(0),
+  defaultDpiX(0),
+  defaultDpiY(0),
+  curWin(0),
+  virtualMousePressedKeys(0),
+  virtualMouseAccelDX(0),
+  virtualMouseAccelDY(0),
+  virtualMouseMaxAccel(0),
+#ifndef Q_SYMBIAN_FIXED_POINTER_CURSORS
+  brokenPointerCursors(0),
+#endif
+  hasTouchscreen(0),
+  mouseInteractionEnabled(0),
+  virtualMouseRequired(0),
+  qtOwnsS60Environment(0),
+  supportsPremultipliedAlpha(0),
+  avkonComponentsSupportTransparency(0),
+  menuBeingConstructed(0),
+  orientationSet(0),
+  s60ApplicationFactory(0)
+#ifdef Q_OS_SYMBIAN
+  ,s60InstalledTrapHandler(0)
+#endif
+{
+}
 …
     S60->screenHeightInTwips = params.iTwipsSize.iHeight;
     S60->virtualMouseMaxAccel = qMax(S60->screenHeightInPixels, S60->screenWidthInPixels) / 20;
+    S60->virtualMouseMaxAccel = qMax(S60->screenHeightInPixels, S60->screenWidthInPixels) / 10;
     TReal inches = S60->screenHeightInTwips / (TReal)KTwipsPerInch;
 …
 inline RWsSession& QS60Data::wsSession()
+{
+    return CCoeEnv::Static()->WsSession();
+    if(!tls.hasLocalData()) {
+        tls.setLocalData(new QS60ThreadLocalData);
+    }
+    return tls.localData()->wsSession;
+}
 …
 inline CWsScreenDevice* QS60Data::screenDevice()
+{
+    return CCoeEnv::Static()->ScreenDevice();
+    if(!tls.hasLocalData()) {
+        tls.setLocalData(new QS60ThreadLocalData);
+    }
+    return tls.localData()->screenDevice;
+}
 …
 inline CEikButtonGroupContainer* QS60Data::buttonGroupContainer()
+{
+    return CEikonEnv::Static()->AppUiFactory()->Cba();
+    return QS60Data::cba;
+}
+inline void QS60Data::setButtonGroupContainer(CEikButtonGroupContainer *newCba)
+{
+    QS60Data::cba = newCba;
+}
 #endif // Q_WS_S60

trunk/src/gui/kernel/qt_x11_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 struct QX11Data;
 extern QX11Data *qt_x11Data;
+extern Q_GUI_EXPORT QX11Data *qt_x11Data;
 enum DesktopEnvironment {
 …
     DE_GNOME,
     DE_CDE,
+    DE_MEEGO_COMPOSITOR,
     DE_4DWM
 };
 …
     bool clipboardWaitForEvent(Window win, int type, XEvent *event, int timeout);
     bool clipboardReadProperty(Window win, Atom property, bool deleteProperty,
                             QByteArray *buffer, int *size, Atom *type, int *format, bool nullterm);
+                            QByteArray *buffer, int *size, Atom *type, int *format);
     QByteArray clipboardReadIncrementalProperty(Window win, Atom property, int nbytes, bool nullterm);
 …
     int xinput_eventbase;
     int xinput_errorbase;
+    // for XKEYBOARD support
+    bool use_xkb;
+    int xkb_major;
+    int xkb_eventbase;
+    int xkb_errorbase;
     QList<QWidget *> deferred_map;
 …
         DTWM_IS_RUNNING,
-        KDE_FULL_SESSION,
-        KWIN_RUNNING,
-        KWM_RUNNING,
-        GNOME_BACKGROUND_PROPERTIES,
         ENLIGHTENMENT_DESKTOP,
+        _DT_SAVE_MODE,
         _SGI_DESKS_MANAGER,
 …
         _NET_SYSTEM_TRAY_VISUAL,
+        _NET_ACTIVE_WINDOW,
         // Property formats

trunk/src/gui/kernel/qtooltip.cpp

r769	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qtooltip.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qwhatsthis.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 */
 Q_DECL_IMPORT extern void qDeleteInEventHandler(QObject *o);
+Q_CORE_EXPORT void qDeleteInEventHandler(QObject *o);
 class QWhatsThat : public QWidget

trunk/src/gui/kernel/qwhatsthis.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qwidget.cpp

-              r786
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 # include "qt_cocoa_helpers_mac_p.h"
 # include "qmainwindow.h"
+# include "qtoolbar.h"
+# include <private/qmainwindowlayout_p.h>
 #endif
 #if defined(Q_WS_QWS)
 …
 #endif // QT_KEYPAD_NAVIGATION
+#ifdef Q_WS_S60
+#include <aknappui.h>
+#endif
 // widget/widget data creation count
 //#define QWIDGET_EXTRA_DEBUG
 …
 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)
 …
       , isGLWidget(0)
       , usesDoubleBufferedGLContext(0)
+#ifndef QT_NO_IM
+      , inheritsInputMethodHints(0)
+#endif
 #if defined(Q_WS_X11)
       , picture(0)
 …
 #elif defined(Q_WS_WIN)
       , noPaintOnScreen(0)
+  #ifndef QT_NO_GESTURES
       , nativeGesturePanEnabled(0)
+  #endif
 #elif defined(Q_WS_MAC)
       , needWindowChange(0)
+      , hasAlienChildren(0)
       , window_event(0)
       , qd_hd(0)
 …
     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;
 …
+}
+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;
+}
 …
     if (ic)
         return ic;
-#endif
     return qApp->inputContext();
+#else
+    return 0;
+#endif
+}
 …
   This function sets the input context \a context
   on this widget.
+  Qt takes ownership of the given input \a context.
   \sa inputContext()
 …
     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
+}
 …
         \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
 …
     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
 …
     \sa windowFlags
 */
 QWidget::QWidget(QWidget *parent, Qt::WindowFlags f)
     : QObject(*new QWidgetPrivate, 0), QPaintDevice()
 …
+    }
     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
 …
     Q_ASSERT(allWidgets);
+    allWidgets->insert(q);
+    if (allWidgets)
+        allWidgets->insert(q);
     QWidget *desktopWidget = 0;
 …
         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();
 …
     //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;
 …
     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))
 …
     // 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);
+    }
 …
     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
 …
+    }
 #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);
 …
         // 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
 …
     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())
 …
     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);
+    }
+}
 …
         x->icon = 0;
         x->iconPixmap = 0;
-        x->backingStore = 0;
         x->windowSurface = 0;
         x->sharedPainter = 0;
 …
         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
 …
         if (extra->topextra) {
             deleteTLSysExtra();
             delete extra->topextra->backingStore;
+            extra->topextra->backingStore.destroy();
             delete extra->topextra->icon;
             delete extra->topextra->iconPixmap;
 …
+{
     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);
 …
+{
     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())) {
 …
+{
     Q_D(QWidget);
+#ifdef ALIEN_DEBUG
+    qDebug()  << "QWidget::createWinId" << this;
+#endif
 //    qWarning("QWidget::createWinId is obsolete, please fix your code.");
     d->createWinId();
 …
     QStyle *oldStyle  = q->style();
 #ifndef QT_NO_STYLE_STYLESHEET
     QStyle *origStyle = 0;
+    QWeakPointer<QStyle> origStyle;
 #endif
 …
 #ifndef QT_NO_STYLE_STYLESHEET
         origStyle = extra->style;
+        origStyle = extra->style.data();
 #endif
         extra->style = newStyle;
 …
+    }
+#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);
 …
 #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
 …
 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
 …
     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();
+}
 …
                                      | 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();
+}
 …
     direction.
+    This method no longer affects text layout direction since Qt 4.7.
     \sa QApplication::layoutDirection
 */
 …
+{
     Q_D(QWidget);
+    if (direction == Qt::LayoutDirectionAuto) {
+        unsetLayoutDirection();
+        return;
+    }
     setAttribute(Qt::WA_SetLayoutDirection);
 …
                      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);
+}
 …
             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;
 …
             //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)
 …
                                 , 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
+}
 …
+    }
     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;
+}
 …
+                }
                 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);
 …
     QWidget *fn = first->d_func()->focus_next;
     if (fn == second)
+    if (fn == second || first == second)
         return;
 …
 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);
 …
            << 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)
 …
     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);
 …
     // 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
 …
     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
 …
             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
 …
+            }
+        }
 #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
 …
         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)
 …
         break;
+    }
+#ifndef QT_NO_GESTURES
     case QEvent::Gesture:
         event->ignore();
         break;
+#endif
 #ifndef QT_NO_PROPERTIES
     case QEvent::DynamicPropertyChange: {
 …
   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,
 …
         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
+        }
 …
+{
 #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;
 …
     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();
 …
 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;
 …
     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))
 …
         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;
 …
 #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)
 …
             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) {
 …
+        {
             // 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();
 …
     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.
 …
         d->updateIsOpaque();
         break;
+    case Qt::WA_X11DoNotAcceptFocus:
+        if (testAttribute(Qt::WA_WState_Created))
+            d->updateX11AcceptFocus();
+        break;
 #endif
     case Qt::WA_DontShowOnScreen: {
 …
         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;
 …
 #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();
 …
     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.
 …
     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.
 …
 */
+#ifndef QT_NO_GESTURES
 /*!
     Subscribes the widget to a given \a gesture with specific \a flags.
 …
     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
 /*!
 …
 #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

trunk/src/gui/kernel/qwidget.h

-              r705
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #endif //QT_NO_GRAPHICSEFFECT
+#ifndef QT_NO_GESTURES
     void grabGesture(Qt::GestureType type, Qt::GestureFlags flags = Qt::GestureFlags());
     void ungrabGesture(Qt::GestureType type);
+#endif
 public Q_SLOTS:
 …
     friend class QStyleSheetStyle;
     friend struct QWidgetExceptionCleaner;
+#ifndef QT_NO_GESTURES
     friend class QGestureManager;
     friend class QWinNativePanGestureRecognizer;
+#endif // QT_NO_GESTURES
     friend class QWidgetEffectSourcePrivate;
 …
     friend void qt_net_update_user_time(QWidget *tlw, unsigned long timestamp);
     friend void qt_net_remove_user_time(QWidget *tlw);
+    friend void qt_set_winid_on_widget(QWidget*, Qt::HANDLE);
 #endif

trunk/src/gui/kernel/qwidget_mac.mm

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 QT_BEGIN_NAMESPACE
+// qmainwindow.cpp
+extern QMainWindowLayout *qt_mainwindow_layout(const QMainWindow *window);
 #define XCOORD_MAX 16383
 #define WRECT_MAX 8191
 …
 bool qt_isGenuineQWidget(const QWidget *window)
+{
+    return window && qt_isGenuineQWidget(OSViewRef(window->winId()));
+    if (!window)
+        return false;
+    if (!window->internalWinId())
+        return true;  //alien
+    return qt_isGenuineQWidget(OSViewRef(window->internalWinId()));
+}
 …
+}
+#ifndef QT_NO_GESTURES
 #if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6
 /* We build the release package against the 10.4 SDK.
 …
 };
 #endif
+#endif // QT_NO_GESTURES
 // window events
 …
         break; }
+#ifndef QT_NO_GESTURES
     case kEventClassGesture: {
         // First, find the widget that was under
 …
         QApplication::sendSpontaneousEvent(widget, &qNGEvent);
     break; }
+#endif // QT_NO_GESTURES
     default:
 …
         QWidget *widget = static_cast<QWidget*>(object);
         if(qt_mac_is_macdrawer(widget)) {
+            bool oldState = widget->testAttribute(Qt::WA_WState_ExplicitShowHide);
             if(visible) {
                 if (!widget->testAttribute(Qt::WA_WState_ExplicitShowHide))
 …
             } else {
                 widget->hide();
+                widget->setAttribute(Qt::WA_WState_ExplicitShowHide, false);
+                if(!oldState)
+                    widget->setAttribute(Qt::WA_WState_ExplicitShowHide, false);
+            }
+        }
 …
     else if(popup || (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5 && type == Qt::SplashScreen))
         wclass = kModalWindowClass;
     else if(q->testAttribute(Qt::WA_ShowModal) || type == Qt::Dialog)
+    else if(type == Qt::Dialog)
         wclass = kMovableModalWindowClass;
     else if(type == Qt::ToolTip)
 …
                                  && type == Qt::SplashScreen))
         wclass = kFloatingWindowClass;
+    else if(q->testAttribute(Qt::WA_ShowModal))
+        wclass = kMovableModalWindowClass;
     else
         wclass = kDocumentWindowClass;
 …
             if((tmp_wattr & known_attribs[i].tag) == known_attribs[i].tag) {
                 tmp_wattr ^= known_attribs[i].tag;
-                qDebug("Qt: internal: * %s %s", known_attribs[i].name,
-                        (GetAvailableWindowAttributes(wclass) & known_attribs[i].tag) ? "" : "(*)");
+            }
+        }
 …
+}
 #else  // QT_MAC_USE_COCOA
+void QWidgetPrivate::setWindowLevel()
+{
+    Q_Q(QWidget);
+    const QWidget * const windowParent = q->window()->parentWidget();
+    const QWidget * const primaryWindow = windowParent ? windowParent->window() : 0;
+    NSInteger winLevel = -1;
+    if (q->windowType() == Qt::Popup) {
+        winLevel = NSPopUpMenuWindowLevel;
+        // Popup should be in at least the same level as its parent.
+        if (primaryWindow) {
+            OSWindowRef parentRef = qt_mac_window_for(primaryWindow);
+            winLevel = qMax([parentRef level], winLevel);
+        }
+    } else if (q->windowType() == Qt::Tool) {
+        winLevel = NSFloatingWindowLevel;
+    } else if (q->windowType() == Qt::Dialog) {
+        // Correct modality level (NSModalPanelWindowLevel) will be
+        // set by cocoa when creating a modal session later.
+        winLevel = NSNormalWindowLevel;
+    }
+    // StayOnTop window should appear above Tool windows.
+    if (data.window_flags & Qt::WindowStaysOnTopHint)
+        winLevel = NSPopUpMenuWindowLevel;
+    // Tooltips should appear above StayOnTop windows.
+    if (q->windowType() == Qt::ToolTip)
+        winLevel = NSScreenSaverWindowLevel;
+    // All other types are Normal level.
+    if (winLevel == -1)
+        winLevel = NSNormalWindowLevel;
+    [qt_mac_window_for(q) setLevel:winLevel];
+}
 void QWidgetPrivate::finishCreateWindow_sys_Cocoa(void * /*NSWindow * */ voidWindowRef)
+{
 …
             registerDropSite(true);
         transferChildren();
+        // Tell Cocoa explicit that we wan't the view to receive key events
+        // (regardless of focus policy) because this is how it works on other
+        // platforms (and in the carbon port):
+        if (!qApp->focusWidget())
+            [windowRef makeFirstResponder:nsview];
+    }
 …
+    }
+    if (qApp->overrideCursor())
+        [windowRef disableCursorRects];
+    setWindowLevel();
     macUpdateHideOnSuspend();
     macUpdateOpaqueSizeGrip();
 …
     determineWindowClass();
     createWindow_sys();
+    if (QMainWindowLayout *mwl = qobject_cast<QMainWindowLayout *>(q->layout())) {
+    if (QMainWindowLayout *mwl = qt_mainwindow_layout(qobject_cast<QMainWindow *>(q))) {
         mwl->updateHIToolBarStatus();
+    }
 …
     } else {
         data.fstrut_dirty = false; // non-toplevel widgets don't have a frame, so no need to update the strut
+        if(OSViewRef osview = qt_mac_create_widget(q, this, qt_mac_nativeview_for(parentWidget))) {
+#ifdef QT_MAC_USE_COCOA
+        if (q->testAttribute(Qt::WA_NativeWindow) == false ||
+            q->internalWinId() != 0) {
+#ifdef ALIEN_DEBUG
+            qDebug() << "Skipping native widget creation for" << this;
+#endif
+        } else
+#endif
+        if (OSViewRef osview = qt_mac_create_widget(q, this, qt_mac_nativeview_for(parentWidget))) {
 #ifndef QT_MAC_USE_COCOA
             HIRect bounds = CGRectMake(data.crect.x(), data.crect.y(), data.crect.width(), data.crect.height());
 …
+{
     Q_D(QWidget);
+    d->aboutToDestroy();
     if (!isWindow() && parentWidget())
         parentWidget()->d_func()->invalidateBuffer(d->effectiveRectFor(geometry()));
 …
+}
+#ifdef QT_MAC_USE_COCOA
+void QWidgetPrivate::setSubWindowStacking(bool set)
+{
+    // This will set/remove a visual relationship between parent and child on screen.
+    // The reason for doing this is to ensure that a child always stacks infront of
+    // its parent. Unfortunatly is turns out that [NSWindow addChildWindow] has
+    // several unwanted side-effects, one of them being the moving of a child when
+    // moving the parent, which we choose to accept. A way tougher side-effect is
+    // that Cocoa will hide the parent if you hide the child. And in the case of
+    // a tool window, since it will normally hide when you deactivate the
+    // application, Cocoa will hide the parent upon deactivate as well. The result often
+    // being no more visible windows on screen. So, to make a long story short, we only
+    // allow parent-child relationships between windows that both are either a plain window
+    // or a dialog.
+    Q_Q(QWidget);
+    if (!q->isWindow())
+        return;
+    NSWindow *qwin = [qt_mac_nativeview_for(q) window];
+    if (!qwin)
+        return;
+    Qt::WindowType qtype = q->windowType();
+    if (set && !(qtype == Qt::Window || qtype == Qt::Dialog))
+        return;
+    if (set && ![qwin isVisible])
+        return;
+    if (QWidget *parent = q->parentWidget()) {
+        if (NSWindow *pwin = [qt_mac_nativeview_for(parent) window]) {
+            if (set) {
+                Qt::WindowType ptype = parent->window()->windowType();
+                if ([pwin isVisible] && (ptype == Qt::Window || ptype == Qt::Dialog) && ![qwin parentWindow]) {
+                    NSInteger level = [qwin level];
+                    [pwin addChildWindow:qwin ordered:NSWindowAbove];
+                    if ([qwin level] < level)
+                        [qwin setLevel:level];
+                }
+            } else {
+                [pwin removeChildWindow:qwin];
+            }
+        }
+    }
+    QObjectList widgets = q->children();
+    for (int i=0; i<widgets.size(); ++i) {
+        QWidget *child = qobject_cast<QWidget *>(widgets.at(i));
+        if (child && child->isWindow()) {
+            if (NSWindow *cwin = [qt_mac_nativeview_for(child) window]) {
+                if (set) {
+                    Qt::WindowType ctype = child->window()->windowType();
+                    if ([cwin isVisible] && (ctype == Qt::Window || ctype == Qt::Dialog) && ![cwin parentWindow]) {
+                        NSInteger level = [cwin level];
+                        [qwin addChildWindow:cwin ordered:NSWindowAbove];
+                        if ([cwin level] < level)
+                            [cwin setLevel:level];
+                    }
+                } else {
+                    [qwin removeChildWindow:qt_mac_window_for(child)];
+                }
+            }
+        }
+    }
+}
+#endif
 void QWidgetPrivate::setParent_sys(QWidget *parent, Qt::WindowFlags f)
+{
 …
         if (wasWindow) {
             oldToolbar = [oldWindow toolbar];
+            [oldToolbar retain];
+            oldToolbarVisible = [oldToolbar isVisible];
+            [oldWindow setToolbar:nil];
+            if (oldToolbar) {
+                [oldToolbar retain];
+                oldToolbarVisible = [oldToolbar isVisible];
+                [oldWindow setToolbar:nil];
+            }
+        }
 #endif
 …
     //recreate and setup flags
     QObjectPrivate::setParent_helper(parent);
-    QPoint pt = q->pos();
     bool explicitlyHidden = q->testAttribute(Qt::WA_WState_Hidden) && q->testAttribute(Qt::WA_WState_ExplicitShowHide);
     if (wasCreated && !qt_isGenuineQWidget(q))
         return;
     if ((data.window_flags & Qt::Sheet) && topData && topData->opacity == 242)
+    if (!q->testAttribute(Qt::WA_WState_WindowOpacitySet)) {
         q->setWindowOpacity(1.0f);
+        q->setAttribute(Qt::WA_WState_WindowOpacitySet, false);
+    }
     setWinId(0); //do after the above because they may want the id
 …
     q->setAttribute(Qt::WA_WState_Hidden, false);
     adjustFlags(data.window_flags, q);
+    // keep compatibility with previous versions, we need to preserve the created state
+    // (but we recreate the winId for the widget being reparented, again for compatibility)
+    if (wasCreated || (!q->isWindow() && parent->testAttribute(Qt::WA_WState_Created))) {
+    // keep compatibility with previous versions, we need to preserve the created state.
+    // (but we recreate the winId for the widget being reparented, again for compatibility,
+    // unless this is an alien widget. )
+    const bool nonWindowWithCreatedParent = !q->isWindow() && parent->testAttribute(Qt::WA_WState_Created);
+    const bool nativeWidget = q->internalWinId() != 0;
+    if (wasCreated || nativeWidget && nonWindowWithCreatedParent) {
         createWinId();
         if (q->isWindow()) {
 …
             // (only for performance, it gets called a lot anyway).
             if (!wasCreated) {
                 if (QMainWindowLayout *mwl = qobject_cast<QMainWindowLayout *>(q->layout())) {
+                if (QMainWindowLayout *mwl = qt_mainwindow_layout(qobject_cast<QMainWindow *>(q))) {
                     mwl->updateHIToolBarStatus();
+                }
 …
         // So redo the status one more time. It apparently is not an issue with Cocoa.
         if (q->isWindow()) {
             if (QMainWindowLayout *mwl = qobject_cast<QMainWindowLayout *>(q->layout())) {
+            if (QMainWindowLayout *mwl = qt_mainwindow_layout(qobject_cast<QMainWindow *>(q))) {
                 mwl->updateHIToolBarStatus();
+            }
 …
+        }
+    }
     invalidateBuffer(q->rect());
     qt_event_request_window_change(q);
 …
+{
     Q_D(const QWidget);
     if (!testAttribute(Qt::WA_WState_Created)) {
+    if (!testAttribute(Qt::WA_WState_Created) || !internalWinId()) {
         QPoint p = pos + data->crect.topLeft();
         return isWindow() ?  p : parentWidget()->mapToGlobal(p);
 …
+{
     Q_D(const QWidget);
     if (!testAttribute(Qt::WA_WState_Created)) {
+    if (!testAttribute(Qt::WA_WState_Created) || !internalWinId()) {
         QPoint p = isWindow() ?  pos : parentWidget()->mapFromGlobal(pos);
         return p - data->crect.topLeft();
 …
 #ifndef QT_MAC_USE_COCOA
         ActivateWindow(win, true);
+        qApp->setActiveWindow(tlw);
 #else
         [win makeKeyWindow];
 #endif
-        qApp->setActiveWindow(tlw);
     } else if(!isMinimized()) {
 #ifndef QT_MAC_USE_COCOA
 …
             HIViewSetNeedsDisplay(qt_mac_nativeview_for(q), true);
 #else
             [qt_mac_nativeview_for(q) setNeedsDisplay:YES];
+            qt_mac_set_needs_display(q, QRegion());
 #endif
         return;
 …
+    }
 #else
+    // Cocoa doesn't do regions, it seems more efficient to just update the bounding rect instead of a potential number of message passes for each rect.
+    const QRect &boundingRect = rgn.boundingRect();
+    [qt_mac_nativeview_for(q) setNeedsDisplayInRect:NSMakeRect(boundingRect.x(),
+                                                            boundingRect.y(), boundingRect.width(),
+                                                            boundingRect.height())];
+    // Alien support: get the first native ancestor widget (will be q itself in the non-alien case),
+    // map the coordinates from q space to NSView space and invalidate the rect.
+    QWidget *nativeParent = q->internalWinId() ? q : q->nativeParentWidget();
+    if (nativeParent == 0)
+        return;
+    QVector<QRect> rects = rgn.rects();
+    for (int i = 0; i < rects.count(); ++i) {
+        const QRect &rect = rects.at(i);
+        const QRect nativeBoundingRect = QRect(
+                QPoint(q->mapTo(nativeParent, rect.topLeft())),
+                QSize(rect.size()));
+        [qt_mac_nativeview_for(nativeParent) setNeedsDisplayInRect:NSMakeRect(nativeBoundingRect.x(),
+                nativeBoundingRect.y(), nativeBoundingRect.width(),
+                nativeBoundingRect.height())];
+    }
 #endif
+}
 …
     bool realWindow = isRealWindow();
+#ifndef QT_MAC_USE_COCOA
     if (realWindow && !q->testAttribute(Qt::WA_Moved)) {
+        if (qt_mac_is_macsheet(q))
+            recreateMacWindow();
         q->createWinId();
         if (QWidget *p = q->parentWidget()) {
             p->createWinId();
-#ifndef QT_MAC_USE_COCOA
             RepositionWindow(qt_mac_window_for(q), qt_mac_window_for(p), kWindowCenterOnParentWindow);
-#else
-            CGRect parentFrame = NSRectToCGRect([qt_mac_window_for(p) frame]);
-            OSWindowRef windowRef = qt_mac_window_for(q);
-            NSRect windowFrame = [windowRef frame];
-            NSPoint parentCenter = NSMakePoint(CGRectGetMidX(parentFrame), CGRectGetMidY(parentFrame));
-            [windowRef setFrameTopLeftPoint:NSMakePoint(parentCenter.x - (windowFrame.size.width / 2),
-                                                        (parentCenter.y + (windowFrame.size.height / 2)))];
-#endif
         } else {
-#ifndef QT_MAC_USE_COCOA
             RepositionWindow(qt_mac_window_for(q), 0, kWindowCenterOnMainScreen);
+#else
+            // Ideally we would do a "center" here, but NSWindow's center is more equivalent to
+            // kWindowAlertPositionOnMainScreen instead of kWindowCenterOnMainScreen.
+            QRect availGeo = QApplication::desktop()->availableGeometry(q);
+            // Center the content only.
+            data.crect.moveCenter(availGeo.center());
+            QRect fStrut = frameStrut();
+            QRect frameRect(data.crect.x() - fStrut.left(), data.crect.y() - fStrut.top(),
+                            fStrut.left() + fStrut.right() + data.crect.width(),
+                            fStrut.top() + fStrut.bottom() + data.crect.height());
+            NSRect cocoaFrameRect = NSMakeRect(frameRect.x(), flipYCoordinate(frameRect.bottom() + 1), frameRect.width(), frameRect.height());
+            [qt_mac_window_for(q) setFrame:cocoaFrameRect display:NO];
+#endif
+        }
+    }
+        }
+    }
+#endif
     data.fstrut_dirty = true;
     if (realWindow) {
 …
             // sync the opacity value back (in case of a fade).
             [window setAlphaValue:q->windowOpacity()];
+            [window makeKeyAndOrderFront:window];
+            // If this window is app modal, we need to start spinning
+            // a modal session for it. Interrupting
+            // the event dispatcher will make this happend:
+            if (data.window_modality == Qt::ApplicationModal)
+                QEventDispatcherMac::instance()->interrupt();
+            QWidget *top = 0;
+            if (QApplicationPrivate::tryModalHelper(q, &top)) {
+                [window makeKeyAndOrderFront:window];
+                // If this window is app modal, we need to start spinning
+                // a modal session for it. Interrupting
+                // the event dispatcher will make this happend:
+                if (data.window_modality == Qt::ApplicationModal)
+                    QEventDispatcherMac::instance()->interrupt();
+            } else {
+                // The window is modally shaddowed, so we need to make
+                // sure that we don't pop in front of the modal window:
+                [window orderFront:window];
+                if (!top->testAttribute(Qt::WA_DontShowOnScreen)) {
+                    if (NSWindow *modalWin = qt_mac_window_for(top))
+                        [modalWin orderFront:window];
+                }
+            }
+            setSubWindowStacking(true);
 #endif
             if (q->windowType() == Qt::Popup) {
 …
 #ifndef QT_MAC_USE_COCOA
             qt_event_request_activate(q);
-#else
-            [qt_mac_window_for(q) makeKeyWindow];
 #endif
+        }
 …
     QMacCocoaAutoReleasePool pool;
     if(q->isWindow()) {
+#ifdef QT_MAC_USE_COCOA
+        setSubWindowStacking(false);
+#endif
         OSWindowRef window = qt_mac_window_for(q);
         if(qt_mac_is_macsheet(q)) {
 …
 #endif
+        }
+        if(q->isActiveWindow() && !(q->windowType() == Qt::Popup)) {
+#ifndef QT_MAC_USE_COCOA
+        // If the window we now hide was the active window, we need
+        // to find, and activate another window on screen. NB: Cocoa takes care of this
+        // logic for us (and distinquishes between main windows and key windows)
+        if (q->isActiveWindow() && !(q->windowType() == Qt::Popup)) {
             QWidget *w = 0;
             if(q->parentWidget())
                 w = q->parentWidget()->window();
             if(!w || (!w->isVisible() && !w->isMinimized())) {
-#ifndef QT_MAC_USE_COCOA
                 for (WindowPtr wp = GetFrontWindowOfClass(kMovableModalWindowClass, true);
                     wp; wp = GetNextWindowOfClass(wp, kMovableModalWindowClass, true)) {
 …
+                    }
+                }
-#else
-                NSArray *windows = [NSApp windows];
-                NSUInteger totalWindows = [windows count];
-                for (NSUInteger i = 0; i < totalWindows; ++i) {
-                    OSWindowRef wp = [windows objectAtIndex:i];
-                    if ((w = qt_mac_find_window(wp)))
-                        break;
+                }
-#endif
+            }
             if(w && w->isVisible() && !w->isMinimized()) {
+#ifndef QT_MAC_USE_COCOA
+            qt_event_request_activate(w);
+#else
+            [qt_mac_window_for(w) makeKeyWindow];
+#endif
+            }
+        }
+                qt_event_request_activate(w);
+            }
+        }
+#endif
     } else {
          invalidateBuffer(q->rect());
 …
     QMacCocoaAutoReleasePool pool;
     if (isRealWindow()) {
+        // Calling orderFront shows the window on Cocoa too.
+        // With the introduction of spaces it is not as simple as just raising the window.
+        // First we need to check if we are in the right space. If we are, then we just continue
+        // as usual. The problem comes when we are not in the active space. There are two main cases:
+        // 1. Our parent was moved to a new space. In this case we want the window to be raised
+        // in the same space as its parent.
+        // 2. We don't have a parent. For this case we will just raise the window and let Cocoa
+        // switch to the corresponding space.
+        // NOTICE: There are a lot of corner cases here. We are keeping this simple for now, if
+        // required we will introduce special handling for some of them.
         if (!q->testAttribute(Qt::WA_DontShowOnScreen) && q->isVisible()) {
+            [qt_mac_window_for(q) orderFront:qt_mac_window_for(q)];
+            OSWindowRef window = qt_mac_window_for(q);
+            // isOnActiveSpace is available only from 10.6 onwards, so we need to check if it is
+            // available before calling it.
+            if([window respondsToSelector:@selector(isOnActiveSpace)]) {
+                if(![window performSelector:@selector(isOnActiveSpace)]) {
+                    QWidget *parentWidget = q->parentWidget();
+                    if(parentWidget) {
+                        OSWindowRef parentWindow = qt_mac_window_for(parentWidget);
+                        if(parentWindow && [parentWindow isOnActiveSpace]) {
+                            // The window was created in a different space. Therefore if we want
+                            // to show it in the current space we need to recreate it in the new
+                            // space.
+                            recreateMacWindow();
+                            window = qt_mac_window_for(q);
+                        }
+                    }
+                }
+            }
+            [window orderFront:window];
+        }
         if (qt_mac_raise_process) { //we get to be the active process now
 …
     flag
 */
 static void qt_mac_update_widget_posisiton(QWidget *q, QRect oldRect, QRect newRect)
+static void qt_mac_update_widget_position(QWidget *q, QRect oldRect, QRect newRect)
+{
 #ifndef QT_MAC_USE_COCOA
 …
         // the position update is a part of a drag-and-drop operation
         QDragManager::self()->object ||
         // we are on Panther (no HIViewSetNeedsDisplayInRect)
         QSysInfo::MacintoshVersion < QSysInfo::MV_10_4
+        QDragManager::self()->object ||
+        // we are on Panther (no HIViewSetNeedsDisplayInRect)
+        QSysInfo::MacintoshVersion < QSysInfo::MV_10_4
     ){
         HIViewSetFrame(view, &bounds);
 …
     Q_UNUSED(oldRect);
     NSRect bounds = NSMakeRect(newRect.x(), newRect.y(),
                                newRect.width(), newRect.height());
+            newRect.width(), newRect.height());
     [qt_mac_nativeview_for(q) setFrame:bounds];
 #endif
 …
     QRect parentWRect;
+    if (q->isWindow() && topData()->embedded) {
+    bool isEmbeddedWindow = (q->isWindow() && topData()->embedded);
+    if (isEmbeddedWindow) {
 #ifndef QT_MAC_USE_COCOA
         HIViewRef parentView = HIViewGetSuperview(qt_mac_nativeview_for(q));
 …
     if (parentWRect.isValid()) {
         // parent is clipped, and we have to clip to the same limit as parent
         if (!parentWRect.contains(xrect)) {
+        if (!parentWRect.contains(xrect) && !isEmbeddedWindow) {
             xrect &= parentWRect;
             wrect = xrect;
 …
+    }
     qt_mac_update_widget_posisiton(q, oldRect, xrect);
+    qt_mac_update_widget_position(q, oldRect, xrect);
     if  (jump)
 …
     QMacCocoaAutoReleasePool pool;
     bool realWindow = isRealWindow();
+    BOOL needDisplay = realWindow ? YES : NO;
     if (realWindow && !q->testAttribute(Qt::WA_DontShowOnScreen)){
 …
+        }
 #else
+        if (!isMove && !q->testAttribute(Qt::WA_Moved) && !q->isVisible()) {
+            // INVARIANT: The location of the window has not yet been set. The default will
+            // instead be to center it on the desktop, or over the parent, if any. Since we now
+            // resize the window, we need to adjust the top left position to keep the window
+            // centeralized. And we need to to this now (and before show) in case the positioning
+            // of other windows (e.g. sub-windows) depend on this position:
+            if (QWidget *p = q->parentWidget()) {
+                x = p->geometry().center().x() - (w / 2);
+                y = p->geometry().center().y() - (h / 2);
+            } else {
+                QRect availGeo = QApplication::desktop()->availableGeometry(q);
+                x = availGeo.center().x() - (w / 2);
+                y = availGeo.center().y() - (h / 2);
+            }
+        }
         QSize  olds = q->size();
         const bool isResize = (olds != QSize(w, h));
 …
                 && cocoaFrameRect.size.width != 0
                 && cocoaFrameRect.size.height != 0) {
             [window setFrame:cocoaFrameRect display:NO];
+            [window setFrame:cocoaFrameRect display:needDisplay];
         } else {
             // The window is moved and resized (or resized to zero).
 …
             // window back and forth inbetween.
             cocoaFrameRect.origin.y += 1;
             [window setFrame:cocoaFrameRect display:NO];
+            [window setFrame:cocoaFrameRect display:needDisplay];
             cocoaFrameRect.origin.y -= 1;
             [window setFrameOrigin:cocoaFrameRect.origin];
 …
     const bool visible = q->isVisible();
+    // Apply size restrictions, applicable for Windows & Widgets.
+    if (QWExtra *extra = extraData()) {
+        w = qMin(w, extra->maxw);
+        h = qMin(h, extra->maxh);
+        w = qMax(w, extra->minw);
+        h = qMax(h, extra->minh);
+    }
     data.crect = QRect(x, y, w, h);
 …
     SetControlDragTrackingEnabled(qt_mac_nativeview_for(q), on);
 #else
+    NSView *view = qt_mac_nativeview_for(q);
+    if (on && [view isKindOfClass:[QT_MANGLE_NAMESPACE(QCocoaView) class]]) {
+        [static_cast<QT_MANGLE_NAMESPACE(QCocoaView) *>(view) registerDragTypes];
+    NSWindow *win = qt_mac_window_for(q);
+    if (on) {
+        if ([win isKindOfClass:[QT_MANGLE_NAMESPACE(QCocoaWindow) class]])
+            [static_cast<QT_MANGLE_NAMESPACE(QCocoaWindow) *>(win) registerDragTypes];
+        else if ([win isKindOfClass:[QT_MANGLE_NAMESPACE(QCocoaPanel) class]])
+            [static_cast<QT_MANGLE_NAMESPACE(QCocoaPanel) *>(win) registerDragTypes];
+    }
 #endif
 …
         [window invalidateShadow];
+    }
     [qt_mac_nativeview_for(q) setNeedsDisplay:YES];
+    qt_mac_set_needs_display(q, QRegion());
+}
 #endif
 …
     if (windowParent && q->windowModality() == Qt::WindowModal){
         // Window should be window-modal, which implies a sheet.
+        // INVARIANT: Window should be window-modal (which implies a sheet).
         if (!alreadySheet) {
             // NB: the following call will call setModal_sys recursivly:
 …
+        }
     } else {
         // Window shold not be window-modal, and as such, not a sheet.
+        // INVARIANT: Window shold _not_ be window-modal (and as such, not a sheet).
         if (alreadySheet){
             // NB: the following call will call setModal_sys recursivly:
 …
             windowRef = qt_mac_window_for(q);
+        }
+        if (q->windowModality() == Qt::ApplicationModal) {
+            [windowRef setLevel:NSModalPanelWindowLevel];
+        } else if (primaryWindow && primaryWindow->windowModality() == Qt::ApplicationModal) {
+            // INVARIANT: Our window is a dialog that has a dialog parent that is
+            // application modal, or . This means that q is supposed to be on top of this
+            // dialog and not be modally shaddowed:
+            [windowRef setLevel:NSModalPanelWindowLevel];
+        if (q->windowModality() == Qt::NonModal
+            && primaryWindow && primaryWindow->windowModality() == Qt::ApplicationModal) {
+            // INVARIANT: Our window has a parent that is application modal.
+            // This means that q is supposed to be on top of this window and
+            // not be modally shaddowed:
             if ([windowRef isKindOfClass:[NSPanel class]])
                 [static_cast<NSPanel *>(windowRef) setWorksWhenModal:YES];
-        } else {
-            // INVARIANT: q should not be modal.
-            NSInteger winLevel = -1;
-            if (q->windowType() == Qt::Popup) {
-                winLevel = NSPopUpMenuWindowLevel;
-                // Popup should be in at least the same level as its parent.
-                if (primaryWindow) {
-                    OSWindowRef parentRef = qt_mac_window_for(primaryWindow);
-                    winLevel = qMax([parentRef level], winLevel);
+                }
-            } else if (q->windowType() == Qt::Tool) {
-                winLevel = NSFloatingWindowLevel;
-            } else if (q->windowType() == Qt::Dialog) {
-                winLevel = NSModalPanelWindowLevel;
+            }
-            // StayOnTop window should appear above Tool windows.
-            if (data.window_flags & Qt::WindowStaysOnTopHint)
-                winLevel = NSPopUpMenuWindowLevel;
-            // Tooltips should appear above StayOnTop windows.
-            if (q->windowType() == Qt::ToolTip)
-                winLevel = NSScreenSaverWindowLevel;
-            // All other types are Normal level.
-            if (winLevel == -1)
-                winLevel = NSNormalWindowLevel;
-            [windowRef setLevel:winLevel];
+        }
+    }
 …
         recreateMacWindow();
 #else
         QMainWindowLayout *layout = qobject_cast<QMainWindowLayout *>(q->layout());
+        QMainWindowLayout *layout = qt_mainwindow_layout(qobject_cast<QMainWindow *>(q));
         if (q->testAttribute(Qt::WA_MacBrushedMetal)) {
             if (layout)

trunk/src/gui/kernel/qwidget_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 class QStyle;
+class Q_AUTOTEST_EXPORT QWidgetBackingStoreTracker
+{
+public:
+    QWidgetBackingStoreTracker();
+    ~QWidgetBackingStoreTracker();
+    void create(QWidget *tlw);
+    void destroy();
+    void registerWidget(QWidget *w);
+    void unregisterWidget(QWidget *w);
+    void unregisterWidgetSubtree(QWidget *w);
+    inline QWidgetBackingStore* data()
+    {
+        return m_ptr;
+    }
+    inline QWidgetBackingStore* operator->()
+    {
+        return m_ptr;
+    }
+    inline QWidgetBackingStore& operator*()
+    {
+        return *m_ptr;
+    }
+    inline operator bool() const
+    {
+        return (0 != m_ptr);
+    }
+private:
+    Q_DISABLE_COPY(QWidgetBackingStoreTracker)
+private:
+    QWidgetBackingStore* m_ptr;
+    QSet<QWidget *> m_widgets;
+};
 struct QTLWExtra {
     // *************************** Cross-platform variables *****************************
 …
     QIcon *icon; // widget icon
     QPixmap *iconPixmap;
     QWidgetBackingStore *backingStore;
+    QWidgetBackingStoreTracker backingStore;
     QWindowSurface *windowSurface;
     QPainter *sharedPainter;
 …
 #endif
 #elif defined(Q_WS_WIN) // <--------------------------------------------------------- WIN
+    uint hotkeyRegistered: 1; // Hot key from the STARTUPINFO has been registered.
     HICON winIconBig; // internal big Windows icon
     HICON winIconSmall; // internal small Windows icon
 …
     IconRef windowIcon; // the current window icon, if set with setWindowIcon_sys.
     quint32 savedWindowAttributesFromMaximized; // Saved attributes from when the calling updateMaximizeButton_sys()
+#ifdef QT_MAC_USE_COCOA
+    // This value is just to make sure we maximize and restore to the right location, yet we allow apps to be maximized and
+    // manually resized.
+    // The name is misleading, since this is set when maximizing the window. It is a hint to saveGeometry(..) to record the
+    // starting position as 0,0 instead of the normal starting position.
+    bool wasMaximized;
+#endif // QT_MAC_USE_COCOA
 #elif defined(Q_WS_QWS) // <--------------------------------------------------------- QWS
 #ifndef QT_NO_QWS_MANAGER
 …
 #elif defined(Q_OS_SYMBIAN)
     uint inExpose : 1; // Prevents drawing recursion
+    uint nativeWindowTransparencyEnabled : 1; // Tracks native window transparency
 #elif defined(Q_WS_PM)
     HWND fId;
 …
     void render_helper(QPainter *painter, const QPoint &targetOffset, const QRegion &sourceRegion,
                        QWidget::RenderFlags renderFlags);
+    void render(QPaintDevice *target, const QPoint &targetOffset, const QRegion &sourceRegion,
+                QWidget::RenderFlags renderFlags, bool readyToRender);
     void drawWidget(QPaintDevice *pdev, const QRegion &rgn, const QPoint &offset, int flags,
                     QPainter *sharedPainter = 0, QWidgetBackingStore *backingStore = 0);
 …
     bool setMaximumSize_helper(int &maxw, int &maxh);
     void setConstraints_sys();
+    bool pointInsideRectAndMask(const QPoint &) const;
     QWidget *childAt_helper(const QPoint &, bool) const;
+    QWidget *childAtRecursiveHelper(const QPoint &p, bool, bool includeFrame = false) const;
     void updateGeometry_helper(bool forceUpdate);
 …
     void setLayoutItemMargins(int left, int top, int right, int bottom);
     void setLayoutItemMargins(QStyle::SubElement element, const QStyleOption *opt = 0);
+    // aboutToDestroy() is called just before the contents of
+    // QWidget::destroy() is executed. It's used to signal QWidget
+    // sub-classes that their internals are about to be released.
+    virtual void aboutToDestroy() {}
     QInputContext *inputContext() const;
 …
     QList<QAction*> actions;
 #endif
+#ifndef QT_NO_GESTURES
     QMap<Qt::GestureType, Qt::GestureFlags> gestureContext;
+#endif
     // Bit fields.
     uint high_attributes[3]; // the low ones are in QWidget::widget_attributes
+    uint high_attributes[4]; // the low ones are in QWidget::widget_attributes
     QPalette::ColorRole fg_role : 8;
     QPalette::ColorRole bg_role : 8;
 …
     uint isGLWidget : 1;
     uint usesDoubleBufferedGLContext : 1;
+#ifndef QT_NO_IM
+    uint inheritsInputMethodHints : 1;
+#endif
     // *************************** Platform specific ************************************
 …
     void x11UpdateIsOpaque();
     bool isBackgroundInherited() const;
+    void updateX11AcceptFocus();
 #elif defined(Q_WS_PM) // <----------------------------------------------------------- PM
     uint noPaintOnScreen : 1; // see qwidget_pm.cpp ::paintEngine()
 …
 #elif defined(Q_WS_WIN) // <--------------------------------------------------------- WIN
     uint noPaintOnScreen : 1; // see qwidget_win.cpp ::paintEngine()
+#ifndef QT_NO_GESTURES
     uint nativeGesturePanEnabled : 1;
+#endif
     bool shouldShowMaximizeButton();
     void winUpdateIsOpaque();
 …
     // This is new stuff
     uint needWindowChange : 1;
+    uint hasAlienChildren : 1;
     // Each wiget keeps a list of all its child and grandchild OpenGL widgets.
 …
     void finishCreateWindow_sys_Carbon(OSWindowRef windowRef);
 #else
+    void setSubWindowStacking(bool set);
+    void setWindowLevel();
     void finishCreateWindow_sys_Cocoa(void * /*NSWindow * */ windowRef);
     void syncCocoaMask();
     void finishCocoaMaskSetup();
+    void syncUnifiedMode();
+    // Did we add the drawRectOriginal method?
+    bool drawRectOriginalAdded;
+    // Is the original drawRect method available?
+    bool originalDrawMethod;
+    // Do we need to change the methods?
+    bool changeMethods;
 #endif
     void determineWindowClass();
 …
+}
+inline bool QWidgetPrivate::pointInsideRectAndMask(const QPoint &p) const
+{
+    Q_Q(const QWidget);
+    return q->rect().contains(p) && (!extra || !extra->hasMask || q->testAttribute(Qt::WA_MouseNoMask)
+                                     || extra->mask.contains(p));
+}
 inline QWidgetBackingStore *QWidgetPrivate::maybeBackingStore() const
+{
     Q_Q(const QWidget);
     QTLWExtra *x = q->window()->d_func()->maybeTopData();
     return x ? x->backingStore : 0;
+    return x ? x->backingStore.data() : 0;
+}

trunk/src/gui/kernel/qwidget_qws.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
+{
     Q_D(QWidget);
+    d->aboutToDestroy();
     if (!isWindow() && parentWidget())
         parentWidget()->d_func()->invalidateBuffer(d->effectiveRectFor(geometry()));
 …
         const QScreen *screen = d->getScreen();
         return qRound(screen->height() / double(screen->physicalHeight() / 25.4));
+    } else if (m == PdmNumColors) {
+        QScreen *screen = d->getScreen();
+        int ret = screen->colorCount();
+        if (!ret) {
+            const int depth = qwsDisplay()->depth();
+            switch (depth) {
+            case 1:
+                ret = 2;
+                break;
+            case 8:
+                ret = 256;
+                break;
+            case 16:
+                ret = 65536;
+                break;
+            case 24:
+                ret = 16777216;
+                break;
+            case 32:
+                ret = 2147483647;
+                break;
+            }
+        }
+        return ret;
     } else {
         val = QPaintDevice::metric(m);// XXX

trunk/src/gui/kernel/qwidget_s60.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #ifdef Q_WS_S60
 #include <aknappui.h>
+#include <eikbtgpc.h>
 #endif
 // This is necessary in order to be able to perform delayed invokation on slots
+// This is necessary in order to be able to perform delayed invocation on slots
 // which take arguments of type WId.  One example is
 // QWidgetPrivate::_q_delayedDestroy, which is used to delay destruction of
 …
 Q_DECLARE_METATYPE(WId)
+// Workaround for the fact that S60 SDKs 3.x do not contain the akntoolbar.h
+// header, even though the documentation says that it should be there, and indeed
+// it is present in the library.
+class CAknToolbar : public CAknControl,
+                    public MCoeControlObserver,
+                    public MCoeControlBackground,
+                    public MEikCommandObserver,
+                    public MAknFadedComponent
+{
+public:
+    IMPORT_C void SetToolbarVisibility(const TBool visible);
+};
 QT_BEGIN_NAMESPACE
 …
 QWidget *QWidgetPrivate::mouseGrabber = 0;
 QWidget *QWidgetPrivate::keyboardGrabber = 0;
+CEikButtonGroupContainer *QS60Data::cba = 0;
 static bool isEqual(const QList<QAction*>& a, const QList<QAction*>& b)
 …
         // Symbian windows are always created in an inactive state
         // We perform this assignment for the case where the window is being re-created
         // as aa result of a call to setParent_sys, on either this widget or one of its
+        // as a result of a call to setParent_sys, on either this widget or one of its
         // ancestors.
         extra->activated = 0;
 …
         // Symbian windows are always created in an inactive state
         // We perform this assignment for the case where the window is being re-created
         // as aa result of a call to setParent_sys, on either this widget or one of its
+        // as a result of a call to setParent_sys, on either this widget or one of its
         // ancestors.
         extra->activated = 0;
 …
         drawableWindow->PointerFilter(EPointerFilterEnterExit
             | EPointerFilterMove | EPointerFilterDrag, 0);
+        drawableWindow->EnableVisibilityChangeEvents();
         if (q->isVisible() && q->testAttribute(Qt::WA_Mapped)) {
 …
          QSymbianControl *id = static_cast<QSymbianControl *>(q->internalWinId());
+         const bool isFullscreen = q->windowState() & Qt::WindowFullScreen;
+         const TBool cbaRequested = q->windowFlags() & Qt::WindowSoftkeysVisibleHint;
 #ifdef Q_WS_S60
         // Lazily initialize the S60 screen furniture when the first window is shown.
         if (!QApplication::testAttribute(Qt::AA_S60DontConstructApplicationPanes)
+        if (q->isWindow() && !QApplication::testAttribute(Qt::AA_S60DontConstructApplicationPanes)
                 && !S60->buttonGroupContainer() && !S60->statusPane()) {
-            bool isFullscreen = q->windowState() & Qt::WindowFullScreen;
             if (!q->testAttribute(Qt::WA_DontShowOnScreen)) {
 …
                 CEikAppUi *ui = static_cast<CEikAppUi *>(S60->appUi());
                 MEikAppUiFactory *factory = CEikonEnv::Static()->AppUiFactory();
+                TRAP_IGNORE(factory->ReadAppInfoResourceL(0, ui));
+                if (S60->buttonGroupContainer())
+                    S60->buttonGroupContainer()->SetCommandSetL(R_AVKON_SOFTKEYS_EMPTY_WITH_IDS);
+                QT_TRAP_THROWING(
+                    factory->CreateResourceIndependentFurnitureL(ui);
+                    TRect boundingRect = static_cast<CEikAppUi*>(S60->appUi())->ClientRect();
+                    CEikButtonGroupContainer *cba = CEikButtonGroupContainer::NewL(CEikButtonGroupContainer::ECba,
+                        CEikButtonGroupContainer::EHorizontal,ui,R_AVKON_SOFTKEYS_EMPTY_WITH_IDS);
+                    if (isFullscreen && !cbaRequested)
+                        cba->MakeVisible(false);
+                    CEikButtonGroupContainer *oldCba = factory->SwapButtonGroup(cba);
+                    Q_ASSERT(!oldCba);
+                    S60->setButtonGroupContainer(cba);
+                    // If the creation of the first widget is delayed, for example by doing it
+                    // inside the event loop, S60 somehow "forgets" to set the visibility of the
+                    // toolbar (the three middle softkeys) when you flip the phone over, so we
+                    // need to do it ourselves to avoid a "hole" in the application, even though
+                    // Qt itself does not use the toolbar directly..
+                    CAknAppUi *appui = dynamic_cast<CAknAppUi *>(CEikonEnv::Static()->AppUi());
+                    if (appui) {
+                        CAknToolbar *toolbar = appui->PopupToolbar();
+                        if (toolbar && !toolbar->IsVisible())
+                            toolbar->SetToolbarVisibility(ETrue);
+                    }
+                    CEikMenuBar *menuBar = new(ELeave) CEikMenuBar;
+                    menuBar->ConstructL(ui, 0, R_AVKON_MENUPANE_EMPTY);
+                    menuBar->SetMenuType(CEikMenuBar::EMenuOptions);
+                    S60->appUi()->AddToStackL(menuBar,ECoeStackPriorityMenu,ECoeStackFlagRefusesFocus);
+                    CEikMenuBar *oldMenu = factory->SwapMenuBar(menuBar);
+                    Q_ASSERT(!oldMenu);
+                )
                 if (S60->statusPane()) {
 …
                     QSymbianControl *desktopControl = static_cast<QSymbianControl *>(QApplication::desktop()->winId());
                     S60->statusPane()->SetObserver(desktopControl);
-                    // Hide the status pane if fullscreen OR
-                    // Fill client area if maximized OR
-                    // Put window below status pane unless the window has an explicit position.
                     if (isFullscreen) {
+                        S60->statusPane()->MakeVisible(false);
+                    } else if (q->windowState() & Qt::WindowMaximized) {
+                        TRect r = static_cast<CEikAppUi*>(S60->appUi())->ClientRect();
+                        id->SetExtent(r.iTl, r.Size());
+                    } else if (!q->testAttribute(Qt::WA_Moved)) {
+                        id->SetPosition(static_cast<CEikAppUi*>(S60->appUi())->ClientRect().iTl);
+                        const bool cbaVisible = S60->buttonGroupContainer() && S60->buttonGroupContainer()->IsVisible();
+                        S60->setStatusPaneAndButtonGroupVisibility(false, cbaVisible);
+                    }
+                }
 …
 #endif
+        // Fill client area if maximized OR
+        // Put window below status pane unless the window has an explicit position.
+        if (!isFullscreen) {
+            if (q->windowState() & Qt::WindowMaximized) {
+                TRect r = static_cast<CEikAppUi*>(S60->appUi())->ClientRect();
+                id->SetExtent(r.iTl, r.Size());
+            } else if (!q->testAttribute(Qt::WA_Moved) && q->windowType() != Qt::Dialog) {
+                id->SetPosition(static_cast<CEikAppUi*>(S60->appUi())->ClientRect().iTl);
+            }
+        }
         id->MakeVisible(true);
         if(q->isWindow())
+        if(q->isWindow()&&!q->testAttribute(Qt::WA_ShowWithoutActivating))
             id->setFocusSafely(true);
+    }
 …
     if (id) {
         //Incorrect optimisation - for popup windows, Qt's focus is moved before
+        //Incorrect optimization - for popup windows, Qt's focus is moved before
         //hide_sys is called, resulting in the popup window keeping its elevated
         //position in the CONE control stack.
 …
     if ((q->windowType() == Qt::Desktop))
         old_winid = 0;
+    // old_winid may not have received a 'not visible' visibility
+    // changed event before being destroyed; make sure that it is
+    // removed from the backing store's list of visible windows.
+    if (old_winid)
+        S60->controlVisibilityChanged(old_winid, false);
     setWinId(0);
 …
         return;
+    if ((data.window_flags & Qt::FramelessWindowHint) == 0)
+        return;
+    createTLExtra();
     RWindow *const window = static_cast<RWindow *>(q->effectiveWinId()->DrawableWindow());
 …
 #ifdef Q_SYMBIAN_SEMITRANSPARENT_BG_SURFACE
     window->SetSurfaceTransparency(!isOpaque);
+    extra->topextra->nativeWindowTransparencyEnabled = !isOpaque;
 #else
     if (!isOpaque) {
         const TDisplayMode displayMode = static_cast<TDisplayMode>(window->SetRequiredDisplayMode(EColor16MA));
         if (window->SetTransparencyAlphaChannel() == KErrNone)
+        if (window->SetTransparencyAlphaChannel() == KErrNone) {
             window->SetBackgroundColor(TRgb(255, 255, 255, 0));
+    } else
+            extra->topextra->nativeWindowTransparencyEnabled = 1;
+            if (extra->topextra->backingStore.data() &&
+                    QApplicationPrivate::graphics_system_name == QLatin1String("openvg")) {
+                // Semi-transparent EGL surfaces aren't supported. We need to
+                // recreate backing store to get translucent surface (raster surface).
+                extra->topextra->backingStore.create(q);
+                extra->topextra->backingStore.registerWidget(q);
+            }
+        }
+    } else if (extra->topextra->nativeWindowTransparencyEnabled) {
         window->SetTransparentRegion(TRegionFix<1>());
+        extra->topextra->nativeWindowTransparencyEnabled = 0;
+    }
 #endif
+}
 …
 void QWidgetPrivate::createTLSysExtra()
+{
-    extra->topextra->backingStore = 0;
     extra->topextra->inExpose = 0;
+    extra->topextra->nativeWindowTransparencyEnabled = 0;
+}
 void QWidgetPrivate::deleteTLSysExtra()
+{
+    delete extra->topextra->backingStore;
+    extra->topextra->backingStore = 0;
+    extra->topextra->backingStore.destroy();
+}
 …
     if (q->testAttribute(Qt::WA_WState_Created) && q->windowType() != Qt::Desktop) {
         RWindow *rwindow = static_cast<RWindow *>(q->effectiveWinId()->DrawableWindow());
+        rwindow->EnableAdvancedPointers();
+        QSymbianControl *window = static_cast<QSymbianControl *>(q->effectiveWinId());
+        //Enabling advanced pointer events for controls that already have active windows causes a panic.
+        if (!window->isControlActive())
+            rwindow->EnableAdvancedPointers();
+    }
 #endif
 …
     const TBool isFullscreen = newstate & Qt::WindowFullScreen;
+#ifdef Q_WS_S60
     const TBool cbaRequested = windowFlags() & Qt::WindowSoftkeysVisibleHint;
     const TBool cbaVisible = CEikButtonGroupContainer::Current() ? true : false;
 …
     if (oldstate == newstate && !softkeyVisibilityChange)
         return;
+#endif // Q_WS_S60
     if (isWindow()) {
 …
 #ifdef Q_WS_S60
+        // Hide window decoration when switching to fullsccreen / minimized otherwise show decoration.
+        // The window decoration visibility has to be changed before doing actual window state
+        // change since in that order the availableGeometry will return directly the right size and
+        // we will avoid unnecessarty redraws
+        CEikStatusPane *statusPane = S60->statusPane();
+        CEikButtonGroupContainer *buttonGroup = S60->buttonGroupContainer();
+        TBool visible = !(newstate & (Qt::WindowFullScreen | Qt::WindowMinimized));
+        if (statusPane)
+            statusPane->MakeVisible(visible);
+        if (buttonGroup) {
+            // Visibility
+            buttonGroup->MakeVisible(visible || (isFullscreen && cbaRequested));
+        bool decorationsVisible(false);
+        if (!parentWidget()) { // Only top level native windows have control over cba/status pane
+            // Hide window decoration when switching to fullscreen / minimized otherwise show decoration.
+            // The window decoration visibility has to be changed before doing actual window state
+            // change since in that order the availableGeometry will return directly the right size and
+            // we will avoid unnecessary redraws
+            decorationsVisible = !(newstate & (Qt::WindowFullScreen | Qt::WindowMinimized));
+            const bool statusPaneVisibility = decorationsVisible;
+            const bool buttonGroupVisibility = (decorationsVisible || (isFullscreen && cbaRequested));
+            S60->setStatusPaneAndButtonGroupVisibility(statusPaneVisibility, buttonGroupVisibility);
+        }
 #endif // Q_WS_S60
 …
         const bool cbaVisibilityHint = windowFlags() & Qt::WindowSoftkeysVisibleHint;
         if (newstate & Qt::WindowFullScreen && !cbaVisibilityHint) {
+            setAttribute(Qt::WA_OutsideWSRange, false);
             window->SetExtentToWholeScreen();
         } else if (newstate & Qt::WindowMaximized || ((newstate & Qt::WindowFullScreen) && cbaVisibilityHint)) {
+            setAttribute(Qt::WA_OutsideWSRange, false);
             TRect maxExtent = qt_QRect2TRect(qApp->desktop()->availableGeometry(this));
             window->SetExtent(maxExtent.iTl, maxExtent.Size());
 …
             // normal mode after showing the status pane, the geometry would overlap so we should
             // move it if it never had an explicit position.
             if (!wasMoved && statusPane && visible) {
+            if (!wasMoved && S60->statusPane() && decorationsVisible) {
                 TPoint tl = static_cast<CEikAppUi*>(S60->appUi())->ClientRect().iTl;
                 normalGeometry.setTopLeft(QPoint(tl.iX, tl.iY));
 …
+{
     Q_D(QWidget);
+    d->aboutToDestroy();
     if (!isWindow() && parentWidget())
         parentWidget()->d_func()->invalidateBuffer(geometry());
 …
         // so we flush the command buffer to ensure that the freeing of
         // those resources and deleting the window can happen "atomically"
+        S60->wsSession().Flush();
+        if (qApp)
+            S60->wsSession().Flush();
+    }
+}

trunk/src/gui/kernel/qwidget_win.cpp

-              r807
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include "qimage.h"
 #include "qlayout.h"
-#include "qlibrary.h"
 #include "qpainter.h"
 #include "qstack.h"
 …
 #include <private/qwininputcontext_p.h>
 #include <private/qpaintengine_raster_p.h>
+#include <private/qsystemlibrary_p.h>
 #if defined(Q_WS_WINCE)
 …
 QT_USE_NAMESPACE
 extern void qt_wince_maximize(QWidget *widget);                          //defined in qguifunctions_wince.cpp
+extern void qt_wince_unmaximize(QWidget *widget);                        //defined in qguifunctions_wince.cpp
 extern void qt_wince_minimize(HWND hwnd);                                //defined in qguifunctions_wince.cpp
 extern void qt_wince_full_screen(HWND hwnd, bool fullScreen, UINT swpf); //defined in qguifunctions_wince.cpp
 …
 static PtrWTQueueSizeGet ptrWTQueueSizeGet = 0;
 static PtrWTQueueSizeSet ptrWTQueueSizeSet = 0;
+#ifndef QT_NO_TABLETEVENT
 static void init_wintab_functions();
 static void qt_tablet_init();
 static void qt_tablet_cleanup();
+#endif // QT_NO_TABLETEVENT
 extern HCTX qt_tablet_context;
 extern bool qt_tablet_tilt_support;
 …
 extern bool qt_is_gui_used;
+#ifndef QT_NO_TABLETEVENT
 static void init_wintab_functions()
+{
 …
     if (!qt_is_gui_used)
         return;
     QLibrary library(QLatin1String("wintab32"));
+    QSystemLibrary library(QLatin1String("wintab32"));
     ptrWTOpen = (PtrWTOpen)library.resolve("WTOpenW");
     ptrWTInfo = (PtrWTInfo)library.resolve("WTInfoW");
 …
     qt_tablet_widget->createWinId();
     qt_tablet_widget->setObjectName(QLatin1String("Qt internal tablet widget"));
     // We dont need this internal widget to appear in QApplication::topLevelWidgets()
+    // We don't need this internal widget to appear in QApplication::topLevelWidgets()
     if (QWidgetPrivate::allWidgets)
         QWidgetPrivate::allWidgets->remove(qt_tablet_widget);
 …
     qt_tablet_widget = 0;
+}
+#endif // QT_NO_TABLETEVENT
 const QString qt_reg_winclass(QWidget *w);                // defined in qapplication_win.cpp
 …
 static HHOOK   journalRec  = 0;
 extern "C" LRESULT CALLBACK QtWndProc(HWND, UINT, WPARAM, LPARAM);
+extern "C" LRESULT QT_WIN_CALLBACK QtWndProc(HWND, UINT, WPARAM, LPARAM);
 #define XCOORD_MAX 16383
 …
+    }
+#ifndef QT_NO_TABLETEVENT
     if (q != qt_tablet_widget && QWidgetPrivate::mapper)
         qt_tablet_init();
+#endif // QT_NO_TABLETEVENT
     if (q->testAttribute(Qt::WA_DropSiteRegistered))
 …
+{
     Q_D(QWidget);
+    d->aboutToDestroy();
     if (!isWindow() && parentWidget())
         parentWidget()->d_func()->invalidateBuffer(d->effectiveRectFor(geometry()));
 …
 // The procedure does nothing, but is required for mousegrabbing to work
 #ifndef Q_WS_WINCE
 LRESULT CALLBACK qJournalRecordProc(int nCode, WPARAM wParam, LPARAM lParam)
+LRESULT QT_WIN_CALLBACK qJournalRecordProc(int nCode, WPARAM wParam, LPARAM lParam)
+{
     return CallNextHookEx(journalRec, nCode, wParam, lParam);
 …
         invalidateBuffer(q->rect());
         return;
+    }
+    if (data.window_flags & Qt::Window) {
+        QTLWExtra *extra = topData();
+        if (!extra->hotkeyRegistered) {
+            // Try to set the hotkey using information from STARTUPINFO
+            STARTUPINFO startupInfo;
+            GetStartupInfo(&startupInfo);
+            // If STARTF_USEHOTKEY is set, hStdInput is the virtual keycode
+            if (startupInfo.dwFlags & 0x00000200) {
+                WPARAM hotKey = (WPARAM)startupInfo.hStdInput;
+                SendMessage(data.winid, WM_SETHOTKEY, hotKey, 0);
+            }
+            extra->hotkeyRegistered = 1;
+        }
+    }
 …
         if (IsZoomed(q->internalWinId()))
             data.window_state |= Qt::WindowMaximized;
+        // This is to resolve the problem where popups are opened from the
+        // system tray and not being implicitly activated
+        if (q->windowType() == Qt::Popup &&
+            !q->parentWidget() && !qApp->activeWindow())
+            q->activateWindow();
+    }
 …
     if (data.window_flags & Qt::MSWindowsFixedSizeDialogHint)
         return false;
     // if the user explicitely asked for the maximize button, we try to add
+    // if the user explicitly asked for the maximize button, we try to add
     // it even if the window has fixed size.
     if (data.window_flags & Qt::CustomizeWindowHint &&
 …
 void QWidgetPrivate::createTLSysExtra()
+{
+    extra->topextra->hotkeyRegistered = 0;
     extra->topextra->savedFlags = 0;
     extra->topextra->winIconBig = 0;
 …
     if (!function_resolved) {
         ptrSetLayeredWindowAttributes =
             (PtrSetLayeredWindowAttributes) QLibrary::resolve(QLatin1String("user32"),
+            (PtrSetLayeredWindowAttributes) QSystemLibrary::resolve(QLatin1String("user32"),
                                                               "SetLayeredWindowAttributes");
         function_resolved = true;
 …
 void QWidgetPrivate::winSetupGestures()
+{
 #if !defined(QT_NO_NATIVE_GESTURES)
+#if !defined(QT_NO_GESTURES) && !defined(QT_NO_NATIVE_GESTURES)
     Q_Q(QWidget);
     if (!q || !q->isVisible() || !nativeGesturePanEnabled)

trunk/src/gui/kernel/qwidget_wince.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 const QString qt_reg_winclass(QWidget *w);                // defined in qapplication_win.cpp
 extern "C" LRESULT CALLBACK QtWndProc(HWND, UINT, WPARAM, LPARAM);
+extern "C" LRESULT QT_WIN_CALLBACK QtWndProc(HWND, UINT, WPARAM, LPARAM);
 //#define TABLET_DEBUG
 …
 typedef BOOL    (API *PtrWTQueueSizeSet)(HCTX, int);
+#ifndef QT_NO_TABLETEVENT
 static void qt_tablet_init_wce();
 static void qt_tablet_cleanup_wce();
 …
     qt_tablet_widget = 0;
+}
+#endif // QT_NO_TABLETEVENT
 …
+    }
+#ifndef QT_NO_TABLETEVENT
     if (q != qt_tablet_widget && QWidgetPrivate::mapper)
         qt_tablet_init_wce();
+#endif // QT_NO_TABLETEVENT
     if (q->testAttribute(Qt::WA_DropSiteRegistered))
 …
                 SetWindowLong(internalWinId(), GWL_STYLE, style);
                 SetWindowLong(internalWinId(), GWL_EXSTYLE, GetWindowLong (internalWinId(), GWL_EXSTYLE) & ~ WS_EX_NODRAG);
+                qt_wince_unmaximize(this);
+            }
             if (isVisible() && newstate & Qt::WindowMaximized)
 …
 // The procedure does nothing, but is required for mousegrabbing to work
 LRESULT CALLBACK qJournalRecordProc(int nCode, WPARAM wParam, LPARAM lParam) {
+LRESULT QT_WIN_CALLBACK qJournalRecordProc(int nCode, WPARAM wParam, LPARAM lParam) {
     Q_UNUSED(nCode);
     Q_UNUSED(wParam);

trunk/src/gui/kernel/qwidget_x11.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include "qlayout.h"
 #include "qtextcodec.h"
 #include "qdatetime.h"
+#include "qelapsedtimer.h"
 #include "qcursor.h"
 #include "qstack.h"
 …
     QApplication::flush();
     XEvent ev;
     QTime t;
+    QElapsedTimer t;
     t.start();
     static const int maximumWaitTime = 2000;
 …
         memset(&wm_hints, 0, sizeof(wm_hints)); // make valgrind happy
         wm_hints.flags = InputHint | StateHint | WindowGroupHint;
         wm_hints.input = True;
+        wm_hints.input = q->testAttribute(Qt::WA_X11DoNotAcceptFocus) ? False : True;
         wm_hints.initial_state = NormalState;
         wm_hints.window_group = X11->wm_client_leader;
 …
+        }
     } else if (q->testAttribute(Qt::WA_SetCursor) && q->internalWinId()) {
+    } else if (q->internalWinId()) {
         qt_x11_enforce_cursor(q);
+        if (QWidget *p = q->parentWidget()) // reset the cursor on the native parent
+            qt_x11_enforce_cursor(p);
+    }
 …
+{
     Q_D(QWidget);
+    d->aboutToDestroy();
     if (!isWindow() && parentWidget())
         parentWidget()->d_func()->invalidateBuffer(d->effectiveRectFor(geometry()));
 …
     // keep compatibility with previous versions, we need to preserve the created state
     // (but we recreate the winId for the widget being reparented, again for compatibility)
     if (wasCreated || (!q->isWindow() && parent->testAttribute(Qt::WA_WState_Created)))
+    if (wasCreated)
         createWinId();
     if (q->isWindow() || (!parent || parent->isVisible()) || explicitlyHidden)
 …
             X11->userTime = X11->time;
         qt_net_update_user_time(tlw, X11->userTime);
+        XSetInputFocus(X11->display, tlw->internalWinId(), XRevertToParent, X11->time);
+        if (X11->isSupportedByWM(ATOM(_NET_ACTIVE_WINDOW))
+            && !(tlw->windowFlags() & Qt::X11BypassWindowManagerHint)) {
+            XEvent e;
+            e.xclient.type = ClientMessage;
+            e.xclient.message_type = ATOM(_NET_ACTIVE_WINDOW);
+            e.xclient.display = X11->display;
+            e.xclient.window = tlw->internalWinId();
+            e.xclient.format = 32;
+            e.xclient.data.l[0] = 1;     // 1 == application
+            e.xclient.data.l[1] = X11->userTime;
+            if (QWidget *aw = QApplication::activeWindow())
+                e.xclient.data.l[2] = aw->internalWinId();
+            else
+                e.xclient.data.l[2] = XNone;
+            e.xclient.data.l[3] = 0;
+            e.xclient.data.l[4] = 0;
+            XSendEvent(X11->display, RootWindow(X11->display, tlw->x11Info().screen()),
+                       false, SubstructureNotifyMask | SubstructureRedirectMask, &e);
+        } else {
+            if (!qt_widget_private(tlw)->topData()->waitingForMapNotify)
+                XSetInputFocus(X11->display, tlw->internalWinId(), XRevertToParent, X11->time);
+        }
+    }
+}
 …
             if (flags & Qt::WindowStaysOnBottomHint)
                 qWarning() << "QWidget: Incompatible window flags: the window can't be on top and on bottom at the same time";
+            netWmState.append(ATOM(_NET_WM_STATE_ABOVE));
+            netWmState.append(ATOM(_NET_WM_STATE_STAYS_ON_TOP));
+            if (!netWmState.contains(ATOM(_NET_WM_STATE_ABOVE)))
+                netWmState.append(ATOM(_NET_WM_STATE_ABOVE));
+            if (!netWmState.contains(ATOM(_NET_WM_STATE_STAYS_ON_TOP)))
+                netWmState.append(ATOM(_NET_WM_STATE_STAYS_ON_TOP));
         } else if (flags & Qt::WindowStaysOnBottomHint) {
+            netWmState.append(ATOM(_NET_WM_STATE_BELOW));
+            if (!netWmState.contains(ATOM(_NET_WM_STATE_BELOW)))
+                netWmState.append(ATOM(_NET_WM_STATE_BELOW));
+        }
         if (q->isFullScreen()) {
+            netWmState.append(ATOM(_NET_WM_STATE_FULLSCREEN));
+            if (!netWmState.contains(ATOM(_NET_WM_STATE_FULLSCREEN)))
+                netWmState.append(ATOM(_NET_WM_STATE_FULLSCREEN));
+        }
         if (q->isMaximized()) {
+            netWmState.append(ATOM(_NET_WM_STATE_MAXIMIZED_HORZ));
+            netWmState.append(ATOM(_NET_WM_STATE_MAXIMIZED_VERT));
+            if (!netWmState.contains(ATOM(_NET_WM_STATE_MAXIMIZED_HORZ)))
+                netWmState.append(ATOM(_NET_WM_STATE_MAXIMIZED_HORZ));
+            if (!netWmState.contains(ATOM(_NET_WM_STATE_MAXIMIZED_VERT)))
+                netWmState.append(ATOM(_NET_WM_STATE_MAXIMIZED_VERT));
+        }
         if (data.window_modality != Qt::NonModal) {
+            netWmState.append(ATOM(_NET_WM_STATE_MODAL));
+            if (!netWmState.contains(ATOM(_NET_WM_STATE_MODAL)))
+                netWmState.append(ATOM(_NET_WM_STATE_MODAL));
+        }
 …
+    }
     // none found, replace one
     int i = rand() % 16;
+    int i = qrand() % 16;
     if (X11->solid_fills[i].screen != screen && X11->solid_fills[i].picture) {
 …
+}
+void QWidgetPrivate::updateX11AcceptFocus()
+{
+    Q_Q(QWidget);
+    if (!q->isWindow() || !q->internalWinId())
+        return;
+    XWMHints *h = XGetWMHints(X11->display, q->internalWinId());
+    XWMHints wm_hints;
+    if (!h) {
+        memset(&wm_hints, 0, sizeof(wm_hints)); // make valgrind happy
+        h = &wm_hints;
+    }
+    h->flags |= InputHint;
+    h->input = q->testAttribute(Qt::WA_X11DoNotAcceptFocus) ? False : True;
+    XSetWMHints(X11->display, q->internalWinId(), h);
+    if (h != &wm_hints)
+        XFree((char *)h);
+}
 QT_END_NAMESPACE

trunk/src/gui/kernel/qwidgetaction.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qwidgetaction.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qwidgetaction_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qwidgetcreate_x11.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qwindowdefs.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qwindowdefs_win.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qwinnativepangesturerecognizer_win.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include "private/qapplication_p.h"
 #include "private/qwidget_p.h"
+#ifndef QT_NO_GESTURES
 QT_BEGIN_NAMESPACE
 …
 QT_END_NAMESPACE
+#endif // QT_NO_GESTURES

trunk/src/gui/kernel/qwinnativepangesturerecognizer_win_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include <QGestureRecognizer>
-#include <objbase.h>
+class IInkRectangle;
+class TabletHardwareCapabilities;
+class TabletPropertyMetricUnit;
+DECLARE_INTERFACE_(IInkTablet, IDispatch)
+{
+        STDMETHOD(get_Name)(THIS_ BSTR *Name) PURE;
+        STDMETHOD(get_PlugAndPlayId)(THIS_ BSTR *Id) PURE;
+        STDMETHOD(get_MaximumInputRectangle)(THIS_ IInkRectangle **Rectangle) PURE;
+        STDMETHOD(get_HardwareCapabilities)(THIS_ TabletHardwareCapabilities *Capabilities) PURE;
+        STDMETHOD(IsPacketPropertySupported)(THIS_ BSTR packetPropertyName) PURE;
+        STDMETHOD(GetPropertyMetrics)(THIS_ BSTR propertyName, long *Minimum, long *Maximum, TabletPropertyMetricUnit *Units, float *Resolution) PURE;
+};
+enum TabletDeviceKind
+{
+        TDK_Mouse = 0,
+        TDK_Pen   = 1,
+        TDK_Touch = 2
+};
+DECLARE_INTERFACE_(IInkTablet2, IDispatch)
+{
+        STDMETHOD(get_DeviceKind)(THIS_ TabletDeviceKind *Kind) PURE;
+};
+DECLARE_INTERFACE_(IInkTablets, IDispatch)
+{
+        STDMETHOD(get_Count)(THIS_ long *Count) PURE;
+        STDMETHOD(get__NewEnum)(THIS_ IUnknown **_NewEnum) PURE;
+        STDMETHOD(get_DefaultTablet)(THIS_ IInkTablet **DefaultTablet) PURE;
+        STDMETHOD(Item)(THIS_ long Index, IInkTablet **Tablet) PURE;
+        STDMETHOD(IsPacketPropertySupported)(THIS_ BSTR packetPropertyName, VARIANT_BOOL *Supported) PURE;
+};
+#ifndef QT_NO_GESTURES
 QT_BEGIN_NAMESPACE
 …
 QT_END_NAMESPACE
+#endif // QT_NO_GESTURES
 #endif // QWINNATIVEPANGESTURERECOGNIZER_WIN_P_H

trunk/src/gui/kernel/qx11embed_x11.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** 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)
 …
 #include <qstyle.h>
 #include <qstyleoption.h>
 #include <qdatetime.h>
+#include <qelapsedtimer.h>
 #include <qpointer.h>
 #include <qdebug.h>
 …
     d->focusProxy->setAttribute(Qt::WA_NativeWindow);
     d->focusProxy->setAttribute(Qt::WA_DontCreateNativeAncestors);
+    d->focusProxy->createWinId();
     d->focusProxy->setGeometry(-1, -1, 1, 1);
 …
 /*! \internal
     Returns wether or not the windows' embedded flag is set.
+    Returns whether or not the windows' embedded flag is set.
 */
 bool QX11EmbedContainerPrivate::isEmbedded() const
 …
       preemptively workaround buggy window managers.
     */
     QTime t;
+    QElapsedTimer t;
     t.start();

trunk/src/gui/kernel/qx11embed_x11.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qx11info_x11.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/gui/kernel/qx11info_x11.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

/branches/vendor/nokia/qt/4.7.2 (added)	merged: 845
/branches/vendor/nokia/qt/current	merged: 844
/branches/vendor/nokia/qt/4.6.3	removed

Context Navigation

Legend: