/*

* 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:  ?Description

*

*/

#include <barsread.h> //resourcereader

#include <lcdui.rsg>

#include <lcdui.mbg>

#include <aknbutton.h>

#include <aknconsts.h>

#include <gulicon.h>

#include <layoutmetadata.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <data_caging_path_literals.hrh>

#include <s60commonutils.h>

#ifdef RD_TACTILE_FEEDBACK

#include <touchfeedback.h>

#endif // RD_TACTILE_FEEDBACK

#include "CMIDCanvasKeypad.h"

#include "CMIDDisplayable.h"

#include "CMIDCanvas.h"

#include "CMIDMenuHandler.h"

#include <j2me/jdebug.h>

_LIT(KLcduiBitmapResourceFileName, "lcdui.mif");

//Pointer Drag event dismiss rate (for performance reasons)

const TInt KDragEventHandlingRate = 3;//every third drag event is handled

//Alpha value for keypad/canvas separator lines

const TInt KAlphaValue = 50;

// Keyboard delays and repeat periods

const TInt KFirstTimerExpiryInterval = KAknKeyboardRepeatInitialDelay;

// For second time onwards ,the duration of the time interval.

const TInt KTimerExpiryInterval = KAknStandardKeyboardRepeatRate;

// Constants for tap timers, interval timer

const TInt KFirstTapTimerExpiryInterval = 10000; // 10 ms

const TInt KTapTimerExpiryInterval = 10000; // 10 ms

// Max tap counter KTapMaxCnt*KTapTimerExpiryInterval

const TInt KTapMaxCnt = 8;

CMIDCanvasKeypad::~CMIDCanvasKeypad()

{

    DeleteButtons();

    iButtonData.Close();

    iCurrentButtonData.Close();

    iButtonStack.Close();

    if (iRepeatTimer)

    {

        iRepeatTimer->Cancel();

        delete iRepeatTimer;

        iRepeatTimer = NULL;

    }

    // stop and destroy event timer

    if (iTapTimer)

    {

        iTapTimer->Cancel();

        delete iTapTimer;

        iTapTimer = NULL;

    }

    iOSKInBackground = EFalse;

}

TInt CMIDCanvasKeypad::CountComponentControls() const

{

    return iCurrentButtonData.Count();

}

CCoeControl* CMIDCanvasKeypad::ComponentControl(TInt aIndex) const

{

    if (aIndex < iCurrentButtonData.Count())

    {

        return iCurrentButtonData[aIndex]->iButton;

    }

    return NULL;

}

void CMIDCanvasKeypad::SizeChanged()

{

    SetRectForAllButtons();

}

void CMIDCanvasKeypad::ButtonPriorityQueue(TInt aIdx)

{

    // Argument aIdx stored index of last pressed key on OSK.

    // Key was hit on the last is set to first in iButtonStack array.

    // Loop started from index aIdx.

    if (aIdx < iButtonStack.Count())

    {

        for (TInt i = aIdx; i > 0 ; i--)

        {

            TInt tmp = iButtonStack[i];

            iButtonStack[i] = iButtonStack[i-1];

            iButtonStack[i-1] = tmp;

        }

    }

}

void CMIDCanvasKeypad::HandlePointerEventL(const TPointerEvent &aPointerEvent)

