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

 * Copyright (c) 2005, 2010 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Nokia Corporation - S60 implementation

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

#include <coecntrl.h>

#include <AknUtils.h>

#include "swtevents.h"

#include "eswtwidgetscore.h"

#include "eswtwidgetsexpanded.h"

#include "javalocalref.h"

#include "methodcall.h"

#include "utils.h"

#include "swtdialogbroker.h"

// ======== MEMBER FUNCTIONS ========

// -----------------------------------------------------------------------------

// CSwtEvent::CSwtEvent

// -----------------------------------------------------------------------------

//

inline CSwtEvent::CSwtEvent(TSwtPeer aPeer)

        : iPeer(aPeer)

{

    ASSERT(iPeer);

}

// -----------------------------------------------------------------------------

// CSwtEvent::Dispatch

// -----------------------------------------------------------------------------

//

void CSwtEvent::Dispatch(JNIEnv* aJniEnv)

{

    ASSERT(!IsDisplayDisposed());

    ASSERT(!IsPeerDisposed());

    DoDispatch(aJniEnv);

}

// -----------------------------------------------------------------------------

// CSwtCallbackEvent::CSwtCallbackEvent

// -----------------------------------------------------------------------------

//

inline CSwtCallbackEvent::CSwtCallbackEvent(TSwtPeer aPeer)

        : CSwtEvent(aPeer)

{

}

// -----------------------------------------------------------------------------

// CSwtCallbackEvent::DoDispatch

// -----------------------------------------------------------------------------

//

void CSwtCallbackEvent::DoDispatch(JNIEnv* aJniEnv)

{

    // Dispatch the message

    jboolean doIt;

    TBool ok = SendEvent(aJniEnv, doIt);

    // Check if further execution should stop

    if (IsDisplayDisposed() || IsPeerDisposed() || !ok)

    {

        return;

    }

    // Call back the originator

    TRAPD(error, CallMethodL(this, &CSwtCallbackEvent::CallbackL, doIt));

    ThrowIfError(error, aJniEnv);

}

// -----------------------------------------------------------------------------

// CSwtPlainEvent::CSwtPlainEvent

// -----------------------------------------------------------------------------

//

CSwtPlainEvent::CSwtPlainEvent(TSwtPeer aPeer, TSwtEventType aType)

        : CSwtEvent(aPeer)

        , iType(aType)

        , iDetail(KSwtNone)

        , iItemPeer(NULL)

{

}

// -----------------------------------------------------------------------------

// CSwtPlainEvent::CSwtPlainEvent

// -----------------------------------------------------------------------------

//

CSwtPlainEvent::CSwtPlainEvent(TSwtPeer aPeer, TSwtEventType aType,

                               TInt aDetail, TSwtPeer aItemPeer)

        : CSwtEvent(aPeer)

        , iType(aType)

        , iDetail(aDetail)

        , iItemPeer(aItemPeer)

{

}

// -----------------------------------------------------------------------------

// CSwtPlainEvent::Type

// -----------------------------------------------------------------------------

//

TSwtEventType CSwtPlainEvent::Type() const

{

    return iType;

}

// -----------------------------------------------------------------------------

// CSwtPlainEvent::DoDispatch

// -----------------------------------------------------------------------------

//

void CSwtPlainEvent::DoDispatch(JNIEnv* aJniEnv)

{

    TBool failed;

    CallVoidJavaMethod(failed, aJniEnv, Peer(), "internal_sendEvent",

                       "(IILorg/eclipse/swt/widgets/Widget;)V", static_cast<jint>(iType),

                       iDetail, iItemPeer);

}

// -----------------------------------------------------------------------------

// CSwtKeyEvent::CSwtKeyEvent

// -----------------------------------------------------------------------------

//

CSwtKeyEvent::CSwtKeyEvent(MSwtControl& aControl, const TSwtKeyEventData& aData,

                           const TKeyEvent& aKeyEvent, TEventCode aType)

        : CSwtCallbackEvent(aControl.JavaPeer())

        , iControl(aControl)

        , iSwtType(aData.iType)

        , iCharacter(static_cast<jchar>(aData.iCharacter))

        , iKeyCode(aData.iKeyCode)

        , iStateMask(aData.iStateMask)

        , iKeyEvent(aKeyEvent)

        , iType(aType)

{

    ASSERT(aType == EEventKeyDown || aType == EEventKey || aType == EEventKeyUp);

}

// -----------------------------------------------------------------------------

