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

**

** 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 "qapplication_p.h"

#include "qsessionmanager.h"

#include "qevent.h"

#include "qsymbianevent.h"

#include "qeventdispatcher_s60_p.h"

#include "qwidget.h"

#include "qdesktopwidget.h"

#include "private/qbackingstore_p.h"

#include "qt_s60_p.h"

#include "private/qevent_p.h"

#include "qstring.h"

#include "qdebug.h"

#include "qimage.h"

#include "private/qkeymapper_p.h"

#include "private/qfont_p.h"

#ifndef QT_NO_STYLE_S60

#include "private/qs60style_p.h"

#endif

#include "private/qwindowsurface_s60_p.h"

#include "qpaintengine.h"

#include "private/qmenubar_p.h"

#include "private/qsoftkeymanager_p.h"

#include "apgwgnam.h" // For CApaWindowGroupName

#include <mdaaudiotoneplayer.h>     // For CMdaAudioToneUtility

#if defined(Q_WS_S60)

# if !defined(QT_NO_IM)

#  include "qinputcontext.h"

#  include <private/qcoefepinputcontext_p.h>

# endif

# include <private/qs60mainapplication_p.h>

#endif

#include "private/qstylesheetstyle_p.h"

#include <hal.h>

#include <hal_data.h>

QT_BEGIN_NAMESPACE

#if defined(QT_DEBUG)

static bool        appNoGrab        = false;        // Grabbing enabled

#endif

static bool        app_do_modal        = false;        // modal mode

Q_GLOBAL_STATIC(QS60Data, qt_s60Data);

extern bool qt_sendSpontaneousEvent(QObject*,QEvent*);

extern QWidgetList *qt_modal_stack;              // stack of modal widgets

extern QDesktopWidget *qt_desktopWidget; // qapplication.cpp

QWidget *qt_button_down = 0;                     // widget got last button-down

QSymbianControl *QSymbianControl::lastFocusedControl = 0;

QS60Data* qGlobalS60Data()

{

    return qt_s60Data();

}

bool qt_nograb()                                // application no-grab option

{

#if defined(QT_DEBUG)

    return appNoGrab;

#else

    return false;

#endif

}

// Modified from http://www3.symbian.com/faq.nsf/0/0F1464EE96E737E780256D5E00503DD1?OpenDocument

class QS60Beep : public CBase, public MMdaAudioToneObserver

{

public:

    static QS60Beep* NewL(TInt aFrequency,  TTimeIntervalMicroSeconds iDuration);

    void Play();

    ~QS60Beep();

private:

    void ConstructL(TInt aFrequency,  TTimeIntervalMicroSeconds iDuration);

    void MatoPrepareComplete(TInt aError);

    void MatoPlayComplete(TInt aError);

private:

    typedef enum

        {

        EBeepNotPrepared,

        EBeepPrepared,

        EBeepPlaying

        } TBeepState;

private:

    CMdaAudioToneUtility* iToneUtil;

    TBeepState iState;

    TInt iFrequency;

    TTimeIntervalMicroSeconds iDuration;

};

static QS60Beep* qt_S60Beep = 0;

QS60Beep::~QS60Beep()

{

    if (iToneUtil) {

        switch (iState) {

        case EBeepPlaying:

            iToneUtil->CancelPlay();

            break;

        case EBeepNotPrepared:

            iToneUtil->CancelPrepare();

            break;

        }

    }

    delete iToneUtil;

}

QS60Beep* QS60Beep::NewL(TInt aFrequency, TTimeIntervalMicroSeconds aDuration)

{

    QS60Beep* self = new (ELeave) QS60Beep();

    CleanupStack::PushL(self);

    self->ConstructL(aFrequency, aDuration);

    CleanupStack::Pop();

    return self;

}

void QS60Beep::ConstructL(TInt aFrequency, TTimeIntervalMicroSeconds aDuration)

{

    iToneUtil = CMdaAudioToneUtility::NewL(*this);

    iState = EBeepNotPrepared;

    iFrequency = aFrequency;

    iDuration = aDuration;

    iToneUtil->PrepareToPlayTone(iFrequency, iDuration);

}

void QS60Beep::Play()