{

    // Because of performance reasons we do not handle all the drag events

    if (aPointerEvent.iType == TPointerEvent::EDrag)

    {

        if (iDrag < KDragEventHandlingRate)

        {

            iDrag++;

            return;

        }

        else

        {

            iDrag = 0;

        }

    }

    else

    {

        iDrag = 0;

    }

    if (iOSKInBackground)

    {

        return;

    }

    TButtonData* oldRockerKey = iCurrentRockerKey;

    TButtonData* newRockerKey = NULL;

    // Indicates which area of the keypad (ERockerKey, EOtherKey or ENoneKey)

    // should handle the pointer event.

    TButtonPress keypadArea = ENoneKey;

    // Rocker keys are: up, down, left right and fire.

    // Other keys are: Game_A, Game_B, Game_C, Game_D, LSK and RSK.

    // 'Rocker keys' are handled differently than 'other keys'

    // When 'Other key' is pressed all the events are delivered to it

    // until the 'Other key' is released. When rocker key is pressed dragging

    // the pointer between rocker keys will also cause changes in button states.

    // If any of the 'Other keys' is not pressed already,

    // then we find out which On Screen Keypad key (if any) was hit by pointer event.

    if (!iCurrentOtherKey)

    {

        TInt buttonCount = iCurrentButtonData.Count();

        TInt i;

        // Array iButtonStack stored indexes of all OSK buttons.

        // Because of performance reasons we used iButtonStack array

        // for priority level sets. Key was hit on the last is set to first.

        for (i = 0; i < buttonCount ; i++)

        {

            if (iCurrentButtonData[ iButtonStack[i] ]->keyType < ENavigationKeysNumberOfButtons)

            {

                const MCoeControlHitTest* buttonHitArea = iCurrentButtonData[ iButtonStack[i] ]->iButton->HitTest();

                // Select rocker key. Method HitRegionContains recognized which button pressed.

                if (iRockerRect.Contains(aPointerEvent.iPosition) &&

                        buttonHitArea->HitRegionContains(aPointerEvent.iPosition, *this))

                {

                    keypadArea = ERockerKey;

                    newRockerKey = iCurrentButtonData[ iButtonStack[i] ];

                    break;

                }

            }

            else if (iCurrentButtonData[ iButtonStack[i] ]->keyType > ENavigationKeysNumberOfButtons)

            {

                // Select other key. Method Contains from Rect() recognized which button pressed.

                if (iCurrentButtonData[ iButtonStack[i] ]->iButton->Rect().Contains(aPointerEvent.iPosition))

                {

                    if (iCurrentRockerKey)

                    {

                        // Pointer event hits 'Other key', but because currently some rocker key is active

                        // the pointer event is handled in the rocker keys.

                        keypadArea = ERockerKey;

                    }

                    else if (!iCurrentRockerKey &&

                             aPointerEvent.iType == TPointerEvent::EButton1Down)

                    {

                        keypadArea = EOtherKey;

                        iCurrentOtherKey = iCurrentButtonData[ iButtonStack[i] ];

                    }

                    break;

                }

            }

        }

        ButtonPriorityQueue(i);

    }

    else // This means that 'Other key' is already pressed so this event is handled there.

    {

        keypadArea = EOtherKey;

    }

    TKeyResponse response = EKeyWasNotConsumed;

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

    iDragBetweenArrowKeys = EFalse;

    iDragOutsideArrowKeys = EFalse;

#endif //RD_JAVA_ADVANCED_TACTILE_FEEDBACK

    switch (keypadArea)

    {

    case ENoneKey:

    {

        // Rocker key is released when pointer is dragged outside rocker keys area

        if (iCurrentRockerKey)

        {

            iRepeatTimer->Cancel();

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

            iDragOutsideArrowKeys = ETrue;

#endif //RD_JAVA_ADVANCED_TACTILE_FEEDBACK

            response = RaiseOfferKeyEventL(iCurrentRockerKey->iKeyEvent, EEventKeyUp);

            iCurrentRockerKey->iKeyEvent_2.iRepeats = 0;

            iCurrentRockerKey->iButton->SetCurrentState(0, ETrue);

            iCurrentRockerKey = NULL;

            return;

        }

        break;

    }

    case ERockerKey:

    {

        //Fire button:Ignore drag from rocker arrows to Fire button i.e. drag allowed only among rocker arrow keys

        if (newRockerKey && newRockerKey->keyType == ENavigationKeysFire &&

                aPointerEvent.iType == TPointerEvent::EDrag)

        {

            return;

        }

        // Rocker key changes from one to another, so we cancel the timer and post up event for the old rocker key etc.

        if (iCurrentRockerKey && newRockerKey != iCurrentRockerKey)

        {

            iRepeatTimer->Cancel();

            oldRockerKey = iCurrentRockerKey;

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

            iDragBetweenArrowKeys = ETrue;

#endif //RD_JAVA_ADVANCED_TACTILE_FEEDBACK

            response = RaiseOfferKeyEventL(oldRockerKey->iKeyEvent, EEventKeyUp);

            oldRockerKey->iKeyEvent_2.iRepeats = 0;

            //change button state, refresh rocker keys area

            ChangeStatus(EFalse, oldRockerKey);

        }

        //Fire button:iCurrentRockerKey is changed only for arrow rocker keys

        if (newRockerKey &&

                !(newRockerKey->keyType == ENavigationKeysFire &&

                  aPointerEvent.iType == TPointerEvent::EButton1Up))

        {

            iCurrentRockerKey = newRockerKey;

        }

        // New rocker key pressed. Posts EEventKeyDown and EEventKey events and then starts repeating.

        if ((aPointerEvent.iType == TPointerEvent::EButton1Down ||

                aPointerEvent.iType == TPointerEvent::EDrag) &&

                iCurrentRockerKey && (oldRockerKey != iCurrentRockerKey))

        {

            iRepeatTimer->Cancel();

            // If fire button pressed in normal mode Canvas, then we try to execute a Command

            if (iCurrentRockerKey->keyType == ENavigationKeysFire && !iIsFullScreenMode && !iSelectionKeyCompatibility)

            {

                response = RaiseOfferKeyEventL(iCurrentRockerKey->iKeyEvent, EEventKeyDown);

                //change button state, refresh rocker keys area

                ChangeStatus(ETrue, iCurrentRockerKey);

            }

            else

            {

                iStoreKeyDownEvent = aPointerEvent;

                RaiseOfferKeyEventL(iCurrentRockerKey->iKeyEvent, EEventKeyDown);

                response = RaiseOfferKeyEventL(iCurrentRockerKey->iKeyEvent_2, EEventKey, EFalse);

                if (response == EKeyWasNotConsumed)

                {

                    iCurrentRockerKey->iKeyEvent_2.iRepeats = 1;

                    iRepeatTimer->Start(KFirstTimerExpiryInterval, KTimerExpiryInterval,

                                        TCallBack(RepeatTimerCallbackL, this));

                }

                //change button state, refresh rocker keys area

                ChangeStatus(ETrue, iCurrentRockerKey);

            }

        }

        // Rocker key released. Cancels (possible) repeating and then posts corresponding key up event.

        else if (aPointerEvent.iType == TPointerEvent::EButton1Up && iCurrentRockerKey)

        {

            iRepeatTimer->Cancel();

            response = RaiseOfferKeyEventL(iCurrentRockerKey->iKeyEvent, EEventKeyUp);

            iCurrentRockerKey->iKeyEvent_2.iRepeats = 0;

            //change button state, refresh rocker keys area

            ChangeStatus(EFalse, iCurrentRockerKey);

            iCurrentRockerKey = NULL;

        }

        break;

    }

    case EOtherKey:

    {

        // Drag events are not handled at all.

        if (aPointerEvent.iType == TPointerEvent::EDrag)

        {

            return;

        }

        // Other key is pressed. Posts EEventKeyDown and EEventKey events and then starts repeating.

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

        {

            iStoreKeyDownEvent = aPointerEvent;

            iRepeatTimer->Cancel();

            RaiseOfferKeyEventL(iCurrentOtherKey->iKeyEvent, EEventKeyDown);

            response = RaiseOfferKeyEventL(iCurrentOtherKey->iKeyEvent_2, EEventKey, EFalse);

            if (response == EKeyWasNotConsumed)

            {

                iCurrentOtherKey->iKeyEvent_2.iRepeats = 1;

                iRepeatTimer->Start(KFirstTimerExpiryInterval, KTimerExpiryInterval,

                                    TCallBack(RepeatTimerCallbackL, this));

            }

        }

        // Other key is released. Cancels (possible) repeating and then posts corresponding key up event etc.

        else if (aPointerEvent.iType == TPointerEvent::EButton1Up)

        {

            iRepeatTimer->Cancel();

            response = RaiseOfferKeyEventL(iCurrentOtherKey->iKeyEvent, EEventKeyUp);

            iCurrentOtherKey->iKeyEvent_2.iRepeats = 0;

            iCurrentOtherKey = NULL;

        }

        // Forwards pointer event to CCoeControl if we did not consume the event.

        if (response == EKeyWasNotConsumed)

        {

            CCoeControl::HandlePointerEventL(aPointerEvent);

        }

        break;

    }

    default:

    {

        return;

    }

    }

}

