Changeset 769 for trunk/src/gui/kernel

Timestamp:

Aug 2, 2010, 9:27:30 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

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

Location:

trunk

Files:

• . (modified) (1 prop)
• src/gui/kernel/qapplication.cpp (modified) (3 diffs)
• src/gui/kernel/qapplication_mac.mm (modified) (5 diffs)
• src/gui/kernel/qapplication_p.h (modified) (3 diffs)
• src/gui/kernel/qapplication_s60.cpp (modified) (23 diffs)
• src/gui/kernel/qapplication_win.cpp (modified) (10 diffs)
• src/gui/kernel/qapplication_x11.cpp (modified) (9 diffs)
• src/gui/kernel/qclipboard_mac.cpp (modified) (1 diff)
• src/gui/kernel/qclipboard_s60.cpp (modified) (1 diff)
• src/gui/kernel/qcocoamenuloader_mac.mm (modified) (1 diff)
• src/gui/kernel/qcocoamenuloader_mac_p.h (modified) (1 diff)
• src/gui/kernel/qcocoapanel_mac.mm (modified) (1 diff)
• src/gui/kernel/qcocoasharedwindowmethods_mac_p.h (modified) (2 diffs)
• src/gui/kernel/qcocoaview_mac.mm (modified) (5 diffs)
• src/gui/kernel/qcocoawindow_mac_p.h (modified) (1 diff)
• src/gui/kernel/qcursor.cpp (modified) (1 diff)
• src/gui/kernel/qdesktopwidget_s60.cpp (modified) (2 diffs)
• src/gui/kernel/qdnd_s60.cpp (modified) (1 diff)
• src/gui/kernel/qdnd_x11.cpp (modified) (1 diff)
• src/gui/kernel/qeventdispatcher_mac.mm (modified) (1 diff)
• src/gui/kernel/qgesturemanager.cpp (modified) (2 diffs)
• src/gui/kernel/qgridlayout.cpp (modified) (1 diff)
• src/gui/kernel/qguifunctions_wince.cpp (modified) (1 diff)
• src/gui/kernel/qkeymapper_p.h (modified) (1 diff)
• src/gui/kernel/qkeymapper_s60.cpp (modified) (2 diffs)
• src/gui/kernel/qkeymapper_x11.cpp (modified) (4 diffs)
• src/gui/kernel/qmime_mac.cpp (modified) (1 diff)
• src/gui/kernel/qmime_win.cpp (modified) (2 diffs)
• src/gui/kernel/qsoftkeymanager.cpp (modified) (6 diffs)
• src/gui/kernel/qsoftkeymanager_common_p.h (modified) (1 diff)
• src/gui/kernel/qsoftkeymanager_p.h (modified) (3 diffs)
• src/gui/kernel/qsoftkeymanager_s60.cpp (modified) (8 diffs)
• src/gui/kernel/qsoftkeymanager_s60_p.h (modified) (3 diffs)
• src/gui/kernel/qsound.cpp (modified) (1 diff)
• src/gui/kernel/qsound_mac.mm (modified) (1 diff)
• src/gui/kernel/qsound_s60.cpp (modified) (1 diff)
• src/gui/kernel/qt_cocoa_helpers_mac.mm (modified) (3 diffs)
• src/gui/kernel/qt_s60_p.h (modified) (5 diffs)
• src/gui/kernel/qt_x11_p.h (modified) (1 diff)
• src/gui/kernel/qtooltip.cpp (modified) (2 diffs)
• src/gui/kernel/qwhatsthis.cpp (modified) (1 diff)
• src/gui/kernel/qwidget.cpp (modified) (14 diffs)
• src/gui/kernel/qwidget_mac.mm (modified) (12 diffs)
• src/gui/kernel/qwidget_p.h (modified) (5 diffs)
• src/gui/kernel/qwidget_s60.cpp (modified) (7 diffs)
• src/gui/kernel/qwidget_win.cpp (modified) (1 diff)
• src/gui/kernel/qwidget_x11.cpp (modified) (2 diffs)
• src/gui/kernel/qwinnativepangesturerecognizer_win_p.h (modified) (1 diff)

trunk/src/gui/kernel/qapplication.cpp

@@ -139 +139 @@
 QT_BEGIN_NAMESPACE
 
-extern void qt_call_post_routines();
+Q_DECL_IMPORT extern void qt_call_post_routines();
 
 int QApplicationPrivate::app_compile_version = 0x040000; //we don't know exactly, but it's at least 4.0.0
@@ -895 +895 @@
     QWidgetPrivate::mapper = new QWidgetMapper;
     QWidgetPrivate::allWidgets = new QWidgetSet;
+
+#if !defined(Q_WS_X11) && !defined(Q_WS_QWS)
+    // initialize the graphics system - on X11 this is initialized inside
+    // qt_init() in qapplication_x11.cpp because of several reasons.
+    // On QWS, the graphics system is set by the QScreen plugin.
+    graphics_system = QGraphicsSystemFactory::create(graphics_system_name);
+#endif
+
     if (qt_appType != QApplication::Tty)
         (void) QApplication::style();  // trigger creation of application style
@@ -929 +937 @@
     qInitDrawhelperAsm();
 
-#if !defined(Q_WS_X11) && !defined(Q_WS_QWS)
-    // initialize the graphics system - on X11 this is initialized inside
-    // qt_init() in qapplication_x11.cpp because of several reasons.
-    // On QWS, the graphics system is set by the QScreen plugin.
-    graphics_system = QGraphicsSystemFactory::create(graphics_system_name);
-#endif
 #ifndef QT_NO_WHEELEVENT
     QApplicationPrivate::wheel_scroll_lines = 3;

trunk/src/gui/kernel/qapplication_mac.mm

@@ -2144 +2144 @@
 
             if (wheel_deltaX || wheel_deltaY) {
+#ifndef QT_NO_WHEELEVENT
                 if (wheel_deltaX) {
                     QWheelEvent qwe(plocal, p, wheel_deltaX, buttons, modifiers, Qt::Horizontal);
@@ -2166 +2167 @@
                     }
                 }
+#endif // QT_NO_WHEELEVENT
             } else {
 #ifdef QMAC_SPEAK_TO_ME
@@ -2718 +2720 @@
 }
 
+#ifndef QT_NO_WHEELEVENT
 void QApplication::setWheelScrollLines(int n)
 {
@@ -2727 +2730 @@
     return QApplicationPrivate::wheel_scroll_lines;
 }
+#endif
 
 void QApplication::setEffectEnabled(Qt::UIEffect effect, bool enable)
@@ -2889 +2893 @@
         QApplication::setCursorFlashTime(num);
 
+#ifndef QT_NO_WHEELEVENT
         num = settings.value(QLatin1String("wheelScrollLines"),
                             QApplication::wheelScrollLines()).toInt();
         QApplication::setWheelScrollLines(num);
+#endif
 
         QString colorspec = settings.value(QLatin1String("colorSpec"),

trunk/src/gui/kernel/qapplication_p.h

@@ -429 +429 @@
     static int  mouse_double_click_time;
     static int  keyboard_input_time;
+#ifndef QT_NO_WHEELEVENT
     static int  wheel_scroll_lines;
+#endif
 
     static bool animate_ui;
@@ -533 +535 @@
 
 #if defined(Q_WS_WIN)
+    static bool HasTouchSupport;
     static PtrRegisterTouchWindow RegisterTouchWindow;
     static PtrGetTouchInputInfo GetTouchInputInfo;
@@ -568 +571 @@
 #endif
 
-#if defined(Q_WS_S60)
+#if defined(Q_OS_SYMBIAN)
+    int pressureSupported;
     int maxTouchPressure;
     QList<QTouchEvent::TouchPoint> appAllTouchPoints;

trunk/src/gui/kernel/qapplication_s60.cpp

@@ -53 +53 @@
 #include "qdebug.h"
 #include "qimage.h"
+#include "qcombobox.h"
 #include "private/qkeymapper_p.h"
 #include "private/qfont_p.h"
@@ -64 +65 @@
 
 #include "apgwgnam.h" // For CApaWindowGroupName
-#include <MdaAudioTonePlayer.h>     // For CMdaAudioToneUtility
+#include <mdaaudiotoneplayer.h>     // For CMdaAudioToneUtility
 
 #if defined(Q_WS_S60)
@@ -73 +74 @@
 # include <private/qs60mainapplication_p.h>
 # include <centralrepository.h>
+# include "qs60mainappui.h"
 #endif
 
@@ -372 +374 @@
     if (S60->curWin == this)
         S60->curWin = 0;
-    if (!QApplicationPrivate::is_app_closing)
-        setFocusSafely(false);
+    if (!QApplicationPrivate::is_app_closing) {
+        QT_TRY {
+            setFocusSafely(false);
+        } QT_CATCH(const std::exception&) {
+            // ignore exceptions, nothing can be done
+        }
+    }
     S60->appUi()->RemoveFromStack(this);
     delete m_longTapDetector;
@@ -401 +408 @@
 {
     QApplicationPrivate *d = QApplicationPrivate::instance();
+    qreal pressure;
+    if(d->pressureSupported
+        && event->Pressure() > 0) //workaround for misconfigured HAL
+        pressure = event->Pressure() / qreal(d->maxTouchPressure);
+    else
+        pressure = qreal(1.0);
 
     QRect screenGeometry = qApp->desktop()->screenGeometry(qwidget);
 
-    while (d->appAllTouchPoints.count() <= event->PointerNumber())
-        d->appAllTouchPoints.append(QTouchEvent::TouchPoint(d->appAllTouchPoints.count()));
+    QList<QTouchEvent::TouchPoint> points = d->appAllTouchPoints;
+    while (points.count() <= event->PointerNumber())
+        points.append(QTouchEvent::TouchPoint(points.count()));
 
     Qt::TouchPointStates allStates = 0;
-    for (int i = 0; i < d->appAllTouchPoints.count(); ++i) {
-        QTouchEvent::TouchPoint &touchPoint = d->appAllTouchPoints[i];
+    for (int i = 0; i < points.count(); ++i) {
+        QTouchEvent::TouchPoint &touchPoint = points[i];
 
         if (touchPoint.id() == event->PointerNumber()) {
@@ -434 +448 @@
             touchPoint.setState(state);
 
-            QPointF screenPos = QPointF(event->iPosition.iX, event->iPosition.iY);
+            QPointF screenPos = qwidget->mapToGlobal(QPoint(event->iPosition.iX, event->iPosition.iY));
             touchPoint.setScreenPos(screenPos);
             touchPoint.setNormalizedPos(QPointF(screenPos.x() / screenGeometry.width(),
                                                 screenPos.y() / screenGeometry.height()));
 
-            touchPoint.setPressure(event->Pressure() / qreal(d->maxTouchPressure));
+            touchPoint.setPressure(pressure);
         } else if (touchPoint.state() != Qt::TouchPointReleased) {
             // all other active touch points should be marked as stationary
@@ -451 +465 @@
         // all touch points released
         d->appAllTouchPoints.clear();
+    } else {
+        d->appAllTouchPoints = points;
     }
 
     QApplicationPrivate::translateRawTouchEvent(qwidget,
                                                 QTouchEvent::TouchScreen,
-                                                d->appAllTouchPoints);
+                                                points);
 }
 #endif
@@ -533 +549 @@
     sendMouseEvent(receiver, type, globalPos, button, modifiers);
 }
+
+#ifdef Q_WS_S60
+void QSymbianControl::HandleStatusPaneSizeChange()
+{
+    QS60MainAppUi *s60AppUi = static_cast<QS60MainAppUi *>(S60->appUi());
+    s60AppUi->HandleStatusPaneSizeChange();
+}
+#endif
 
 void QSymbianControl::sendMouseEvent(
@@ -598 +622 @@
                 keyEvent.iCode);
         int keyCode;
-        if (s60Keysym >= 0x20 && s60Keysym < ENonCharacterKeyBase) {
+        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;
@@ -626 +652 @@
                 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)
+                    if (keyCode == Qt::Key_Select &&
+                        (S60->virtualMousePressedKeys & QS60Data::Select))
                         fakeEvent.iType = TPointerEvent::EButton1Up;
                     S60->virtualMouseAccel = 1;
@@ -678 +706 @@
                         // 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 != 0) {
-                            S60->virtualMousePressedKeys |= QS60Data::Select;
+                        if (S60->virtualMousePressedKeys & QS60Data::Select) {
                             return EKeyWasConsumed;
                         } else {
@@ -702 +729 @@
                 fakeEvent.iPosition = cpos;
                 fakeEvent.iParentPosition = epos;
-                HandlePointerEvent(fakeEvent);
+                if(fakeEvent.iType != -1)
+                    HandlePointerEvent(fakeEvent);
                 return EKeyWasConsumed;
             }
@@ -907 +935 @@
             if (!slowResize && tlwExtra)
                 tlwExtra->inTopLevelResize = false;
+        } else {
+            QResizeEvent *e = new QResizeEvent(newSize, oldSize);
+            QApplication::postEvent(qwidget, e);
         }
     }
