/*

 * 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 KLeftSoftKeyCode  = EKeyDevice0;

const TInt KRightSoftKeyCode = EKeyDevice1;

const TInt KHelpWindowBorderPixels = 20;

const TInt KHelpWindowSpaceBetweenColumns = 25;

const TInt KHelpWindowSpaceBetweenRows = 2;

struct TKeyListEntry

    {

    TInt         keyCode;

    const TText* keyName;

    };

const TKeyListEntry KSupportedKeys[KSupportedKeysCount] =

        {

            {EKeyEnter,      STR("Enter")},      

            {EKeyUpArrow,    STR("Up")},

            {EKeyDownArrow,  STR("Down")}, 

            {EKeyLeftArrow,  STR("Left")},

            {EKeyRightArrow, STR("Right")},

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

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

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

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

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

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

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

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

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

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

            {'*',            STR("*")},

            {'#',            STR("#")}

        };

static TPtrC KeyName( TInt aIndex )

    {

    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();

    iHelpWindow->PointerFilter(EPointerFilterDrag, 0);

    // Initialize soft key indices

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

        {

        iSoftkeyIndices[i] = iKeyMap[i].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[iSoftkeyIndices[iCurrentPage]].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);

    }

void CTestAppBase::StartReceivingPointerEvents()

    {

    iRoutePointerEventsToApp = true;

    }

void CTestAppBase::StopReceivingPointerEvents()

    {

    iRoutePointerEventsToApp = false;

    }

//virtual void HandlePointerEvent( const TPointerEvent& aEvent ) {}

CTestAppBase::TTestAppPointerEvent CTestAppBase::CharacterizePointerEvent( const 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 keyCode = 0;

    bool processKeyCode = false;

    TInt operation = KOperation_None; 

    // Other potentially useful events are EEventKeyUp and EEventKeyDown.

    if( event.Type() == EEventKey )

        {

        keyCode = event.Key()->iCode;

        RDebug::Printf( "key event keyCode=%x/%c scanCode=%x/%c", keyCode, keyCode, event.Key()->iScanCode, event.Key()->iScanCode );

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

        // do not handle the key as normal.

        if( !ConsumeKeyEvent( keyCode ) )

            {

            processKeyCode = true;        

            }

        }

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

        {

        TAdvancedPointerEvent* p = event.Pointer();

        if( iRoutePointerEventsToApp  )

            {

            HandlePointerEvent( *p );

            }

        else

            {        

            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;

                }

            }

        }

    else

        {

        RDebug::Printf( "other event, type=%i", event.Type() );    

        }

    if( processKeyCode )

        {

        // 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( keyCode )

            {

            case KLeftSoftKeyCode:

            case 'a':

            case 'A':

                {

                operation = KOperation_NextOption;

                break;

                } 

            case KRightSoftKeyCode:

            case 'b':

            case 'B':

                {

                // Execute softkey function.

                operation = KOperation_ExecuteOption;

                break;

                }

            default:

                {

                // Search for keycode 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].keyCode == keyCode )

                        {                

                        // Found!

                        operationIndex = index;

                        }

                    else

                        {

                        index++;

                        }

                    }

                break;

                }                

            }        

        }

    if( operation == KOperation_ExecuteOption )

        {

        operationIndex = iSoftkeyIndices[iCurrentPage];

        }

    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( iSoftkeyIndices[iCurrentPage], 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( iSoftkeyIndices[iCurrentPage], 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;

                DrawHelpText();

                SoftkeyFunctionUpdated();                

                break;

                }

            case KOperation_NextOptionPage:

                {

                iCurrentPage = (iCurrentPage + 1) % iPageCount;

                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);

                    }