/*

 * Copyright (c) 2010 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:

 * Source file containing common test app functionality.

 */

#include <f32file.h>

#include <remconcoreapitarget.h>

#include <remconinterfaceselector.h>

#include "testappbase.h"

const TInt KLeftSoftKeyScanCode = EStdKeyDevice0;

const TInt KRightSoftKeyScanCode = EStdKeyDevice1;

const TInt KHelpWindowBorderPixels = 20;

const TInt KHelpWindowSpaceBetweenColumns = 25;

const TInt KHelpWindowSpaceBetweenRows = 2;

// TODO: WOULD BE BETTER TO DYNAMICALLY DETECT THE AVAILABLE DRIVES

_LIT( KDriveC, "C:" );

_LIT( KDriveE, "E:" );

_LIT( KDriveF, "F:" );

_LIT( KDriveZ, "Z:" );

struct TKeyListEntry

    {

    TInt scanCode;

    TInt scanCode2;

    const TText* keyName;

    };

// Some emulators return '1' when key 1 is pressed and others returned EStdKeyNkp1.

// Convert both case into '1'.

const TKeyListEntry KSupportedKeys[KSupportedKeysCount] =

    {

        {EStdKeyEnter,      EStdKeyNull, STR("Enter")},

        {EStdKeyUpArrow,    EStdKeyNull, STR("Up")},

        {EStdKeyDownArrow,  EStdKeyNull, STR("Down")},

        {EStdKeyLeftArrow,  EStdKeyNull, STR("Left")},

        {EStdKeyRightArrow, EStdKeyNull, STR("Right")},

        {'0',               EStdKeyNkp0, STR("0")},

        {'1',               EStdKeyNkp1, STR("1")},

        {'2',               EStdKeyNkp2, STR("2")},

        {'3',               EStdKeyNkp3, STR("3")},

        {'4',               EStdKeyNkp4, STR("4")},

        {'5',               EStdKeyNkp5, STR("5")},

        {'6',               EStdKeyNkp6, STR("6")},

        {'7',               EStdKeyNkp7, STR("7")},

        {'8',               EStdKeyNkp8, STR("8")},

        {'9',               EStdKeyNkp9, STR("9")}

    };

static TPtrC KeyName(TInt aIndex)

    {

    //TODO: Check aIndex range

    return TPtrC(KSupportedKeys[aIndex].keyName);

    }

// Portable app implementation

CTestAppBase::CTestAppBase(TInt aFontSize) :

    CActive(EPriorityStandard), iFontSize(aFontSize),

            iHelpSemitransparentBackgroundActive(true)

    {

    CActiveScheduler::Add(this);

    }

CTestAppBase::~CTestAppBase()

    {

    delete iInterfaceSelector;

    delete iHelpWindow;

    delete iSelectionWindow;

    delete iGc;

    delete iWindowGroup;

    delete iScreenDevice;

    delete iTypefaceStore;

    iWs.Close();

    iFs.Close();

    iFileHistory.ResetAndDestroy();

    }

void CTestAppBase::BaseConstructL(const TOperationsPage* aKeyMap,

        TInt aPageCount)

    {

    iKeyMap = aKeyMap;

    iPageCount = aPageCount;

    User::LeaveIfError(iFs.Connect());

    User::LeaveIfError(iWs.Connect());

    iScreenDevice = new (ELeave) CWsScreenDevice(iWs);

    User::LeaveIfError(iScreenDevice->Construct());

    iDisplaySize = iScreenDevice->SizeInPixels();

    User::LeaveIfError(iScreenDevice->CreateContext(iGc));

    iWindowGroup = new (ELeave) RWindowGroup(iWs);

    User::LeaveIfError(iWindowGroup->Construct(KNullWsHandle));

    iSelectionWindow = new (ELeave) RWindow(iWs);

    User::LeaveIfError(iSelectionWindow->Construct(*iWindowGroup,

            KNullWsHandle));

    iSelectionWindow->SetVisible(false);

    iSelectionWindow->Activate();

    // Load the font to be used for all text operations.

    TFontSpec fontSpec;

    fontSpec.iHeight = iFontSize;

    iTypefaceStore = CFbsTypefaceStore::NewL(NULL);

    User::LeaveIfError(iTypefaceStore->GetNearestFontToDesignHeightInPixels(

            iFont, fontSpec));

    CalculateHelpWindowSize();

    iHelpWindowTopRight = TPoint(iDisplaySize.iWidth / 2

            - iHelpWindowSize.iWidth / 2, iDisplaySize.iHeight / 2

            - iHelpWindowSize.iHeight / 2);

    iHelpWindow = new (ELeave) RWindow(iWs);

    User::LeaveIfError(iHelpWindow->Construct(*iWindowGroup, KNullWsHandle));

    iHelpWindow->SetExtent(iHelpWindowTopRight, iHelpWindowSize);

    iHelpWindow->SetTransparencyAlphaChannel();

    iHelpWindow->SetBackgroundColor(KRgbTransparent);

    iHelpWindow->SetVisible(false);

    iHelpWindow->Activate();

    iSoftkeyIndex = iKeyMap[iCurrentPage].defaultSoftkeyIndex;

    // Only need to draw the help text when the options page is changed.  Window is displayed later by

    // toggling the visibility of the window.

    DrawHelpText();

    // THE FOLLOWING CODE IS COMMENTED OUT BECAUSE IT CAUSES A CRASH IN NCP BUILDS.

    // THIS CAN BE ENABLED IN DFS BUILDS, TO ALLOW FOR TWO BUTTON OPERATION USING THE VOLUME KEYS.

    //

    // Since some phone have no keyboard or soft keys, treat the volume keys like the soft keys.

    // SetupVolumeKeysL();    

    }