@@ -965 +996 @@
 #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();
+        CEikStatusPane *statusPane = S60->statusPane();
+        CEikButtonGroupContainer *buttonGroup = S60->buttonGroupContainer();
         TBool visible = !(qwidget->windowState() & (Qt::WindowFullScreen | Qt::WindowMinimized));
         if (statusPane)
             statusPane->MakeVisible(visible);
-        if (buttonGroup)
-            buttonGroup->MakeVisible(visible);
+        if (buttonGroup) {
+            // Visibility
+            const TBool isFullscreen = qwidget->windowState() & Qt::WindowFullScreen;
+            const TBool cbaVisibilityHint = qwidget->windowFlags() & Qt::WindowSoftkeysVisibleHint;
+            buttonGroup->MakeVisible(visible || (isFullscreen && cbaVisibilityHint));
+        }
 #endif
     } else if (QApplication::activeWindow() == qwidget->window()) {
-        if (CCoeEnv::Static()->AppUi()->IsDisplayingMenuOrDialog()) {
+        if (CCoeEnv::Static()->AppUi()->IsDisplayingMenuOrDialog() || S60->menuBeingConstructed) {
             QWidget *fw = QApplication::focusWidget();
             if (fw) {
@@ -989 +1024 @@
 }
 
+void QSymbianControl::handleClientAreaChange()
+{
+    const bool cbaVisibilityHint = qwidget->windowFlags() & Qt::WindowSoftkeysVisibleHint;
+    if (qwidget->isFullScreen() && !cbaVisibilityHint) {
+        SetExtentToWholeScreen();
+    } else if (qwidget->isMaximized() || (qwidget->isFullScreen() && cbaVisibilityHint)) {
+        TRect r = static_cast<CEikAppUi*>(S60->appUi())->ClientRect();
+        SetExtent(r.iTl, r.Size());
+    } else if (!qwidget->isMinimized()) { // Normal geometry
+        if (!qwidget->testAttribute(Qt::WA_Resized)) {
+            qwidget->adjustSize();
+            qwidget->setAttribute(Qt::WA_Resized, false); //not a user resize
+        }
+        if (!qwidget->testAttribute(Qt::WA_Moved) && qwidget->windowType() != Qt::Dialog) {
+            TRect r = static_cast<CEikAppUi*>(S60->appUi())->ClientRect();
+            SetPosition(r.iTl);
+            qwidget->setAttribute(Qt::WA_Moved, false); // not really an explicit position
+        }
+    }
+}
+
 void QSymbianControl::HandleResourceChange(int resourceType)
 {
     switch (resourceType) {
     case KInternalStatusPaneChange:
-        if (qwidget->isFullScreen()) {
-            SetExtentToWholeScreen();
-        } else if (qwidget->isMaximized()) {
-            TRect r = static_cast<CEikAppUi*>(S60->appUi())->ClientRect();
-            SetExtent(r.iTl, r.Size());
-        }
+        handleClientAreaChange();
         if (IsFocused() && IsVisible()) {
             qwidget->d_func()->setWindowIcon_sys(true);
@@ -1010 +1061 @@
     case KEikDynamicLayoutVariantSwitch:
     {
-        if (qwidget->isFullScreen()) {
-            SetExtentToWholeScreen();
-        } else if (qwidget->isMaximized()) {
-            TRect r = static_cast<CEikAppUi*>(S60->appUi())->ClientRect();
-            SetExtent(r.iTl, r.Size());
-        }
+        handleClientAreaChange();
         break;
     }
@@ -1146 +1192 @@
 #endif
         S60->wsSession().SetAutoFlush(ETrue);
+
+#ifdef Q_SYMBIAN_WINDOW_SIZE_CACHE
+    TRAP_IGNORE(S60->wsSession().EnableWindowSizeCacheL());
+#endif
 
     S60->updateScreenSize();
@@ -1209 +1259 @@
 
     S60->avkonComponentsSupportTransparency = false;
+    S60->menuBeingConstructed = false;
 
 #ifdef Q_WS_S60
@@ -1224 +1275 @@
         }
     }
-#endif    
+#endif
 
     if (touch) {
@@ -1379 +1430 @@
 void QApplicationPrivate::openPopup(QWidget *popup)
 {
+    if (popup && qobject_cast<QComboBox *>(popup->parentWidget()))
+        static_cast<QSymbianControl *>(popup->effectiveWinId())->FadeBehindPopup(ETrue);
+
     if (!QApplicationPrivate::popupWidgets)
         QApplicationPrivate::popupWidgets = new QWidgetList;
     QApplicationPrivate::popupWidgets->append(popup);
-
 
     // Cancel focus widget pointer capture and long tap timer
@@ -1422 +1475 @@
 void QApplicationPrivate::closePopup(QWidget *popup)
 {
+    if (popup && qobject_cast<QComboBox *>(popup->parentWidget()))
+        static_cast<QSymbianControl *>(popup->effectiveWinId())->FadeBehindPopup(EFalse);
+
     if (!QApplicationPrivate::popupWidgets)
         return;
@@ -1445 +1501 @@
               : q_func()->focusWidget();
           if (fw) {
+              if(fw->window()->isModal()) // restore pointer capture for modal window
+                  fw->effectiveWinId()->SetPointerCapture(true);
+
               if (fw != q_func()->focusWidget()) {
                   fw->setFocus(Qt::PopupFocusReason);
@@ -1870 +1929 @@
 {
 #ifdef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER
+    if (HAL::Get(HALData::EPointer3DPressureSupported, pressureSupported) != KErrNone)
+        pressureSupported = 0;
     if (HAL::Get(HALData::EPointer3DMaxPressure, maxTouchPressure) != KErrNone)
         maxTouchPressure = KMaxTInt;

trunk/src/gui/kernel/qapplication_win.cpp

@@ -116 +116 @@
 #endif
 
+#include "private/qwinnativepangesturerecognizer_win_p.h"
+
 #ifndef WM_TOUCH
 #  define WM_TOUCH 0x0240
@@ -929 +931 @@
     bool icon;
     QString cname;
-    if (flags & Qt::MSWindowsOwnDC) {
+    if (qt_widget_private(w)->isGLWidget) {
+        cname = QLatin1String("QGLWidget");
+        style = CS_DBLCLKS;
+        icon  = true;
+    } else if (flags & Qt::MSWindowsOwnDC) {
         cname = QLatin1String("QWidgetOwnDC");
         style = CS_DBLCLKS;
@@ -1022 +1028 @@
     wc.hCursor      = 0;
 #ifndef Q_WS_WINCE
-    wc.hbrBackground = (HBRUSH)GetSysColorBrush(COLOR_WINDOW);
+    wc.hbrBackground = qt_widget_private(w)->isGLWidget ? 0 : (HBRUSH)GetSysColorBrush(COLOR_WINDOW);
 #else
     wc.hbrBackground = 0;
@@ -1902 +1908 @@
 
             if (!msg.wParam) {
+#ifdef Q_WS_WINCE
+                // On Windows CE, lParam parameter is a constant, not a char pointer.
+                if (msg.lParam == INI_INTL) {
+#else
                 QString area = QString::fromWCharArray((wchar_t*)msg.lParam);
                 if (area == QLatin1String("intl")) {
+#endif
                     QLocalePrivate::updateSystemPrivate();
                     if (!widget->testAttribute(Qt::WA_SetLocale))
@@ -2437 +2448 @@
             else
 #ifndef QT_NO_MENUBAR
-                QMenuBar::wceCommands(LOWORD(wParam), (HWND) lParam);
+                QMenuBar::wceCommands(LOWORD(wParam));
 #endif
             result = true;
@@ -2516 +2527 @@
             result = false;
             break;
+#if !defined(Q_WS_WINCE) || defined(QT_WINCE_GESTURES)
         case WM_GESTURE: {
             GESTUREINFO gi;
@@ -2548 +2560 @@
             break;
         }
+#endif // !defined(Q_WS_WINCE) || defined(QT_WINCE_GESTURES)
         default:
             result = false;                        // event was not processed
@@ -3617 +3630 @@
 
     setAttribute(Qt::WA_PendingUpdate, false);
-    const QRegion dirtyInBackingStore(qt_dirtyRegion(this));
-    // Make sure the invalidated region contains the region we're about to repaint.
-    // BeginPaint will set the clip to the invalidated region and it is impossible
-    // to enlarge it afterwards (only shrink it). Using GetDCEx is not suffient
-    // as it may return an invalid context (especially on Windows Vista).
-    if (!dirtyInBackingStore.isEmpty())
-        InvalidateRgn(internalWinId(), dirtyInBackingStore.handle(), false);
+
+    if (d_func()->isGLWidget) {
+        if (d_func()->usesDoubleBufferedGLContext)
+            InvalidateRect(internalWinId(), 0, false);
+    } else {
+        const QRegion dirtyInBackingStore(qt_dirtyRegion(this));
+        // Make sure the invalidated region contains the region we're about to repaint.
+        // BeginPaint will set the clip to the invalidated region and it is impossible
+        // to enlarge it afterwards (only shrink it). Using GetDCEx is not suffient
+        // as it may return an invalid context (especially on Windows Vista).
+        if (!dirtyInBackingStore.isEmpty())
+            InvalidateRgn(internalWinId(), dirtyInBackingStore.handle(), false);
+    }
     PAINTSTRUCT ps;
     d_func()->hd = BeginPaint(internalWinId(), &ps);
@@ -3984 +4003 @@
 
 
+bool QApplicationPrivate::HasTouchSupport = false;
 PtrRegisterTouchWindow QApplicationPrivate::RegisterTouchWindow = 0;
 PtrGetTouchInputInfo QApplicationPrivate::GetTouchInputInfo = 0;
@@ -3990 +4010 @@
 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"));
     // MinGW (g++ 3.4.5) accepts only C casts.

trunk/src/gui/kernel/qapplication_x11.cpp

@@ -97 +97 @@
 #endif
 
+#ifndef QT_GUI_DOUBLE_CLICK_RADIUS
+#define QT_GUI_DOUBLE_CLICK_RADIUS 5
+#endif
+
+
 //#define ALIEN_DEBUG
 
@@ -316 +321 @@
     "_XEMBED_INFO\0"
 
+    // Wacom old. (before version 0.10)
     "Wacom Stylus\0"
     "Wacom Cursor\0"
     "Wacom Eraser\0"
+
+    // Tablet
+    "STYLUS\0"
+    "ERASER\0"
 };
 
@@ -945 +955 @@
     QApplication::setCursorFlashTime(num);
 
+#ifndef QT_NO_WHEELEVENT
     num =
         settings.value(QLatin1String("wheelScrollLines"),
                        QApplication::wheelScrollLines()).toInt();
     QApplication::setWheelScrollLines(num);
+#endif
 
     QString colorspec = settings.value(QLatin1String("colorSpec"),
@@ -2360 +2372 @@
                 }
 #else
-                if (devs->type == ATOM(XWacomStylus)) {
+                if (devs->type == ATOM(XWacomStylus) || devs->type == ATOM(XTabletStylus)) {
                     deviceType = QTabletEvent::Stylus;
                     if (wacomDeviceName()->isEmpty())
                         wacomDeviceName()->append(devs->name);
                     gotStylus = true;
-                } else if (devs->type == ATOM(XWacomEraser)) {
+                } else if (devs->type == ATOM(XWacomEraser) || devs->type == ATOM(XTabletEraser)) {
                     deviceType = QTabletEvent::XFreeEraser;
                     gotEraser = true;
@@ -4214 +4226 @@
                 (long)event->xbutton.time -(long)mouseButtonPressTime
                 < QApplication::doubleClickInterval() &&
-                qAbs(event->xbutton.x - mouseXPos) < 5 &&
-                qAbs(event->xbutton.y - mouseYPos) < 5) {
+                qAbs(event->xbutton.x - mouseXPos) < QT_GUI_DOUBLE_CLICK_RADIUS &&
+                qAbs(event->xbutton.y - mouseYPos) < QT_GUI_DOUBLE_CLICK_RADIUS) {
                 type = QEvent::MouseButtonDblClick;
                 mouseButtonPressTime -= 2000;        // no double-click next time
@@ -4402 +4414 @@
         if (popup && window() != popup)
             popup->close();
+#ifndef QT_NO_WHEELEVENT
         QWheelEvent e(pos, globalPos, delta, buttons, modifiers, orient);
         if (QApplication::sendSpontaneousEvent(widget, &e))
+#endif
             return true;
     }
@@ -4414 +4428 @@
         if (popup && widget != popup)
             popup->hide();
+#ifndef QT_NO_WHEELEVENT
         QWheelEvent e(pos, globalPos, delta, buttons, modifiers, orient);
         if (QApplication::sendSpontaneousEvent(widget, &e))
+#endif
             return true;
     }
@@ -5314 +5330 @@
 }
 
+#ifndef QT_NO_WHEELEVENT
 void QApplication::setWheelScrollLines(int n)
 {
@@ -5323 +5340 @@
     return QApplicationPrivate::wheel_scroll_lines;
 }
+#endif
 
 void QApplication::setEffectEnabled(Qt::UIEffect effect, bool enable)

trunk/src/gui/kernel/qclipboard_mac.cpp

@@ -389 +389 @@
         QStringList formats = mime_src->formats();
 
+#ifdef QT_MAC_USE_COCOA
+        // QMimeData sub classes reimplementing the formats() might not expose the
+        // temporary "application/x-qt-mime-type-name" mimetype. So check the existence
+        // of this mime type while doing drag and drop.
+        QString dummyMimeType(QLatin1String("application/x-qt-mime-type-name"));
+        if (!formats.contains(dummyMimeType)) {
+            QByteArray dummyType = mime_src->data(dummyMimeType);
+            if (!dummyType.isEmpty()) {
+                formats.append(dummyMimeType);
+            }
+        }
+#endif
         for(int f = 0; f < formats.size(); ++f) {
             QString mimeType = formats.at(f);

trunk/src/gui/kernel/qclipboard_s60.cpp

@@ -165 +165 @@
         aStream >> mimeTypeSize;
         HBufC* mimeTypeBuf = HBufC::NewLC(aStream,mimeTypeSize);
-        QString mimeType = QString::fromUtf16(mimeTypeBuf->Des().Ptr(),mimeTypeBuf->Length());
+        QString mimeType = QString(reinterpret_cast<const QChar *>(mimeTypeBuf->Des().Ptr()),
+                                   mimeTypeBuf->Length());
         CleanupStack::PopAndDestroy(mimeTypeBuf);
         // mime data

trunk/src/gui/kernel/qcocoamenuloader_mac.mm

@@ -111 +111 @@
 }
 
+- (void)removeActionsFromAppMenu
+{
+    for (NSMenuItem *item in [appMenu itemArray])
+        [item setTag:nil];
+}
+
 - (void)dealloc
 {

trunk/src/gui/kernel/qcocoamenuloader_mac_p.h

@@ -71 +71 @@
 }
 - (void)ensureAppMenuInMenu:(NSMenu *)menu;
+- (void)removeActionsFromAppMenu;
 - (NSMenu *)applicationMenu;
 - (NSMenu *)menu;

trunk/src/gui/kernel/qcocoapanel_mac.mm

@@ -47 +47 @@
 #import <private/qcocoaview_mac_p.h>
 #import <private/qcocoawindowcustomthemeframe_mac_p.h>
+#include <private/qapplication_p.h>
+#include <private/qbackingstore_p.h>
+
 
 #include <QtGui/QWidget>

trunk/src/gui/kernel/qcocoasharedwindowmethods_mac_p.h

@@ -51 +51 @@
  NSPanel, while QCocoaWindow needs to inherit NSWindow rather than NSPanel).
 ****************************************************************************/
+
+// WARNING: Don't include any header files from within this file. Put them
+// directly into qcocoawindow_mac_p.h and qcocoapanel_mac_p.h
 
 QT_BEGIN_NAMESPACE
@@ -186 +189 @@
 }
 
+- (void)displayIfNeeded
+{
+
+    QWidget *qwidget = [[QT_MANGLE_NAMESPACE(QCocoaWindowDelegate) sharedDelegate] qt_qwidgetForWindow:self];
+    if (qwidget == 0) {
+        [super displayIfNeeded];
+        return;
+    }
+
+    if (QApplicationPrivate::graphicsSystem() != 0) {
+        if (QWidgetBackingStore *bs = qt_widget_private(qwidget)->maybeBackingStore())
+            bs->sync(qwidget, qwidget->rect());
+    }
+    [super displayIfNeeded];
+}
+
+

trunk/src/gui/kernel/qcocoaview_mac.mm

@@ -521 +521 @@
 {
     if (QApplicationPrivate::graphicsSystem() != 0) {
-        if (QWidgetBackingStore *bs = qwidgetprivate->maybeBackingStore())
-            bs->markDirty(qwidget->rect(), qwidget);
-        qwidgetprivate->syncBackingStore(qwidget->rect());
-        return;
+        if (QWidgetBackingStore *bs = qwidgetprivate->maybeBackingStore()) {
+            // Drawing is handled on the window level
+            // See qcocoasharedwindowmethods_mac_p.
+            return;
+        }
     }
     CGContextRef cg = (CGContextRef)[[NSGraphicsContext currentContext] graphicsPort];
@@ -645 +646 @@
 - (void)mouseEntered:(NSEvent *)event
 {
+    if (qwidgetprivate->data.in_destructor)
+        return;
     QEvent enterEvent(QEvent::Enter);
     NSPoint windowPoint = [event locationInWindow];
@@ -826 +829 @@
     }
 
+#ifndef QT_NO_WHEELEVENT
     if (deltaX != 0) {
         QWheelEvent qwe(qlocal, qglobal, deltaX, buttons, keyMods, Qt::Horizontal);
@@ -866 +870 @@
         }
     }
+#endif //QT_NO_WHEELEVENT
+
     if (!wheelOK) {
         return [super scrollWheel:theEvent];
@@ -1402 +1408 @@
     // setup the data
     QMacPasteboard dragBoard((CFStringRef) NSDragPboard, QMacPasteboardMime::MIME_DND);
-    dragPrivate()->data->setData(QLatin1String("application/x-qt-mime-type-name"), QByteArray());
+    dragPrivate()->data->setData(QLatin1String("application/x-qt-mime-type-name"), QByteArray("dummy"));
     dragBoard.setMimeData(dragPrivate()->data);
 

trunk/src/gui/kernel/qcocoawindow_mac_p.h

@@ -54 +54 @@
 #include "qmacdefines_mac.h"
 #import <Cocoa/Cocoa.h>
+#include <private/qapplication_p.h>
+#include <private/qbackingstore_p.h>
+
 
 enum { QtMacCustomizeWindow = 1 << 21 }; // This will one day be run over by

trunk/src/gui/kernel/qcursor.cpp

@@ -343 +343 @@
     \o B=0 and M=1 gives white.
     \o B=0 and M=0 gives transparent.
-    \o B=1 and M=0 gives an XOR'd result.
+    \o B=1 and M=0 gives an XOR'd result under Windows, undefined
+    results on all other platforms.
     \endlist
 

trunk/src/gui/kernel/qdesktopwidget_s60.cpp

@@ -89 +89 @@
 void QDesktopWidgetPrivate::init(QDesktopWidget *that)
 {
-    int screenCount=0;
+    Q_UNUSED(that);
+//    int screenCount=0;
 
-    if (HAL::Get(0, HALData::EDisplayNumberOfScreens, screenCount) == KErrNone)
-        QDesktopWidgetPrivate::screenCount = screenCount;
-    else
-        QDesktopWidgetPrivate::screenCount = 0;
+    // ### TODO: Implement proper multi-display support
+        QDesktopWidgetPrivate::screenCount = 1;
+//    if (HAL::Get(0, HALData::EDisplayNumberOfScreens, screenCount) == KErrNone)
+//        QDesktopWidgetPrivate::screenCount = screenCount;
+//    else
+//        QDesktopWidgetPrivate::screenCount = 0;
 
     rects = new QVector<QRect>();
@@ -101 +104 @@
     rects->resize(QDesktopWidgetPrivate::screenCount);
     workrects->resize(QDesktopWidgetPrivate::screenCount);
-
-    // ### TODO: Implement proper multi-display support
-    rects->resize(1);
-    rects->replace(0, that->rect());
-    workrects->resize(1);
-    workrects->replace(0, that->rect());
 }
 

trunk/src/gui/kernel/qdnd_s60.cpp

@@ -53 +53 @@
 #include "qt_s60_p.h"
 
-#include <COECNTRL.H>
+#include <coecntrl.h>
 // pointer cursor
 #include <w32std.h>

trunk/src/gui/kernel/qdnd_x11.cpp

@@ -618 +618 @@
             // to verify that it is utf16
             if (data.size() > 1 && data.at(1) == 0)
-                return QString::fromUtf16(reinterpret_cast<const ushort *>(data.constData()),
+                return QString::fromRawData((const QChar *)data.constData(),
                                 data.size() / 2).split(QLatin1Char('\n')).first().toLatin1();
         }

trunk/src/gui/kernel/qeventdispatcher_mac.mm

@@ -493 +493 @@
         case NSOtherMouseUp:     
         case NSOtherMouseDragged:
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+        case NSEventTypeGesture: // touch events
+        case NSEventTypeMagnify:
+        case NSEventTypeSwipe:
+        case NSEventTypeRotate:
+        case NSEventTypeBeginGesture:
+        case NSEventTypeEndGesture:
+#endif
             result    = true;
         break;

trunk/src/gui/kernel/qgesturemanager.cpp

@@ -46 +46 @@
 #include "private/qgraphicsitem_p.h"
 #include "private/qevent_p.h"
+#include "private/qapplication_p.h"
 #include "qgesture.h"
 #include "qevent.h"
@@ -87 +88 @@
 #if defined(Q_OS_WIN)
   #if !defined(QT_NO_NATIVE_GESTURES)
-    registerGestureRecognizer(new QWinNativePanGestureRecognizer);
+    if (QApplicationPrivate::HasTouchSupport)
+        registerGestureRecognizer(new QWinNativePanGestureRecognizer);
   #endif
 #else

trunk/src/gui/kernel/qgridlayout.cpp

@@ -1853 +1853 @@
     \fn int QGridLayout::colSpacing(int col) const
 
-    Use columnSpacing() instead.
+    Use columnMinimumWidth() instead.
 */
 

trunk/src/gui/kernel/qguifunctions_wince.cpp

@@ -279 +279 @@
 bool qt_wince_is_windows_mobile_65()
 {
-    return ((qt_wince_get_version() == 52) && (qt_wince_get_build() > 2000));
+    const DWORD dwFirstWM65BuildNumber = 21139;
+    OSVERSIONINFO osvi;
+    osvi.dwOSVersionInfoSize = sizeof(osvi);
+    if (!GetVersionEx(&osvi))
+        return false;
+    return osvi.dwMajorVersion > 5
+        || (osvi.dwMajorVersion == 5 && (osvi.dwMinorVersion > 2 ||
+            (osvi.dwMinorVersion == 2 && osvi.dwBuildNumber >= dwFirstWM65BuildNumber)));
 }
 

trunk/src/gui/kernel/qkeymapper_p.h

@@ -217 +217 @@
 #elif defined(Q_WS_QWS)
 #elif defined(Q_OS_SYMBIAN)
-private:
-    QHash<TUint, int> s60ToQtKeyMap;
-    void fillKeyMap();
 public:
     QString translateKeyEvent(int keySym, Qt::KeyboardModifiers modifiers);
     int mapS60KeyToQt(TUint s60key);
+    int mapS60ScanCodesToQt(TUint s60key);
+    int mapQtToS60Key(int qtKey);
+    int mapQtToS60ScanCodes(int qtKey);
 #endif
 };

trunk/src/gui/kernel/qkeymapper_s60.cpp

@@ -47 +47 @@
 QKeyMapperPrivate::QKeyMapperPrivate()
 {
-    fillKeyMap();
 }
 
@@ -75 +74 @@
 }
 
-void QKeyMapperPrivate::fillKeyMap()
-{
-    using namespace Qt;
-    static const struct {
-        TUint s60Key;
-        int qtKey;
-    } map[] = {
-        {EKeyBell, Key_unknown},
-        {EKeyBackspace, Key_Backspace},
-        {EKeyTab, Key_Tab},
-        {EKeyLineFeed, Key_unknown},
-        {EKeyVerticalTab, Key_unknown},
-        {EKeyFormFeed, Key_unknown},
-        {EKeyEnter, Key_Enter},
-        {EKeyEscape, Key_Escape},
-        {EKeySpace, Key_Space},
-        {EKeyDelete, Key_Delete},
-        {EKeyPrintScreen, Key_SysReq},
-        {EKeyPause, Key_Pause},
-        {EKeyHome, Key_Home},
-        {EKeyEnd, Key_End},
-        {EKeyPageUp, Key_PageUp},
-        {EKeyPageDown, Key_PageDown},
-        {EKeyInsert, Key_Insert},
-        {EKeyLeftArrow, Key_Left},
-        {EKeyRightArrow, Key_Right},
-        {EKeyUpArrow, Key_Up},
-        {EKeyDownArrow, Key_Down},
-        {EKeyLeftShift, Key_Shift},
-        {EKeyRightShift, Key_Shift},
-        {EKeyLeftAlt, Key_Alt},
-        {EKeyRightAlt, Key_AltGr},
-        {EKeyLeftCtrl, Key_Control},
-        {EKeyRightCtrl, Key_Control},
-        {EKeyLeftFunc, Key_Super_L},
-        {EKeyRightFunc, Key_Super_R},
-        {EKeyCapsLock, Key_CapsLock},
-        {EKeyNumLock, Key_NumLock},
-        {EKeyScrollLock, Key_ScrollLock},
-        {EKeyF1, Key_F1},
-        {EKeyF2, Key_F2},
-        {EKeyF3, Key_F3},
-        {EKeyF4, Key_F4},
-        {EKeyF5, Key_F5},
-        {EKeyF6, Key_F6},
-        {EKeyF7, Key_F7},
-        {EKeyF8, Key_F8},
-        {EKeyF9, Key_F9},
-        {EKeyF10, Key_F10},
-        {EKeyF11, Key_F11},
-        {EKeyF12, Key_F12},
-        {EKeyF13, Key_F13},
-        {EKeyF14, Key_F14},
-        {EKeyF15, Key_F15},
-        {EKeyF16, Key_F16},
-        {EKeyF17, Key_F17},
-        {EKeyF18, Key_F18},
-        {EKeyF19, Key_F19},
-        {EKeyF20, Key_F20},
-        {EKeyF21, Key_F21},
-        {EKeyF22, Key_F22},
-        {EKeyF23, Key_F23},
-        {EKeyF24, Key_F24},
-        {EKeyOff, Key_unknown},
-        {EKeyIncContrast, Key_unknown},
-        {EKeyDecContrast, Key_unknown},
-        {EKeyBacklightOn, Key_unknown},
-        {EKeyBacklightOff, Key_unknown},
-        {EKeyBacklightToggle, Key_unknown},
-        {EKeySliderDown, Key_unknown},
-        {EKeySliderUp, Key_unknown},
-        {EKeyMenu, Key_Menu},
-        {EKeyDictaphonePlay, Key_unknown},
-        {EKeyDictaphoneStop, Key_unknown},
-        {EKeyDictaphoneRecord, Key_unknown},
-        {EKeyHelp, Key_unknown},
-        {EKeyDial, Key_Call},
-        {EKeyScreenDimension0, Key_unknown},
-        {EKeyScreenDimension1, Key_unknown},
-        {EKeyScreenDimension2, Key_unknown},
-        {EKeyScreenDimension3, Key_unknown},
-        {EKeyIncVolume, Key_unknown},
-        {EKeyDecVolume, Key_unknown},
-        {EKeyDevice0, Key_Context1}, // Found by manual testing, left softkey.
-        {EKeyDevice1, Key_Context2}, // Found by manual testing.
-        {EKeyDevice2, Key_unknown},
-        {EKeyDevice3, Key_Select}, // Found by manual testing.
-        {EKeyDevice4, Key_unknown},
-        {EKeyDevice5, Key_unknown},
-        {EKeyDevice6, Key_unknown},
-        {EKeyDevice7, Key_unknown},
-        {EKeyDevice8, Key_unknown},
-        {EKeyDevice9, Key_unknown},
-        {EKeyDeviceA, Key_unknown},
-        {EKeyDeviceB, Key_unknown},
-        {EKeyDeviceC, Key_unknown},
-        {EKeyDeviceD, Key_unknown},
-        {EKeyDeviceE, Key_unknown},
-        {EKeyDeviceF, Key_unknown},
-        {EKeyApplication0, Key_Launch0},
-        {EKeyApplication1, Key_Launch1},
-        {EKeyApplication2, Key_Launch2},
-        {EKeyApplication3, Key_Launch3},
-        {EKeyApplication4, Key_Launch4},
-        {EKeyApplication5, Key_Launch5},
-        {EKeyApplication6, Key_Launch6},
-        {EKeyApplication7, Key_Launch7},
-        {EKeyApplication8, Key_Launch8},
-        {EKeyApplication9, Key_Launch9},
-        {EKeyApplicationA, Key_LaunchA},
-        {EKeyApplicationB, Key_LaunchB},
-        {EKeyApplicationC, Key_LaunchC},
-        {EKeyApplicationD, Key_LaunchD},
-        {EKeyApplicationE, Key_LaunchE},
-        {EKeyApplicationF, Key_LaunchF},
-        {EKeyYes, Key_Yes},
-        {EKeyNo, Key_No},
-        {EKeyIncBrightness, Key_unknown},
-        {EKeyDecBrightness, Key_unknown},
-        {EKeyKeyboardExtend, Key_unknown},
-        {EKeyDevice10, Key_unknown},
-        {EKeyDevice11, Key_unknown},
-        {EKeyDevice12, Key_unknown},
-        {EKeyDevice13, Key_unknown},
-        {EKeyDevice14, Key_unknown},
-        {EKeyDevice15, Key_unknown},
-        {EKeyDevice16, Key_unknown},
-        {EKeyDevice17, Key_unknown},
-        {EKeyDevice18, Key_unknown},
-        {EKeyDevice19, Key_unknown},
-        {EKeyDevice1A, Key_unknown},
-        {EKeyDevice1B, Key_unknown},
-        {EKeyDevice1C, Key_unknown},
-        {EKeyDevice1D, Key_unknown},
-        {EKeyDevice1E, Key_unknown},
-        {EKeyDevice1F, Key_unknown},
-        {EKeyApplication10, Key_unknown},
-        {EKeyApplication11, Key_unknown},
-        {EKeyApplication12, Key_unknown},
-        {EKeyApplication13, Key_unknown},
-        {EKeyApplication14, Key_unknown},
-        {EKeyApplication15, Key_unknown},
-        {EKeyApplication16, Key_unknown},
-        {EKeyApplication17, Key_unknown},
-        {EKeyApplication18, Key_unknown},
-        {EKeyApplication19, Key_unknown},
-        {EKeyApplication1A, Key_unknown},
-        {EKeyApplication1B, Key_unknown},
-        {EKeyApplication1C, Key_unknown},
-        {EKeyApplication1D, Key_unknown},
-        {EKeyApplication1E, Key_unknown},
-        {EKeyApplication1F, Key_unknown}
-    };
-    const int mapSize = int(sizeof(map)/sizeof(map[0]));
-    s60ToQtKeyMap.reserve(mapSize + 5); // +5? docs: Ideally, slightly more than number of items
-    for (int i = 0; i < mapSize; ++i)
-        s60ToQtKeyMap.insert(map[i].s60Key, map[i].qtKey);
-}
+#include <e32keys.h>
+struct KeyMapping{
+    TKeyCode s60KeyCode;
+    TStdScanCode s60ScanCode;
+    Qt::Key qtKey;
+};
+
+using namespace Qt;
+
+static const KeyMapping keyMapping[] = {
+    {EKeyBackspace, EStdKeyBackspace, Key_Backspace},
+    {EKeyTab, EStdKeyTab, Key_Tab},
+    {EKeyEnter, EStdKeyEnter, Key_Enter},
+    {EKeyEscape, EStdKeyEscape, Key_Escape},
+    {EKeySpace, EStdKeySpace, Key_Space},
+    {EKeyDelete, EStdKeyDelete, Key_Delete},
+    {EKeyPrintScreen, EStdKeyPrintScreen, Key_SysReq},
+    {EKeyPause, EStdKeyPause, Key_Pause},
+    {EKeyHome, EStdKeyHome, Key_Home},
+    {EKeyEnd, EStdKeyEnd, Key_End},
+    {EKeyPageUp, EStdKeyPageUp, Key_PageUp},
+    {EKeyPageDown, EStdKeyPageDown, Key_PageDown},
+    {EKeyInsert, EStdKeyInsert, Key_Insert},
+    {EKeyLeftArrow, EStdKeyLeftArrow, Key_Left},
+    {EKeyRightArrow, EStdKeyRightArrow, Key_Right},
+    {EKeyUpArrow, EStdKeyUpArrow, Key_Up},
+    {EKeyDownArrow, EStdKeyDownArrow, Key_Down},
+    {EKeyLeftShift, EStdKeyLeftShift, Key_Shift},
+    {EKeyRightShift, EStdKeyRightShift, Key_Shift},
+    {EKeyLeftAlt, EStdKeyLeftAlt, Key_Alt},
+    {EKeyRightAlt, EStdKeyRightAlt, Key_AltGr},
+    {EKeyLeftCtrl, EStdKeyLeftCtrl, Key_Control},
+    {EKeyRightCtrl, EStdKeyRightCtrl, Key_Control},
+    {EKeyLeftFunc, EStdKeyLeftFunc, Key_Super_L},
+    {EKeyRightFunc, EStdKeyRightFunc, Key_Super_R},
+    {EKeyCapsLock, EStdKeyCapsLock, Key_CapsLock},
+    {EKeyNumLock, EStdKeyNumLock, Key_NumLock},
+    {EKeyScrollLock, EStdKeyScrollLock, Key_ScrollLock},
+    {EKeyF1, EStdKeyF1, Key_F1},
+    {EKeyF2, EStdKeyF2, Key_F2},
+    {EKeyF3, EStdKeyF3, Key_F3},
+    {EKeyF4, EStdKeyF4, Key_F4},
+    {EKeyF5, EStdKeyF5, Key_F5},
+    {EKeyF6, EStdKeyF6, Key_F6},
+    {EKeyF7, EStdKeyF7, Key_F7},
+    {EKeyF8, EStdKeyF8, Key_F8},
+    {EKeyF9, EStdKeyF9, Key_F9},
+    {EKeyF10, EStdKeyF10, Key_F10},
+    {EKeyF11, EStdKeyF11, Key_F11},
+    {EKeyF12, EStdKeyF12, Key_F12},
+    {EKeyF13, EStdKeyF13, Key_F13},
+    {EKeyF14, EStdKeyF14, Key_F14},
+    {EKeyF15, EStdKeyF15, Key_F15},
+    {EKeyF16, EStdKeyF16, Key_F16},
+    {EKeyF17, EStdKeyF17, Key_F17},
+    {EKeyF18, EStdKeyF18, Key_F18},
+    {EKeyF19, EStdKeyF19, Key_F19},
+    {EKeyF20, EStdKeyF20, Key_F20},
+    {EKeyF21, EStdKeyF21, Key_F21},
+    {EKeyF22, EStdKeyF22, Key_F22},
+    {EKeyF23, EStdKeyF23, Key_F23},
+    {EKeyF24, EStdKeyF24, Key_F24},
+    {EKeyOff, EStdKeyOff, Key_PowerOff},
+//    {EKeyMenu, EStdKeyMenu, Key_Menu}, // Menu is EKeyApplication0
+    {EKeyHelp, EStdKeyHelp, Key_Help},
+    {EKeyDial, EStdKeyDial, Key_Call},
+    {EKeyIncVolume, EStdKeyIncVolume, Key_VolumeUp},
+    {EKeyDecVolume, EStdKeyDecVolume, Key_VolumeDown},
+    {EKeyDevice0, EStdKeyDevice0, Key_Context1}, // Found by manual testing.
+    {EKeyDevice1, EStdKeyDevice1, Key_Context2}, // Found by manual testing.
+    {EKeyDevice3, EStdKeyDevice3, Key_Select},
+//    {EKeyDevice7, EStdKeyDevice7, Key_Camera},  //not supported by qt yet
+    {EKeyApplication0, EStdKeyApplication0, Key_Menu}, // Found by manual testing.
+    {EKeyApplication1, EStdKeyApplication1, Key_Launch1}, // Found by manual testing.
+    {EKeyApplication2, EStdKeyApplication2, Key_MediaPlay}, // Found by manual testing.
+    {EKeyApplication3, EStdKeyApplication3, Key_MediaStop}, // Found by manual testing.
+    {EKeyApplication4, EStdKeyApplication4, Key_MediaNext}, // Found by manual testing.
+    {EKeyApplication5, EStdKeyApplication5, Key_MediaPrevious}, // Found by manual testing.
+    {EKeyApplication6, EStdKeyApplication6, Key_Launch6},
+    {EKeyApplication7, EStdKeyApplication7, Key_Launch7},
+    {EKeyApplication8, EStdKeyApplication8, Key_Launch8},
+    {EKeyApplication9, EStdKeyApplication9, Key_Launch9},
+    {EKeyApplicationA, EStdKeyApplicationA, Key_LaunchA},
+    {EKeyApplicationB, EStdKeyApplicationB, Key_LaunchB},
+    {EKeyApplicationC, EStdKeyApplicationC, Key_LaunchC},
+    {EKeyApplicationD, EStdKeyApplicationD, Key_LaunchD},
+    {EKeyApplicationE, EStdKeyApplicationE, Key_LaunchE},
+    {EKeyApplicationF, EStdKeyApplicationF, Key_LaunchF},
+//    {EKeyApplication19, EStdKeyApplication19, Key_CameraFocus},  //not supported by qt yet
+    {EKeyYes, EStdKeyYes, Key_Yes},
+    {EKeyNo, EStdKeyNo, Key_No},
+    {TKeyCode(0), TStdScanCode(0), Qt::Key(0)}
+};
 
 int QKeyMapperPrivate::mapS60KeyToQt(TUint s60key)
 {
-    QHash<TUint, int>::const_iterator mapping;
-    mapping = s60ToQtKeyMap.find(s60key);
-    if (mapping != s60ToQtKeyMap.end()) {
-        return *mapping;
-    } else {
-        return Qt::Key_unknown;
-    }
-}
-
+    int res = Qt::Key_unknown;
+    for (int i = 0; keyMapping[i].s60KeyCode != 0; i++) {
+        if (keyMapping[i].s60KeyCode == s60key) {
+            res = keyMapping[i].qtKey;
+            break;
+        }
+    }
+    return res;
+}
+
+int QKeyMapperPrivate::mapS60ScanCodesToQt(TUint s60scanCode)
+{
+    int res = Qt::Key_unknown;
+    for (int i = 0; keyMapping[i].s60KeyCode != 0; i++) {
+        if (keyMapping[i].s60ScanCode == s60scanCode) {
+            res = keyMapping[i].qtKey;
+            break;
+        }
+    }
+    return res;
+}
+
+int QKeyMapperPrivate::mapQtToS60Key(int qtKey)
+{
+    int res = KErrUnknown;
+    for (int i = 0; keyMapping[i].s60KeyCode != 0; i++) {
+        if (keyMapping[i].qtKey == qtKey) {
+            res = keyMapping[i].s60KeyCode;
+            break;
+        }
+    }
+    return res;
+}
+
+int QKeyMapperPrivate::mapQtToS60ScanCodes(int qtKey)
+{
+    int res = KErrUnknown;
+    for (int i = 0; keyMapping[i].s60KeyCode != 0; i++) {
+        if (keyMapping[i].qtKey == qtKey) {
+            res = keyMapping[i].s60ScanCode;
+            break;
+        }
+    }
+    return res;
+}
 QT_END_NAMESPACE

trunk/src/gui/kernel/qkeymapper_x11.cpp

@@ -361 +361 @@
         if (code && code < 0xfffe)
             code = QChar(code).toUpper().unicode();
+
+        if (code == Qt::Key_Tab && (baseModifiers & Qt::ShiftModifier)) {
+            // map shift+tab to shift+backtab
+            code = Qt::Key_Backtab;
+            text = QString();
+        }
+
         if (code == baseCode)
             continue;
@@ -449 +456 @@
         if (code && code < 0xfffe)
             code = QChar(code).toUpper().unicode();
+
+        if (code == Qt::Key_Tab && (baseModifiers & Qt::ShiftModifier)) {
+            // map shift+tab to shift+backtab
+            code = Qt::Key_Backtab;
+            text = QString();
+        }
+
         if (code == baseCode)
             continue;
@@ -1060 +1074 @@
     XF86XK_AudioRecord,         Qt::Key_MediaRecord,
     XF86XK_Mail,                Qt::Key_LaunchMail,
-    XF86XK_MyComputer,          Qt::Key_Launch0,
-    XF86XK_Calculator,          Qt::Key_Calculator,
+    XF86XK_MyComputer,          Qt::Key_Launch0,  // ### Qt 5: remap properly
+    XF86XK_Calculator,          Qt::Key_Launch1,
     XF86XK_Memo,                Qt::Key_Memo,
     XF86XK_ToDoList,            Qt::Key_ToDoList,
@@ -1159 +1173 @@
     XF86XK_Suspend,             Qt::Key_Suspend,
     XF86XK_Hibernate,           Qt::Key_Hibernate,
-    XF86XK_Launch0,             Qt::Key_Launch2,
+    XF86XK_Launch0,             Qt::Key_Launch2, // ### Qt 5: remap properly
     XF86XK_Launch1,             Qt::Key_Launch3,
     XF86XK_Launch2,             Qt::Key_Launch4,

trunk/src/gui/kernel/qmime_mac.cpp

@@ -432 +432 @@
         ret = QString(str);
     } else if (flavor == QLatin1String("public.utf16-plain-text")) {
-        ret = QString::fromUtf16(reinterpret_cast<const ushort *>(firstData.constData()),
-                                 firstData.size() / sizeof(ushort));
+        ret = QString(reinterpret_cast<const QChar *>(firstData.constData()),
+                      firstData.size() / sizeof(QChar));
     } else {
         qWarning("QMime::convertToMime: unhandled mimetype: %s", qPrintable(mimetype));

trunk/src/gui/kernel/qmime_win.cpp

@@ -641 +641 @@
             QList<QUrl> urls = mimeData->urls();
             QByteArray result;
-            QString url = urls.at(0).toString();
-            result = QByteArray((const char *)url.utf16(), url.length() * sizeof(ushort));
+            if (!urls.isEmpty()) {
+                QString url = urls.at(0).toString();
+                result = QByteArray((const char *)url.utf16(), url.length() * sizeof(ushort));
+            }
             result.append('\0');
             result.append('\0');
@@ -648 +650 @@
         } else if (getCf(formatetc) == CF_INETURL) {
             QList<QUrl> urls = mimeData->urls();
-            QByteArray result = urls.at(0).toString().toLocal8Bit();
+            QByteArray result;
+            if (!urls.isEmpty())
+                result = urls.at(0).toString().toLocal8Bit();
             return setData(result, pmedium);
         }

trunk/src/gui/kernel/qsoftkeymanager.cpp

@@ -56 +56 @@
 QSoftKeyManager *QSoftKeyManagerPrivate::self = 0;
 
-const char *QSoftKeyManager::standardSoftKeyText(StandardSoftKey standardKey)
-{
-    const char *softKeyText = 0;
+QString QSoftKeyManager::standardSoftKeyText(StandardSoftKey standardKey)
+{
+    QString softKeyText;
     switch (standardKey) {
     case OkSoftKey:
-        softKeyText = QT_TRANSLATE_NOOP("QSoftKeyManager", "Ok");
+        softKeyText = QSoftKeyManager::tr("Ok");
         break;
     case SelectSoftKey:
-        softKeyText = QT_TRANSLATE_NOOP("QSoftKeyManager", "Select");
+        softKeyText = QSoftKeyManager::tr("Select");
         break;
     case DoneSoftKey:
-        softKeyText = QT_TRANSLATE_NOOP("QSoftKeyManager", "Done");
+        softKeyText = QSoftKeyManager::tr("Done");
         break;
     case MenuSoftKey:
-        softKeyText = QT_TRANSLATE_NOOP("QSoftKeyManager", "Options");
+        softKeyText = QSoftKeyManager::tr("Options");
         break;
     case CancelSoftKey:
-        softKeyText = QT_TRANSLATE_NOOP("QSoftKeyManager", "Cancel");
+        softKeyText = QSoftKeyManager::tr("Cancel");
         break;
     default:
@@ -101 +101 @@
 QAction *QSoftKeyManager::createAction(StandardSoftKey standardKey, QWidget *actionWidget)
 {
-    const char* text = standardSoftKeyText(standardKey);
-    QAction *action = new QAction(QSoftKeyManager::tr(text), actionWidget);
+    QAction *action = new QAction(standardSoftKeyText(standardKey), actionWidget);
     QAction::SoftKeyRole softKeyRole = QAction::NoSoftKey;
     switch (standardKey) {
@@ -117 +116 @@
     }
     action->setSoftKeyRole(softKeyRole);
+    action->setVisible(false);
+    setForceEnabledInSoftkeys(action);
     return action;
 }
@@ -170 +171 @@
     Q_D(QSoftKeyManager);
     bool ret = false;
-    QList<QAction*> actions = source.actions();
-    for (int i = 0; i < actions.count(); ++i) {
-        if (actions.at(i)->softKeyRole() != QAction::NoSoftKey) {
-            d->requestedSoftKeyActions.insert(level, actions.at(i));
+    foreach(QAction *action, source.actions()) {
+        if (action->softKeyRole() != QAction::NoSoftKey
+            && (action->isVisible() || isForceEnabledInSofkeys(action))) {
+            d->requestedSoftKeyActions.insert(level, action);
             ret = true;
         }
     }
     return ret;
+}
+
+
+static bool isChildOf(const QWidget *c, const QWidget *p)
+{
+    while (c) {
+        if (c == p)
+            return true;
+        c = c->parentWidget();
+    }
+    return false;
 }
 
@@ -186 +198 @@
     if (!previousSource) {
         // Initial source is primarily focuswidget and secondarily activeWindow
-        source = QApplication::focusWidget();
-        if (!source)
-            source = QApplication::activeWindow();
+        QWidget *focus = QApplication::focusWidget();
+        QWidget *popup = QApplication::activePopupWidget();
+        if (popup) {
+            if (isChildOf(focus, popup))
+                source = focus;
+            else
+                source = popup;
+        }
+        if (!source) {
+            QWidget *modal = QApplication::activeModalWidget();
+            if (modal) {
+                if (isChildOf(focus, modal))
+                    source = focus;
+                else
+                    source = modal;
+            }
+        }
+        if (!source) {
+            source = focus;
+            if (!source)
+                source = QApplication::activeWindow();
+        }
     } else {
         // Softkey merging is based on four criterias
@@ -212 +243 @@
     bool recursiveMerging = false;
     QWidget *source = softkeySource(NULL, recursiveMerging);
-    do {
-        if (source) {
-            bool added = appendSoftkeys(*source, level);
-            source = softkeySource(source, recursiveMerging);
-            level = added ? ++level : level;
-        }
-    } while (source);
+    d->initialSoftKeySource = source;
+    while (source) {
+        if (appendSoftkeys(*source, level))
+            ++level;
+        source = softkeySource(source, recursiveMerging);
+    }
 
     d->updateSoftKeys_sys();
     return true;
+}
+
+void QSoftKeyManager::setForceEnabledInSoftkeys(QAction *action)
+{
+    action->setProperty(FORCE_ENABLED_PROPERTY, QVariant(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;
 }
 

trunk/src/gui/kernel/qsoftkeymanager_common_p.h

@@ -71 +71 @@
     QHash<QAction*, Qt::Key> keyedActions;
     QMultiHash<int, QAction*> requestedSoftKeyActions;
+    QWidget *initialSoftKeySource;
 
 };

trunk/src/gui/kernel/qsoftkeymanager_p.h

@@ -64 +64 @@
 class QSoftKeyManagerPrivate;
 
-const char MENU_ACTION_PROPERTY[] = "_q_menuaction";
+const char MENU_ACTION_PROPERTY[] = "_q_menuAction";
+const char FORCE_ENABLED_PROPERTY[] = "_q_forceEnabledInSoftkeys";
 
 class Q_AUTOTEST_EXPORT QSoftKeyManager : public QObject
@@ -88 +89 @@
     static QAction *createAction(StandardSoftKey standardKey, QWidget *actionWidget);
     static QAction *createKeyedAction(StandardSoftKey standardKey, Qt::Key key, QWidget *actionWidget);
+    static QString standardSoftKeyText(StandardSoftKey standardKey);
+    static void setForceEnabledInSoftkeys(QAction *action);
+    static bool isForceEnabledInSofkeys(QAction *action);
 
 protected:
@@ -95 +99 @@
     QSoftKeyManager();
     static QSoftKeyManager *instance();
-    static const char *standardSoftKeyText(StandardSoftKey standardKey);
     bool appendSoftkeys(const QWidget &source, int level);
     QWidget *softkeySource(QWidget *previousSource, bool& recursiveMerging);

trunk/src/gui/kernel/qsoftkeymanager_s60.cpp

@@ -61 +61 @@
 const int RSK_POSITION = 2;
 
-QSoftKeyManagerPrivateS60::QSoftKeyManagerPrivateS60()
+QSoftKeyManagerPrivateS60::QSoftKeyManagerPrivateS60() : cbaHasImage(4) // 4 since MSK position index is 3
 {
     cachedCbaIconSize[0] = QSize(0,0);
@@ -67 +67 @@
     cachedCbaIconSize[2] = QSize(0,0);
     cachedCbaIconSize[3] = QSize(0,0);
-    skipNextUpdate = false;
 }
 
 bool QSoftKeyManagerPrivateS60::skipCbaUpdate()
 {
-    // lets not update softkeys if
+    // Lets not update softkeys if
     // 1. We don't have application panes, i.e. cba
-    // 2. S60 native dialog or menu is shown
-    if (QApplication::testAttribute(Qt::AA_S60DontConstructApplicationPanes) ||
-        CCoeEnv::Static()->AppUi()->IsDisplayingMenuOrDialog() || skipNextUpdate) {
-        skipNextUpdate = false;
+    // 2. Our CBA is not active, i.e. S60 native dialog or menu with custom CBA is shown
+    //    2.1. Except if thre is no current CBA at all and WindowSoftkeysRespondHint is set
+
+    // Note: Cannot use IsDisplayingMenuOrDialog since CBA update can be triggered before
+    // menu/dialog CBA is actually displayed i.e. it is being costructed.
+    CEikButtonGroupContainer *appUiCba = S60->buttonGroupContainer();
+    if (!appUiCba)
+        return true;
+    // CEikButtonGroupContainer::Current returns 0 if CBA is not visible at all
+    CEikButtonGroupContainer *currentCba = CEikButtonGroupContainer::Current();
+    // Check if softkey need to be update even they are not visible
+    bool cbaRespondsWhenInvisible = false;
+    QWidget *window = QApplication::activeWindow();
+    if (window && (window->windowFlags() & Qt::WindowSoftkeysRespondHint))
+        cbaRespondsWhenInvisible = true;
+
+    if (QApplication::testAttribute(Qt::AA_S60DontConstructApplicationPanes)
+            || (appUiCba != currentCba && !cbaRespondsWhenInvisible)) {
         return true;
     }
@@ -255 +268 @@
 
             EikSoftkeyImage::SetImage(cba, *myimage, left); // Takes myimage ownership
+            cbaHasImage[position] = true;
             ret = true;
         } else {
             // Restore softkey to text based
-            EikSoftkeyImage::SetLabel(cba, left);
+            if (cbaHasImage[position]) {
+                EikSoftkeyImage::SetLabel(cba, left);
+                cbaHasImage[position] = false;
+            }
         }
     }
@@ -274 +291 @@
         int command = S60_COMMAND_START + position;
         setNativeSoftkey(cba, position, command, nativeText);
-        cba.DimCommand(command, !action->isEnabled());
+        const bool dimmed = !action->isEnabled() && !QSoftKeyManager::isForceEnabledInSofkeys(action);
+        cba.DimCommand(command, dimmed);
         realSoftKeyActions.insert(command, action);
         return true;
@@ -297 +315 @@
 {
     if (!setSoftkey(cba, QAction::NegativeSoftKey, RSK_POSITION)) {
-        Qt::WindowType windowType = Qt::Window;
-        QAction *action = requestedSoftKeyActions.value(0);
-        if (action) {
-            QWidget *actionParent = action->parentWidget();
-            Q_ASSERT_X(actionParent, Q_FUNC_INFO, "No parent set for softkey action!");
-
-            QWidget *actionWindow = actionParent->window();
-            Q_ASSERT_X(actionWindow, Q_FUNC_INFO, "Softkey action does not have window!");
-            windowType = actionWindow->windowType();
-        }
-
+        const Qt::WindowType windowType = initialSoftKeySource
+            ? initialSoftKeySource->window()->windowType() : Qt::Window;
         if (windowType != Qt::Dialog && windowType != Qt::Popup) {
             QString text(QSoftKeyManager::tr("Exit"));
             TPtrC nativeText = qt_QString2TPtrC(text);
-            EikSoftkeyImage::SetLabel(&cba, false);
+            if (cbaHasImage[RSK_POSITION]) {
+                EikSoftkeyImage::SetLabel(&cba, false);
+                cbaHasImage[RSK_POSITION] = false;
+            }
             setNativeSoftkey(cba, RSK_POSITION, EAknSoftkeyExit, nativeText);
+            cba.DimCommand(EAknSoftkeyExit, false);
             return true;
         }
@@ -355 +368 @@
 }
 
+static void resetMenuBeingConstructed(TAny* /*aAny*/)
+{
+    S60->menuBeingConstructed = false;
+}
+
+void QSoftKeyManagerPrivateS60::tryDisplayMenuBarL()
+{
+    CleanupStack::PushL(TCleanupItem(resetMenuBeingConstructed, NULL));
+    S60->menuBeingConstructed = true;
+    S60->menuBar()->TryDisplayMenuBarL();
+    CleanupStack::PopAndDestroy(); // Reset menuBeingConstructed to false in all cases
+}
+
 bool QSoftKeyManagerPrivateS60::handleCommand(int command)
 {
@@ -361 +387 @@
         QVariant property = action->property(MENU_ACTION_PROPERTY);
         if (property.isValid() && property.toBool()) {
-            QT_TRAP_THROWING(S60->menuBar()->TryDisplayMenuBarL());
+            QT_TRAP_THROWING(tryDisplayMenuBarL());
         } else if (action->menu()) {
             // TODO: This is hack, in order to use exising QMenuBar implementation for Symbian
             // menubar needs to have widget to which it is associated. Since we want to associate
-            // menubar to action (which is inherited from QObejct), we create and associate QWidget
+            // menubar to action (which is inherited from QObject), we create and associate QWidget
             // to action and pass that for QMenuBar. This associates the menubar to action, and we
             // can have own menubar for each action.
@@ -384 +410 @@
             }
             qt_symbian_next_menu_from_action(actionContainer);
-            QT_TRAP_THROWING(S60->menuBar()->TryDisplayMenuBarL());
-            // TODO: hack remove, it can happen that IsDisplayingMenuOrDialog return false
-            // in updateSoftKeys_sys, and we will override menu CBA with our own
-            skipNextUpdate = true;
-        } else {
-            Q_ASSERT(action->softKeyRole() != QAction::NoSoftKey);
-            QWidget *actionParent = action->parentWidget();
-            Q_ASSERT_X(actionParent, Q_FUNC_INFO, "No parent set for softkey action!");
-            if (actionParent->isEnabled()) {
-                action->activate(QAction::Trigger);
-                return true;
-            }
+            QT_TRAP_THROWING(tryDisplayMenuBarL());
+        }
+
+        Q_ASSERT(action->softKeyRole() != QAction::NoSoftKey);
+        QWidget *actionParent = action->parentWidget();
+        Q_ASSERT_X(actionParent, Q_FUNC_INFO, "No parent set for softkey action!");
+        if (actionParent->isEnabled()) {
+            action->activate(QAction::Trigger);
+            return true;
         }
     }

trunk/src/gui/kernel/qsoftkeymanager_s60_p.h

@@ -54 +54 @@
 //
 
+#include "qbitarray.h"
 #include "private/qobject_p.h"
 #include "private/qsoftkeymanager_common_p.h"
@@ -78 +79 @@
 
 private:
+    void tryDisplayMenuBarL();
     bool skipCbaUpdate();
     void ensureCbaVisibilityAndResponsiviness(CEikButtonGroupContainer &cba);
@@ -99 +101 @@
     QHash<int, QAction*> realSoftKeyActions;
     QSize cachedCbaIconSize[4];
-    bool skipNextUpdate;
+    QBitArray cbaHasImage;
 };
 

trunk/src/gui/kernel/qsound.cpp

@@ -155 +155 @@
     \o A built-in mixing sound server is used, accessing \c /dev/dsp
     directly. Only the WAVE format is supported.
+    \row
     \o Symbian
     \o CMdaAudioPlayerUtility is used. All formats that Symbian OS or devices support

trunk/src/gui/kernel/qsound_mac.mm

@@ -175 +175 @@
     QMacSoundDelegate * const delegate = [[QMacSoundDelegate alloc] initWithQSound:qSound:this];
     [nsSound setDelegate:delegate];
+    [nsFileName release];
     return nsSound;
 }

trunk/src/gui/kernel/qsound_s60.cpp

@@ -52 +52 @@
 
 #include <e32std.h>
-#include <MdaAudioSamplePlayer.h>
+#include <mdaaudiosampleplayer.h>
 
 QT_BEGIN_NAMESPACE

trunk/src/gui/kernel/qt_cocoa_helpers_mac.mm

@@ -144 +144 @@
 void macWindowFade(void * /*OSWindowRef*/ window, float durationSeconds)
 {
+#ifdef QT_MAC_USE_COCOA
+    QMacCocoaAutoReleasePool pool;
+#endif
     OSWindowRef wnd = static_cast<OSWindowRef>(window);
     if (wnd) {
@@ -1160 +1163 @@
     QDBeginCGContext(port, &context);
 #else
-    CGContextRef context = (CGContextRef)[[NSGraphicsContext graphicsContextWithWindow:qt_mac_window_for(widget)] graphicsPort];
+    CGContextRef context = reinterpret_cast<CGContextRef>([[qt_mac_window_for(widget) graphicsContext] graphicsPort]);
 #endif
     return context;
+}
+
+void qt_mac_dispatchPendingUpdateRequests(QWidget *widget)
+{
+    if (!widget)
+        return;
+#ifndef QT_MAC_USE_COCOA
+    HIViewRender(qt_mac_nativeview_for(widget));
+#else
+    [qt_mac_nativeview_for(widget) displayIfNeeded];
+#endif
 }
 
@@ -1279 +1293 @@
 #endif
 
+QMacCocoaAutoReleasePool::QMacCocoaAutoReleasePool()
+{
+#ifndef QT_MAC_USE_COCOA
+    NSApplicationLoad();
+#endif
+    pool = (void*)[[NSAutoreleasePool alloc] init];
+}
+
+QMacCocoaAutoReleasePool::~QMacCocoaAutoReleasePool()
+{
+    [(NSAutoreleasePool*)pool release];
+}
+
 QT_END_NAMESPACE

trunk/src/gui/kernel/qt_s60_p.h

@@ -69 +69 @@
 
 #ifdef Q_WS_S60
-#include <aknutils.h>               // AknLayoutUtils
+#include <AknUtils.h>               // AknLayoutUtils
 #include <avkon.hrh>                // EEikStatusPaneUidTitle
 #include <akntitle.h>               // CAknTitlePane
 #include <akncontext.h>             // CAknContextPane
 #include <eikspane.h>               // CEikStatusPane
-#include <aknpopupfader.h>          // MAknFadedComponent and TAknPopupFader
+#include <AknPopupFader.h>          // MAknFadedComponent and TAknPopupFader
 #endif
 
@@ -123 +123 @@
     int supportsPremultipliedAlpha : 1;
     int avkonComponentsSupportTransparency : 1;
+    int menuBeingConstructed : 1;
     QApplication::QS60MainApplicationFactory s60ApplicationFactory; // typedef'ed pointer type
     static inline void updateScreenSize();
@@ -155 +156 @@
 class QSymbianControl : public CCoeControl, public QAbstractLongTapObserver
 #ifdef Q_WS_S60
-, public MAknFadedComponent
+, public MAknFadedComponent, public MEikStatusPaneObserver
 #endif
 {
@@ -183 +184 @@
 #ifdef Q_WS_S60
     void FadeBehindPopup(bool fade){ popupFader.FadeBehindPopup( this, this, fade); }
+    void HandleStatusPaneSizeChange();
 
 protected: // from MAknFadedComponent
@@ -213 +215 @@
     void translateAdvancedPointerEvent(const TAdvancedPointerEvent *event);
 #endif
+    void handleClientAreaChange();
 
 private:

trunk/src/gui/kernel/qt_x11_p.h

@@ -676 +676 @@
         XWacomEraser,
 
+        XTabletStylus,
+        XTabletEraser,
+
         NPredefinedAtoms,
 

trunk/src/gui/kernel/qtooltip.cpp

@@ -169 +169 @@
 QTipLabel::QTipLabel(const QString &text, QWidget *w)
 #ifndef QT_NO_STYLE_STYLESHEET
-    : QLabel(w, Qt::ToolTip), styleSheetParent(0), widget(0)
+    : QLabel(w, Qt::ToolTip | Qt::BypassGraphicsProxyWidget), styleSheetParent(0), widget(0)
 #else
-    : QLabel(w, Qt::ToolTip), widget(0)
+    : QLabel(w, Qt::ToolTip | Qt::BypassGraphicsProxyWidget), widget(0)
 #endif
 {
@@ -369 +369 @@
 
 #ifdef Q_WS_MAC
-    QRect screen = QApplication::desktop()->availableGeometry(getTipScreen(pos, w));
+    // When in full screen mode, there is no Dock nor Menu so we can use
+    // the whole screen for displaying the tooltip. However when not in
+    // full screen mode we need to save space for the dock, so we use
+    // availableGeometry instead.
+    extern bool qt_mac_app_fullscreen; //qapplication_mac.mm
+    QRect screen;
+    if(qt_mac_app_fullscreen)
+        screen = QApplication::desktop()->screenGeometry(getTipScreen(pos, w));
+    else
+        screen = QApplication::desktop()->availableGeometry(getTipScreen(pos, w));
 #else
     QRect screen = QApplication::desktop()->screenGeometry(getTipScreen(pos, w));

trunk/src/gui/kernel/qwhatsthis.cpp

@@ -144 +144 @@
 */
 
-extern void qDeleteInEventHandler(QObject *o);
+Q_DECL_IMPORT extern void qDeleteInEventHandler(QObject *o);
 
 class QWhatsThat : public QWidget

trunk/src/gui/kernel/qwidget.cpp

@@ -123 +123 @@
 #include "private/qgesturemanager_p.h"
 
+#ifdef QT_KEYPAD_NAVIGATION
+#include "qtabwidget.h" // Needed in inTabWidget()
+#endif // QT_KEYPAD_NAVIGATION
+
 // widget/widget data creation count
 //#define QWIDGET_EXTRA_DEBUG
@@ -197 +201 @@
       , isScrolled(0)
       , isMoved(0)
+      , isGLWidget(0)
       , usesDoubleBufferedGLContext(0)
 #if defined(Q_WS_X11)
@@ -207 +212 @@
 #elif defined(Q_WS_MAC)
       , needWindowChange(0)
-      , isGLWidget(0)
       , window_event(0)
       , qd_hd(0)
@@ -1446 +1450 @@
 #endif
 
+#ifdef Q_OS_SYMBIAN
     if (d->extra && d->extra->topextra && d->extra->topextra->backingStore) {
         // Okay, we are about to destroy the top-level window that owns
@@ -1455 +1460 @@
         delete d->extra->topextra->backingStore;
         d->extra->topextra->backingStore = 0;
-    } else if (QWidgetBackingStore *bs = d->maybeBackingStore()) {
+    }
+#endif
+    if (QWidgetBackingStore *bs = d->maybeBackingStore()) {
         bs->removeDirtyWidget(this);
         if (testAttribute(Qt::WA_StaticContents))
@@ -1487 +1494 @@
         QWidgetPrivate::allWidgets->remove(this);
 
-    QEvent e(QEvent::Destroy);
-    QCoreApplication::sendEvent(this, &e);
+    QT_TRY {
+        QEvent e(QEvent::Destroy);
+        QCoreApplication::sendEvent(this, &e);
+    } QT_CATCH(const std::exception&) {
+        // if this fails we can't do anything about it but at least we are not allowed to throw.
+    }
 }
 
@@ -1676 +1687 @@
         dirty = QRegion();
     } else if (QWidgetBackingStore *bs = maybeBackingStore()) {
+#ifdef QT_MAC_USE_COCOA
+        Q_UNUSED(bs);
+        void qt_mac_set_needs_display(QWidget *, QRegion);
+        qt_mac_set_needs_display(q_func(), QRegion());
+#else
         bs->sync();
+#endif
     }
 }
@@ -1684 +1701 @@
     if (paintOnScreen())
         repaint_sys(region);
-    else if (QWidgetBackingStore *bs = maybeBackingStore())
+    else if (QWidgetBackingStore *bs = maybeBackingStore()) {
+#ifdef QT_MAC_USE_COCOA
+        Q_UNUSED(bs);
+        void qt_mac_set_needs_display(QWidget *, QRegion);
+        qt_mac_set_needs_display(q_func(), region);
+#else
         bs->sync(q_func(), region);
+#endif
+    }
 }
 
@@ -3368 +3392 @@
     appear on screen. This also applies to windows.
 
-    \sa pos, geometry, minimumSize, maximumSize, resizeEvent()
+    \sa pos, geometry, minimumSize, maximumSize, resizeEvent(), adjustSize()
 */
 
@@ -6110 +6134 @@
             if (previousProxyFocus && previousProxyFocus->focusProxy())
                 previousProxyFocus = previousProxyFocus->focusProxy();
+            if (previousProxyFocus == this && !topData->proxyWidget->d_func()->proxyIsGivingFocus)
+                return;
         }
     }
@@ -7522 +7548 @@
         if (!widget || widget->isWindow() || widget->testAttribute(Qt::WA_WState_Hidden))
             continue;
+#ifdef QT_MAC_USE_COCOA
+        // Before doing anything we need to make sure that we don't leave anything in a non-consistent state.
+        // When hiding a widget we need to make sure that no mouse_down events are active, because
+        // the mouse_up event will never be received by a hidden widget or one of its descendants.
+        // The solution is simple, before going through with this we check if there are any mouse_down events in
+        // progress, if so we check if it is related to this widget or not. If so, we just reset the mouse_down and
+        // then we continue.
+        // In X11 and Windows we send a mouse_release event, however we don't do that here because we were already
+        // ignoring that from before. I.e. Carbon did not send the mouse release event, so we will not send the
+        // mouse release event. There are two ways to interpret this:
+        // 1. If we don't send the mouse release event, the widget might get into an inconsistent state, i.e. it
+        // might be waiting for a release event that will never arrive.
+        // 2. If we send the mouse release event, then the widget might decide to trigger an action that is not
+        // supposed to trigger because it is not visible.
+        if(widget == qt_button_down)
+            qt_button_down = 0;
+#endif // QT_MAC_USE_COCOA
         if (spontaneous)
             widget->setAttribute(Qt::WA_Mapped, false);
@@ -7916 +7959 @@
     if(w && w->isWindow() && w->isVisible() && w->isEnabled()) {
         LONG dwStyle = GetWindowLong(w->winId(), GWL_STYLE);
+        LONG newStyle = dwStyle;
         if (setStyle)
-            dwStyle |= WS_DISABLED;
+            newStyle |= WS_DISABLED;
         else
-            dwStyle &= ~WS_DISABLED;
-        SetWindowLong(w->winId(), GWL_STYLE, dwStyle);
-        // we might need to repaint in some situations (eg. menu)
-        w->repaint();
+            newStyle &= ~WS_DISABLED;
+        if (newStyle != dwStyle) {
+            SetWindowLong(w->winId(), GWL_STYLE, newStyle);
+            // we might need to repaint in some situations (eg. menu)
+            w->repaint();
+        }
     }
 }
@@ -8262 +8308 @@
 
 #ifdef QT_SOFTKEYS_ENABLED
-        if (isWindow() && isActiveWindow())
+        if (isWindow())
             QSoftKeyManager::updateSoftKeys();
 #endif
@@ -11731 +11777 @@
     return targetWidget;
 }
+
+/*!
+    \internal
+
+    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
+    currently has not the editFocus.
+
+    \sa QWidgetPrivate::widgetInNavigationDirection(), QWidget::hasEditFocus()
+*/
+bool QWidgetPrivate::canKeypadNavigate(Qt::Orientation orientation)
+{
+    return orientation == Qt::Horizontal?
+            (QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionEast)
+                    || QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionWest))
+            :(QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionNorth)
+                    || QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionSouth));
+}
+/*!
+    \internal
+
+    Checks, if the \a widget is inside a QTabWidget. If is is inside
+    one, left/right key events will be used to switch between tabs in keypad
+    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
+    not the editFocus.
+
+    \sa QWidget::hasEditFocus()
+*/
+bool QWidgetPrivate::inTabWidget(QWidget *widget)
+{
+    for (QWidget *tabWidget = widget; tabWidget; tabWidget = tabWidget->parentWidget())
+        if (qobject_cast<const QTabWidget*>(tabWidget))
+            return true;
+    return false;
+}
 #endif
 

trunk/src/gui/kernel/qwidget_mac.mm

@@ -153 +153 @@
 QWidget *mac_mouse_grabber = 0;
 QWidget *mac_keyboard_grabber = 0;
+extern QPointer<QWidget> qt_button_down; //qapplication_mac.cpp
 
 #ifndef QT_MAC_USE_COCOA
@@ -563 +564 @@
     // below 'stays on top' windows. Add 1 to get above pure stay-on-top windows.
     qt_mac_set_window_group(window, Qt::Popup, qt_mac_get_group_level(kOverlayWindowClass)+1);
+}
+#endif
+
+#ifdef QT_MAC_USE_COCOA
+void qt_mac_set_needs_display(QWidget *widget, QRegion region)
+{
+    NSView *theNSView = qt_mac_nativeview_for(widget);
+    if (region.isEmpty()) {
+        [theNSView setNeedsDisplay:YES];
+        return;
+    }
+
+    QVector<QRect> rects = region.rects();
+    for (int i = 0; i<rects.count(); ++i) {
+        const QRect &rect = rects.at(i);
+        NSRect nsrect = NSMakeRect(rect.x(), rect.y(), rect.width(), rect.height());
+        [theNSView setNeedsDisplayInRect:nsrect];
+    }
+
 }
 #endif
@@ -848 +868 @@
                 QApplication::sendSpontaneousEvent(widget, &e);
             }
-            extern QPointer<QWidget> qt_button_down; //qapplication_mac.cpp
             qt_button_down = 0;
         } else if(ekind == kEventWindowCollapsed) {
@@ -876 +895 @@
             QEvent e(QEvent::Hide);
             QApplication::sendSpontaneousEvent(widget, &e);
-            extern QPointer<QWidget> qt_button_down; //qapplication_mac.cpp
             qt_button_down = 0;
         } else if(ekind == kEventWindowToolbarSwitchMode) {
@@ -1250 +1268 @@
                     if(widget->testAttribute(Qt::WA_WState_InPaintEvent))
                         qWarning("QWidget::repaint: Recursive repaint detected");
+                    if (widget->isWindow() && !widget->d_func()->isOpaque
+                        && !widget->testAttribute(Qt::WA_MacBrushedMetal)) {
+                        QRect qrgnRect = qrgn.boundingRect();
+                        CGContextClearRect(cg, CGRectMake(qrgnRect.x(), qrgnRect.y(), qrgnRect.width(), qrgnRect.height()));
+                    }
 
                     QPoint redirectionOffset(0, 0);
@@ -1299 +1322 @@
                             widget->d_func()->restoreRedirected();
                     }
