/*

* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

#include "CMIDKeyTranslator.h"

#include <jdebug.h>

// Uncomment for loads of debug output

//#define DEBUG_KEY_TRANSLATOR

#ifndef DEBUG_KEY_TRANSLATOR

#ifdef DEBUG_STR

#undef DEBUG_STR

#define DEBUG_STR(msg, str)

#endif // def DEBUG_STR

#ifdef DEBUG_INT

#undef DEBUG_INT

#define DEBUG_INT(msg,val)

#endif // def DEBUG_INT

#ifdef DEBUG_INT2

#undef DEBUG_INT2

#define DEBUG_INT2(msg,val1,val2)

#endif // def DEBUG_INT2

#endif // def DEBUG_KEY_TRANSLATOR

#if defined(__WINS__) // from w32cmd.h

// Under WINS character code is passed in as HIWORD of the scan code,

// and will need to be removed in some situations

#define SCANCODE(x) ((x) & 0xFFFF)

#else

#define SCANCODE(x) (x)

#endif

const TInt KMIDKeyEdit = -50;

const TInt KMIDKeySelect = -5;

inline TBool NonUnicodeKeyCode(TInt aKeyCode)

{

    return (aKeyCode > CMIDKeyTranslator::KMaxUnicodeKeyCode) || (aKeyCode <= 0);

}

//

// Record of translated keys.

//

CMIDKeyTranslator::CMIDKeyTranslator(MMIDEnv& aEnv)

        : iEnv(aEnv)

        , iKeyList(4) // granularity

        , iS60SelectionKeyCompatibility(EFalse)

{

}

void CMIDKeyTranslator::ConstructL()

{

    iS60SelectionKeyCompatibility = iEnv.MidletAttributeIsSetToVal(

                                        LcduiMidletAttributes::KAttribS60SelectionKeyCompatibility,

                                        LcduiMidletAttributeValues::KTrueValue

                                    );

}

CMIDKeyTranslator::~CMIDKeyTranslator()

{

    iKeyList.Reset();

}

void CMIDKeyTranslator::SetUtils(MMIDUtils* aUtils)

{

    iUtils = aUtils;

}

void CMIDKeyTranslator::Reset()

{

    iKeyList.Reset();

}

/**

DEBUG

*/

TText EventCode(TEventCode aType)

{

    switch (aType)

    {

    case EEventKeyDown:

        return L'D';

    case EEventKey:

        return L'C';

    case EEventKeyUp:

        return L'U';

    default:

        return L'?';

    }

}

TBool CMIDKeyTranslator::TranslateL(TMIDKeyEvent& aMIDPKeyEvent, const TKeyEvent& aWsEvent, TEventCode aEventCode)

