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

Timestamp:

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

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.1 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/gui/kernel/qapplication.cpp (modified) (97 diffs)

trunk/src/gui/kernel/qapplication.cpp

@@ -2 +2 @@
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -21 +22 @@
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
@@ -34 +34 @@
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
 
+#include "qplatformdefs.h"
 #include "qabstracteventdispatcher.h"
 #include "qaccessible.h"
@@ -75 +76 @@
 #ifdef Q_WS_X11
 #include <private/qt_x11_p.h>
+#endif
+
+#if defined(Q_WS_X11) || defined(Q_WS_S60)
 #include "qinputcontextfactory.h"
 #endif
+
+#include "qguiplatformplugin_p.h"
 
 #include <qthread.h>
@@ -86 +92 @@
 
 #include "qapplication_p.h"
+#include "qevent_p.h"
 #include "qwidget_p.h"
 
 #include "qapplication.h"
 
-#ifdef Q_OS_WINCE
+#include "qgesture.h"
+#include "private/qgesturemanager_p.h"
+
+#ifndef QT_NO_LIBRARY
+#include "qlibrary.h"
+#endif
+
+#ifdef Q_WS_WINCE
 #include "qdatetime.h"
 #include "qguifunctions_wince.h"
@@ -98 +112 @@
 #endif
 
+#include "qdatetime.h"
+
+#ifdef QT_MAC_USE_COCOA
+#include <private/qt_cocoa_helpers_mac_p.h>
+#endif
+
 //#define ALIEN_DEBUG
 
 static void initResources()
 {
-#ifdef Q_OS_WINCE
+#ifdef Q_WS_WINCE
     Q_INIT_RESOURCE(qstyle_wince);
 #else
@@ -108 +128 @@
 #endif
 
-#if !defined(QT_NO_DIRECT3D) && defined(Q_WS_WIN)
-    Q_INIT_RESOURCE(qpaintengine_d3d);
-#endif
     Q_INIT_RESOURCE(qmessagebox);
 #if !defined(QT_NO_PRINTDIALOG)
@@ -128 +145 @@
 
 #ifndef QT_NO_IM
-QInputContext *QApplicationPrivate::inputContext;
+QInputContext *QApplicationPrivate::inputContext = 0;
 #endif
 
 bool QApplicationPrivate::quitOnLastWindowClosed = true;
 
-#ifdef Q_OS_WINCE
+#ifdef Q_WS_WINCE
 int QApplicationPrivate::autoMaximizeThreshold = -1;
 bool QApplicationPrivate::autoSipEnabled = false;
+#else
+bool QApplicationPrivate::autoSipEnabled = true;
 #endif
 
@@ -161 +180 @@
 #endif
 
+    gestureManager = 0;
+    gestureWidget = 0;
+
     if (!self)
         self = this;
@@ -176 +198 @@
     flow and main settings.
 
-    \ingroup application
-    \mainclass
-
     QApplication contains the main event loop, where all events from the window
     system and other sources are processed and dispatched. It also handles the
-    application's initialization and finalization, and provides session
-    management. In addition, it handles most system-wide and application-wide
-    settings.
-
-    For any GUI application using Qt, there is precisely one QApplication
+    application's initialization, finalization, and provides session
+    management. In addition, QApplication handles most of the system-wide and
+    application-wide settings.
+
+    For any GUI application using Qt, there is precisely \bold one QApplication
     object, no matter whether the application has 0, 1, 2 or more windows at
     any given time. For non-GUI Qt applications, use QCoreApplication instead,
@@ -241 +260 @@
         \endlist
 
-    The QApplication object does so much initialization. Hence, it \e{must} be
+    Since the QApplication object does so much initialization, it \e{must} be
     created before any other objects related to the user interface are created.
-    Since QApplication also deals with common command line arguments, it is
+    QApplication also deals with common command line arguments. Hence, it is
     usually a good idea to create it \e before any interpretation or
     modification of \c argv is done in the application itself.
@@ -397 +416 @@
 
 QStyle *QApplicationPrivate::app_style = 0;        // default application style
+QString QApplicationPrivate::styleOverride;        // style override
 
 #ifndef QT_NO_STYLE_STYLESHEET
@@ -411 +431 @@
 QString QApplicationPrivate::graphics_system_name;         // graphics system id - for delayed initialization
 
-Q_GLOBAL_STATIC(QMutex, applicationFontMutex);
+Q_GLOBAL_STATIC(QMutex, applicationFontMutex)
 QFont *QApplicationPrivate::app_font = 0;        // default application font
 QFont *QApplicationPrivate::sys_font = 0;        // default system font
@@ -433 +453 @@
 int qt_antialiasing_threshold = -1;
 static int drag_time = 500;
+#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;
+#else
 static int drag_distance = 4;
+#endif
 static Qt::LayoutDirection layout_direction = Qt::LeftToRight;
 QSize QApplicationPrivate::app_strut = QSize(0,0); // no default application strut
@@ -444 +469 @@
 bool QApplicationPrivate::animate_toolbox = false;
 bool QApplicationPrivate::widgetCount = false;
-QString* QApplicationPrivate::styleOverride = 0;
-#if defined(Q_WS_WIN) && !defined(Q_OS_WINCE)
-bool QApplicationPrivate::inSizeMove = false;
-#endif
+bool QApplicationPrivate::load_testability = false;
 #ifdef QT_KEYPAD_NAVIGATION
-bool QApplicationPrivate::keypadNavigation = false;
+#  ifdef Q_OS_SYMBIAN
+Qt::NavigationMode QApplicationPrivate::navigationMode = Qt::NavigationModeKeypadDirectional;
+#  else
+Qt::NavigationMode QApplicationPrivate::navigationMode = Qt::NavigationModeKeypadTabOrder;
+#  endif
 QWidget *QApplicationPrivate::oldEditFocus = 0;
 #endif
@@ -456 +482 @@
 static bool force_reverse = false;
 
-static inline bool isAlien(QWidget *widget)
+inline bool QApplicationPrivate::isAlien(QWidget *widget)
 {
     if (!widget)
         return false;
-#ifdef Q_WS_MAC // Fake alien behavior on the Mac :)
+#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)
+    return !widget->isWindow()
+# ifdef Q_BACKINGSTORE_SUBSURFACES
+        && !(widget->d_func()->maybeTopData() && widget->d_func()->maybeTopData()->windowSurface)
+# endif
+        ;
 #else
     return !widget->internalWinId();
@@ -469 +501 @@
 // ######## move to QApplicationPrivate
 // Default application palettes and fonts (per widget type)
-
-typedef QHash<QByteArray, QPalette> PaletteHash;
 Q_GLOBAL_STATIC(PaletteHash, app_palettes)
 PaletteHash *qt_app_palettes_hash()
@@ -477 +507 @@
 }
 
-typedef QHash<QByteArray, QFont> FontHash;
 Q_GLOBAL_STATIC(FontHash, app_fonts)
 FontHash *qt_app_fonts_hash()
@@ -497 +526 @@
 void QApplicationPrivate::process_cmdline()
 {
-    Q_Q(QApplication);
-    Q_UNUSED(q);// only static members being used.
     // process platform-indep command line
     if (!qt_is_gui_used || !argc)
@@ -543 +570 @@
         } else if (qstrcmp(arg, "-reverse") == 0) {
             force_reverse = true;
-            q->setLayoutDirection(Qt::RightToLeft);
+            QApplication::setLayoutDirection(Qt::RightToLeft);
         } else if (qstrcmp(arg, "-widgetcount") == 0) {
             widgetCount = true;
+        } else if (qstrcmp(arg, "-testability") == 0) {
+            load_testability = true;
         } else if (arg == "-graphicssystem" && i < argc-1) {
             graphics_system_name = QString::fromLocal8Bit(argv[++i]);
@@ -556 +585 @@
                 app_style = 0;
             }
-            if (!styleOverride)
-                styleOverride = new QString;
-            *styleOverride = s;
+            styleOverride = s;
         }
     }
@@ -621 +648 @@
         \o  -graphicssystem, sets the backend to be used for on-screen widgets
             and QPixmaps. Available options are \c{raster} and \c{opengl}.
-    \endlist
-
-    The Windows version of Qt supports an additional command line  option, if
-    Direct3D support has been compiled into Qt:
-    \list
-        \o  -direct3d will make the Direct3D paint engine the default widget
-            paint engine in Qt. \bold {This functionality is experimental.}
     \endlist
 
@@ -689 +709 @@
     On X11, the window system is initialized if \a GUIenabled is true. If
     \a GUIenabled is false, the application does not connect to the X server.
-    On Windows and Macintosh, currently the window system is always
-    initialized, regardless of the value of GUIenabled. This may change in
-    future versions of Qt.
+    On Windows and Mac OS, currently the window system is always initialized,
+    regardless of the value of GUIenabled. This may change in future versions
+    of Qt.
 
     The following example shows how to create an application that uses a