-
-                    if (widget->isWindow() && !widget->d_func()->isOpaque
-                           && !widget->testAttribute(Qt::WA_MacBrushedMetal)) {
-                        QRect qrgnRect = qrgn.boundingRect();
-                        CGContextClearRect(cg, CGRectMake(qrgnRect.x(), qrgnRect.y(), qrgnRect.width(), qrgnRect.height()));
-                    }
-
 
                     if(!HIObjectIsOfClass((HIObjectRef)hiview, kObjectQWidget))
@@ -1503 +1519 @@
                 qt_event_request_window_change(widget);
                 if (!HIViewIsVisible(HIViewRef(widget->winId()))) {
-                    extern QPointer<QWidget> qt_button_down; //qapplication_mac.cpp
                     if (widget == qt_button_down)
                         qt_button_down = 0;
@@ -1512 +1527 @@
     case kEventClassMouse: {
         bool send_to_app = false;
-        extern QPointer<QWidget> qt_button_down; //qapplication_mac.cpp
         if(qt_button_down)
             send_to_app = true;
@@ -3389 +3403 @@
     if((q->windowType() == Qt::Desktop)) //you can't hide the desktop!
         return;
-
     QMacCocoaAutoReleasePool pool;
     if(q->isWindow()) {
@@ -3511 +3524 @@
     if (!QWidget::mouseGrabber()){
         QWidget *enterWidget = QApplication::widgetAt(QCursor::pos());
+        if (enterWidget && enterWidget->data->in_destructor)
+            enterWidget = 0;
         QApplicationPrivate::dispatchEnterLeave(enterWidget, qt_mouseover);
         qt_mouseover = enterWidget;
@@ -4455 +4470 @@
     }
 
+    // ### Scroll the dirty regions as well, the following is not correct.
+    QRegion displayRegion = r.isNull() ? dirtyOnWidget : (dirtyOnWidget & r);
+    const QVector<QRect> &rects = dirtyOnWidget.rects();
+    const QVector<QRect>::const_iterator end = rects.end();
+    QVector<QRect>::const_iterator it = rects.begin();
+    while (it != end) {
+        const QRect rect = *it;
+        const NSRect dirtyRect = NSMakeRect(rect.x() + dx, rect.y() + dy,
+                rect.width(), rect.height());
+        [view setNeedsDisplayInRect:dirtyRect];
+        ++it;
+    }
+
     NSSize deltaSize = NSMakeSize(dx, dy);
-    [view translateRectsNeedingDisplayInRect:scrollRect by:deltaSize];
     [view scrollRect:scrollRect by:deltaSize];
     [view setNeedsDisplayInRect:deltaXRect];
@@ -4656 +4683 @@
         return;
 
-    if (extra->hasMask && extra->maskBits.size() != q->size()) {
-        extra->maskBits = QImage(q->size(), QImage::Format_Mono);
+    if (extra->hasMask) {
+        if(extra->maskBits.size() != q->size()) {
+            extra->maskBits = QImage(q->size(), QImage::Format_Mono);
+        }
         extra->maskBits.fill(QColor(Qt::color1).rgba());
         extra->maskBits.setNumColors(2);

trunk/src/gui/kernel/qwidget_p.h

@@ -242 +242 @@
 
     /**
+     * If this bit is set, each native widget receives the signals from the
+     * Symbian control immediately before and immediately after draw ops are
+     * sent to the window server for this control:
+     *      void beginNativePaintEvent(const QRect &paintRect);
+     *      void endNativePaintEvent(const QRect &paintRect);
+     */
+    uint receiveNativePaintEvents : 1;
+
+    /**
      * Defines the behaviour of QSymbianControl::Draw.
      */
@@ -266 +275 @@
     };
 
-    NativePaintMode nativePaintMode : 2;
-
-    /**
-     * If this bit is set, each native widget receives the signals from the
-     * Symbian control immediately before and immediately after draw ops are
-     * sent to the window server for this control:
-     *      void beginNativePaintEvent(const QRect &paintRect);
-     *      void endNativePaintEvent(const QRect &paintRect);
-     */
-    uint receiveNativePaintEvents : 1;
+    NativePaintMode nativePaintMode;
 
 #elif defined(Q_WS_PM) // <----------------------------------------------------- PM
@@ -483 +483 @@
     static bool navigateToDirection(Direction direction);
     static QWidget *widgetInNavigationDirection(Direction direction);
+    static bool canKeypadNavigate(Qt::Orientation orientation);
+    static bool inTabWidget(QWidget *widget);
 #endif
 
@@ -694 +696 @@
     uint isScrolled : 1;
     uint isMoved : 1;
+    uint isGLWidget : 1;
     uint usesDoubleBufferedGLContext : 1;
 
@@ -734 +737 @@
     // This is new stuff
     uint needWindowChange : 1;
-    uint isGLWidget : 1;
 
     // Each wiget keeps a list of all its child and grandchild OpenGL widgets.

trunk/src/gui/kernel/qwidget_s60.cpp

@@ -388 +388 @@
             drawableWindow->EnableVisibilityChangeEvents();
 
-            if (!isOpaque) {
-                RWindow *const window = static_cast<RWindow *>(drawableWindow);
-#ifdef Q_SYMBIAN_SEMITRANSPARENT_BG_SURFACE
-                window->SetSurfaceTransparency(true);
-#else
-                const TDisplayMode displayMode = static_cast<TDisplayMode>(window->SetRequiredDisplayMode(EColor16MA));
-                if (window->SetTransparencyAlphaChannel() == KErrNone)
-                    window->SetBackgroundColor(TRgb(255, 255, 255, 0));
-#endif
-            }
         }
 
@@ -409 +399 @@
         // this generates a WinIdChanged event.
         setWinId(control.take());
+
+        if (!desktop)
+            s60UpdateIsOpaque(); // must be called after setWinId()
 
     } else if (q->testAttribute(Qt::WA_NativeWindow) || paintOnScreen()) { // create native child widget
@@ -488 +481 @@
 
          QSymbianControl *id = static_cast<QSymbianControl *>(q->internalWinId());
+
+#ifdef Q_WS_S60
+        // Lazily initialize the S60 screen furniture when the first window is shown.
+        if (!QApplication::testAttribute(Qt::AA_S60DontConstructApplicationPanes)
+                && !S60->buttonGroupContainer() && !S60->statusPane()) {
+
+            bool isFullscreen = q->windowState() & Qt::WindowFullScreen;
+
+            if (!q->testAttribute(Qt::WA_DontShowOnScreen)) {
+
+                // Create the status pane and CBA here
+                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);
+
+                if (S60->statusPane()) {
+                    // Use QDesktopWidget as the status pane observer to proxy for the AppUi.
+                    // Can't use AppUi directly because it privately inherits from MEikStatusPaneObserver.
+                    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);
+                    }
+                }
+            }
+        }
+#endif
 
         id->MakeVisible(true);