{

#ifdef DEBUG_KEY_TRANSLATOR

    TBuf<64> buf;

    buf.Format(_L("[%C,%d,%d,%d]"), EventCode(aEventCode), SCANCODE(aWsEvent.iScanCode), aWsEvent.iCode, aWsEvent.iRepeats);

    DEBUG_STR("TKeyEvent: %S", buf);

#endif

    ASSERT(iUtils);

    // check if this key should be sent to java

    if (!iUtils->IsJavaKey(SCANCODE(aWsEvent.iScanCode)))

    {

        DEBUG_INT("Non-Java scancode rejected: %d", SCANCODE(aWsEvent.iScanCode));

        return EFalse;

    }

    aMIDPKeyEvent.iEvents =0;

    aMIDPKeyEvent.iKeyCode=0;

    aMIDPKeyEvent.iRepeats=0;

    // check if key is already pressed

    TInt index = FindKeyRecord(SCANCODE(aWsEvent.iScanCode));

    if (index == KErrNotFound)

    {

        // new key press

        TKeyRecord record;

        record.iScanCode = SCANCODE(aWsEvent.iScanCode);

        record.iIsSpecialKey = EFalse;

        //store the value for some special key (non-unicode)

        TInt mappedCode = Map(record.iScanCode, aWsEvent.iCode);

        if (aWsEvent.iCode &&

                (aWsEvent.iScanCode == EStdKeyLeftShift ||

                 aWsEvent.iScanCode == EStdKeyLeftFunc ||

                 aWsEvent.iScanCode == EStdKeySpace))

        {

            //If iCode has some non-zero value, the key was already mapped

            //via PTIEngine. Key code value is simply copied to record.

            //This step is because in Half-QWERTY keyboard layout, some keys

            //can have additionl characters.

            //E.g. Chr key on half-QWERTY keyboard has '*'.

            record.iKeyCode = aWsEvent.iCode;

            if (mappedCode == KMIDKeyEdit)

            {

                //Some special keys (in different keyborad layouts) have

                //additional key value. So we need to store information that

                //special key was pressed.

                record.iIsSpecialKey = ETrue;

            }

        }

        else

        {

            //If iCode is 0, this means, that special key was pressed

            //(e.g Fn or Shift) and it doesn't have any additional character

            //(so PTIEngine didn't do any mapping)

            record.iKeyCode = mappedCode;

        }

        record.iState = TKeyRecord::EStateInitial;

        User::LeaveIfError(iKeyList.Append(record));

        index = iKeyList.Count()-1;

    }

    TKeyRecord& record = iKeyList[index];

    if (record.iKeyCode == 0 && aEventCode == EEventKey)

    {

        record.iKeyCode = Map(record.iScanCode, aWsEvent.iCode);

    }

    // transition to next state...

    record.Transition(aEventCode, aMIDPKeyEvent, aWsEvent.iRepeats, iS60SelectionKeyCompatibility);

    if (record.iState == TKeyRecord::EStateInitial)

    {

        iKeyList.Remove(index);

    }

    return aMIDPKeyEvent.iEvents;   // non-zero == true post something

}

TInt CMIDKeyTranslator::FindKeyRecord(TInt aScanCode) const

{

    for (TInt ii=iKeyList.Count(); ii--;)

    {

        if (iKeyList[ii].iScanCode==aScanCode)

            return ii;

    }

    return KErrNotFound;

}

TInt CMIDKeyTranslator::Map(TInt aScanCode, TInt aCode)

{

    //

    // Fitler out some non-unicode keys - only rejects obviously

    // out of bounds unicode values. Any keys that should be

    // mapped to Java will be mapped in MapNonUnicodeKeyCode

    // below.

    //

    if (NonUnicodeKeyCode(aCode))

    {

        aCode = KInvalidKeyCode;

    }

    //

    // At this point keyCode can be any valid EPOC key code, some of which

    // will not be UNICODE values. To comply with the MIDP spec, all non

    // UNICODE keys must be mapped to negative values.

    //

    // Any keys for which we do not have a valid MIDP keyCode, will be

    // mapped to KInvalidKeyCode.

    //

    // We do the mapping here regardless of the return value of

    // NonUnicodeKeyCode() as that function may not remove all non-unicode

    // keycodes.

    //

    // The mapping is done from the scancode.

    //

    TInt specialKey = MapNonUnicodeKeyCode(aScanCode);

    if (KInvalidKeyCode != specialKey)

    {

        DEBUG_INT2("mapping non-unicode keycode: %d to %d", aCode, specialKey);

        aCode = specialKey;

    }

    DEBUG_INT("keycode = %d\n", aCode);

    return aCode;

}

TInt CMIDKeyTranslator::MapNonUnicodeKeyCode(TInt aScanCode)

{

    ASSERT(iUtils);

    return iUtils->MapNonUnicodeKey(aScanCode);

}

TBool CMIDKeyTranslator::PostKeyEvent(MMIDComponent& aComponent, const TMIDKeyEvent& aEvent)

{

    ASSERT(aEvent.iKeyCode);

    TBool posted(EFalse);

    if (aEvent.iEvents & TMIDKeyEvent::EPressed)

    {

        PostKeyEvent(aComponent, EKeyPressed, aEvent.iKeyCode, 0);

        posted=ETrue;

    }

    if (aEvent.iEvents & TMIDKeyEvent::ERepeated)

    {

        PostKeyEvent(aComponent, EKeyRepeated, aEvent.iKeyCode, aEvent.iRepeats);

        posted=ETrue;

    }

    if (aEvent.iEvents & TMIDKeyEvent::EReleased)

    {

        PostKeyEvent(aComponent, EKeyReleased, aEvent.iKeyCode, 0);

        posted=ETrue;

    }

    return posted;

}