void CTestAppBase::SetupVolumeKeysL()

    {

    iInterfaceSelector = CRemConInterfaceSelector::NewL();

    iCoreTarget = CRemConCoreApiTarget::NewL(*iInterfaceSelector, *this);

    iInterfaceSelector->OpenTargetL();

    }

void CTestAppBase::StartMonitoringWindowEvents()

    {

    // Request notification for windows server events, to detect key presses.    

    SetActive();

    iWs.EventReady(&iStatus);

    }

TInt CTestAppBase::CurrentPageNumber()

    {

    return iCurrentPage + 1;

    }

TPtrC CTestAppBase::CurrentPageName()

    {

    return TPtrC(iKeyMap[iCurrentPage].pageName);

    }

TPtrC CTestAppBase::CurrentSoftkeyName()

    {

    return TPtrC(iKeyMap[iCurrentPage].mapping[iSoftkeyIndex].text);

    }

TPtrC CTestAppBase::KeyMapText(TInt aIndex, TInt aPage)

    {

    return TPtrC(iKeyMap[aPage].mapping[aIndex].text);

    }

TInt CTestAppBase::KeyMapOperation(TInt aIndex, TInt aPage)

    {

    return iKeyMap[aPage].mapping[aIndex].operation;

    }

void CTestAppBase::IncrementKeymapIndex(TInt& aIndex, TInt aPage)

    {

    aIndex = (aIndex + 1) % KSupportedKeysCount;

    while (iKeyMap[aPage].mapping[aIndex].operation == KOperation_None)

        {

        aIndex = (aIndex + 1) % KSupportedKeysCount;

        }

    }

void CTestAppBase::DecrementKeymapIndex(TInt& aIndex, TInt aPage)

    {

    aIndex = (aIndex + KSupportedKeysCount - 1) % KSupportedKeysCount;

    while (iKeyMap[aPage].mapping[aIndex].operation == KOperation_None)

        {

        aIndex = (aIndex + KSupportedKeysCount - 1) % KSupportedKeysCount;

        }

    }

void CTestAppBase::CalculateHelpWindowSize()

    {

    iHelpWindowColumn1Width = 0;

    iHelpWindowColumn2Width = 0;

    // Find the widest strings for each column to determine the width of the window.

    for (TInt index = 0; index < KSupportedKeysCount; index++)

        {

        TInt width = iFont->TextWidthInPixels(KeyName(index));

        if (width > iHelpWindowColumn1Width)

            {

            iHelpWindowColumn1Width = width;

            }

        for (TInt index2 = 0; index2 < iPageCount; index2++)

            {

            width = iFont->TextWidthInPixels(KeyMapText(index, index2));

            if (width > iHelpWindowColumn2Width)

                {

                iHelpWindowColumn2Width = width;

                }

            }

        }

    iHelpWindowSize.iWidth = 2 * KHelpWindowBorderPixels

            + iHelpWindowColumn1Width + KHelpWindowSpaceBetweenColumns

            + iHelpWindowColumn2Width;

    iHelpWindowSize.iHeight = 2 * KHelpWindowBorderPixels + iFontSize

            * KSupportedKeysCount + KHelpWindowSpaceBetweenRows

            * (KSupportedKeysCount - 1);

    }