@@ -1038 +1069 @@
 }
 
+static Qt::WindowStates effectiveState(Qt::WindowStates state)
+{
+    if (state & Qt::WindowMinimized)
+        return Qt::WindowMinimized;
+    else if (state & Qt::WindowFullScreen)
+        return Qt::WindowFullScreen;
+    else if (state & Qt::WindowMaximized)
+        return Qt::WindowMaximized;
+    return Qt::WindowNoState;
+}
+
 void QWidget::setWindowState(Qt::WindowStates newstate)
 {
@@ -1043 +1085 @@
 
     Qt::WindowStates oldstate = windowState();
-    if (oldstate == newstate)
+
+    const TBool isFullscreen = newstate & Qt::WindowFullScreen;
+    const TBool cbaRequested = windowFlags() & Qt::WindowSoftkeysVisibleHint;
+    const TBool cbaVisible = CEikButtonGroupContainer::Current() ? true : false;
+    const TBool softkeyVisibilityChange = isFullscreen && (cbaRequested != cbaVisible);
+
+    if (oldstate == newstate && !softkeyVisibilityChange)
         return;
 
     if (isWindow()) {
+        createWinId();
+        Q_ASSERT(testAttribute(Qt::WA_WState_Created));
+
+        const bool wasResized = testAttribute(Qt::WA_Resized);
+        const bool wasMoved = testAttribute(Qt::WA_Moved);
 
         QSymbianControl *window = static_cast<QSymbianControl *>(effectiveWinId());
@@ -1059 +1112 @@
 #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 
+        // 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)); 
+        CEikStatusPane *statusPane = S60->statusPane();
+        CEikButtonGroupContainer *buttonGroup = S60->buttonGroupContainer();
+        TBool visible = !(newstate & (Qt::WindowFullScreen | Qt::WindowMinimized));
         if (statusPane)
             statusPane->MakeVisible(visible);
-        if (buttonGroup)
-            buttonGroup->MakeVisible(visible);
+        if (buttonGroup) {
+            // Visibility
+            buttonGroup->MakeVisible(visible || (isFullscreen && cbaRequested));
+        }
 #endif // Q_WS_S60
 
-        createWinId();
-        Q_ASSERT(testAttribute(Qt::WA_WState_Created));
         // Ensure the initial size is valid, since we store it as normalGeometry below.
-        if (!testAttribute(Qt::WA_Resized) && !isVisible())
+        if (!wasResized && !isVisible())
             adjustSize();
 
         QTLWExtra *top = d->topData();
-        const QRect normalGeometry = (top->normalGeometry.width() < 0) ? geometry() : top->normalGeometry;
-
-        if (newstate & Qt::WindowFullScreen)
-            setGeometry(qApp->desktop()->screenGeometry(this));
-        else if (newstate & Qt::WindowMaximized)
-            setGeometry(qApp->desktop()->availableGeometry(this));
-        else
+        QRect normalGeometry = (top->normalGeometry.width() < 0) ? geometry() : top->normalGeometry;
+
+        const bool cbaVisibilityHint = windowFlags() & Qt::WindowSoftkeysVisibleHint;
+        if (newstate & Qt::WindowFullScreen && !cbaVisibilityHint) {
+            window->SetExtentToWholeScreen();
+        } else if (newstate & Qt::WindowMaximized || ((newstate & Qt::WindowFullScreen) && cbaVisibilityHint)) {
+            TRect maxExtent = qt_QRect2TRect(qApp->desktop()->availableGeometry(this));
+            window->SetExtent(maxExtent.iTl, maxExtent.Size());
+        } else {
+#ifdef Q_WS_S60
+            // With delayed creation of S60 app panes, the normalGeometry calculated above is not
+            // accurate because it did not consider the status pane. This means that when returning
+            // 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) {
+                TPoint tl = static_cast<CEikAppUi*>(S60->appUi())->ClientRect().iTl;
+                normalGeometry.setTopLeft(QPoint(tl.iX, tl.iY));
+            }
+#endif
             setGeometry(normalGeometry);
+        }
 
         //restore normal geometry
         top->normalGeometry = normalGeometry;
+
+        // FixMe QTBUG-8977
+        // In some platforms, WA_Resized and WA_Moved are also not set when application window state is
+        // anything else than normal. In Symbian we can restore them only for normal window state since
+        // restoring for other modes, will make fluidlauncher to be launched in wrong size (200x100)
+        if (effectiveState(newstate) == Qt::WindowNoState) {
+            setAttribute(Qt::WA_Resized, wasResized);
+            setAttribute(Qt::WA_Moved, wasMoved);
+        }
     }
 
