/*
* Copyright (c) 2008 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:  This is the implementation of application class
*
*/


#include <e32std.h>
#include <e32svr.h>
#include <ecom/ecom.h>
#include "modifier.h"
#include "layout.h"
#include "decode.h"
#include "codestore.h"
#include "client.h"
#include "debug.h"
#include "hidvalues.h"

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

CKeyboardDecoder::CKeyboardDecoder()
        : iLayout(0), iAltGrSequence(EFalse), iNumKeysDown(0)
    {
    TRACE_INFO( (
                    _L("[HID]\tCKeyboardDecoder::CKeyboardDecoder at 0x%08x"), this));
    }

CKeyboardDecoder* CKeyboardDecoder::NewL()
    {
    CKeyboardDecoder* self =
        new (ELeave) CKeyboardDecoder;
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop();
    return self;
    }

void CKeyboardDecoder::ConstructL()
    {
    iScanCodes = CScanCodeStore::NewL();
    }

CKeyboardDecoder::~CKeyboardDecoder()
    {
    TRACE_INFO( (_L("[HID]\t~CKeyboardDecoder() 0x%08x"), this));

    iLayout = 0; // (we don't own iLayout)

    delete iScanCodes;
    }

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

void CKeyboardDecoder::Event(const TKeyEventInfo &aEvent,
                             TDecodedKeyInfo& aDecodedKeys)
    {
    aDecodedKeys.iCount = 0;
    aDecodedKeys.iScanCode = EStdKeyNull;

    iNumKeysDown += (aEvent.iIsKeyDown ? 1 : -1);
    // (NB. it is possible to get an up without a down just after a new
    // decoder goes into use when the keyboard layout is changed -- but
    // only if the Bluetooth keyboard is used to make the layout change.)
    if (iNumKeysDown < 0)
        iNumKeysDown = 0;

    if (iLayout)
        {
        if (!HandleRightAlt(aEvent, aDecodedKeys))
            {
            if (aEvent.iIsKeyDown)
                {
                // Key down event:

                TInt rawCode = iLayout->RawScanCode(aEvent.iHidKey,
                                                    aEvent.iUsagePage, aEvent.iModifiers);

                // Store the raw scan code, so that the scan code for
                // the "key up" event for this key will match the one
                // sent for the "key down" event.  These could be
                // different, for example, if the scan code changes
                // depending on the current modifier state.
                //
                if (iScanCodes->Store(aEvent.iHidKey, aEvent.iUsagePage,
                                      rawCode) == KErrNone)
                    {
                    aDecodedKeys.iScanCode = rawCode;
                    }
                else
                    {
                    // Store() may fail due to low memory. In that
                    // case we don't send key down (or key up) events:
                    //
                    aDecodedKeys.iScanCode = EStdKeyNull;
                    }

                // Decode any key press events:

                TUint16 unicodeKey = iLayout->TranslateKey(aEvent.iHidKey,
                                     aEvent.iUsagePage, aEvent.iModifiers, aEvent.iLockKeys);

                if (unicodeKey != 0)
                    {
                    ProcessDeadKeys(unicodeKey, aEvent.iHidKey,
                                    aEvent.iUsagePage, aDecodedKeys);
                    }
                }
            else
                {
                // Key up event:

                aDecodedKeys.iScanCode =
                    iScanCodes->Retrieve(aEvent.iHidKey, aEvent.iUsagePage);
                }
            }
        }
    }

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