// CSwtKeyEvent::Type

// -----------------------------------------------------------------------------

//

TSwtEventType CSwtKeyEvent::Type() const

{

    return iSwtType;

}

// -----------------------------------------------------------------------------

// CSwtKeyEvent::SendEvent

// -----------------------------------------------------------------------------

//

TBool CSwtKeyEvent::SendEvent(JNIEnv* aJniEnv, jboolean& aDoIt)

{

    TBool failed;

    aDoIt = CallBooleanJavaMethod(failed, aJniEnv, Peer(), "sendKeyEvent",

                                  "(ICII)Z", static_cast<jint>(iSwtType), iCharacter, iKeyCode,

                                  iStateMask);

    return (failed || aJniEnv->ExceptionCheck()) ? EFalse : ETrue;

}

// -----------------------------------------------------------------------------

// CSwtKeyEvent::CSwtKeyEvent

// -----------------------------------------------------------------------------

//

void CSwtKeyEvent::CallbackL(TBool aDoIt)

{

    if (aDoIt)

    {

        // There is no difference between key-down and key event in SWT. Therefore,

        // those events are merged. If this is such an event, let's un-merge.

        // EEventKeyDown can be posted only if the key does not generate EEventKey!

        if (iType == EEventKey && iKeyEvent.iRepeats == 0)

        {

            TKeyEvent keyDownEvent(iKeyEvent);

            keyDownEvent.iCode = 0;

            iControl.ProcessKeyEventL(keyDownEvent, EEventKeyDown);

        }

        iControl.ProcessKeyEventL(iKeyEvent, iType);

#ifndef RD_JAVA_S60_RELEASE_9_2

        if (AknLayoutUtils::MSKEnabled())

        {

            // Cba consumes the MSK event key, we have to create a simulated

            // EEventKey for EStdKeyDevice3 key down event.

            if (iType == EEventKeyDown && iKeyEvent.iScanCode == EStdKeyDevice3 &&

                    iKeyEvent.iRepeats == 0)

            {

                TKeyEvent keyEvent(iKeyEvent);

                keyEvent.iCode = EKeyOK;

                iControl.ProcessKeyEventL(keyEvent, EEventKey);

            }

        }

#endif // RD_JAVA_S60_RELEASE_9_2

    }

}

// -----------------------------------------------------------------------------

// CSwtTraverseEvent::CSwtTraverseEvent

// -----------------------------------------------------------------------------

//

CSwtTraverseEvent::CSwtTraverseEvent(MSwtControl& aControl, TSwtTraversal aDetail,

                                     TBool aDoIt, const TSwtKeyEventData& aData, const TKeyEvent& aKeyEvent,

                                     TEventCode aType)

        : CSwtKeyEvent(aControl, aData, aKeyEvent, aType)

        , iDetail(aDetail)

        , iDoItDefault(ConvertBoolean(aDoIt))

{

}

// -----------------------------------------------------------------------------

// CSwtTraverseEvent::Type

// -----------------------------------------------------------------------------

//

TSwtEventType CSwtTraverseEvent::Type() const

{

    return ESwtEventTraverse;

}

// -----------------------------------------------------------------------------

// CSwtTraverseEvent::DoDispatch

// Dispatches the traverse event, and depending on the event's "doit" field may

// also dispatch the original key event.

// -----------------------------------------------------------------------------

//

void CSwtTraverseEvent::DoDispatch(JNIEnv* aJniEnv)

{

    // Dispatch the message

    jboolean doIt;

    TBool ok = SendTraverseEvent(aJniEnv, doIt);

    // Check if further execution should stop

    if (IsDisplayDisposed() || IsPeerDisposed() || !ok)

    {

        return;

    }

    // Perform traversal or key event

    if (doIt)

    {

        if (iDetail != ESwtTraverseNone)

        {

            TRAPD(error, CallMethodL(this, &CSwtTraverseEvent::TraverseCallbackL));

            ThrowIfError(error, aJniEnv);

        }

    }

    else

    {

        CSwtKeyEvent::DoDispatch(aJniEnv);

    }

}

// -----------------------------------------------------------------------------

// CSwtTraverseEvent::SendTraverseEvent

// -----------------------------------------------------------------------------

//

TBool CSwtTraverseEvent::SendTraverseEvent(JNIEnv* aJniEnv, jboolean& aDoIt)