CTestAppBase::TTestAppPointerEvent CTestAppBase::CharacterizePointerEvent(

        TAdvancedPointerEvent& event)

    {

    TTestAppPointerEvent returnValue = EPointerEvent_None;

    RDebug::Printf("POINTER EVENT:");

    RDebug::Printf("iType=%i", event.iType);

    RDebug::Printf("iModifiers=%x", event.iModifiers);

    RDebug::Printf("iPosition=%i,%i", event.iPosition.iX, event.iPosition.iY);

    RDebug::Printf("iParentPosition=%i,%i", event.iParentPosition.iX,

            event.iParentPosition.iY);

    RDebug::Printf("PointerNumber=%i", event.PointerNumber());

    RDebug::Printf("Proximity=%i", event.Proximity());

    RDebug::Printf("Pressure=%i", event.Pressure());

    RDebug::Printf("ProximityAndPressure=%i", event.ProximityAndPressure());

    RDebug::Printf("Position3D=%i,%i,%i", event.Position3D().iX,

            event.Position3D().iY, event.Position3D().iZ);

    RDebug::Printf("Pressure3D=%i,%i,%i", event.Pressure3D().iX,

            event.Pressure3D().iY, event.Pressure3D().iZ);

    RDebug::Printf("PositionAndPressure3D=%i,%i,%i",

            event.PositionAndPressure3D().iX,

            event.PositionAndPressure3D().iY,

            event.PositionAndPressure3D().iZ);

    switch (event.iType)

        {

        case TPointerEvent::EButton1Down:

            {

            iPointerDownPosition = event.iPosition;

            break;

            }

        case TPointerEvent::EButton1Up:

            {

            TInt xDelta = event.iPosition.iX - iPointerDownPosition.iX;

            TInt yDelta = event.iPosition.iY - iPointerDownPosition.iY;

            TInt xMagnitude = xDelta;

            if (xMagnitude < 0)

                {

                xMagnitude = -xMagnitude;

                }

            TInt yMagnitude = yDelta;

            if (yMagnitude < 0)

                {

                yMagnitude = -yMagnitude;

                }

            const TInt KTapThreshold = 30;

            if (yMagnitude > xMagnitude)

                {

                if (yMagnitude < KTapThreshold)

                    {

                    RDebug::Printf("POINTER EVENT ENTER x=%i y=%i", xDelta,

                            yDelta);

                    returnValue = EPointerEvent_Select;

                    }

                else if (yDelta < 0)

                    {

                    RDebug::Printf("POINTER EVENT UP x=%i y=%i", xDelta,

                            yDelta);

                    returnValue = EPointerEvent_Up;

                    }

                else

                    {

                    RDebug::Printf("POINTER EVENT DOWN x=%i y=%i", xDelta,

                            yDelta);

                    returnValue = EPointerEvent_Down;

                    }

                }

            else

                {

                if (xMagnitude < KTapThreshold)

                    {

                    RDebug::Printf("POINTER EVENT ENTER x=%i y=%i", xDelta,

                            yDelta);

                    returnValue = EPointerEvent_Select;

                    }

                else if (xDelta < 0)

                    {

                    RDebug::Printf("POINTER EVENT LEFT x=%i y=%i", xDelta,

                            yDelta);

                    returnValue = EPointerEvent_Left;

                    }

                else

                    {

                    RDebug::Printf("POINTER EVENT RIGHT x=%i y=%i", xDelta,

                            yDelta);

                    returnValue = EPointerEvent_Right;

                    }

                }

            break;

            }

        }

    return returnValue;

    }