{

    if (iState == EBeepPlaying) {

        iToneUtil->CancelPlay();

        iState = EBeepPrepared;

    }

    iToneUtil->Play();

    iState = EBeepPlaying;

}

void QS60Beep::MatoPrepareComplete(TInt aError)

{

    if (aError == KErrNone) {

        iState = EBeepPrepared;

        Play();

    }

}

void QS60Beep::MatoPlayComplete(TInt aError)

{

    Q_UNUSED(aError);

    iState = EBeepPrepared;

}

QHash<TInt, TUint> QApplicationPrivate::scanCodeCache;

static Qt::KeyboardModifiers mapToQtModifiers(TUint s60Modifiers)

{

    Qt::KeyboardModifiers result = Qt::NoModifier;

    if (s60Modifiers & EModifierKeypad)

        result |= Qt::KeypadModifier;

    if (s60Modifiers & EModifierShift || s60Modifiers & EModifierLeftShift

            || s60Modifiers & EModifierRightShift)

        result |= Qt::ShiftModifier;

    if (s60Modifiers & EModifierCtrl || s60Modifiers & EModifierLeftCtrl

            || s60Modifiers & EModifierRightCtrl)

        result |= Qt::ControlModifier;

    if (s60Modifiers & EModifierAlt || s60Modifiers & EModifierLeftAlt

            || s60Modifiers & EModifierRightAlt)

        result |= Qt::AltModifier;

    return result;

}

static void mapS60MouseEventTypeToQt(QEvent::Type *type, Qt::MouseButton *button, const TPointerEvent *pEvent)

{

    switch (pEvent->iType) {

    case TPointerEvent::EButton1Down:

        *type = QEvent::MouseButtonPress;

        *button = Qt::LeftButton;

        break;

    case TPointerEvent::EButton1Up:

        *type = QEvent::MouseButtonRelease;

        *button = Qt::LeftButton;

        break;

    case TPointerEvent::EButton2Down:

        *type = QEvent::MouseButtonPress;

        *button = Qt::MidButton;

        break;

    case TPointerEvent::EButton2Up:

        *type = QEvent::MouseButtonRelease;

        *button = Qt::MidButton;

        break;

    case TPointerEvent::EButton3Down:

        *type = QEvent::MouseButtonPress;

        *button = Qt::RightButton;

        break;

    case TPointerEvent::EButton3Up:

        *type = QEvent::MouseButtonRelease;

        *button = Qt::RightButton;

        break;

    case TPointerEvent::EDrag:

        *type = QEvent::MouseMove;

        *button = Qt::NoButton;

        break;

    case TPointerEvent::EMove:

        // Qt makes no distinction between move and drag

        *type = QEvent::MouseMove;

        *button = Qt::NoButton;

        break;

    default:

        *type = QEvent::None;

        *button = Qt::NoButton;

        break;

    }

    if (pEvent->iModifiers & EModifierDoubleClick){

        *type = QEvent::MouseButtonDblClick;

    }

    if (*type == QEvent::MouseButtonPress || *type == QEvent::MouseButtonDblClick)

        QApplicationPrivate::mouse_buttons = QApplicationPrivate::mouse_buttons | (*button);

    else if (*type == QEvent::MouseButtonRelease)

        QApplicationPrivate::mouse_buttons = QApplicationPrivate::mouse_buttons &(~(*button));

    QApplicationPrivate::mouse_buttons = QApplicationPrivate::mouse_buttons & Qt::MouseButtonMask;

}

//### Can be replaced with CAknLongTapDetector if animation is required.

//NOTE: if CAknLongTapDetector is used make sure it gets variated out of 3.1 and 3.2,.

//also MLongTapObserver needs to be changed to MAknLongTapDetectorCallBack if CAknLongTapDetector is used.

class QLongTapTimer : public CTimer

{

public:

    static QLongTapTimer* NewL(QAbstractLongTapObserver *observer);

    QLongTapTimer(QAbstractLongTapObserver *observer);

    void ConstructL();

public:

    void PointerEventL(const TPointerEvent &event);

    void RunL();

protected:

private:

    QAbstractLongTapObserver *m_observer;

    TPointerEvent m_event;

    QPoint m_pressedCoordinates;

    int m_dragDistance;

};