@@ -756 +776 @@
     extern void qt_gui_eval_init(uint);
     qt_gui_eval_init(application_type);
+#endif
+
+#ifndef QT_NO_LIBRARY
+    if(load_testability) {
+        QLibrary testLib(QLatin1String("qttestability"));
+        if (testLib.load()) {
+            typedef void (*TasInitialize)(void);
+            TasInitialize initFunction = (TasInitialize)testLib.resolve("qt_testability_init");
+            if (initFunction) {
+                initFunction();
+            } else {
+                qCritical("Library qttestability resolve failed!");
+            }
+        } else {
+            qCritical("Library qttestability load failed!");
+        }
+    }
+
+    //make sure the plugin is loaded
+    if (qt_is_gui_used)
+        qt_guiPlatformPlugin();
 #endif
 }
@@ -835 +876 @@
 #endif // Q_WS_X11
 
-
-/*!
+extern void qInitDrawhelperAsm();
+extern int qRegisterGuiVariant();
+extern int qUnregisterGuiVariant();
+#ifndef QT_NO_STATEMACHINE
+extern int qRegisterGuiStateMachine();
+extern int qUnregisterGuiStateMachine();
+#endif
+
+/*!
+  \fn void QApplicationPrivate::initialize()
+
   Initializes the QApplication object, called from the constructors.
 */
-extern void qInitDrawhelperAsm();
-
 void QApplicationPrivate::initialize()
 {
     QWidgetPrivate::mapper = new QWidgetMapper;
-    QWidgetPrivate::uncreatedWidgets = new QWidgetSet;
+    QWidgetPrivate::allWidgets = new QWidgetSet;
     if (qt_appType != QApplication::Tty)
         (void) QApplication::style();  // trigger creation of application style
     // trigger registering of QVariant's GUI types
-    extern int qRegisterGuiVariant();
     qRegisterGuiVariant();
+#ifndef QT_NO_STATEMACHINE
+    // trigger registering of QStateMachine's GUI types
+    qRegisterGuiStateMachine();
+#endif
 
     is_app_running = true; // no longer starting up
@@ -862 +913 @@
         q->setAttribute(Qt::AA_NativeWindows);
 
-#if defined(Q_WS_WIN)
-    // Alien is not currently working on Windows 98
-    if (QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based)
-        q->setAttribute(Qt::AA_NativeWindows);
-#endif
-
-#ifdef Q_OS_WINCE
+#ifdef Q_WS_WINCE
 #ifdef QT_AUTO_MAXIMIZE_THRESHOLD
     autoMaximizeThreshold = QT_AUTO_MAXIMIZE_THRESHOLD;
@@ -877 +922 @@
         autoMaximizeThreshold = -1;
 #endif //QT_AUTO_MAXIMIZE_THRESHOLD
-#endif //Q_OS_WINCE
+#endif //Q_WS_WINCE
 
     // Set up which span functions should be used in raster engine...
@@ -889 +934 @@
 #endif
 #ifndef QT_NO_WHEELEVENT
-#ifdef QT_MAC_USE_COCOA
-    QApplicationPrivate::wheel_scroll_lines = 1;
-#else
     QApplicationPrivate::wheel_scroll_lines = 3;
 #endif
-#endif
+
+    if (qt_is_gui_used)
+        initializeMultitouch();
 }
 
@@ -978 +1022 @@
     d->eventDispatcher->closingDown();
     d->eventDispatcher = 0;
+    QApplicationPrivate::is_app_closing = true;
+    QApplicationPrivate::is_app_running = false;
 
     delete qt_desktopWidget;
     qt_desktopWidget = 0;
-    QApplicationPrivate::is_app_closing = true;
-    QApplicationPrivate::is_app_running = false;
 
 #ifndef QT_NO_CLIPBOARD
@@ -989 +1033 @@
 #endif
 