void CTestAppBase::RunL()

    {

    if (iWait.IsStarted())

        {

        // This is an event during synchronous list selection.  Stop the nested scheduler.

        iWait.AsyncStop();

        return;

        }

    TWsEvent event;

    iWs.GetEvent(event);

    TInt operationIndex = -1;

    TInt scanCode = 0;

    bool processScanCode = false;

    TInt operation = KOperation_None;

    // Other potentially useful events are EEventKeyUp and EEventKeyDown.

    if (event.Type() == EEventKey)

        {

        scanCode = event.Key()->iScanCode;

        RDebug::Printf("key event %x %c", scanCode, scanCode);

        // Allow subclasses a chance to consume the key event directly.  If that happens, then

        // do not handle the key as normal.

        if (!ConsumeKeyEvent(scanCode))

            {

            processScanCode = true;

            }

        }

    else if (event.Type() == EEventPointer)

        {

        TAdvancedPointerEvent* p = event.Pointer();

        TTestAppPointerEvent pointerEvent = CharacterizePointerEvent(*p);

        switch (pointerEvent)

            {

            case EPointerEvent_None:

                // Do nothing.

                break;

            case EPointerEvent_Up:

                operation = KOperation_PreviousOption;

                break;

            case EPointerEvent_Down:

                operation = KOperation_NextOption;

                break;

            case EPointerEvent_Left:

                operation = KOperation_PreviousOptionPage;

                break;

            case EPointerEvent_Right:

                operation = KOperation_NextOptionPage;

                break;

            case EPointerEvent_Select:

                operation = KOperation_ExecuteOption;

                break;

            }

        }

    if (processScanCode)

        {

        // If one of the softkeys were pressed then take the appropriate action.

        // This is to support a two button touch device with no numeric keypad.

        // Support 'A' and 'B' also, for the NCP emulator where a keyboard  is

        // not displayed.

        switch (scanCode)

            {

            case KLeftSoftKeyScanCode:

            case 'a':

            case 'A':

                {

                operation = KOperation_NextOption;

                break;

                }

            case KRightSoftKeyScanCode:

            case 'b':

            case 'B':

                {

                // Execute softkey function.

                operation = KOperation_ExecuteOption;

                break;

                }

            default:

                {

                // Search for scancode in keymap.  If not found then the key was not a valid

                // key, so ignore.                

                TInt index = 0;

                while ((index < KSupportedKeysCount)

                        && (operationIndex == -1))

                    {

                    if (KSupportedKeys[index].scanCode == scanCode

                            || KSupportedKeys[index].scanCode2 == scanCode)

                        {

                        // Found!

                        operationIndex = index;

                        }

                    else

                        {

                        index++;

                        }

                    }

                break;

                }

            }

        }

    if (operation == KOperation_ExecuteOption)

        {

        operationIndex = iSoftkeyIndex;

        }

    if (operationIndex >= 0)

        {

        operation = KeyMapOperation(operationIndex, iCurrentPage);

        }

    if (operation != KOperation_None)

        {

        // Valid operation.

        switch (operation)

            {

            case KOperation_Exit:

                {

                CActiveScheduler::Stop();

                break;

                }

            case KOperation_PreviousOption:

                {

                // Change softkey function.

                DecrementKeymapIndex(iSoftkeyIndex, iCurrentPage);

                // Redraw help text, since a new function should now be underlined.

                DrawHelpText();

                // Notify subclass that softkey function has been updated.

                SoftkeyFunctionUpdated();

                break;

                }

            case KOperation_NextOption:

                {

                // Change softkey function.

                IncrementKeymapIndex(iSoftkeyIndex, iCurrentPage);

                // Redraw help text, since a new function should now be underlined.

                DrawHelpText();

                // Notify subclass that softkey function has been updated.

                SoftkeyFunctionUpdated();

                break;

                }

            case KOperation_PreviousOptionPage:

                {

                iCurrentPage = (iCurrentPage + iPageCount - 1) % iPageCount;

                iSoftkeyIndex = iKeyMap[iCurrentPage].defaultSoftkeyIndex;

                DrawHelpText();

                SoftkeyFunctionUpdated();

                break;

                }

            case KOperation_NextOptionPage:

                {

                iCurrentPage = (iCurrentPage + 1) % iPageCount;

                iSoftkeyIndex = iKeyMap[iCurrentPage].defaultSoftkeyIndex;

                DrawHelpText();

                SoftkeyFunctionUpdated();

                break;

                }

            case KOperation_ToggleHelpVisibility:

                {

                // Toggle help text on/off.

                iHelpActive = !iHelpActive;

                iHelpWindow->SetVisible(iHelpActive);

                break;

                }

            case KOperation_ToggleHelpTransparency:

                {

                iHelpSemitransparentBackgroundActive

                        = !iHelpSemitransparentBackgroundActive;

                if (iHelpSemitransparentBackgroundActive)

                    {

                    // Turn on help if it is currently off.

                    iHelpActive = true;

                    iHelpWindow->SetVisible(true);