QLongTapTimer* QLongTapTimer::NewL(QAbstractLongTapObserver *observer)

{

    QLongTapTimer* self = new QLongTapTimer(observer);

    self->ConstructL();

    return self;

}

void QLongTapTimer::ConstructL()

{

    CTimer::ConstructL();

}

QLongTapTimer::QLongTapTimer(QAbstractLongTapObserver *observer):CTimer(CActive::EPriorityHigh)

{

    m_observer = observer;

    m_dragDistance = qApp->startDragDistance();

    CActiveScheduler::Add(this);

}

void QLongTapTimer::PointerEventL(const TPointerEvent& event)

{

    if ( event.iType == TPointerEvent::EDrag || event.iType == TPointerEvent::EButtonRepeat)

    {

        QPoint diff(QPoint(event.iPosition.iX,event.iPosition.iY) - m_pressedCoordinates);

        if (diff.manhattanLength() < m_dragDistance)

            return;

    }

    Cancel();

    m_event = event;

    if (event.iType == TPointerEvent::EButton1Down)

    {

        m_pressedCoordinates = QPoint(event.iPosition.iX,event.iPosition.iY);

        // must be same as KLongTapDelay in aknlongtapdetector.h

        After(800000);

    }

}

void QLongTapTimer::RunL()

{

    if (m_observer)

        m_observer->HandleLongTapEventL(m_event.iPosition, m_event.iParentPosition);

}

QSymbianControl::QSymbianControl(QWidget *w)

    : CCoeControl()

    , qwidget(w)

    , m_longTapDetector(0)

    , m_ignoreFocusChanged(0)

    , m_symbianPopupIsOpen(0)

{

}

void QSymbianControl::ConstructL(bool isWindowOwning, bool desktop)

{

    if (!desktop)

    {

        if (isWindowOwning or !qwidget->parentWidget())

            CreateWindowL(S60->windowGroup());

        else

            /**

             * TODO: in order to avoid creating windows for all ancestors of

             * this widget up to the root window, the parameter passed to

             * CreateWindowL should be

             * qwidget->parentWidget()->effectiveWinId().  However, if we do

             * this, then we need to take care of re-parenting when a window

             * is created for a widget between this one and the root window.

             */

            CreateWindowL(qwidget->parentWidget()->winId());

        // Necessary in order to be able to track the activation status of

        // the control's window

        qwidget->d_func()->createExtra();

        SetFocusing(true);

        m_longTapDetector = QLongTapTimer::NewL(this);

        DrawableWindow()->SetPointerGrab(ETrue);

    }

}

QSymbianControl::~QSymbianControl()

{

    if (S60->curWin == this)

        S60->curWin = 0;

    if (!QApplicationPrivate::is_app_closing)

        setFocusSafely(false);

    S60->appUi()->RemoveFromStack(this);

    delete m_longTapDetector;

}

void QSymbianControl::setWidget(QWidget *w)

{

    qwidget = w;

}

void QSymbianControl::HandleLongTapEventL( const TPoint& aPenEventLocation, const TPoint& aPenEventScreenLocation )

{

    QWidget *alienWidget;

    QPoint widgetPos = QPoint(aPenEventLocation.iX, aPenEventLocation.iY);

    QPoint globalPos = QPoint(aPenEventScreenLocation.iX,aPenEventScreenLocation.iY);

    alienWidget = qwidget->childAt(widgetPos);

    if (!alienWidget)

        alienWidget = qwidget;

#if !defined(QT_NO_CONTEXTMENU)

    QContextMenuEvent contextMenuEvent(QContextMenuEvent::Mouse, widgetPos, globalPos, Qt::NoModifier);

    qt_sendSpontaneousEvent(alienWidget, &contextMenuEvent);

#endif

}

#ifdef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER

void QSymbianControl::translateAdvancedPointerEvent(const TAdvancedPointerEvent *event)