void CMIDCanvasKeypad::UpdateVisualAppearanceL(CMIDCanvas& aCanvas, TInt aKeypadType, MMIDDisplayable& aDisplayable)

{

    if (aKeypadType <= EKeypadValueNo)

    {

        return;

    }

    TRect screenRect;

    AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EScreen, screenRect);

    iCanvas = static_cast<CMIDCanvas*>(&aCanvas);

    iSelectionKeyCompatibility = iCanvas->SelectionKeyCompatibility();

    iKeypadType = aKeypadType;

    iDisplayable = static_cast<CMIDDisplayable*>(&aDisplayable);

    SetMopParent(iDisplayable);

    iIsFullScreenMode = iDisplayable->IsFullScreenMode();

    ResetButtons();

    TBool oldIsPortrait = iIsPortrait;

    UpdateKeypadPaneRect();

    if ((iScreenRect != screenRect) || (oldIsPortrait != iIsPortrait))

    {

        iScreenRect = screenRect;

    }

    SetRectForAllButtons();//Needed for updating OSK-buttons when closing/opening hw-keyboard

    CreateButtonsL();

    InitializeKeys();

    ActivateL(); // Window owning control draws all children (buttons)

    MakeVisible(ETrue);

    DrawDeferred();

    iOSKInBackground = EFalse;

}

void CMIDCanvasKeypad::Draw(const TRect& /*aRect*/) const