@@ -1221 +1296 @@
     if (!qt_nograb() && QWidgetPrivate::mouseGrabber == this) {
         Q_ASSERT(testAttribute(Qt::WA_WState_Created));
-        WId id = effectiveWinId();
-        id->SetPointerCapture(false);
+        if(!window()->isModal()) {
+            WId id = effectiveWinId();
+            id->SetPointerCapture(false);
+        }
         QWidgetPrivate::mouseGrabber = 0;
 #ifndef QT_NO_CURSOR

trunk/src/gui/kernel/qwidget_win.cpp

@@ -2053 +2053 @@
         return;
 
+    if (!QApplicationPrivate::HasTouchSupport)
+        return;
     QApplicationPrivate *qAppPriv = QApplicationPrivate::instance();
     if (!qAppPriv->SetGestureConfig)

trunk/src/gui/kernel/qwidget_x11.cpp

@@ -347 +347 @@
 }
 
-static Bool checkForConfigureAndExpose(Display *, XEvent *e, XPointer)
-{
-    return e->type == ConfigureNotify || e->type == Expose;
-}
-
 Q_GUI_EXPORT void qt_x11_wait_for_window_manager(QWidget* w)
 {
@@ -364 +359 @@
         return;
 
-    if (!(w->windowFlags() & Qt::X11BypassWindowManagerHint)) {
-        // if the window is not override-redirect, then the window manager
-        // will reparent us to the frame decoration window.
-        while (!XCheckTypedWindowEvent(X11->display, w->effectiveWinId(), ReparentNotify, &ev)) {
-            if (t.elapsed() > maximumWaitTime)
-                return;
-            qApp->syncX(); // non-busy wait
-        }
-    }
-
-    while (!XCheckTypedWindowEvent(X11->display, w->effectiveWinId(), MapNotify, &ev)) {
+    WId winid = w->internalWinId();
+
+    // first deliver events that are already in the local queue
+    QApplication::sendPostedEvents();
+
+    // the normal sequence is:
+    //  ... ConfigureNotify ... ReparentNotify ... MapNotify ... Expose
+    // with X11BypassWindowManagerHint:
+    //  ConfigureNotify ... MapNotify ... Expose
+
+    enum State {
+        Initial, Mapped
+    } state = Initial;
+
+    do {
+        if (XEventsQueued(X11->display, QueuedAlready)) {
+            XNextEvent(X11->display, &ev);
+            qApp->x11ProcessEvent(&ev);
+
+            switch (state) {
+            case Initial:
+                if (ev.type == MapNotify && ev.xany.window == winid)
+                    state = Mapped;
+                break;
+            case Mapped:
+                if (ev.type == Expose && ev.xany.window == winid)
+                    return;
+                break;
+            }
+        } else {
+            if (!XEventsQueued(X11->display, QueuedAfterFlush))
+                qApp->syncX(); // non-busy wait
+        }
         if (t.elapsed() > maximumWaitTime)
             return;
-        qApp->syncX(); // non-busy wait
-    }
-
-    qApp->x11ProcessEvent(&ev);
-
-    // ok, seems like the window manager successfully reparented us, we'll wait
-    // for the first paint event to arrive, while handling ConfigureNotify in
-    // the arrival order
-    while(1)
-    {
-        if (XCheckIfEvent(X11->display, &ev, checkForConfigureAndExpose, 0)) {
-            qApp->x11ProcessEvent(&ev);
-            if (ev.type == Expose)
-                return;
-        }
-        if (t.elapsed() > maximumWaitTime)
-            return;
-        qApp->syncX(); // non-busy wait
-    }
+    } while(1);
 }
 

trunk/src/gui/kernel/qwinnativepangesturerecognizer_win_p.h

@@ -55 +55 @@
 
 #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;
+};
 
 QT_BEGIN_NAMESPACE