{

    QApplicationPrivate *d = QApplicationPrivate::instance();

    QRect screenGeometry = qApp->desktop()->screenGeometry(qwidget);

    while (d->appAllTouchPoints.count() <= event->PointerNumber())

        d->appAllTouchPoints.append(QTouchEvent::TouchPoint(d->appAllTouchPoints.count()));

    Qt::TouchPointStates allStates = 0;

    for (int i = 0; i < d->appAllTouchPoints.count(); ++i) {

        QTouchEvent::TouchPoint &touchPoint = d->appAllTouchPoints[i];

        if (touchPoint.id() == event->PointerNumber()) {

            Qt::TouchPointStates state;

            switch (event->iType) {

            case TPointerEvent::EButton1Down:

            case TPointerEvent::EEnterHighPressure:

                state = Qt::TouchPointPressed;

                break;

            case TPointerEvent::EButton1Up:

            case TPointerEvent::EExitCloseProximity:

                state = Qt::TouchPointReleased;

                break;

            case TPointerEvent::EDrag:

                state = Qt::TouchPointMoved;

                break;

            default:

                // how likely is this to happen?

                state = Qt::TouchPointStationary;

                break;

            }

            if (event->PointerNumber() == 0)

                state |= Qt::TouchPointPrimary;

            touchPoint.setState(state);

            QPointF screenPos = QPointF(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));

        } else if (touchPoint.state() != Qt::TouchPointReleased) {

            // all other active touch points should be marked as stationary

            touchPoint.setState(Qt::TouchPointStationary);

        }

        allStates |= touchPoint.state();

    }

    if ((allStates & Qt::TouchPointStateMask) == Qt::TouchPointReleased) {

        // all touch points released

        d->appAllTouchPoints.clear();

    }

    QApplicationPrivate::translateRawTouchEvent(qwidget,

                                                QTouchEvent::TouchScreen,

                                                d->appAllTouchPoints);

}

#endif

void QSymbianControl::HandlePointerEventL(const TPointerEvent& pEvent)

{

#ifdef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER

    if (pEvent.IsAdvancedPointerEvent()) {

        const TAdvancedPointerEvent *advancedPointerEvent = pEvent.AdvancedPointerEvent();

        translateAdvancedPointerEvent(advancedPointerEvent);

        if (advancedPointerEvent->PointerNumber() != 0) {

            // only send mouse events for the first touch point

            return;

        }

    }

#endif

    m_longTapDetector->PointerEventL(pEvent);

    QT_TRYCATCH_LEAVING(HandlePointerEvent(pEvent));

}

void QSymbianControl::HandlePointerEvent(const TPointerEvent& pEvent)

{

    QMouseEvent::Type type;

    Qt::MouseButton button;

    mapS60MouseEventTypeToQt(&type, &button, &pEvent);

    Qt::KeyboardModifiers modifiers = mapToQtModifiers(pEvent.iModifiers);

    QPoint widgetPos = QPoint(pEvent.iPosition.iX, pEvent.iPosition.iY);

    TPoint controlScreenPos = PositionRelativeToScreen();

    QPoint globalPos = QPoint(controlScreenPos.iX, controlScreenPos.iY) + widgetPos;

    S60->lastCursorPos = globalPos;

    S60->lastPointerEventPos = widgetPos;

    QWidget *mouseGrabber = QWidget::mouseGrabber();

    QWidget *popupWidget = qApp->activePopupWidget();

    QWidget *popupReceiver = 0;

    if (popupWidget) {

        QWidget *popupChild = popupWidget->childAt(popupWidget->mapFromGlobal(globalPos));

        popupReceiver = popupChild ? popupChild : popupWidget;

    }

    if (mouseGrabber) {

        if (popupReceiver) {

            sendMouseEvent(popupReceiver, type, globalPos, button, modifiers);

        } else {

            sendMouseEvent(mouseGrabber, type, globalPos, button, modifiers);

        }

        // No Enter/Leave events in grabbing mode.

        return;

    }

    QWidget *widgetUnderPointer = qwidget->childAt(widgetPos);

    if (!widgetUnderPointer)

        widgetUnderPointer = qwidget;

    QApplicationPrivate::dispatchEnterLeave(widgetUnderPointer, S60->lastPointerEventTarget);

    S60->lastPointerEventTarget = widgetUnderPointer;

    QWidget *receiver;

    if (!popupReceiver && S60->mousePressTarget && type != QEvent::MouseButtonPress) {

        receiver = S60->mousePressTarget;

        if (type == QEvent::MouseButtonRelease)

            S60->mousePressTarget = 0;