{

    TBool failed;

    const char* signature = "(IZCII)Lorg/eclipse/swt/widgets/Event;";

    jobject event = CallObjectJavaMethod(failed, aJniEnv, Peer(),

                                         "sendTraverseEvent", signature, iDetail, iDoItDefault,

                                         iCharacter, iKeyCode, iStateMask);

    // Check if further execution should stop

    if (IsDisplayDisposed() || aJniEnv->ExceptionCheck() || failed)

    {

        return EFalse;

    }

    ASSERT(event);

    jclass clazz = aJniEnv->FindClass("org/eclipse/swt/widgets/Event");

    if (!clazz)

    {

        failed = ETrue;

    }

    else

    {

        aDoIt = GetBooleanField(aJniEnv, event, clazz, "doit", failed);

        iDetail = GetIntField(aJniEnv, event, clazz, "detail", failed);

        aJniEnv->DeleteLocalRef(clazz);

    }

    aJniEnv->DeleteLocalRef(event);

    return !failed;

}

// -----------------------------------------------------------------------------

// CSwtTraverseEvent::TraverseCallbackL

// -----------------------------------------------------------------------------

//

void CSwtTraverseEvent::TraverseCallbackL()

{

    // Ensure the control still has the focus, it may not always be so if

    // too many events have been generated before being processed

    // Must call here IsFocusControl() instead of CoeControl().IsFocused()

    // because Shells can never get Coe focus. Shell focus is defined to be

    // the state when the Shell is active and has no focused children.

    if (iControl.IsFocusControl())

    {

        // Find the Control's Shell

        MSwtControl* ctrl = &iControl;

        // Find next focusable control

        if (newFocus)

        {

            newFocus->CoeControl().SetFocus(ETrue, ENoDrawNow);

        }

    }

}

// -----------------------------------------------------------------------------

// CSwtMouseEvent::CSwtMouseEvent

// -----------------------------------------------------------------------------

//

CSwtMouseEvent::CSwtMouseEvent(TSwtPeer aPeer, TSwtEventType aType,

                               TInt aButton, const TPoint& aPos, TInt aStateMask)

        : CSwtEvent(aPeer)

        , iType(aType)

        , iButton(aButton)

        , iX(aPos.iX)

        , iY(aPos.iY)

        , iStateMask(aStateMask)

{

}

// -----------------------------------------------------------------------------

// CSwtMouseEvent::Type

// -----------------------------------------------------------------------------

//

TSwtEventType CSwtMouseEvent::Type() const

{

    return iType;

}

// -----------------------------------------------------------------------------

// CSwtMouseEvent::DoDispatch

// -----------------------------------------------------------------------------

//

void CSwtMouseEvent::DoDispatch(JNIEnv* aJniEnv)

{

    TBool failed;

    CallVoidJavaMethod(failed, aJniEnv, Peer(), "sendMouseEvent", "(IIIII)V",

                       static_cast<jint>(iType), iButton, iX, iY, iStateMask);

}

// -----------------------------------------------------------------------------

// CSwtScrollEvent::CSwtScrollEvent

// -----------------------------------------------------------------------------

//

CSwtScrollEvent::CSwtScrollEvent(TSwtPeer aPeer, TInt aDetail)

        : CSwtEvent(aPeer)

        , iDetail(aDetail)

{

    ASSERT((aDetail >= ESwtKeyArrowUp && aDetail <= ESwtKeyEnd)

           || aDetail == KSwtDrag || aDetail == 0);

}

// -----------------------------------------------------------------------------

// CSwtScrollEvent::Type

// -----------------------------------------------------------------------------

//

TSwtEventType CSwtScrollEvent::Type() const

{

    return ESwtEventSelection;

}

// -----------------------------------------------------------------------------

// CSwtScrollEvent::DoDispatch

// -----------------------------------------------------------------------------

//

void CSwtScrollEvent::DoDispatch(JNIEnv* aJniEnv)

{

    TBool failed;

    CallVoidJavaMethod(failed, aJniEnv, Peer(), "sendScrollEvent", "(I)V", iDetail);

}

// -----------------------------------------------------------------------------

// CSwtPaintEvent::CSwtPaintEvent

// -----------------------------------------------------------------------------

//

CSwtPaintEvent::CSwtPaintEvent(TSwtPeer aSenderPeer, TSwtPeer aShellPeer,

                               const TRect& aRect, TBool aMergeable)

        : CSwtEvent(aShellPeer)

        , iMergeable(aMergeable)

        , iRect(aRect)

        , iSenderPeer(aSenderPeer)