-    // delete widget mapper
-    if (QWidgetPrivate::mapper) {
-        QWidgetMapper * myMapper = QWidgetPrivate::mapper;
-        QWidgetPrivate::mapper = 0;
-        for (QWidgetMapper::Iterator it = myMapper->begin(); it != myMapper->end(); ++it) {
-            register QWidget *w = *it;
-            if (!w->parent())                        // window
-                w->destroy(true, true);
-        }
-        delete myMapper;
-    }
-
-    // delete uncreated widgets
-    if (QWidgetPrivate::uncreatedWidgets) {
-        QWidgetSet *mySet = QWidgetPrivate::uncreatedWidgets;
-        QWidgetPrivate::uncreatedWidgets = 0;
-        for (QWidgetSet::Iterator it = mySet->begin(); it != mySet->end(); ++it) {
+    delete QWidgetPrivate::mapper;
+    QWidgetPrivate::mapper = 0;
+
+    // delete all widgets
+    if (QWidgetPrivate::allWidgets) {
+        QWidgetSet *mySet = QWidgetPrivate::allWidgets;
+        QWidgetPrivate::allWidgets = 0;
+        for (QWidgetSet::ConstIterator it = mySet->constBegin(); it != mySet->constEnd(); ++it) {
             register QWidget *w = *it;
             if (!w->parent())                        // window
@@ -1044 +1079 @@
         delete QDragManager::self();
 #endif
+
+    d->cleanupMultitouch();
 
     qt_cleanup();
@@ -1071 +1108 @@
     QApplicationPrivate::widgetCount = false;
 
+#ifndef QT_NO_STATEMACHINE
+    // trigger unregistering of QStateMachine's GUI types
+    qUnregisterGuiStateMachine();
+#endif
     // trigger unregistering of QVariant's GUI types
-    extern int qUnregisterGuiVariant();
     qUnregisterGuiVariant();
 }
@@ -1153 +1193 @@
           || event->type() == QEvent::Move
           || event->type() == QEvent::LanguageChange
+          || event->type() == QEvent::UpdateSoftKeys
           || event->type() == QEvent::InputMethod)) {
         for (int i = 0; i < postedEvents->size(); ++i) {
@@ -1170 +1211 @@
             } else if (cur.event->type() == QEvent::LanguageChange) {
                 ;
+            } else if (cur.event->type() == QEvent::UpdateSoftKeys) {
+                ;
             } else if ( cur.event->type() == QEvent::InputMethod ) {
                 *(QInputMethodEvent *)(cur.event) = *(QInputMethodEvent *)event;
@@ -1199 +1242 @@
     \brief defines a threshold for auto maximizing widgets
 
-    The auto maximize threshold is only available as part of Qt for Windows CE.
+    \bold{The auto maximize threshold is only available as part of Qt for
+    Windows CE.}
 
     This property defines a threshold for the size of a window as a percentage
     of the screen size. If the minimum size hint of a window exceeds the
-    threshold, calling show() will then cause the window to be maximized
+    threshold, calling show() will cause the window to be maximized
     automatically.
 
-    Setting the threshold to be 100 or greater means that it will cause it to
-    always be maximized. Setting it to be 50 means that the widget is maximized
-    if the vertical minimum size hint is at least 50% of the vertical screen
-    size.
-
-    If -1 is specified then this will disable the feature.
-
-    On Windows CE the default is -1 (i.e. it is disabled).
+    Setting the threshold to 100 or greater means that the widget will always
+    be maximized. Alternatively, setting the threshold to 50 means that the
+    widget will be maximized only if the vertical minimum size hint is at least
+    50% of the vertical screen size.
+
+    Setting the threshold to -1 disables the feature.
+
+    On Windows CE the default is -1 (i.e., it is disabled).
     On Windows Mobile the default is 40.
 */
@@ -1222 +1266 @@
     \brief toggles automatic SIP (software input panel) visibility
 
-    The auto SIP property is only available as part of Qt for Windows CE.
-
-    Set this property to true to automatically display the SIP when entering
+    Set this property to \c true to automatically display the SIP when entering
     widgets that accept keyboard input. This property only affects widgets with
-    the WA_InputMethodEnabled attribute set.
-*/
-
-#ifdef Q_OS_WINCE
+    the WA_InputMethodEnabled attribute set, and is typically used to launch
+    a virtual keyboard on devices which have very few or no keys.
+
+    \bold{ The property only has an effect on platforms which use software input
+    panels, such as Windows CE and Symbian.}
+
+    The default is platform dependent.
+*/
+
+#ifdef Q_WS_WINCE
 void QApplication::setAutoMaximizeThreshold(const int threshold)
 {
@@ -1239 +1287 @@
     return QApplicationPrivate::autoMaximizeThreshold;
 }
+#endif
 
 void QApplication::setAutoSipEnabled(const bool enabled)
@@ -1249 +1298 @@
     return QApplicationPrivate::autoSipEnabled;
 }
-#endif
 
 #ifndef QT_NO_STYLE_STYLESHEET
@@ -1291 +1339 @@
     }
 
-#if defined(Q_WS_X11)
-    if(!QApplicationPrivate::styleOverride)
-        QApplicationPrivate::x11_initialize_style(); // run-time search for default style
-#endif
     if (!QApplicationPrivate::app_style) {
         // Compile-time search for default style
         //
         QString style;
-        if (QApplicationPrivate::styleOverride) {
-            style = *QApplicationPrivate::styleOverride;
-            delete QApplicationPrivate::styleOverride;
-            QApplicationPrivate::styleOverride = 0;
-        } else {
-#if defined(Q_WS_WIN) && defined(Q_OS_WINCE)
-    if (qt_wince_is_smartphone() || qt_wince_is_pocket_pc())
-        style = QLatin1String("WindowsMobile");
-     else
-        style = QLatin1String("WindowsCE");
-
-#elif defined(Q_WS_WIN)
-            if ((QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA
-                && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based))
-                style = QLatin1String("WindowsVista");
-                else if ((QSysInfo::WindowsVersion >= QSysInfo::WV_XP
-                && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based))
-                style = QLatin1String("WindowsXP");
-            else
-                style = QLatin1String("Windows");                // default styles for Windows
-#elif defined(Q_WS_X11) && defined(Q_OS_SOLARIS)
-            style = QLatin1String("CDE");                        // default style for X11 on Solaris
-#elif defined(Q_WS_X11) && defined(Q_OS_IRIX)
-            style = QLatin1String("SGI");                        // default style for X11 on IRIX
-#elif defined(Q_WS_X11) || defined(Q_WS_QWS)
-            style = QLatin1String("Plastique");                  // default style for X11 and small devices
-#elif defined(Q_WS_MAC)
-                style = QLatin1String("Macintosh");              // default style for all Mac's
-#endif
-        }
+        if (!QApplicationPrivate::styleOverride.isEmpty())
+            style = QApplicationPrivate::styleOverride;
+        else
+            style = QApplicationPrivate::desktopStyleKey();
 
         QStyle *&app_style = QApplicationPrivate::app_style;
@@ -1416 +1434 @@
 #endif // QT_NO_STYLE_STYLESHEET
         QApplicationPrivate::app_style = style;
-
     QApplicationPrivate::app_style->setParent(qApp); // take ownership
 
@@ -1553 +1570 @@
             texts and pixmaps with few colors. With this option, the
             application uses system global colors. This works fine for most
-            applications under X11, but on Windows machines it may cause
+            applications under X11, but on the Windows platform, it may cause
             dithering of non-standard colors.
         \o  QApplication::CustomColor. Use this option if your application
@@ -1940 +1957 @@
 }
 
+/*! \internal
+*/
+QString QApplicationPrivate::desktopStyleKey()
+{
+    return qt_guiPlatformPlugin()->styleName();
+}
+
 /*!
     \property QApplication::windowIcon
@@ -2012 +2036 @@
 QWidgetList QApplication::allWidgets()
 {
-    QWidgetList list;
-    if (QWidgetPrivate::mapper)
-        list += QWidgetPrivate::mapper->values();
-    if (QWidgetPrivate::uncreatedWidgets)
-        list += QWidgetPrivate::uncreatedWidgets->toList();
-    return list;
+    if (QWidgetPrivate::allWidgets)
+        return QWidgetPrivate::allWidgets->toList();
+    return QWidgetList();
 }
 
@@ -2034 +2055 @@
 void QApplicationPrivate::setFocusWidget(QWidget *focus, Qt::FocusReason reason)
 {
-    if (focus && focus->window()
 #ifndef QT_NO_GRAPHICSVIEW
-        && focus->window()->graphicsProxyWidget()
-#endif
-       )
+    if (focus && focus->window()->graphicsProxyWidget())
         return;
+#endif
 
     hidden_focus_widget = 0;
@@ -2057 +2076 @@
         QWidget *prev = focus_widget;
         focus_widget = focus;
-
 #ifndef QT_NO_IM
         if (prev && ((reason != Qt::PopupFocusReason && reason != Qt::MenuBarFocusReason
@@ -2071 +2089 @@
             }
         }
-#endif
+#endif //QT_NO_IM
 
         if(focus_widget)
@@ -2082 +2100 @@
 #ifdef QT_KEYPAD_NAVIGATION
                 if (QApplication::keypadNavigationEnabled()) {
-                    if (prev->hasEditFocus() && reason != Qt::PopupFocusReason)
+                    if (prev->hasEditFocus() && reason != Qt::PopupFocusReason
+#ifdef Q_OS_SYMBIAN
+                            && reason != Qt::ActiveWindowFocusReason
+#endif
+                            )
                         prev->setEditFocus(false);
+                }
+#endif
+#ifndef QT_NO_IM
+                if (focus) {
+                    QInputContext *prevIc;
+                    prevIc = prev->inputContext();
+                    if (prevIc && prevIc != focus->inputContext()) {
+                        QEvent closeSIPEvent(QEvent::CloseSoftwareInputPanel);
+                        QApplication::sendEvent(prev, &closeSIPEvent);
+                    }
                 }
 #endif
@@ -2096 +2128 @@
                 if (focus->testAttribute(Qt::WA_InputMethodEnabled)) {
                     QInputContext *qic = focus->inputContext();
-                    if (qic && focus_widget->testAttribute(Qt::WA_WState_Created))
-                        qic->setFocusWidget( focus_widget );
+                    if (qic && focus->testAttribute(Qt::WA_WState_Created)
+                        && focus->isEnabled())
+                        qic->setFocusWidget(focus);
                 }
-#endif
+#endif //QT_NO_IM
                 QFocusEvent in(QEvent::FocusIn, reason);
                 QPointer<QWidget> that = focus;
@@ -2106 +2139 @@
                     QApplication::sendEvent(that->style(), &in);
             }
-        }
-        emit qApp->focusChanged(prev, focus_widget);
+            emit qApp->focusChanged(prev, focus_widget);
+        }
     }
 }
@@ -2317 +2350 @@
             d->toolTipFallAsleep.stop();
         }
-#ifdef QT_MAC_USE_COCOA
-    } else if (e->type() == QEvent::CocoaRequestModal) {
-        d->_q_runAppModalWindow();
-#endif
     }
     return QCoreApplication::event(e);
@@ -2464 +2493 @@
  * Helper function that returns the new focus widget, but does not set the focus reason.
  * Returns 0 if a new focus widget could not be found.
+ * Shared with QGraphicsProxyWidgetPrivate::findFocusChild()
 */
 QWidget *QApplicationPrivate::focusNextPrevChild_helper(QWidget *toplevel, bool next)
@@ -2504 +2534 @@
     widget \a leave is left.
  */
-#if defined(Q_WS_WIN)
-  extern void qt_win_set_cursor(QWidget *, bool);
-#elif defined(Q_WS_PM)
-  extern void qt_pm_set_cursor(QWidget *, bool);
-#elif defined(Q_WS_X11)
-  extern void qt_x11_enforce_cursor(QWidget *, bool);
-#endif
-
 void QApplicationPrivate::dispatchEnterLeave(QWidget* enter, QWidget* leave) {
 #if 0
@@ -2586 +2608 @@
     for (int i = 0; i < leaveList.size(); ++i) {
         w = leaveList.at(i);
-        if (!qApp->activeModalWidget() || QApplicationPrivate::tryModalHelper(w, 0)) {
+        if (!QApplication::activeModalWidget() || QApplicationPrivate::tryModalHelper(w, 0)) {
 #if defined(Q_WS_WIN) || defined(Q_WS_PM) || defined(Q_WS_X11)
             if (leaveAfterRelease == w)
@@ -2593 +2615 @@
             QApplication::sendEvent(w, &leaveEvent);
             if (w->testAttribute(Qt::WA_Hover) &&
-                (!qApp->activePopupWidget() || qApp->activePopupWidget() == w->window())) {
+                (!QApplication::activePopupWidget() || QApplication::activePopupWidget() == w->window())) {
                 Q_ASSERT(instance());
                 QHoverEvent he(QEvent::HoverLeave, QPoint(-1, -1), w->mapFromGlobal(QApplicationPrivate::instance()->hoverGlobalPos));
@@ -2604 +2626 @@
     for (int i = 0; i < enterList.size(); ++i) {
         w = enterList.at(i);
-        if (!qApp->activeModalWidget() || QApplicationPrivate::tryModalHelper(w, 0)) {
+        if (!QApplication::activeModalWidget() || QApplicationPrivate::tryModalHelper(w, 0)) {
             QApplication::sendEvent(w, &enterEvent);
             if (w->testAttribute(Qt::WA_Hover) &&
-                (!qApp->activePopupWidget() || qApp->activePopupWidget() == w->window())) {
+                (!QApplication::activePopupWidget() || QApplication::activePopupWidget() == w->window())) {
                 QHoverEvent he(QEvent::HoverEnter, w->mapFromGlobal(posEnter), QPoint(-1, -1));
                 qApp->d_func()->notify_helper(w, &he);
@@ -2627 +2649 @@
             break;
         if (w->testAttribute(Qt::WA_SetCursor)) {
-            parentOfLeavingCursor = w->parentWidget();
+            QWidget *parent = w->parentWidget();
+            while (parent && parent->d_func()->data.in_destructor)
+                parent = parent->parentWidget();
+            parentOfLeavingCursor = parent;
             //continue looping, we need to find the downest alien widget with a cursor.
             // (downest on the screen)
@@ -2659 +2684 @@
 #if defined(Q_WS_WIN)
             qt_win_set_cursor(cursorWidget, true);
+#elif defined(Q_WS_X11)
+            qt_x11_enforce_cursor(cursorWidget, true);
+#elif defined(Q_WS_S60)
+            qt_symbian_set_cursor(cursorWidget, true);
 #elif defined(Q_WS_PM)
             qt_pm_set_cursor(cursorWidget, true);
-#elif defined(Q_WS_X11)
-            qt_x11_enforce_cursor(cursorWidget, true);
 #endif
         }
@@ -2683 +2710 @@
     if (!modalState())
         return false;
-    if (qApp->activePopupWidget() == widget)
+    if (QApplication::activePopupWidget() == widget)
         return false;
 
@@ -2772 +2799 @@
 {
     QSet<QWidget*> blocked;
-    QList<QWidget*> windows = qApp->topLevelWidgets();
+    QList<QWidget*> windows = QApplication::topLevelWidgets();
     for (int i = 0; i < windows.count(); ++i) {
         QWidget *window = windows.at(i);
@@ -2781 +2808 @@
     enterModal_sys(widget);
 
-    windows = qApp->topLevelWidgets();
+    windows = QApplication::topLevelWidgets();
     QEvent e(QEvent::WindowBlocked);
     for (int i = 0; i < windows.count(); ++i) {
@@ -2795 +2822 @@
 {
     QSet<QWidget*> blocked;
-    QList<QWidget*> windows = qApp->topLevelWidgets();
+    QList<QWidget*> windows = QApplication::topLevelWidgets();
     for (int i = 0; i < windows.count(); ++i) {
         QWidget *window = windows.at(i);
@@ -2804 +2831 @@
     leaveModal_sys(widget);
 
-    windows = qApp->topLevelWidgets();
+    windows = QApplication::topLevelWidgets();
     QEvent e(QEvent::WindowUnblocked);
     for (int i = 0; i < windows.count(); ++i) {
@@ -2827 +2854 @@
 
     // the active popup widget always gets the input event
-    if (qApp->activePopupWidget())
+    if (QApplication::activePopupWidget())
         return true;
 
@@ -2861 +2888 @@
 
     if (!mouseGrabber)
-        mouseGrabber = buttonDown ? buttonDown : alienWidget;
+        mouseGrabber = (buttonDown && !isBlockedByModal(buttonDown)) ? buttonDown : alienWidget;
 
     if (mouseGrabber && mouseGrabber != candidate) {
@@ -2880 +2907 @@
 bool QApplicationPrivate::sendMouseEvent(QWidget *receiver, QMouseEvent *event,
                                          QWidget *alienWidget, QWidget *nativeWidget,
-                                         QWidget **buttonDown, QPointer<QWidget> &lastMouseReceiver)
+                                         QWidget **buttonDown, QPointer<QWidget> &lastMouseReceiver,
+                                         bool spontaneous)
 {
     Q_ASSERT(receiver);
@@ -2893 +2921 @@
     QPointer<QWidget> nativeGuard = nativeWidget;
     QPointer<QWidget> alienGuard = alienWidget;
-    QPointer<QWidget> activePopupWidget = qApp->activePopupWidget();
+    QPointer<QWidget> activePopupWidget = QApplication::activePopupWidget();
 
     const bool graphicsWidget = nativeWidget->testAttribute(Qt::WA_DontShowOnScreen);
@@ -2933 +2961 @@
     // leaveAfterRelease is set to null, but we shall not update lastMouseReceiver.
     const bool wasLeaveAfterRelease = leaveAfterRelease != 0;
-    bool result = QApplication::sendSpontaneousEvent(receiver, event);
+    bool result;
+    if (spontaneous)
+        result = QApplication::sendSpontaneousEvent(receiver, event);
+    else
+        result = QApplication::sendEvent(receiver, event);
 
     if (!graphicsWidget && leaveAfterRelease && event->type() == QEvent::MouseButtonRelease
@@ -2962 +2994 @@
 }
 
-#if defined(Q_WS_WIN) || defined(Q_WS_PM) || defined(Q_WS_X11)
+#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined(Q_WS_QWS) || defined(Q_WS_PM)
 /*
     This function should only be called when the widget changes visibility, i.e.
@@ -2974 +3006 @@
 {
 #ifndef QT_NO_CURSOR
+#ifdef Q_WS_QWS
+    if (!widget || widget->isWindow())
+        return;
+#else
     if (!widget || widget->internalWinId() || widget->isWindow())
         return;
-
+#endif
     const bool widgetInShow = widget->isVisible() && !widget->data->in_destructor;
     if (!widgetInShow && widget != qt_last_mouse_receiver)
@@ -3014 +3050 @@
 
     // Send enter/leave events followed by a mouse move on the entered widget.
-    QMouseEvent e(QEvent::MouseMove, pos, globalPos, Qt::NoButton, mouse_buttons, modifier_buttons);
+    QMouseEvent e(QEvent::MouseMove, pos, globalPos, Qt::NoButton, Qt::NoButton, Qt::NoModifier);
     sendMouseEvent(widgetUnderCursor, &e, widgetUnderCursor, tlw, &qt_button_down, qt_last_mouse_receiver);
 #endif // QT_NO_CURSOR
@@ -3489 +3525 @@
         return;
     qApp->d_func()->cursor_list.removeFirst();
+#ifdef QT_MAC_USE_COCOA
+    // We use native NSCursor stacks in Cocoa. The currentCursor is the
+    // top of this stack. So to avoid flickering of cursor, we have to
+    // change the cusor instead of pop-ing the existing OverrideCursor
+    // and pushing the new one.
+    qApp->d_func()->cursor_list.prepend(cursor);
+    qt_cocoaChangeOverrideCursor(cursor);
+    return;
+#endif
     setOverrideCursor(cursor);
 }
@@ -3519 +3564 @@
     We recommend that you connect clean-up code to the
     \l{QCoreApplication::}{aboutToQuit()} signal, instead of putting it in your
-    application's \c{main()} function because on some platforms the
-    QApplication::exec() call may not return. For example, on Windows when the
-    user logs off, the system terminates the process after Qt closes all
-    top-level windows. Hence, there is no guarantee that the application will
-    have time to exit its event loop and execute code at the end of the
-    \c{main()} function after the QApplication::exec() call.
+    application's \c{main()} function. This is because, on some platforms the
+    QApplication::exec() call may not return. For example, on the Windows
+    platform, when the user logs off, the system terminates the process after Qt
+    closes all top-level windows. Hence, there is \e{no guarantee} that the
+    application will have time to exit its event loop and execute code at the
+    end of the \c{main()} function, after the QApplication::exec() call.
 
     \sa quitOnLastWindowClosed, quit(), exit(), processEvents(),
@@ -3574 +3619 @@
                 else
                     QApplicationPrivate::mouse_buttons &= ~me->button();
-        }
+            }
 #if !defined(QT_NO_WHEELEVENT) || !defined(QT_NO_TABLETEVENT)
-        else if (
+            else if (false
 #  ifndef QT_NO_WHEELEVENT
-                 e->type() == QEvent::Wheel ||
+                     || e->type() == QEvent::Wheel
 #  endif
 #  ifndef QT_NO_TABLETEVENT
-                 e->type() == QEvent::TabletMove
-                 || e->type() == QEvent::TabletPress
-                 || e->type() == QEvent::TabletRelease
+                     || e->type() == QEvent::TabletMove
+                     || e->type() == QEvent::TabletPress
+                     || e->type() == QEvent::TabletRelease
 #  endif
-        ) {
+                     ) {
             QInputEvent *ie = static_cast<QInputEvent*>(e);
             QApplicationPrivate::modifier_buttons = ie->modifiers();
@@ -3591 +3636 @@
 #endif // !QT_NO_WHEELEVENT || !QT_NO_TABLETEVENT
     }
+
+    // walk through parents and check for gestures
+    if (d->gestureManager) {
+        switch (e->type()) {
+        case QEvent::Paint:
+        case QEvent::MetaCall:
+        case QEvent::DeferredDelete:
+        case QEvent::DragEnter: case QEvent::DragMove: case QEvent::DragLeave:
+        case QEvent::Drop: case QEvent::DragResponse:
+        case QEvent::ChildAdded: case QEvent::ChildPolished:
+#ifdef QT3_SUPPORT
+        case QEvent::ChildInsertedRequest:
+        case QEvent::ChildInserted:
+        case QEvent::LayoutHint:
+#endif
+        case QEvent::ChildRemoved:
+        case QEvent::UpdateRequest:
+        case QEvent::UpdateLater:
+        case QEvent::AccessibilityPrepare:
+        case QEvent::LocaleChange:
+        case QEvent::Style:
+        case QEvent::IconDrag:
+        case QEvent::StyleChange:
+        case QEvent::AccessibilityHelp:
+        case QEvent::AccessibilityDescription:
+        case QEvent::GraphicsSceneDragEnter:
+        case QEvent::GraphicsSceneDragMove:
+        case QEvent::GraphicsSceneDragLeave:
+        case QEvent::GraphicsSceneDrop:
+        case QEvent::DynamicPropertyChange:
+        case QEvent::NetworkReplyUpdated:
+            break;
+        default:
+            if (receiver->isWidgetType()) {
+                if (d->gestureManager->filterEvent(static_cast<QWidget *>(receiver), e))
+                    return true;
+            } else {
+                // a special case for events that go to QGesture objects.
+                // We pass the object to the gesture manager and it'll figure
+                // out if it's QGesture or not.
+                if (d->gestureManager->filterEvent(receiver, e))
+                    return true;
+            }
+        }
+    }
+
 
     // User input and window activation makes tooltips sleep
@@ -3604 +3695 @@
     case QEvent::MouseButtonDblClick:
         d->toolTipFallAsleep.stop();
+        // fall-through
     case QEvent::Leave:
         d->toolTipWakeUp.stop();
@@ -3719 +3811 @@
 
             if (e->spontaneous()) {
+#ifndef QT_NO_IM
+                QInputContext *ic = w->inputContext();
+                if (ic
+                        && w->testAttribute(Qt::WA_InputMethodEnabled)
+                        && ic->filterEvent(mouse))
+                    return true;
+#endif
 
                 if (e->type() == QEvent::MouseButtonPress) {
-                    QWidget *fw = w;
-                    while (fw) {
-                        if (fw->isEnabled()
-                            && QApplicationPrivate::shouldSetFocus(fw, Qt::ClickFocus)) {
-                            fw->setFocus(Qt::MouseFocusReason);
-                            break;
-                        }
-                        if (fw->isWindow())
-                            break;
-                        fw = fw->parentWidget();
-                    }
+                    QApplicationPrivate::giveFocusAccordingToFocusPolicy(w,
+                                                                         Qt::ClickFocus,
+                                                                         Qt::MouseFocusReason);
                 }
 
+                // ### Qt 5 These dynamic tool tips should be an OPT-IN feature. Some platforms
+                // like Mac OS X (probably others too), can optimize their views by not
+                // dispatching mouse move events. We have attributes to control hover,
+                // and mouse tracking, but as long as we are deciding to implement this
+                // feature without choice of opting-in or out, you ALWAYS have to have
+                // tracking enabled. Therefore, the other properties give a false sense of
+                // performance enhancement.
                 if (e->type() == QEvent::MouseMove && mouse->buttons() == 0) {
                     d->toolTipWidget = w;
@@ -3790 +3888 @@
                 while (w) {
                     if (w->testAttribute(Qt::WA_Hover) &&
-                        (!qApp->activePopupWidget() || qApp->activePopupWidget() == w->window())) {
+                        (!QApplication::activePopupWidget() || QApplication::activePopupWidget() == w->window())) {
                         QHoverEvent he(QEvent::HoverMove, relpos, relpos - diff);
                         d->notify_helper(w, &he);
@@ -3813 +3911 @@
 
             if (e->spontaneous()) {
-                QWidget *fw = w;
-                while (fw) {
-                    if (fw->isEnabled()
-                        && QApplicationPrivate::shouldSetFocus(fw, Qt::WheelFocus)) {
-                        fw->setFocus(Qt::MouseFocusReason);
-                        break;
-                    }
-                    if (fw->isWindow())
-                        break;
-                    fw = fw->parentWidget();
-                }
+                QApplicationPrivate::giveFocusAccordingToFocusPolicy(w,
+                                                                     Qt::WheelFocus,
+                                                                     Qt::MouseFocusReason);
             }
 
@@ -4028 +4118 @@
         break;
 #endif
-
+    case QEvent::TouchBegin:
+    // Note: TouchUpdate and TouchEnd events are never propagated
+    {
+        QWidget *widget = static_cast<QWidget *>(receiver);
+        QTouchEvent *touchEvent = static_cast<QTouchEvent *>(e);
+        bool eventAccepted = touchEvent->isAccepted();
+        if (widget->testAttribute(Qt::WA_AcceptTouchEvents) && e->spontaneous()) {
+            // give the widget focus if the focus policy allows it
+            QApplicationPrivate::giveFocusAccordingToFocusPolicy(widget,
+                                                                 Qt::ClickFocus,
+                                                                 Qt::MouseFocusReason);
+        }
+
+        while (widget) {
+            // first, try to deliver the touch event
+            bool acceptTouchEvents = widget->testAttribute(Qt::WA_AcceptTouchEvents);
+            touchEvent->setWidget(widget);
+            touchEvent->setAccepted(acceptTouchEvents);
+            QWeakPointer<QWidget> p = widget;
+            res = acceptTouchEvents && d->notify_helper(widget, touchEvent);
+            eventAccepted = touchEvent->isAccepted();
+            if (p.isNull()) {
+                // widget was deleted
+                widget = 0;
+            } else {
+                widget->setAttribute(Qt::WA_WState_AcceptedTouchBeginEvent, res && eventAccepted);
+            }
+            touchEvent->spont = false;
+            if (res && eventAccepted) {
+                // the first widget to accept the TouchBegin gets an implicit grab.
+                for (int i = 0; i < touchEvent->touchPoints().count(); ++i) {
+                    const QTouchEvent::TouchPoint &touchPoint = touchEvent->touchPoints().at(i);
+                    d->widgetForTouchPointId[touchPoint.id()] = widget;
+                }
+                break;
+            } else if (p.isNull() || widget->isWindow() || widget->testAttribute(Qt::WA_NoMousePropagation)) {
+                break;
+            }
+            QPoint offset = widget->pos();
+            widget = widget->parentWidget();
+            touchEvent->setWidget(widget);
+            for (int i = 0; i < touchEvent->_touchPoints.size(); ++i) {
+                QTouchEvent::TouchPoint &pt = touchEvent->_touchPoints[i];
+                QRectF rect = pt.rect();
+                rect.moveCenter(offset);
+                pt.d->rect = rect;
+                pt.d->startPos = pt.startPos() + offset;
+                pt.d->lastPos = pt.lastPos() + offset;
+            }
+        }
+
+        touchEvent->setAccepted(eventAccepted);
+        break;
+    }
+    case QEvent::RequestSoftwareInputPanel:
+    case QEvent::CloseSoftwareInputPanel:
+#ifndef QT_NO_IM
+        if (receiver->isWidgetType()) {
+            QWidget *w = static_cast<QWidget *>(receiver);
+            QInputContext *ic = w->inputContext();
+            if (ic && ic->filterEvent(e)) {
+                break;
+            }
+        }
+#endif
+        res = d->notify_helper(receiver, e);
+        break;
+
+    case QEvent::NativeGesture:
+    {
+        // only propagate the first gesture event (after the GID_BEGIN)
+        QWidget *w = static_cast<QWidget *>(receiver);
+        while (w) {
+            e->ignore();
+            res = d->notify_helper(w, e);
+            if ((res && e->isAccepted()) || w->isWindow())
+                break;
+            w = w->parentWidget();
+        }
+        break;
+    }
+    case QEvent::Gesture:
+    case QEvent::GestureOverride:
+    {
+        if (receiver->isWidgetType()) {
+            QWidget *w = static_cast<QWidget *>(receiver);
+            QGestureEvent *gestureEvent = static_cast<QGestureEvent *>(e);
+            QList<QGesture *> allGestures = gestureEvent->gestures();
+
+            bool eventAccepted = gestureEvent->isAccepted();
+            bool wasAccepted = eventAccepted;
+            while (w) {
+                // send only gestures the widget expects
+                QList<QGesture *> gestures;
+                QWidgetPrivate *wd = w->d_func();
+                for (int i = 0; i < allGestures.size();) {
+                    QGesture *g = allGestures.at(i);
+                    Qt::GestureType type = g->gestureType();
+                    QMap<Qt::GestureType, Qt::GestureFlags>::iterator contextit =
+                            wd->gestureContext.find(type);
+                    bool deliver = contextit != wd->gestureContext.end() &&
+                        (g->state() == Qt::GestureStarted || w == receiver ||
+                         (contextit.value() & Qt::ReceivePartialGestures));
+                    if (deliver) {
+                        allGestures.removeAt(i);
+                        gestures.append(g);
+                    } else {
+                        ++i;
+                    }
+                }
+                if (!gestures.isEmpty()) { // we have gestures for this w
+                    QGestureEvent ge(gestures);
+                    ge.t = gestureEvent->t;
+                    ge.spont = gestureEvent->spont;
+                    ge.m_accept = wasAccepted;
+                    ge.d_func()->accepted = gestureEvent->d_func()->accepted;
+                    res = d->notify_helper(w, &ge);
+                    gestureEvent->spont = false;
+                    eventAccepted = ge.isAccepted();
+                    for (int i = 0; i < gestures.size(); ++i) {
+                        QGesture *g = gestures.at(i);
+                        if ((res && eventAccepted) || (!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)) {
+                            // if the gesture was explicitly ignored by the application,
+                            // put it back so a parent can get it
+                            allGestures.append(g);
+                        }
+                    }
+                }
+                if (allGestures.isEmpty()) // everything delivered
+                    break;
+                if (w->isWindow())
+                    break;
+                w = w->parentWidget();
+            }
+            foreach (QGesture *g, allGestures)
+                gestureEvent->setAccepted(g, false);
+            gestureEvent->m_accept = false; // to make sure we check individual gestures
+        } else {
+            res = d->notify_helper(receiver, e);
+        }
+        break;
+    }
     default:
         res = d->notify_helper(receiver, e);
@@ -4046 +4281 @@
         QWidget *widget = static_cast<QWidget *>(receiver);
 
-#if !defined(Q_OS_WINCE) || (defined(GWES_ICONCURS) && !defined(QT_NO_CURSOR))
+#if !defined(Q_WS_WINCE) || (defined(GWES_ICONCURS) && !defined(QT_NO_CURSOR))
         // toggle HasMouse widget state on enter and leave
         if ((e->type() == QEvent::Enter || e->type() == QEvent::DragEnter) &&
-            (!qApp->activePopupWidget() || qApp->activePopupWidget() == widget->window()))
+            (!QApplication::activePopupWidget() || QApplication::activePopupWidget() == widget->window()))
             widget->setAttribute(Qt::WA_UnderMouse, true);
         else if (e->type() == QEvent::Leave || e->type() == QEvent::DragLeave)
@@ -4074 +4309 @@
     \class QSessionManager
     \brief The QSessionManager class provides access to the session manager.
-
-    \ingroup application
-    \ingroup environment
 
     A session manager in a desktop environment (in which Qt GUI applications
@@ -4376 +4608 @@
     // We will use the following information to create the GUID
     // 1. absolute path to application
-    wchar_t tempFilename[512];
-    if (!GetModuleFileNameW(0, tempFilename, 512))
+    wchar_t tempFilename[MAX_PATH];
+    if (!GetModuleFileName(0, tempFilename, MAX_PATH))
         return S_FALSE;
-    unsigned int hash = qHash(QString::fromUtf16((const unsigned short *) tempFilename));
+    unsigned int hash = qHash(QString::fromWCharArray(tempFilename));
     guid->Data1 = hash;
     // 2. creation time of file
-    QFileInfo info(QString::fromUtf16((const unsigned short *) tempFilename));
+    QFileInfo info(QString::fromWCharArray(tempFilename));
     guid->Data2 = qHash(info.created().toTime_t());
     // 3. current system time
@@ -4416 +4648 @@
     CoCreateGuid(&guid);
     StringFromGUID2(guid, guidstr, 40);
-    id = QString::fromUtf16((ushort*)guidstr);
+    id = QString::fromWCharArray(guidstr);
     CoCreateGuid(&guid);
     StringFromGUID2(guid, guidstr, 40);
-    key = QString::fromUtf16((ushort*)guidstr);
+    key = QString::fromWCharArray(guidstr);
 #endif
     d->sessionId = id;
@@ -4579 +4811 @@
     app.setWinStyleHighlightColor(color);
     \newcode
-    QPalette palette(qApp->palette());
+    QPalette palette(QApplication::palette());
     palette.setColor(QPalette::Highlight, color);
-    qApp->setPalette(palette);
+    QApplication::setPalette(palette);
     \endcode
 */
@@ -4600 +4832 @@
     \fn const QColor &QApplication::winStyleHighlightColor()
 
-    Use qApp->palette().color(QPalette::Active, QPalette::Highlight) instead.
+    Use QApplication::palette().color(QPalette::Active, QPalette::Highlight) instead.
 */
 
@@ -4685 +4917 @@
 #ifdef QT_KEYPAD_NAVIGATION
 /*!
+    Sets the kind of focus navigation Qt should use to \a mode.
+
+    This feature is available in Qt for Embedded Linux, Symbian and Windows CE
+    only.
+
+    \note On Windows CE this feature is disabled by default for touch device
+          mkspecs. To enable keypad navigation, build Qt with
+          QT_KEYPAD_NAVIGATION defined.
+
+    \note On Symbian, setting the mode to Qt::NavigationModeCursorAuto will enable a
+          virtual mouse cursor on non touchscreen devices, which is controlled
+          by the cursor keys if there is no analog pointer device.
+          On other platforms and on touchscreen devices, it has the same
+          meaning as Qt::NavigationModeNone.
+
+    \since 4.6
+
+    \sa keypadNavigationEnabled()
+*/
+void QApplication::setNavigationMode(Qt::NavigationMode mode)
+{
+#ifdef Q_OS_SYMBIAN
+    QApplicationPrivate::setNavigationMode(mode);
+#else
+    QApplicationPrivate::navigationMode = mode;
+#endif
+}
+
+/*!
+    Returns what kind of focus navigation Qt is using.
+
+    This feature is available in Qt for Embedded Linux, Symbian and Windows CE
+    only.
+
+    \note On Windows CE this feature is disabled by default for touch device
+          mkspecs. To enable keypad navigation, build Qt with
+          QT_KEYPAD_NAVIGATION defined.
+
+    \note On Symbian, the default mode is Qt::NavigationModeNone for touch
+          devices, and Qt::NavigationModeKeypadDirectional.
+
+    \since 4.6
+
+    \sa keypadNavigationEnabled()
+*/
+Qt::NavigationMode QApplication::navigationMode()
+{
+    return QApplicationPrivate::navigationMode;
+}
+
+/*!
     Sets whether Qt should use focus navigation suitable for use with a
     minimal keypad.
 
-    If \a enable is true, Qt::Key_Up and Qt::Key_Down are used to change focus.
-
-    This feature is available in Qt for Embedded Linux only.
-
-    \sa keypadNavigationEnabled()
+    This feature is available in Qt for Embedded Linux, Symbian and Windows CE
+    only.
+
+    \note On Windows CE this feature is disabled by default for touch device
+          mkspecs. To enable keypad navigation, build Qt with
+          QT_KEYPAD_NAVIGATION defined.
+
+    \deprecated
+
+    \sa setNavigationMode()
 */
 void QApplication::setKeypadNavigationEnabled(bool enable)
 {
-    QApplicationPrivate::keypadNavigation = enable;
+    if (enable) {
+#ifdef Q_OS_SYMBIAN
+        QApplication::setNavigationMode(Qt::NavigationModeKeypadDirectional);
+#else
+        QApplication::setNavigationMode(Qt::NavigationModeKeypadTabOrder);
+#endif
+    }
+    else {
+        QApplication::setNavigationMode(Qt::NavigationModeNone);
+    }
 }
 
 /*!
     Returns true if Qt is set to use keypad navigation; otherwise returns
-    false. The default is false.
-
-    This feature is available in Qt for Embedded Linux only.
-
-    \sa setKeypadNavigationEnabled()
+    false.  The default value is true on Symbian, but false on other platforms.
+
+    This feature is available in Qt for Embedded Linux, Symbian and Windows CE
+    only.
+
+    \note On Windows CE this feature is disabled by default for touch device
+          mkspecs. To enable keypad navigation, build Qt with
+          QT_KEYPAD_NAVIGATION defined.
+
+    \deprecated
+
+    \sa navigationMode()
 */
 bool QApplication::keypadNavigationEnabled()
 {
-    return QApplicationPrivate::keypadNavigation;
+    return QApplicationPrivate::navigationMode == Qt::NavigationModeKeypadTabOrder ||
+        QApplicationPrivate::navigationMode == Qt::NavigationModeKeypadDirectional;
 }
 #endif
@@ -4727 +5032 @@
     application icon to bounce in the dock.
 
-    On Windows this causes the window's taskbar entry to flash for a time. If
+    On Windows, this causes the window's taskbar entry to flash for a time. If
     \a msec is zero, the flashing will stop and the taskbar entry will turn a
     different color (currently orange).
@@ -4744 +5049 @@
     flash time, then hidden for the same amount of time, but this may vary.
 
-    The default value on X11 is 1000 milliseconds. On Windows, the control
-    panel value is used. Widgets should not cache this value since it may be
-    changed at any time by the user changing the global desktop settings.
-
-    \note On Microsoft Windows, setting this property sets the cursor flash
-    time for all applications.
+    The default value on X11 is 1000 milliseconds. On Windows, the
+    \gui{Control Panel} value is used and setting this property sets the cursor
+    flash time for all applications.
+
+    We recommend that widgets do not cache this value as it may change at any
+    time if the user changes the global desktop settings.
 */
 
 /*!
     \property QApplication::doubleClickInterval
-    \brief the time limit in milliseconds that distinguishes a double click from two
-    consecutive mouse clicks
-
-    The default value on X11 is 400 milliseconds. On Windows and Mac OS X, the
-    operating system's value is used.
-
-    On Microsoft Windows, calling this function sets the double click interval
-    for all applications.
+    \brief the time limit in milliseconds that distinguishes a double click
+    from two consecutive mouse clicks
+
+    The default value on X11 is 400 milliseconds. On Windows and Mac OS, the
+    operating system's value is used. However, on Windows and Symbian OS,
+    calling this function sets the double click interval for all applications.
 */
 
@@ -4770 +5073 @@
     \since 4.2
 
-    The default value on X11 is 400 milliseconds. On Windows and Mac OS X, the
+    The default value on X11 is 400 milliseconds. On Windows and Mac OS, the
     operating system's value is used.
 */
@@ -4835 +5138 @@
     is an alternative.
 
-    For X11, this function also resizes and moves the main widget according
+    On X11, this function also resizes and moves the main widget according
     to the \e -geometry command-line option, so you should set the default
     geometry (using \l QWidget::setGeometry()) before calling setMainWidget().
@@ -4864 +5167 @@
     pushes the cursor onto the stack, and restoreOverrideCursor() pops the
     active cursor off the stack. changeOverrideCursor() changes the curently
-    active application override cursor. Every setOverrideCursor() must
-    eventually be followed by a corresponding restoreOverrideCursor(),
-    otherwise the stack will never be emptied.
+    active application override cursor.
+
+    Every setOverrideCursor() must eventually be followed by a corresponding
+    restoreOverrideCursor(), otherwise the stack will never be emptied.
 
     Example:
@@ -4920 +5224 @@
         return;
     }
-    if (d->inputContext)
-        delete d->inputContext;
+    delete d->inputContext;
     d->inputContext = inputContext;
 #endif
@@ -4936 +5239 @@
     Q_D(const QApplication);
     Q_UNUSED(d);// only static members being used.
+    if (QApplicationPrivate::is_app_closing)
+        return d->inputContext;
 #ifdef Q_WS_X11
     if (!X11)
@@ -4946 +5251 @@
             qic = QInputContextFactory::create(QLatin1String("xim"), that);
         that->d_func()->inputContext = qic;
+    }
+#elif defined(Q_WS_S60)
+    if (!d->inputContext) {
+        QApplication *that = const_cast<QApplication *>(this);
+        that->d_func()->inputContext = QInputContextFactory::create(QString::fromLatin1("coefep"), that);
     }
 #endif
@@ -4967 +5277 @@
     if (X11->desktopEnvironment == DE_CDE)
         platform |= KB_CDE;
+#elif defined(Q_OS_SYMBIAN)
+    platform = KB_S60;
 #endif
     return platform;
@@ -4999 +5311 @@
         return Qt::LeftToRight;
     return qt_keymapper_private()->keyboardInputDirection;
+}
+
+void QApplicationPrivate::giveFocusAccordingToFocusPolicy(QWidget *widget,
+                                                          Qt::FocusPolicy focusPolicy,
+                                                          Qt::FocusReason focusReason)
+{
+    QWidget *focusWidget = widget;
+    while (focusWidget) {
+        if (focusWidget->isEnabled()
+            && QApplicationPrivate::shouldSetFocus(focusWidget, focusPolicy)) {
+            focusWidget->setFocus(focusReason);
+            break;
+        }
+        if (focusWidget->isWindow())
+            break;
+        focusWidget = focusWidget->parentWidget();
+    }
 }
 
@@ -5014 +5343 @@
 }
 
+/*! \fn QDecoration &QApplication::qwsDecoration()
+    Return the QWSDecoration used for decorating windows.
+
+    \warning This method is non-portable. It is only available in
+    Qt for Embedded Linux.
+
+    \sa QDecoration
+*/
+
+/*!
+    \fn void QApplication::qwsSetDecoration(QDecoration *decoration)
+
+    Sets the QDecoration derived class to use for decorating the
+    windows used by Qt for Embedded Linux to the \a decoration
+    specified.
+
+    This method is non-portable. It is only available in Qt for Embedded Linux.
+
+    \sa QDecoration
+*/
+
+/*! \fn QDecoration* QApplication::qwsSetDecoration(const QString &decoration)
+    \overload
+
+    Requests a QDecoration object for \a decoration from the
+    QDecorationFactory.
+
+    The string must be one of the QDecorationFactory::keys(). Keys are case
+    insensitive.
+
+    A later call to the QApplication constructor will override the requested
+    style when a "-style" option is passed in as a commandline parameter.
+
+    Returns 0 if an unknown \a decoration is passed, otherwise the QStyle object
+    returned is set as the application's GUI style.
+*/
+
+/*!
+    \fn bool QApplication::qwsEventFilter(QWSEvent *event)
+
+    This virtual function is only implemented under Qt for Embedded Linux.
+
+    If you create an application that inherits QApplication and
+    reimplement this function, you get direct access to all QWS (Q
+    Window System) events that the are received from the QWS master
+    process. The events are passed in the \a event parameter.
+
+    Return true if you want to stop the event from being processed.
+    Return false for normal event dispatching. The default
+    implementation returns false.
+*/
+
+/*! \fn void QApplication::qwsSetCustomColors(QRgb *colorTable, int start, int numColors)
+    Set Qt for Embedded Linux custom color table.
+
+    Qt for Embedded Linux on 8-bpp displays allocates a standard 216 color cube.
+    The remaining 40 colors may be used by setting a custom color
+    table in the QWS master process before any clients connect.
+
+    \a colorTable is an array of up to 40 custom colors. \a start is
+    the starting index (0-39) and \a numColors is the number of colors
+    to be set (1-40).
+
+    This method is non-portable. It is available \e only in
+    Qt for Embedded Linux.
+
+    \note The custom colors will not be used by the default screen
+    driver. To make use of the new colors, implement a custom screen
+    driver, or use QDirectPainter.
+*/
+
+/*! \fn int QApplication::qwsProcessEvent(QWSEvent* event)
+    \internal
+*/
+
+/*! \fn int QApplication::x11ClientMessage(QWidget* w, XEvent* event, bool passive_only)
+    \internal
+*/
+
+/*! \fn int QApplication::x11ProcessEvent(XEvent* event)
+    This function does the core processing of individual X
+    \a{event}s, normally by dispatching Qt events to the right
+    destination.
+
+    It returns 1 if the event was consumed by special handling, 0 if
+    the \a event was consumed by normal handling, and -1 if the \a
+    event was for an unrecognized widget.
+
+    \sa x11EventFilter()
+*/
+
+/*!
+    \fn bool QApplication::x11EventFilter(XEvent *event)
+
+    \warning This virtual function is only implemented under X11.
+
+    If you create an application that inherits QApplication and
+    reimplement this function, you get direct access to all X events
+    that the are received from the X server. The events are passed in
+    the \a event parameter.
+
+    Return true if you want to stop the event from being processed.
+    Return false for normal event dispatching. The default
+    implementation returns false.
+
+    It is only the directly addressed messages that are filtered.
+    You must install an event filter directly on the event
+    dispatcher, which is returned by
+    QAbstractEventDispatcher::instance(), to handle system wide
+    messages.
+
+    \sa x11ProcessEvent()
+*/
+
+/*! \fn void QApplication::winFocus(QWidget *widget, bool gotFocus)
+    \internal
+    \since 4.1
+
+    If \a gotFocus is true, \a widget will become the active window.
+    Otherwise the active window is reset to 0.
+*/
+
+/*! \fn void QApplication::winMouseButtonUp()
+  \internal
+ */
+
+/*! \fn void QApplication::syncX()
+  Synchronizes with the X server in the X11 implementation.
+  This normally takes some time. Does nothing on other platforms.
+*/
+
+void QApplicationPrivate::updateTouchPointsForWidget(QWidget *widget, QTouchEvent *touchEvent)
+{
+    for (int i = 0; i < touchEvent->touchPoints().count(); ++i) {
+        QTouchEvent::TouchPoint &touchPoint = touchEvent->_touchPoints[i];
+
+        // preserve the sub-pixel resolution
+        QRectF rect = touchPoint.screenRect();
+        const QPointF screenPos = rect.center();
+        const QPointF delta = screenPos - screenPos.toPoint();
+
+        rect.moveCenter(widget->mapFromGlobal(screenPos.toPoint()) + delta);
+        touchPoint.d->rect = rect;
+        if (touchPoint.state() == Qt::TouchPointPressed) {
+            touchPoint.d->startPos = widget->mapFromGlobal(touchPoint.startScreenPos().toPoint()) + delta;
+            touchPoint.d->lastPos = widget->mapFromGlobal(touchPoint.lastScreenPos().toPoint()) + delta;
+        }
+    }
+}
+
+void QApplicationPrivate::initializeMultitouch()
+{
+    widgetForTouchPointId.clear();
+    appCurrentTouchPoints.clear();
+
+    initializeMultitouch_sys();
+}
+
+void QApplicationPrivate::cleanupMultitouch()
+{
+    cleanupMultitouch_sys();
+
+    widgetForTouchPointId.clear();
+    appCurrentTouchPoints.clear();
+}
+
+int QApplicationPrivate::findClosestTouchPointId(const QPointF &screenPos)
+{
+    int closestTouchPointId = -1;
+    qreal closestDistance = qreal(0.);
+    foreach (const QTouchEvent::TouchPoint &touchPoint, appCurrentTouchPoints) {
+        qreal distance = QLineF(screenPos, touchPoint.screenPos()).length();
+        if (closestTouchPointId == -1 || distance < closestDistance) {
+            closestTouchPointId = touchPoint.id();
+            closestDistance = distance;
+        }
+    }
+    return closestTouchPointId;
+}
+
+void QApplicationPrivate::translateRawTouchEvent(QWidget *window,
+                                                 QTouchEvent::DeviceType deviceType,
+                                                 const QList<QTouchEvent::TouchPoint> &touchPoints)
+{
+    QApplicationPrivate *d = self;
+    typedef QPair<Qt::TouchPointStates, QList<QTouchEvent::TouchPoint> > StatesAndTouchPoints;
+    QHash<QWidget *, StatesAndTouchPoints> widgetsNeedingEvents;
+
+    for (int i = 0; i < touchPoints.count(); ++i) {
+        QTouchEvent::TouchPoint touchPoint = touchPoints.at(i);
+        // explicitly detach from the original touch point that we got, so even
+        // if the touchpoint structs are reused, we will make a copy that we'll
+        // deliver to the user (which might want to store the struct for later use).
+        touchPoint.d = touchPoint.d->detach();
+
+        // update state
+        QWeakPointer<QWidget> widget;
+        switch (touchPoint.state()) {
+        case Qt::TouchPointPressed:
+        {
+            if (deviceType == QTouchEvent::TouchPad) {
+                // on touch-pads, send all touch points to the same widget
+                widget = d->widgetForTouchPointId.isEmpty()
+                         ? QWeakPointer<QWidget>()
+                         : d->widgetForTouchPointId.constBegin().value();
+            }
+
+            if (!widget) {
+                // determine which widget this event will go to
+                if (!window)
+                    window = QApplication::topLevelAt(touchPoint.screenPos().toPoint());
+                if (!window)
+                    continue;
+                widget = window->childAt(window->mapFromGlobal(touchPoint.screenPos().toPoint()));
+                if (!widget)
+                    widget = window;
+            }
+
+            if (deviceType == QTouchEvent::TouchScreen) {
+                int closestTouchPointId = d->findClosestTouchPointId(touchPoint.screenPos());
+                QWidget *closestWidget = d->widgetForTouchPointId.value(closestTouchPointId).data();
+                if (closestWidget
+                    && (widget.data()->isAncestorOf(closestWidget) || closestWidget->isAncestorOf(widget.data()))) {
+                    widget = closestWidget;
+                }
+            }
+
+            d->widgetForTouchPointId[touchPoint.id()] = widget;
+            touchPoint.d->startScreenPos = touchPoint.screenPos();
+            touchPoint.d->lastScreenPos = touchPoint.screenPos();
+            touchPoint.d->startNormalizedPos = touchPoint.normalizedPos();
+            touchPoint.d->lastNormalizedPos = touchPoint.normalizedPos();
+            if (touchPoint.pressure() < qreal(0.))
+                touchPoint.d->pressure = qreal(1.);
+
+            d->appCurrentTouchPoints.insert(touchPoint.id(), touchPoint);
+            break;
+        }
+        case Qt::TouchPointReleased:
+        {
+            widget = d->widgetForTouchPointId.take(touchPoint.id());
+            if (!widget)
+                continue;
+
+            QTouchEvent::TouchPoint previousTouchPoint = d->appCurrentTouchPoints.take(touchPoint.id());
+            touchPoint.d->startScreenPos = previousTouchPoint.startScreenPos();
+            touchPoint.d->lastScreenPos = previousTouchPoint.screenPos();
+            touchPoint.d->startPos = previousTouchPoint.startPos();
+            touchPoint.d->lastPos = previousTouchPoint.pos();
+            touchPoint.d->startNormalizedPos = previousTouchPoint.startNormalizedPos();
+            touchPoint.d->lastNormalizedPos = previousTouchPoint.normalizedPos();
+            if (touchPoint.pressure() < qreal(0.))
+                touchPoint.d->pressure = qreal(0.);
+            break;
+        }
+        default:
+            widget = d->widgetForTouchPointId.value(touchPoint.id());
+            if (!widget)
+                continue;
+
+            Q_ASSERT(d->appCurrentTouchPoints.contains(touchPoint.id()));
+            QTouchEvent::TouchPoint previousTouchPoint = d->appCurrentTouchPoints.value(touchPoint.id());
+            touchPoint.d->startScreenPos = previousTouchPoint.startScreenPos();
+            touchPoint.d->lastScreenPos = previousTouchPoint.screenPos();
+            touchPoint.d->startPos = previousTouchPoint.startPos();
+            touchPoint.d->lastPos = previousTouchPoint.pos();
+            touchPoint.d->startNormalizedPos = previousTouchPoint.startNormalizedPos();
+            touchPoint.d->lastNormalizedPos = previousTouchPoint.normalizedPos();
+            if (touchPoint.pressure() < qreal(0.))
+                touchPoint.d->pressure = qreal(1.);
+            d->appCurrentTouchPoints[touchPoint.id()] = touchPoint;
+            break;
+        }
+        Q_ASSERT(widget.data() != 0);
+
+        // make the *scene* functions return the same as the *screen* functions
+        touchPoint.d->sceneRect = touchPoint.screenRect();
+        touchPoint.d->startScenePos = touchPoint.startScreenPos();
+        touchPoint.d->lastScenePos = touchPoint.lastScreenPos();
+
+        StatesAndTouchPoints &maskAndPoints = widgetsNeedingEvents[widget.data()];
+        maskAndPoints.first |= touchPoint.state();
+        if (touchPoint.isPrimary())
+            maskAndPoints.first |= Qt::TouchPointPrimary;
+        maskAndPoints.second.append(touchPoint);
+    }
+
+    if (widgetsNeedingEvents.isEmpty())
+        return;
+
+    QHash<QWidget *, StatesAndTouchPoints>::ConstIterator it = widgetsNeedingEvents.constBegin();
+    const QHash<QWidget *, StatesAndTouchPoints>::ConstIterator end = widgetsNeedingEvents.constEnd();
+    for (; it != end; ++it) {
+        QWidget *widget = it.key();
+        if (!QApplicationPrivate::tryModalHelper(widget, 0))
+            continue;
+
+        QEvent::Type eventType;
+        switch (it.value().first & Qt::TouchPointStateMask) {
+        case Qt::TouchPointPressed:
+            eventType = QEvent::TouchBegin;
+            break;
+        case Qt::TouchPointReleased:
+            eventType = QEvent::TouchEnd;
+            break;
+        case Qt::TouchPointStationary:
+            // don't send the event if nothing changed
+            continue;
+        default:
+            eventType = QEvent::TouchUpdate;
+            break;
+        }
+
+        QTouchEvent touchEvent(eventType,
+                               deviceType,
+                               QApplication::keyboardModifiers(),
+                               it.value().first,
+                               it.value().second);
+        updateTouchPointsForWidget(widget, &touchEvent);
+
+        switch (touchEvent.type()) {
+        case QEvent::TouchBegin:
+        {
+            // if the TouchBegin handler recurses, we assume that means the event
+            // has been implicitly accepted and continue to send touch events
+            widget->setAttribute(Qt::WA_WState_AcceptedTouchBeginEvent);
+            (void ) QApplication::sendSpontaneousEvent(widget, &touchEvent);
+            break;
+        }
+        default:
+            if (widget->testAttribute(Qt::WA_WState_AcceptedTouchBeginEvent)) {
+                if (touchEvent.type() == QEvent::TouchEnd)
+                    widget->setAttribute(Qt::WA_WState_AcceptedTouchBeginEvent, false);
+                (void) QApplication::sendSpontaneousEvent(widget, &touchEvent);
+            }
+            break;
+        }
+    }
+}
+
+Q_GUI_EXPORT void qt_translateRawTouchEvent(QWidget *window,
+                                            QTouchEvent::DeviceType deviceType,
+                                            const QList<QTouchEvent::TouchPoint> &touchPoints)
+{
+    QApplicationPrivate::translateRawTouchEvent(window, deviceType, touchPoints);
+}
+
+QGestureManager* QGestureManager::instance()
+{
+    QApplicationPrivate *qAppPriv = QApplicationPrivate::instance();
+    if (!qAppPriv->gestureManager)
+        qAppPriv->gestureManager = new QGestureManager(qApp);
+    return qAppPriv->gestureManager;
+}
+
 QT_END_NAMESPACE