{

    CWindowGc& gc = SystemGc();

    //Drawing skin

    MAknsControlContext* cc = NULL;

    gc.SetBrushColor(TRgb(0x0));   //black

    TRAP_IGNORE(cc = CAknsBasicBackgroundControlContext::NewL(

                         KAknsIIDQsnBgScreen,

                         Rect(),

                         EFalse));

    if (!iIsFullScreenMode)  //normal mode

    {

        AknsDrawUtils::DrawBackground(AknsUtils::SkinInstance(),

                                      cc,

                                      NULL,

                                      gc,

                                      TPoint(0,0),

                                      Rect(),

                                      KAknsDrawParamDefault);

        gc.SetPenColor(TRgb(0x0, KAlphaValue));

    }

    else //full screen mode

    {

        AknsDrawUtils::DrawBackground(NULL,

                                      cc,

                                      NULL,

                                      gc,

                                      TPoint(0,0),

                                      Rect(),

                                      KAknsDrawParamDefault);

        gc.SetPenColor(TRgb(0xFF, KAlphaValue));

    }

    //Drawing separator lines

    if (iIsPortrait)

    {

        gc.DrawLine(TPoint(0,0), TPoint(Size().iWidth,0));

    }

    else //landscape

    {

        //left separator

        if (iCanvas->PositionRelativeToScreen().iX > 0)

        {

            gc.DrawLine(TPoint(iCanvas->PositionRelativeToScreen().iX - 1, 0),

                        TPoint(iCanvas->PositionRelativeToScreen().iX - 1,

                               iCanvas->Size().iHeight));

        }

        //right separator

        gc.DrawLine(TPoint(iCanvas->PositionRelativeToScreen().iX + iCanvas->Size().iWidth, 0),

                    TPoint(iCanvas->PositionRelativeToScreen().iX + iCanvas->Size().iWidth,

                           iCanvas->Size().iHeight));

    }

}

CMIDCanvasKeypad* CMIDCanvasKeypad::NewL(MMIDDisplayable* aDisplayable)

{

    if (!aDisplayable)

    {

        User::Leave(KErrArgument);

    }

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

    CleanupStack::PushL(self);

    self->ConstructL(aDisplayable);

    CleanupStack::Pop(self);

    return self;

}

void CMIDCanvasKeypad::ConstructL(MMIDDisplayable* aDisplayable)

{

    iDisplayable = static_cast< CMIDDisplayable* >(aDisplayable);

    // Timer for implementing key repeat feature.

    iRepeatTimer = CPeriodic::NewL(CActive::EPriorityStandard);

    // Timer for implementing tap counter feature.

    iTapTimer = CPeriodic::NewL(CActive::EPriorityStandard);

    iTapCnt = -1;

    CreateWindowL();

    SetComponentsToInheritVisibility(ETrue);

    Window().SetPointerGrab(ETrue);

}

CMIDCanvasKeypad::CMIDCanvasKeypad()

{

}

void CMIDCanvasKeypad::DeleteButtons()

{

    TInt buttonCount = iButtonData.Count();

    for (TInt i = 0; i < buttonCount; i++)

    {

        delete iButtonData[i].iButton;

        iButtonData[i].iButton = NULL;

    }

}

void CMIDCanvasKeypad::CreateButtonsL()

{

    DeleteButtons();

    iButtonData.Reset();

    iCurrentButtonData.Reset();

    if (iKeypadType != EKeypadValueLskRsk)

    {

        TResourceReader reader;

        CCoeEnv::Static()->CreateResourceReaderLC(reader, R_ONSCREEN_KEYBOARD_ROCKER_BUTTONS);

        TInt numButtons(reader.ReadInt16());

        for (TInt i = 0; i < numButtons; i++)

        {

            TButtonData buttonData;

            buttonData.iButton = CAknButton::NewL();

            CleanupStack::PushL(buttonData.iButton);

            buttonData.iButton->ConstructFromResourceL(reader);

            buttonData.iButton->SetContainerWindowL(*this);

            buttonData.iButton->SetExtent(iRockerRect.iTl, iRockerRect.Size());

            buttonData.iButton->ActivateL();

            InitializeKeyEvents(TKeypadKeys(i), &buttonData);

            iButtonData.Append(buttonData);

            CleanupStack::Pop(buttonData.iButton);

        }

        CleanupStack::PopAndDestroy(); // reader;

    }

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    CFbsBitmap* bitmap(NULL);

    CFbsBitmap* mask(NULL);

    // Get icon ids.

    TAknsItemID skinItemId(KAknsIIDNone);

    TFileName fileName;

    fileName.Append(KDC_APP_BITMAP_DIR);

    fileName.Append(KLcduiBitmapResourceFileName);

    fileName = java::util::S60CommonUtils::VerifiedFileNameL(fileName);

    if (iKeypadType == EKeypadValueGameActions)

    {

        //GameA

        AknsUtils::CreateColorIconLC(

            skin,