1 files changed, 302 insertions, 207 deletions

diff --git a/src/gui/kernel/qwidget_s60.cpp b/src/gui/kernel/qwidget_s60.cpp
index 6b5e9b7..37614c7 100644
--- a/src/gui/kernel/qwidget_s60.cpp
+++ b/src/gui/kernel/qwidget_s60.cpp
@@ -4,7 +4,7 @@
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
-** This file is part of the QtGui of the Qt Toolkit.
+** This file is part of the QtGui module of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** No Commercial Usage
@@ -56,6 +56,12 @@
 #include <aknappui.h>
 #endif
 
+// This is necessary in order to be able to perform delayed invokation on slots
+// which take arguments of type WId.  One example is
+// QWidgetPrivate::_q_delayedDestroy, which is used to delay destruction of
+// CCoeControl objects until after the CONE event handler has finished running.
+Q_DECLARE_METATYPE(WId)
+
 QT_BEGIN_NAMESPACE
 
 extern bool qt_nograb();
@@ -78,18 +84,144 @@ static bool isEqual(const QList<QAction*>& a, const QList<QAction*>& b)
     return true;
 }
 
-void QWidgetPrivate::setWSGeometry(bool /* dontShow */, const QRect & /* rect */)
+void QWidgetPrivate::setWSGeometry(bool dontShow, const QRect &)
 {
+    // Note: based on x11 implementation
+
+    static const int XCOORD_MAX = 16383;
+    static const int WRECT_MAX = 16383;
+
+    Q_Q(QWidget);
+
+    Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
+
+    /*
+      There are up to four different coordinate systems here:
+      Qt coordinate system for this widget.
+      Symbian coordinate system for this widget (relative to wrect).
+      Qt coordinate system for parent
+      Symbian coordinate system for parent (relative to parent's wrect).
+     */
+
+    QRect validRange(-XCOORD_MAX,-XCOORD_MAX, 2*XCOORD_MAX, 2*XCOORD_MAX);
+    QRect wrectRange(-WRECT_MAX,-WRECT_MAX, 2*WRECT_MAX, 2*WRECT_MAX);
+    QRect wrect;
+    //xrect is the Symbian geometry of my widget. (starts out in parent's Qt coord sys, and ends up in parent's Symbian coord sys)
+    QRect xrect = data.crect;
+
+    const QWidget *const parent = q->parentWidget();
+    QRect parentWRect = parent->data->wrect;
+
+    if (parentWRect.isValid()) {
+        // parent is clipped, and we have to clip to the same limit as parent
+        if (!parentWRect.contains(xrect)) {
+            xrect &= parentWRect;
+            wrect = xrect;
+            //translate from parent's to my Qt coord sys
+            wrect.translate(-data.crect.topLeft());
+        }
+        //translate from parent's Qt coords to parent's X coords
+        xrect.translate(-parentWRect.topLeft());
+
+    } else {
+        // parent is not clipped, we may or may not have to clip
+
+        if (data.wrect.isValid() && QRect(QPoint(),data.crect.size()).contains(data.wrect)) {
+            // This is where the main optimization is: we are already
+            // clipped, and if our clip is still valid, we can just
+            // move our window, and do not need to move or clip
+            // children
+
+            QRect vrect = xrect & parent->rect();
+            vrect.translate(-data.crect.topLeft()); //the part of me that's visible through parent, in my Qt coords
+            if (data.wrect.contains(vrect)) {
+                xrect = data.wrect;
+                xrect.translate(data.crect.topLeft());
+                if (data.winid)
+                    data.winid->SetExtent(TPoint(xrect.x(), xrect.y()), TSize(xrect.width(), xrect.height()));
+                return;
+            }
+        }
+
+        if (!validRange.contains(xrect)) {
+            // we are too big, and must clip
+            xrect &=wrectRange;
+            wrect = xrect;
+            wrect.translate(-data.crect.topLeft());
+            //parent's X coord system is equal to parent's Qt coord
+            //sys, so we don't need to map xrect.
+        }
+    }
+
+    // unmap if we are outside the valid window system coord system
+    bool outsideRange = !xrect.isValid();
+    bool mapWindow = false;
+    if (q->testAttribute(Qt::WA_OutsideWSRange) != outsideRange) {
+        q->setAttribute(Qt::WA_OutsideWSRange, outsideRange);
+        if (outsideRange) {
+            if (data.winid)
+                data.winid->DrawableWindow()->SetVisible(EFalse);
+            q->setAttribute(Qt::WA_Mapped, false);
+        } else if (!q->isHidden()) {
+            mapWindow = true;
+        }
+    }
+
+    if (outsideRange)
+        return;
+
+    bool jump = (data.wrect != wrect);
+    data.wrect = wrect;
+
+    // and now recursively for all children...
+    for (int i = 0; i < children.size(); ++i) {
+        QObject *object = children.at(i);
+        if (object->isWidgetType()) {
+            QWidget *w = static_cast<QWidget *>(object);
+            if (!w->isWindow() && w->testAttribute(Qt::WA_WState_Created))
+                w->d_func()->setWSGeometry(jump);
+        }
+    }
+
+    if (data.winid) {
+        // move ourselves to the new position and map (if necessary) after
+        // the movement. Rationale: moving unmapped windows is much faster
+        // than moving mapped windows
+        if (!parent->internalWinId())
+            xrect.translate(parent->mapTo(q->nativeParentWidget(), QPoint(0, 0)));
+
+        data.winid->SetExtent(TPoint(xrect.x(), xrect.y()), TSize(xrect.width(), xrect.height()));
+    }
+
+    if (mapWindow and !dontShow) {
+        q->setAttribute(Qt::WA_Mapped);
+        if (q->internalWinId())
+            q->internalWinId()->DrawableWindow()->SetVisible(ETrue);
+    }
 
+    if  (jump && data.winid) {
+        RWindow *const window = static_cast<RWindow *>(data.winid->DrawableWindow());
+        window->Invalidate(TRect(0, 0, wrect.width(), wrect.height()));
+    }
 }
 
 void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove)
 {
     Q_Q(QWidget);
+
     Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
 
     if ((q->windowType() == Qt::Desktop))
         return;
+
+    QPoint oldPos(q->pos());
+    QSize oldSize(q->size());
+    QRect oldGeom(data.crect);
+
+    // Lose maximized status if deliberate resize
+    if (w != oldSize.width() || h != oldSize.height())
+        data.window_state &= ~Qt::WindowMaximized;
+
     if (extra) {                                // any size restrictions?
         w = qMin(w,extra->maxw);
         h = qMin(h,extra->maxh);
@@ -105,17 +237,10 @@ void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove)
         data.window_state = s;
     }
 
