/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qwidget_p.h"

#include "qdesktopwidget.h"

#include "qapplication.h"

#include "qapplication_p.h"

#include "private/qbackingstore_p.h"

#include "qevent.h"

#include "qt_s60_p.h"

#include "qbitmap.h"

#include "private/qwindowsurface_s60_p.h"

#include <qinputcontext.h>

#ifdef Q_WS_S60

#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();

QWidget *QWidgetPrivate::mouseGrabber = 0;

QWidget *QWidgetPrivate::keyboardGrabber = 0;

static bool isEqual(const QList<QAction*>& a, const QList<QAction*>& b)

{

    if ( a.count() != b.count())

        return false;

    int index=0;

    while (index<a.count()) {

        if (a.at(index)->softKeyRole() != b.at(index)->softKeyRole())

            return false;

        if (a.at(index)->text().compare(b.at(index)->text())!=0)

            return false;

        index++;

    }

    return true;

}

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);

        w = qMax(w,extra->minw);

        h = qMax(h,extra->minh);

    }

    if (q->isWindow())

        topData()->normalGeometry = QRect(0, 0, -1, -1);

    else {

        uint s = data.window_state;

        s &= ~(Qt::WindowMaximized | Qt::WindowFullScreen);

        data.window_state = s;

    }

    bool isResize = w != oldSize.width() || h != oldSize.height();

    if (!isMove && !isResize)

        return;

    if (q->isWindow()) {

        if (w == 0 || h == 0) {

            q->setAttribute(Qt::WA_OutsideWSRange, true);

            if (q->isVisible() && q->testAttribute(Qt::WA_Mapped))

                hide_sys();

            data.crect = QRect(x, y, w, h);

            data.window_state &= ~Qt::WindowFullScreen;

        } else if (q->isVisible() && q->testAttribute(Qt::WA_OutsideWSRange)) {

            q->setAttribute(Qt::WA_OutsideWSRange, false);

            // 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);

            data.crect = r;

            q->internalWinId()->SetRect(TRect(TPoint(x, y), TSize(w, h)));

            topData()->normalGeometry = data.crect;

        }

    } else {

        data.crect.setRect(x, y, w, h);

        QTLWExtra *tlwExtra = q->window()->d_func()->maybeTopData();

        const bool inTopLevelResize = tlwExtra ? tlwExtra->inTopLevelResize : false;

        if (q->isVisible() && (!inTopLevelResize || q->internalWinId())) {

            // Top-level resize optimization does not work for native child widgets;

            // disable it for this particular widget.

            if (inTopLevelResize)

                tlwExtra->inTopLevelResize = false;

            if (!isResize && maybeBackingStore())

                moveRect(QRect(oldPos, oldSize), x - oldPos.x(), y - oldPos.y());

            else

                invalidateBuffer_resizeHelper(oldPos, oldSize);

            if (inTopLevelResize)

                tlwExtra->inTopLevelResize = true;

        }

        if (q->testAttribute(Qt::WA_WState_Created))

            setWSGeometry();

    }

    if (q->isVisible()) {

        if (isMove && q->pos() != oldPos) {

            QMoveEvent e(q->pos(), oldPos);

            QApplication::sendEvent(q, &e);

        }

        if (isResize) {

            bool slowResize = qgetenv("QT_SLOW_TOPLEVEL_RESIZE").toInt();

            const bool setTopLevelResize = !slowResize && q->isWindow() && extra && extra->topextra

                                           && !extra->topextra->inTopLevelResize;

            if (setTopLevelResize)

                extra->topextra->inTopLevelResize = true;

            QResizeEvent e(q->size(), oldSize);

            QApplication::sendEvent(q, &e);

            if (!q->testAttribute(Qt::WA_StaticContents) && q->internalWinId())

                q->internalWinId()->DrawDeferred();

            if (setTopLevelResize)

                extra->topextra->inTopLevelResize = false;

        }

    } else {

        if (isMove && q->pos() != oldPos)

            q->setAttribute(Qt::WA_PendingMoveEvent, true);

        if (isResize)

            q->setAttribute(Qt::WA_PendingResizeEvent, true);

    }

}

void QWidgetPrivate::create_sys(WId window, bool /* initializeWindow */, bool destroyOldWindow)

{

    Q_Q(QWidget);

    Qt::WindowType type = q->windowType();

    Qt::WindowFlags &flags = data.window_flags;

    QWidget *parentWidget = q->parentWidget();

    bool topLevel = (flags & Qt::Window);

    bool popup = (type == Qt::Popup);

    bool dialog = (type == Qt::Dialog

                   || type == Qt::Sheet

                   || (flags & Qt::MSWindowsFixedSizeDialogHint));

    bool desktop = (type == Qt::Desktop);

    //bool tool = (type == Qt::Tool || type == Qt::Drawer);

    if (popup)

        flags |= Qt::WindowStaysOnTopHint; // a popup stays on top

    TRect clientRect = static_cast<CEikAppUi*>(S60->appUi())->ClientRect();

    int sw = clientRect.Width();

    int sh = clientRect.Height();

    if (desktop) {

        TSize screenSize = S60->screenDevice()->SizeInPixels();

        data.crect.setRect(0, 0, screenSize.iWidth, screenSize.iHeight);

        q->setAttribute(Qt::WA_DontShowOnScreen);

    } else if (topLevel && !q->testAttribute(Qt::WA_Resized)){

        int width = sw;

        int height = sh;

        if (extra) {

            width = qMax(qMin(width, extra->maxw), extra->minw);

            height = qMax(qMin(height, extra->maxh), extra->minh);

        }

        data.crect.setSize(QSize(width, height));

    }

    CCoeControl *const destroyw = destroyOldWindow ? data.winid : 0;

    createExtra();

    if (window) {

        setWinId(window);

        TRect tr = window->Rect();

        data.crect.setRect(tr.iTl.iX, tr.iTl.iY, tr.Width(), tr.Height());

    } else if (topLevel) {

        if (!q->testAttribute(Qt::WA_Moved) && !q->testAttribute(Qt::WA_DontShowOnScreen))

            data.crect.moveTopLeft(QPoint(clientRect.iTl.iX, clientRect.iTl.iY));

        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;

            if ((q->windowType() & Qt::Popup) == Qt::Popup) {

                stackingFlags = ECoeStackFlagRefusesAllKeys | ECoeStackFlagRefusesFocus;

            } else {

                stackingFlags = ECoeStackFlagStandard;

            }

            control->MakeVisible(false);

            QT_TRAP_THROWING(control->ControlEnv()->AppUi()->AddToStackL(control.data(), ECoeStackPriorityDefault, stackingFlags));

            // Avoid keyboard focus to a hidden window.

            control->setFocusSafely(false);

            RDrawableWindow *const drawableWindow = control->DrawableWindow();

            // Request mouse move events.

            drawableWindow->PointerFilter(EPointerFilterEnterExit

                | EPointerFilterMove | EPointerFilterDrag, 0);

            drawableWindow->EnableVisibilityChangeEvents();

            s60UpdateIsOpaque();

        }

        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)));

        // 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

        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;