void CMIDKeyTranslator::PostKeyEvent(MMIDComponent& aComponent, TEventType aType, TInt aKeyCode, TInt aRepeats)

{

    ASSERT(aKeyCode != KInvalidKeyCode);

    DEBUG_INT2("PostKeyEvent[%d] (%d)", aType, aKeyCode);

    (void) iEnv.PostJavaEvent(

        aComponent,

        aComponent.Type() == MMIDComponent::ECustomItem ? EItem : EDisplayable,

        aType,

        aKeyCode,

        aRepeats,

        0

    );

}

void TKeyRecord::Transition(TEventCode aEventCode, TMIDKeyEvent& aMIDPKeyEvent, TInt aRepeats, TBool aS60SelectionKeyCompatibility)

{

    // transition to next state...

    switch (iState)

    {

    case EStateInitial:

        StateInitial(aEventCode, aMIDPKeyEvent, aRepeats, aS60SelectionKeyCompatibility);

        break;

    case EStateDown:

        StateDown(aEventCode, aMIDPKeyEvent,aRepeats);

        break;

    case EStateDownTranslated:

        StateDownTranslated(aEventCode, aMIDPKeyEvent,aRepeats);

        break;

    case EStateKeyTranslated:

        StateKeyTranslated(aEventCode, aMIDPKeyEvent,aRepeats);

        break;

    case EStateKeyRepeated:

        StateKeyRepeated(aEventCode, aMIDPKeyEvent,aRepeats);

        break;

    case EStateDownRepeated:

        StateDownRepeated(aEventCode, aMIDPKeyEvent,aRepeats);

        break;

    }

}

void TKeyRecord::StateInitial(TEventCode aEventCode, TMIDKeyEvent& aMIDPKeyEvent, TInt aRepeats, TBool aS60SelectionKeyCompatibility)

{

    switch (aEventCode)

    {

    case EEventKeyDown:

        // When canvas is not in full-screen mode then EEventKey event for Edit and

        // Select key-presses is catched in CEikCba::OfferKeyEventL. This function

        // returns EKeyWasConsumed and CCoeControlStack doesn't send EEvent to CMIDCanvas.

        // Therefore EEvent key never reach to CMIDCanvas::OfferKeyEventL.

        // This is why we use here EEventKeyDown for sending the key-press

        // events for Edit and Select to MIDlet.

        //

        // Special keys, like Edit key, can have also additional characters.

        // If special key carries the additional character (mapped by PTIEngine)

        // and it should be sent to Java, iIsSpecialKey is true and record

        // switches to EStateDownTranslated. This will guarantee, that event

        // will be sent to MIDlet.

        if (iKeyCode == KMIDKeyEdit ||

                (iKeyCode == KMIDKeySelect && aS60SelectionKeyCompatibility) ||

                (iIsSpecialKey)

           )

        {

            // have a -ve code, can post KeyPressed now

            KeyPressed(aMIDPKeyEvent);

            iState = EStateDownTranslated;

        }

        else

        {

            // must delay KeyPressed until have keyCode

            iState = EStateDown;

        }

        break;

    case EEventKey:

        // FEP

        KeyPressed(aMIDPKeyEvent);

        if (aRepeats > 0)

        {

            KeyRepeated(aMIDPKeyEvent,aRepeats);

        }

        KeyReleased(aMIDPKeyEvent);

        iState = EStateInitial;

        break;

    case EEventKeyUp:

        iState = EStateInitial;

        break;

    default:

        ASSERT(EFalse);

    }

}

void TKeyRecord::StateDown(TEventCode aEventCode, TMIDKeyEvent& aMIDPKeyEvent, TInt aRepeats)

{

    // key code was previously NOT translated.

    switch (aEventCode)

    {

    case EEventKeyDown:

        // no-op

        DEBUG_INT("THIS SCANCODE REQUIRES MAPPING TO NEGATIVE KEYCODE: %d", iScanCode);

        break;

    case EEventKey:

        // now we have key code, can send key pressed

        KeyPressed(aMIDPKeyEvent);

        if (aRepeats > 0)

        {

            KeyRepeated(aMIDPKeyEvent,aRepeats);

        }

        iState = EStateDownTranslated;

        break;

    case EEventKeyUp:

        iState = EStateInitial;

        DEBUG_INT("THIS SCANCODE REQUIRES MAPPING TO NEGATIVE KEYCODE: %d", iScanCode);

        break;

    default:

        ASSERT(EFalse);

    }

}