-    QPoint oldPos(q->pos());
-    QSize oldSize(q->size());
-    QRect oldGeom(data.crect);
-
     bool isResize = w != oldSize.width() || h != oldSize.height();
     if (!isMove && !isResize)
         return;
 
-    if (isResize)
-        data.window_state &= ~Qt::WindowMaximized;
-
     if (q->isWindow()) {
         if (w == 0 || h == 0) {
             q->setAttribute(Qt::WA_OutsideWSRange, true);
@@ -129,7 +254,6 @@ void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove)
             // put the window in its place and show it
             q->internalWinId()->SetRect(TRect(TPoint(x, y), TSize(w, h)));
             data.crect.setRect(x, y, w, h);
-
             show_sys();
         } else {
             QRect r = QRect(x, y, w, h);
@@ -202,8 +326,6 @@ void QWidgetPrivate::create_sys(WId window, bool /* initializeWindow */, bool de
     bool desktop = (type == Qt::Desktop);
     //bool tool = (type == Qt::Tool || type == Qt::Drawer);
 
-    WId id = 0;
-
     if (popup)
         flags |= Qt::WindowStaysOnTopHint; // a popup stays on top
 
@@ -225,13 +347,10 @@ void QWidgetPrivate::create_sys(WId window, bool /* initializeWindow */, bool de
         data.crect.setSize(QSize(width, height));
     }
 
-    CCoeControl *destroyw = 0;
+    CCoeControl *const destroyw = destroyOldWindow ? data.winid : 0;
 
     createExtra();
     if (window) {
-        if (destroyOldWindow)
-            destroyw = data.winid;
-        id = window;
         setWinId(window);
         TRect tr = window->Rect();
         data.crect.setRect(tr.iTl.iX, tr.iTl.iY, tr.Width(), tr.Height());
@@ -239,10 +358,16 @@ void QWidgetPrivate::create_sys(WId window, bool /* initializeWindow */, bool de
     } else if (topLevel) {
         if (!q->testAttribute(Qt::WA_Moved) && !q->testAttribute(Qt::WA_DontShowOnScreen))
             data.crect.moveTopLeft(QPoint(clientRect.iTl.iX, clientRect.iTl.iY));
-        QSymbianControl *control= q_check_ptr(new QSymbianControl(q));
-        id = (WId)control;
-        setWinId(id);
-        QT_TRAP_THROWING(control->ConstructL(true,desktop));
+
+        QScopedPointer<QSymbianControl> control( q_check_ptr(new QSymbianControl(q)) );
+        QT_TRAP_THROWING(control->ConstructL(true, desktop));
+        control->SetMopParent(static_cast<CEikAppUi*>(S60->appUi()));
+
+        // Symbian windows are always created in an inactive state
+        // We perform this assignment for the case where the window is being re-created
+        // as aa result of a call to setParent_sys, on either this widget or one of its
+        // ancestors.
+        extra->activated = 0;
 
         if (!desktop) {
             TInt stackingFlags;
@@ -251,20 +376,22 @@ void QWidgetPrivate::create_sys(WId window, bool /* initializeWindow */, bool de
             } else {
                 stackingFlags = ECoeStackFlagStandard;
             }
-            QT_TRAP_THROWING(control->ControlEnv()->AppUi()->AddToStackL(control, ECoeStackPriorityDefault, stackingFlags));
+            control->MakeVisible(false);
+            QT_TRAP_THROWING(control->ControlEnv()->AppUi()->AddToStackL(control.data(), ECoeStackPriorityDefault, stackingFlags));
+            // Avoid keyboard focus to a hidden window.
+            control->setFocusSafely(false);
 
-            QTLWExtra *topExtra = topData();
-            topExtra->rwindow = control->DrawableWindow();
+            RDrawableWindow *const drawableWindow = control->DrawableWindow();
             // Request mouse move events.
-            topExtra->rwindow->PointerFilter(EPointerFilterEnterExit
+            drawableWindow->PointerFilter(EPointerFilterEnterExit
                 | EPointerFilterMove | EPointerFilterDrag, 0);
-            topExtra->rwindow->EnableVisibilityChangeEvents();
+            drawableWindow->EnableVisibilityChangeEvents();
 
             if (!isOpaque) {
-                RWindow *rwindow = static_cast<RWindow*>(topExtra->rwindow);
-                TDisplayMode gotDM = (TDisplayMode)rwindow->SetRequiredDisplayMode(EColor16MA);
-                if (rwindow->SetTransparencyAlphaChannel() == KErrNone)
-                    rwindow->SetBackgroundColor(TRgb(255, 255, 255, 0));
+                RWindow *const window = static_cast<RWindow *>(drawableWindow);
+                const TDisplayMode displayMode = static_cast<TDisplayMode>(window->SetRequiredDisplayMode(EColor16MA));
+                if (window->SetTransparencyAlphaChannel() == KErrNone)
+                    window->SetBackgroundColor(TRgb(255, 255, 255, 0));
             }
         }
 
@@ -273,31 +400,61 @@ void QWidgetPrivate::create_sys(WId window, bool /* initializeWindow */, bool de
         int x, y, w, h;
         data.crect.getRect(&x, &y, &w, &h);
         control->SetRect(TRect(TPoint(x, y), TSize(w, h)));
+
+        // We wait until the control is fully constructed before calling setWinId, because
+        // this generates a WinIdChanged event.
+        setWinId(control.take());
+
     } else if (q->testAttribute(Qt::WA_NativeWindow) || paintOnScreen()) { // create native child widget
-        QSymbianControl *control = new QSymbianControl(q);
-        setWinId(control);
+
+        QScopedPointer<QSymbianControl> control( q_check_ptr(new QSymbianControl(q)) );
         QT_TRAP_THROWING(control->ConstructL(!parentWidget));
 
+        // Symbian windows are always created in an inactive state
+        // We perform this assignment for the case where the window is being re-created
+        // as aa result of a call to setParent_sys, on either this widget or one of its
+        // ancestors.
+        extra->activated = 0;
+
         TInt stackingFlags;
         if ((q->windowType() & Qt::Popup) == Qt::Popup) {
             stackingFlags = ECoeStackFlagRefusesAllKeys | ECoeStackFlagRefusesFocus;
         } else {
             stackingFlags = ECoeStackFlagStandard;
         }
-        QT_TRAP_THROWING(control->ControlEnv()->AppUi()->AddToStackL(control, ECoeStackPriorityDefault, stackingFlags));
-
-        WId parentw = parentWidget->effectiveWinId();
-        QT_TRAP_THROWING(control->SetContainerWindowL(*parentw));
+        control->MakeVisible(false);
+        QT_TRAP_THROWING(control->ControlEnv()->AppUi()->AddToStackL(control.data(), ECoeStackPriorityDefault, stackingFlags));
+        // Avoid keyboard focus to a hidden window.
+        control->setFocusSafely(false);
 
         q->setAttribute(Qt::WA_WState_Created);
         int x, y, w, h;
         data.crect.getRect(&x, &y, &w, &h);
         control->SetRect(TRect(TPoint(x, y), TSize(w, h)));
+
+        RDrawableWindow *const drawableWindow = control->DrawableWindow();
+        // Request mouse move events.
+        drawableWindow->PointerFilter(EPointerFilterEnterExit
+            | EPointerFilterMove | EPointerFilterDrag, 0);
+
+        if (q->isVisible() && q->testAttribute(Qt::WA_Mapped)) {
+            activateSymbianWindow(control.data());
+            control->MakeVisible(true);
+        }
+
+        // We wait until the control is fully constructed before calling setWinId, because
+        // this generates a WinIdChanged event.
+        setWinId(control.take());
     }
 
     if (destroyw) {
         destroyw->ControlEnv()->AppUi()->RemoveFromStack(destroyw);
-        CBase::Delete(destroyw);
+
+        // Delay deletion of the control in case this function is called in the
+        // context of a CONE event handler such as
+        // CCoeControl::ProcessPointerEventL
+        QMetaObject::invokeMethod(q, "_q_delayedDestroy",
+            Qt::QueuedConnection, Q_ARG(WId, destroyw));
     }
 
     if (q->testAttribute(Qt::WA_AcceptTouchEvents))
@@ -321,34 +478,54 @@ void QWidgetPrivate::show_sys()
         return;
     }
 
-    if (q->isWindow() && q->internalWinId()) {
+    if (q->internalWinId()) {
+        if (!extra->activated)
+             activateSymbianWindow();
+
+         QSymbianControl *id = static_cast<QSymbianControl *>(q->internalWinId());
 
-        WId id = q->internalWinId();
-        if (!extra->topextra->activated) {
-            QT_TRAP_THROWING(id->ActivateL());
-            extra->topextra->activated = 1;
-        }
         id->MakeVisible(true);
-        id->SetFocus(true);
 
-        // Force setting of the icon after window is made visible,
-        // this is needed even WA_SetWindowIcon is not set, as in that case we need
-        // to reset to the application level window icon
-        setWindowIcon_sys(true);
+        if(q->isWindow())
+            id->setFocusSafely(true);
     }
 
     invalidateBuffer(q->rect());
 }
 
+void QWidgetPrivate::activateSymbianWindow(WId wid)
+{
+    Q_Q(QWidget);
+
+    Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
+    Q_ASSERT(q->testAttribute(Qt::WA_Mapped));
+    Q_ASSERT(!extra->activated);
+
+    if(!wid)
+        wid = q->internalWinId();
+
+    Q_ASSERT(wid);
+
+    QT_TRAP_THROWING(wid->ActivateL());
+    extra->activated = 1;
+}
+
 void QWidgetPrivate::hide_sys()
 {
     Q_Q(QWidget);
+
     Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
     deactivateWidgetCleanup();
-    WId id = q->internalWinId();
-    if (q->isWindow() && id) {
-        if (id->IsFocused()) // Avoid unnecessary calls to FocusChanged()
-            id->SetFocus(false);
+    QSymbianControl *id = static_cast<QSymbianControl *>(q->internalWinId());
+
+    if (id) {
+        //Incorrect optimisation - for popup windows, Qt's focus is moved before
+        //hide_sys is called, resulting in the popup window keeping its elevated
+        //position in the CONE control stack.
+        //This can result in keyboard focus being in an invisible widget in some
+        //conditions - e.g. QTBUG-4733
+        //if(id->IsFocused()) // Avoid unnecessary calls to FocusChanged()
+            id->setFocusSafely(false);
         id->MakeVisible(false);
         if (QWidgetBackingStore *bs = maybeBackingStore())
             bs->releaseBuffer();
@@ -364,55 +541,36 @@ void QWidgetPrivate::setFocus_sys()
     Q_Q(QWidget);
     if (q->testAttribute(Qt::WA_WState_Created) && q->window()->windowType() != Qt::Popup)
         if (!q->effectiveWinId()->IsFocused()) // Avoid unnecessry calls to FocusChanged()
-            q->effectiveWinId()->SetFocus(true);
-}
-
-void QWidgetPrivate::handleSymbianDeferredFocusChanged()
-{
-    Q_Q(QWidget);
-    WId control = q->internalWinId();
-    if (!control) {
-        // This could happen if the widget was reparented, while the focuschange
-        // was in the event queue.
-        return;
-    }
-
-    if (control->IsFocused()) {
-        QApplication::setActiveWindow(q);
-#ifdef Q_WS_S60
-        // If widget is fullscreen, hide status pane and button container
-        // otherwise show them.
-        CEikStatusPane* statusPane = S60->statusPane();
-        CEikButtonGroupContainer* buttonGroup = S60->buttonGroupContainer();
-        bool isFullscreen = q->windowState() & Qt::WindowFullScreen;
-        if (statusPane && (statusPane->IsVisible() == isFullscreen))
-            statusPane->MakeVisible(!isFullscreen);
-        if (buttonGroup && (buttonGroup->IsVisible() == isFullscreen))
-            buttonGroup->MakeVisible(!isFullscreen);
-#endif
-    } else {
-        QApplication::setActiveWindow(0);
-    }
+            static_cast<QSymbianControl *>(q->effectiveWinId())->setFocusSafely(true);
 }
 
 void QWidgetPrivate::raise_sys()
 {
     Q_Q(QWidget);
+
     Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
-    QTLWExtra *tlwExtra = maybeTopData();
-    if (q->internalWinId() && tlwExtra) {
-        tlwExtra->rwindow->SetOrdinalPosition(0);
+    if (q->internalWinId()) {
+        q->internalWinId()->DrawableWindow()->SetOrdinalPosition(0);
+
+        // If toplevel widget, raise app to foreground
+        if (q->isWindow())
+            S60->wsSession().SetWindowGroupOrdinalPosition(S60->windowGroup().Identifier(), 0);
     }
 }
 
 void QWidgetPrivate::lower_sys()
 {
     Q_Q(QWidget);
+
     Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
-    QTLWExtra *tlwExtra = maybeTopData();
-    if (q->internalWinId() && tlwExtra) {
-        tlwExtra->rwindow->SetOrdinalPosition(-1);
+    if (q->internalWinId()) {
+        // If toplevel widget, lower app to background
+        if (q->isWindow())
+            S60->wsSession().SetWindowGroupOrdinalPosition(S60->windowGroup().Identifier(), -1);
+        else
+            q->internalWinId()->DrawableWindow()->SetOrdinalPosition(-1);
     }
+
     if (!q->isWindow())
         invalidateBuffer(q->rect());
 }
@@ -426,10 +584,13 @@ void QWidgetPrivate::stackUnder_sys(QWidget* w)
 {
     Q_Q(QWidget);
     Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
-    QTLWExtra *tlwExtra = maybeTopData();
-    QTLWExtra *tlwExtraSibling = w->d_func()->maybeTopData();
-    if (q->internalWinId() && tlwExtra && w->internalWinId() && tlwExtraSibling)
-        tlwExtra->rwindow->SetOrdinalPosition(tlwExtraSibling->rwindow->OrdinalPosition() + 1);
+
+    if (q->internalWinId() && w->internalWinId()) {
+        RDrawableWindow *const thisWindow = q->internalWinId()->DrawableWindow();
+        RDrawableWindow *const otherWindow = w->internalWinId()->DrawableWindow();
+        thisWindow->SetOrdinalPosition(otherWindow->OrdinalPosition() + 1);
+    }
+
     if (!q->isWindow() || !w->internalWinId())
         invalidateBuffer(q->rect());
 }
@@ -437,6 +598,7 @@ void QWidgetPrivate::stackUnder_sys(QWidget* w)
 void QWidgetPrivate::reparentChildren()
 {
     Q_Q(QWidget);
+
     QObjectList chlist = q->children();
     for (int i = 0; i < chlist.size(); ++i) { // reparent children
         QObject *obj = chlist.at(i);
@@ -448,8 +610,14 @@ void QWidgetPrivate::reparentChildren()
                 w->d_func()->invalidateBuffer(w->rect());
                 WId parent = q->effectiveWinId();
                 WId child = w->effectiveWinId();
-                if (parent != child)
-                    child->SetParent(parent);
+                if (parent != child) {
+                    // Child widget is native.  Because Symbian windows cannot be
+                    // re-parented, we must re-create the window.
+                    const WId window = 0;
+                    const bool initializeWindow = false;
+                    const bool destroyOldWindow = true;
+                    w->d_func()->create_sys(window, initializeWindow, destroyOldWindow);
+                }
                 // ### TODO: We probably also need to update the component array here
                 w->d_func()->reparentChildren();
             } else {
@@ -467,6 +635,7 @@ void QWidgetPrivate::reparentChildren()
 void QWidgetPrivate::setParent_sys(QWidget *parent, Qt::WindowFlags f)
 {
     Q_Q(QWidget);
+
     bool wasCreated = q->testAttribute(Qt::WA_WState_Created);
 
     if (q->isVisible() && q->parentWidget() && parent != q->parentWidget())
@@ -475,7 +644,7 @@ void QWidgetPrivate::setParent_sys(QWidget *parent, Qt::WindowFlags f)
     if (q->testAttribute(Qt::WA_DropSiteRegistered))
         q->setAttribute(Qt::WA_DropSiteRegistered, false);
 
-    WId old_winid = wasCreated ? data.winid : 0;
+    QSymbianControl *old_winid = static_cast<QSymbianControl *>(wasCreated ? data.winid : 0);
     if ((q->windowType() == Qt::Desktop))
         old_winid = 0;
     setWinId(0);
@@ -485,7 +654,7 @@ void QWidgetPrivate::setParent_sys(QWidget *parent, Qt::WindowFlags f)
     if (wasCreated && old_winid) {
         old_winid->MakeVisible(false);
         if (old_winid->IsFocused()) // Avoid unnecessary calls to FocusChanged()
-            old_winid->SetFocus(false);
+            old_winid->setFocusSafely(false);
         old_winid->SetParent(0);
     }
 
@@ -536,73 +705,14 @@ void QWidgetPrivate::s60UpdateIsOpaque()
     if ((data.window_flags & Qt::FramelessWindowHint) == 0)
         return;
 
-    if (!isOpaque) {
-        QTLWExtra *topExtra = topData();
-        RWindow *rwindow = static_cast<RWindow*>(topExtra->rwindow);
-        TDisplayMode gotDM = (TDisplayMode)rwindow->SetRequiredDisplayMode(EColor16MA);
-        if (rwindow->SetTransparencyAlphaChannel() == KErrNone)
-            rwindow->SetBackgroundColor(TRgb(255, 255, 255, 0));
-    } else {
-        QTLWExtra *topExtra = topData();
-        RWindow *rwindow = static_cast<RWindow*>(topExtra->rwindow);
-        rwindow->SetTransparentRegion(TRegionFix<1>());
-    }
-}
-
-CFbsBitmap* qt_pixmapToNativeBitmap(QPixmap pixmap, bool invert)
-{
-    CFbsBitmap* fbsBitmap = q_check_ptr(new CFbsBitmap);    // CBase derived object needs check on new
-    TSize size(pixmap.size().width(), pixmap.size().height());
-    TDisplayMode mode(EColor16MU);
-
-    bool isNull = pixmap.isNull();
-    int depth = pixmap.depth();
-
-    // TODO: dummy assumptions from bit amounts for each color
-    // Will fix later on when native pixmap is implemented
-    switch(pixmap.depth()) {
-    case 1:
-        mode = EGray2;
-        break;
-    case 4:
-        mode = EColor16;
-        break;
-    case 8:
-        mode = EColor256;
-        break;
-    case 12:
-        mode = EColor4K;
-        break;
-    case 16:
-        mode = EColor64K;
-        break;
-    case 24:
-        mode = EColor16M;
-        break;
-    case 32:
-        case EColor16MU:
-        break;
-    default:
-        qFatal("Unsupported pixmap depth");
-        break;
-    }
+    RWindow *const window = static_cast<RWindow *>(q->effectiveWinId()->DrawableWindow());
 
-    qt_symbian_throwIfError(fbsBitmap->Create(size, mode));
-    fbsBitmap->LockHeap();
-    QImage image = pixmap.toImage();
-
-    if (invert)
-        image.invertPixels();
-
-    int height = pixmap.size().height();
-    for(int i=0;i<height;i++ )
-        {
-        TPtr8 scanline(image.scanLine(i), image.bytesPerLine(), image.bytesPerLine());
-        fbsBitmap->SetScanLine( scanline, i );
-        }
-
-    fbsBitmap->UnlockHeap();
-    return fbsBitmap;
+    if (!isOpaque) {
+        const TDisplayMode displayMode = static_cast<TDisplayMode>(window->SetRequiredDisplayMode(EColor16MA));
+        if (window->SetTransparencyAlphaChannel() == KErrNone)
+            window->SetBackgroundColor(TRgb(255, 255, 255, 0));
+    } else
+        window->SetTransparentRegion(TRegionFix<1>());
 }
 
 void QWidgetPrivate::setWindowIcon_sys(bool forceReset)
@@ -633,12 +743,8 @@ void QWidgetPrivate::setWindowIcon_sys(bool forceReset)
                 mask.fill(Qt::color1);
             }
 
-            // Convert to CFbsBitmp
-            // TODO: When QPixmap is adapted to use native CFbsBitmap,
-            // it could be set directly to context pane
-            CFbsBitmap* nBitmap = qt_pixmapToNativeBitmap(pm, false);
-            CFbsBitmap* nMask = qt_pixmapToNativeBitmap(mask, true);
-
+            CFbsBitmap* nBitmap = pm.toSymbianCFbsBitmap();
+            CFbsBitmap* nMask = mask.toSymbianCFbsBitmap();
             contextPane->SetPicture(nBitmap,nMask);
         } else {
             // Icon set to null -> set context pane picture to default
@@ -669,12 +775,8 @@ void QWidgetPrivate::setWindowIcon_sys(bool forceReset)
                     mask.fill(Qt::color1);
                 }
 
-                // Convert to CFbsBitmp
-                // TODO: When QPixmap is adapted to use native CFbsBitmap,
-                // it could be set directly to context pane
-                CFbsBitmap* nBitmap = qt_pixmapToNativeBitmap(pm, false);
-                CFbsBitmap* nMask = qt_pixmapToNativeBitmap(mask, true);
-
+                CFbsBitmap* nBitmap = pm.toSymbianCFbsBitmap();
+                CFbsBitmap* nMask = mask.toSymbianCFbsBitmap();
                 titlePane->SetSmallPicture( nBitmap, nMask, ETrue );
             } else {
                 // Icon set to null -> set context pane picture to default
@@ -722,8 +824,8 @@ void QWidgetPrivate::scroll_sys(int dx, int dy)
         scrollRect(q->rect(), dx, dy);
     } else {
         Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
-        RDrawableWindow* rw = topData()->rwindow;
-        rw->Scroll(TPoint(dx, dy));
+        RDrawableWindow *const window = q->internalWinId()->DrawableWindow();
+        window->Scroll(TPoint(dx, dy));
     }
 }
 
@@ -735,8 +837,8 @@ void QWidgetPrivate::scroll_sys(int dx, int dy, const QRect &r)
         scrollRect(r, dx, dy);
     } else {
         Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
-        RDrawableWindow* rw = topData()->rwindow;
-        rw->Scroll(TPoint(dx, dy), qt_QRect2TRect(r));
+        RDrawableWindow *const window = q->internalWinId()->DrawableWindow();
+        window->Scroll(TPoint(dx, dy), qt_QRect2TRect(r));
     }
 }
 
@@ -768,8 +870,6 @@ void QWidgetPrivate::registerDropSite(bool /* on */)
 void QWidgetPrivate::createTLSysExtra()
 {
     extra->topextra->backingStore = 0;
-    extra->topextra->activated = 0;
-    extra->topextra->rwindow = 0;
 }
 
 void QWidgetPrivate::deleteTLSysExtra()
@@ -780,7 +880,9 @@ void QWidgetPrivate::deleteTLSysExtra()
 
 void QWidgetPrivate::createSysExtra()
 {
-
+    extra->activated = 0;
+    extra->nativePaintMode = QWExtra::Default;
+    extra->receiveNativePaintEvents = 0;
 }
 
 void QWidgetPrivate::deleteSysExtra()
@@ -903,9 +1005,10 @@ QPoint QWidget::mapToGlobal(const QPoint &pos) const
         return pos + tp;
     }
 
-    // This is the native window case. Consider using CCoeControl::PositionRelativeToScreen()
-    // if we decide to go with CCoeControl
-    return QPoint();
+    // Native window case
+    const TPoint widgetScreenOffset = internalWinId()->PositionRelativeToScreen();
+    const QPoint globalPos = QPoint(widgetScreenOffset.iX, widgetScreenOffset.iY) + pos;
+    return globalPos;
 }
 
 QPoint QWidget::mapFromGlobal(const QPoint &pos) const
@@ -919,13 +1022,16 @@ QPoint QWidget::mapFromGlobal(const QPoint &pos) const
         return pos - tp;
     }
 
-    // ### TODO native window
-    return QPoint();
+    // Native window case
+    const TPoint widgetScreenOffset = internalWinId()->PositionRelativeToScreen();
+    const QPoint widgetPos = pos - QPoint(widgetScreenOffset.iX, widgetScreenOffset.iY);
+    return widgetPos;
 }
 
 void QWidget::setWindowState(Qt::WindowStates newstate)
 {
     Q_D(QWidget);
+
     Qt::WindowStates oldstate = windowState();
     if (oldstate == newstate)
         return;
@@ -1002,17 +1108,17 @@ void QWidget::setWindowState(Qt::WindowStates newstate)
         if ((oldstate & Qt::WindowMinimized) != (newstate & Qt::WindowMinimized)) {
             if (newstate & Qt::WindowMinimized) {
                 if (isVisible()) {
-                    WId id = effectiveWinId();
+                    QSymbianControl *id = static_cast<QSymbianControl *>(effectiveWinId());
                     if (id->IsFocused()) // Avoid unnecessary calls to FocusChanged()
-                        id->SetFocus(false);
+                        id->setFocusSafely(false);
                     id->MakeVisible(false);
                 }
             } else {
                 if (isVisible()) {
-                    WId id = effectiveWinId();
+                    QSymbianControl *id = static_cast<QSymbianControl *>(effectiveWinId());
                     id->MakeVisible(true);
                     if (!id->IsFocused()) // Avoid unnecessary calls to FocusChanged()
-                        id->SetFocus(true);
+                        id->setFocusSafely(true);
                 }
                 const QRect normalGeometry = geometry();
                 const QRect r = top->normalGeometry;
@@ -1039,7 +1145,7 @@ void QWidget::destroy(bool destroyWindow, bool destroySubWindows)
     if (!isWindow() && parentWidget())
         parentWidget()->d_func()->invalidateBuffer(geometry());
     d->deactivateWidgetCleanup();
-    WId id = internalWinId();
+    QSymbianControl *id = static_cast<QSymbianControl *>(internalWinId());
     if (testAttribute(Qt::WA_WState_Created)) {
 
 #ifndef QT_NO_IM
@@ -1067,20 +1173,8 @@ void QWidget::destroy(bool destroyWindow, bool destroySubWindows)
         }
         if (destroyWindow && !(windowType() == Qt::Desktop) && id) {
             if (id->IsFocused()) // Avoid unnecessry calls to FocusChanged()
-                id->SetFocus(false);
+                id->setFocusSafely(false);
             id->ControlEnv()->AppUi()->RemoveFromStack(id);
-
-            // Hack to activate window under destroyed one. With this activation
-            // the next visible window will get keyboard focus
-            WId wid = CEikonEnv::Static()->AppUi()->TopFocusedControl();
-            if (wid) {
-                QWidget *widget = QWidget::find(wid);
-                QApplication::setActiveWindow(widget);
-                if (widget) {
-                    // Reset global window title for focusing window
-                    widget->d_func()->setWindowTitle_sys(widget->windowTitle());
-                }
-            }
         }
     }
 
@@ -1127,14 +1221,14 @@ void QWidget::releaseKeyboard()
 
 void QWidget::grabMouse()
 {
-    if (!qt_nograb()) {
+    if (isVisible() && !qt_nograb()) {
         if (QWidgetPrivate::mouseGrabber && QWidgetPrivate::mouseGrabber != this)
             QWidgetPrivate::mouseGrabber->releaseMouse();
         Q_ASSERT(testAttribute(Qt::WA_WState_Created));
         WId id = effectiveWinId();
         id->SetPointerCapture(true);
         QWidgetPrivate::mouseGrabber = this;
-        
+
 #ifndef QT_NO_CURSOR
         QApplication::setOverrideCursor(cursor());
 #endif
@@ -1144,7 +1238,7 @@ void QWidget::grabMouse()
 #ifndef QT_NO_CURSOR
 void QWidget::grabMouse(const QCursor &cursor)
 {
-    if (!qt_nograb()) {
+    if (isVisible() && !qt_nograb()) {
         if (QWidgetPrivate::mouseGrabber && QWidgetPrivate::mouseGrabber != this)
             QWidgetPrivate::mouseGrabber->releaseMouse();
         Q_ASSERT(testAttribute(Qt::WA_WState_Created));
@@ -1173,11 +1267,12 @@ void QWidget::releaseMouse()
 void QWidget::activateWindow()
 {
     Q_D(QWidget);
+
     QWidget *tlw = window();
     if (tlw->isVisible()) {
         window()->createWinId();
-        WId id = tlw->internalWinId();
-        id->SetFocus(true);
+        QSymbianControl *id = static_cast<QSymbianControl *>(tlw->internalWinId());
+        id->setFocusSafely(true);
     }
 }