{

}

// -----------------------------------------------------------------------------

// CSwtPaintEvent::Type

// -----------------------------------------------------------------------------

//

TSwtEventType CSwtPaintEvent::Type() const

{

    return ESwtEventPaint;

}

// -----------------------------------------------------------------------------

// CSwtPaintEvent::DoDispatch

// -----------------------------------------------------------------------------

//

void CSwtPaintEvent::DoDispatch(JNIEnv* aJniEnv)

{

    TBool failed;

    CallObjectJavaMethod(failed, aJniEnv, Peer(), "paint",

                         "(Lorg/eclipse/swt/graphics/Rectangle;ZZ)Lorg/eclipse/swt/graphics/Rectangle;",

                         NewJavaRectangle(aJniEnv, iRect), ConvertBoolean(ETrue),

                         ConvertBoolean(ETrue));

}

// -----------------------------------------------------------------------------

// CSwtResizeEvent::CSwtResizeEvent

// -----------------------------------------------------------------------------

//

CSwtResizeEvent::CSwtResizeEvent(TSwtPeer aPeer)

        : CSwtEvent(aPeer)

{

}

// -----------------------------------------------------------------------------

// CSwtResizeEvent::Type

// -----------------------------------------------------------------------------

//

TSwtEventType CSwtResizeEvent::Type() const

{

    return ESwtEventResize;

}

// -----------------------------------------------------------------------------

// CSwtResizeEvent::DoDispatch

// -----------------------------------------------------------------------------

//

void CSwtResizeEvent::DoDispatch(JNIEnv* aJniEnv)

{

    TBool failed;

    CallVoidJavaMethod(failed, aJniEnv, Peer(), "sendResizeEvent", "()V");

}

// -----------------------------------------------------------------------------

// CSwtTimerCallback::CSwtTimerCallback

// -----------------------------------------------------------------------------

//

CSwtTimerCallback::CSwtTimerCallback(TSwtPeer aPeer, TInt aTimerHandle)

        : CSwtEvent(aPeer)

        , iTimerHandle(aTimerHandle)

{

}

// -----------------------------------------------------------------------------

// CSwtTimerCallback::Type

// -----------------------------------------------------------------------------

//

TSwtEventType CSwtTimerCallback::Type() const

{

    return ESwtEventNone;

}

// -----------------------------------------------------------------------------

// CSwtTimerCallback::DoDispatch

// -----------------------------------------------------------------------------

//

void CSwtTimerCallback::DoDispatch(JNIEnv* aJniEnv)

{

    TBool failed;

    CallVoidJavaMethod(failed, aJniEnv, Peer(), "timerCallback", "(I)V",

                       iTimerHandle);

}

// -----------------------------------------------------------------------------

// CSwtVerifyEvent::CSwtVerifyEvent

// -----------------------------------------------------------------------------

//

CSwtVerifyEvent::CSwtVerifyEvent(MSwtVerifyEventObserver& aWidget,

                                 TSwtPeer aPeer, TInt aStart, TInt aEnd)

        : CSwtEvent(aPeer)

        , iWidget(aWidget)

        , iStart(aStart)

        , iEnd(aEnd)

{

}

// -----------------------------------------------------------------------------

// CSwtVerifyEvent::~CSwtVerifyEvent

// -----------------------------------------------------------------------------

//

CSwtVerifyEvent::~CSwtVerifyEvent()

{

    delete iOriginalText;

}

// -----------------------------------------------------------------------------

// CSwtVerifyEvent::ConstructL

// -----------------------------------------------------------------------------

//

void CSwtVerifyEvent::ConstructL(const TDesC& aText)

{

    iOriginalText = aText.AllocL();

}

// -----------------------------------------------------------------------------

// CSwtVerifyEvent::NewL

// -----------------------------------------------------------------------------

//

CSwtVerifyEvent* CSwtVerifyEvent::NewL(MSwtVerifyEventObserver& aWidget,

                                       TSwtPeer aPeer, TInt aStart, TInt aEnd, const TDesC& aText)

{

    CSwtVerifyEvent* self = new(ELeave) CSwtVerifyEvent(aWidget, aPeer,

            aStart, aEnd);

    CleanupStack::PushL(self);

    self->ConstructL(aText);

    CleanupStack::Pop(self);

    return self;

}

// -----------------------------------------------------------------------------

// CSwtVerifyEvent::Type

// -----------------------------------------------------------------------------

//