void TKeyRecord::StateDownTranslated(TEventCode aEventCode, TMIDKeyEvent& aMIDPKeyEvent, TInt aRepeats)

{

    switch (aEventCode)

    {

    case EEventKeyDown:

        KeyRepeated(aMIDPKeyEvent,1);

        iState = EStateDownRepeated;

        break;

    case EEventKey:

        if (aRepeats > 0)

        {

            KeyRepeated(aMIDPKeyEvent,aRepeats);

            iState= EStateKeyRepeated;

        }

        else

        {

            iState = EStateKeyTranslated;

        }

        break;

    case EEventKeyUp:

        KeyReleased(aMIDPKeyEvent);

        iState = EStateInitial;

        break;

    default:

        ASSERT(EFalse);

    }

}

void TKeyRecord::StateKeyTranslated(TEventCode aEventCode, TMIDKeyEvent& aMIDPKeyEvent, TInt aRepeats)

{

    switch (aEventCode)

    {

    case EEventKeyDown:

        // no-op

        break;

    case EEventKey:

        KeyRepeated(aMIDPKeyEvent, aRepeats ? aRepeats : 1);

        iState=EStateKeyRepeated;

        break;

    case EEventKeyUp:

        KeyReleased(aMIDPKeyEvent);

        iState = EStateInitial;

        break;

    default:

        ASSERT(EFalse);

    }

}

void TKeyRecord::StateKeyRepeated(TEventCode aEventCode, TMIDKeyEvent& aMIDPKeyEvent, TInt aRepeats)

{

    switch (aEventCode)

    {

    case EEventKeyDown:

        // no-op

        break;

    case EEventKey:

        KeyRepeated(aMIDPKeyEvent, aRepeats ? aRepeats : 1);

        iState=EStateKeyRepeated;

        break;

    case EEventKeyUp:

        KeyReleased(aMIDPKeyEvent);

        iState = EStateInitial;

        break;

    default:

        ASSERT(EFalse);

    }

}

void TKeyRecord::StateDownRepeated(TEventCode aEventCode, TMIDKeyEvent& aMIDPKeyEvent, TInt /*aRepeats*/)

{

    switch (aEventCode)

    {

    case EEventKeyDown:

        KeyRepeated(aMIDPKeyEvent,1);

        break;

    case EEventKey:

        iState = EStateDownTranslated;

        break;

    case EEventKeyUp:

        KeyReleased(aMIDPKeyEvent);

        iState = EStateInitial;

        break;

    default:

        ASSERT(EFalse);

    }

}

void TKeyRecord::SetKeyCode(TMIDKeyEvent& aMIDPKeyEvent)

{

    ASSERT(iKeyCode);

    if (0 == aMIDPKeyEvent.iKeyCode)

    {

        aMIDPKeyEvent.iKeyCode = iKeyCode;

    }

    ASSERT(aMIDPKeyEvent.iKeyCode == iKeyCode);

}

void TKeyRecord::KeyPressed(TMIDKeyEvent& aMIDPKeyEvent)

{

    SetKeyCode(aMIDPKeyEvent);

    aMIDPKeyEvent.iEvents |= TMIDKeyEvent::EPressed;

    aMIDPKeyEvent.iRepeats = 0;

}

void TKeyRecord::KeyRepeated(TMIDKeyEvent& aMIDPKeyEvent, TInt aRepeats)

{

    SetKeyCode(aMIDPKeyEvent);

    aMIDPKeyEvent.iEvents |=  TMIDKeyEvent::ERepeated;

    aMIDPKeyEvent.iRepeats = aRepeats;

}

void TKeyRecord::KeyReleased(TMIDKeyEvent& aMIDPKeyEvent)

{

    SetKeyCode(aMIDPKeyEvent);

    aMIDPKeyEvent.iEvents |=  TMIDKeyEvent::EReleased;

    aMIDPKeyEvent.iRepeats = 0;

}