TBool CKeyboardDecoder::HandleRightAlt(const TKeyEventInfo &aEvent,
                                       TDecodedKeyInfo& aDecodedKeys)
    {
    // A press and release of the right-alt (Alt Gr) key should cause
    // the S60 symbol selection dialog to appear, if no other keys are
    // pressed in between.

    TBool handledEvent = EFalse;

    const TInt KRightAltKey = 0xe6;

    if ((aEvent.iHidKey == KRightAltKey) &&
            (aEvent.iUsagePage == EUsagePageKeyboard))
        {
        if (aEvent.iIsKeyDown && (iNumKeysDown == 1))
            {
            iAltGrSequence = ETrue;
            }

        if (!aEvent.iIsKeyDown && iAltGrSequence)
            {
            // We use EKeyApplication2 to indicate to the modified T9
            // FEP that we wish it to produce the symbol selection dialog:
            // EKeyApplication2 is not passed to Fep anymore, but
            // it is converted to '*' in SendKeyPress() (keyboard.cpp)
            aDecodedKeys.iEvent[0] = TTranslatedKey(EKeyApplication2,
                                                    EStdKeyApplication2, 0, 0, EFalse);
            aDecodedKeys.iCount = 1;

            handledEvent = ETrue;
            iAltGrSequence = EFalse;
            }
        }
    else
        {
        iAltGrSequence = EFalse;
        }

    return handledEvent;
    }

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

void CKeyboardDecoder::Reset()
    {
    iDeadKey.iUnicode = 0;
    iAltGrSequence = EFalse;
    iNumKeysDown = 0;
    }

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

void CKeyboardDecoder::SetLayout(CKeyboardLayout* aLayout)
    {
    TRACE_INFO( (_L("[HID]\tCKeyboardDecoder::SetLayout(0x%08x)"), aLayout));

    iLayout = aLayout;
    Reset();
    }

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

void CKeyboardDecoder::ProcessDeadKeys(TUint16 aUnicodeKey,
                                       TInt aHidKey, TInt aUsagePage, TDecodedKeyInfo &aDecodedKeys)
    {
    if (iDeadKey.iUnicode == 0)
        {
        // Check if the current key is a dead key:
        //
        if (iLayout->IsDeadKey(aUnicodeKey))
            {
            // We've received a dead key event, so there's no key press
            // to issue -- just record the details for later:
            //
            TRACE_INFO( (_L("[HID]\tDeadkey 0x%04x (%d:%d)"),
                         aUnicodeKey, aUsagePage, aHidKey));

            iDeadKey = TTranslatedKey(aUnicodeKey,
                                      aDecodedKeys.iScanCode, aHidKey, aUsagePage, EFalse);
            aDecodedKeys.iCount = 0;
            }
        else
            {
            // No dead key processing to do, so just send a
            // normal key code:
            //
            TRACE_INFO( (_L("[HID]\tNo dead key processing, one event")));

            aDecodedKeys.iEvent[0] = TTranslatedKey(aUnicodeKey,
                                                    aDecodedKeys.iScanCode, aHidKey, aUsagePage,
                                                    iLayout->IsRepeatingKey(aUnicodeKey));
            aDecodedKeys.iCount = 1;
            }
        }
    else
        {
        // We've an active dead key, see if the current key produces
        // a combination character:
        //
        TUint16 comboChar =
            iLayout->FindCombiningChar(iDeadKey.iUnicode, aUnicodeKey);

        if (comboChar == 0)
            {
            TRACE_INFO( (_L("[HID]\tNo match for 0x%04x, sending after 0x%04x"),
                         aUnicodeKey, iDeadKey.iUnicode));

            // No match, so two key events to send:

            aDecodedKeys.iEvent[0] = iDeadKey;
            aDecodedKeys.iEvent[1] = TTranslatedKey(aUnicodeKey,
                                                    aDecodedKeys.iScanCode, aHidKey, aUsagePage,
                                                    iLayout->IsRepeatingKey(aUnicodeKey));
            aDecodedKeys.iCount = 2;
            }
        else
            {
            TRACE_INFO( (_L("[HID]\tFound a match 0x%04x, one combo to send 0x%04x"),
                         aUnicodeKey, comboChar));

            // Found a match, so one combo key event to send:

            aDecodedKeys.iEvent[0] = TTranslatedKey(comboChar,
                                                    aDecodedKeys.iScanCode, aHidKey, aUsagePage,
                                                    iLayout->IsRepeatingKey(comboChar));
            aDecodedKeys.iCount = 1;
            }

        // We've finished processing the dead key sequence:
        iDeadKey.iUnicode = 0;
        }
    }

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