/*

* Copyright (c) 2006 - 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:  AppUi class of the application.

*

*/

// SYSTEM INCLUDES

#include <aknnotewrappers.h>

#include <e32property.h>

#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION

#include "touchscprivatepskeys.h"

#else //RD_STARTUP_ANIMATION_CUSTOMIZATION

#include <StartupAppInternalPSKeys.h>

#endif //RD_STARTUP_ANIMATION_CUSTOMIZATION

#include <aknlayoutscalable_apps.cdl.h>

#include <layoutmetadata.cdl.h>

#include <centralrepository.h>

#include <starterdomaincrkeys.h>

#include <starterclient.h>     //used for RemoveSplashScreen

// USER INCLUDES

#include "TouchScreenCalibApplication.h"

#include "TouchScreenCalibAppUi.h"

#include "TouchScreenCalibDefines.h"

#include "TouchScreenCalibDocument.h"

#include "TouchScreenCalibView.h"

#include "TouchScreenCalibPubSubObserver.h"

// CONSTANTS

_LIT_SECURITY_POLICY_C1(KReadDeviceDataPolicy, ECapabilityReadDeviceData);

_LIT_SECURITY_POLICY_C1(KWriteDeviceDataPolicy, ECapabilityWriteDeviceData);

// ================= MEMBER FUNCTIONS =======================

//

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

// CTouchScreenCalibAppUi::CTouchScreenCalibAppUi()

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

CTouchScreenCalibAppUi::CTouchScreenCalibAppUi():

    iTouchScreenCalibPubSubObserver( NULL ),

    iCurrentCalibrationStep( 0 ),

    iExitting( EFalse ),

    iCalibrationDone( EFalse ),

    iCalibrationCancel( EFalse )

    {

    TRACES("CTouchScreenCalibAppUi::CTouchScreenCalibAppUi");

    iNativeOrientation = KUnknownOrientation;

    }

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

// CTouchScreenCalibAppUi::ConstructL()

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

void CTouchScreenCalibAppUi::ConstructL()

    {

    TRACES("CTouchScreenCalibAppUi::ConstructL()");

    TInt flags = EStandardApp|EAknEnableSkin;

    BaseConstructL(flags);

#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION

    RProperty::Define(KPSUidTouchScreenCalibration,

#else //RD_STARTUP_ANIMATION_CUSTOMIZATION    

    RProperty::Define(KPSUidStartup,

#endif //RD_STARTUP_ANIMATION_CUSTOMIZATION

                      KPSTouchScreenCalibration,

                      RProperty::EInt,

                      KReadDeviceDataPolicy,

                      KWriteDeviceDataPolicy );

    // Clearing the calibration before doing the actual calibration

    TDigitizerCalibrationType caltype = EFactory;

    UserHal::RestoreXYInputCalibration(caltype);

    ResetTapPoints();

//    SetOrientation();

    iCalibrationPoints = CalibrationPoints();

    // Set TSC application to be system application

    CEikonEnv& eikEnv = *CEikonEnv::Static();

    eikEnv.SetSystem( ETrue );

    iTouchScreenCalibLayout.iAnimImageLayout1.LayoutRect(Rect(),AknLayoutScalable_Apps::main_touch_calib_pane_g1().LayoutLine());

    iTouchScreenCalibLayout.iAnimImageLayout2.LayoutRect(Rect(),AknLayoutScalable_Apps::main_touch_calib_pane_g2().LayoutLine());

    iTouchScreenCalibLayout.iAnimImageLayout3.LayoutRect(Rect(),AknLayoutScalable_Apps::main_touch_calib_pane_g3().LayoutLine());

    iTouchScreenCalibLayout.iAnimImageLayout4.LayoutRect(Rect(),AknLayoutScalable_Apps::main_touch_calib_pane_g4().LayoutLine());

    iTouchScreenCalibView = CTouchScreenCalibView::NewL( this );

    AddToStackL( iTouchScreenCalibView );

    iTouchScreenCalibView->SetWinPriority(0);

    // Disable priority changes of window server

    eikEnv.WsSession().ComputeMode( RWsSession::EPriorityControlDisabled );

    UpdateL();

    iTouchScreenCalibPubSubObserver = CTouchScreenCalibPubSubObserver::NewL( this );

    if (FirstBoot())

        {

        TRACES("CTouchScreenCalibAppUi::ConstructL(): First boot ongoing");        

        TRACES("CTouchScreenCalibAppUi::ConstructL(): Connect to Starter");

        RStarterSession startersession;

        if( startersession.Connect() == KErrNone )

            {

            TRACES("CTouchScreenCalibAppUi::ConstructL(): Connected to Starter");

            startersession.EndSplashScreen();

            TRACES("CTouchScreenCalibAppUi::ConstructL(): Splash screen removed");

            startersession.Close();

            }

        }

    NextCalibrationStepL();

    TRACES("CTouchScreenCalibAppUi::ConstructL(): End");

    }

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

// CTouchScreenCalibAppUi::~CTouchScreenCalibAppUi()

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

CTouchScreenCalibAppUi::~CTouchScreenCalibAppUi()

    {

    TRACES("CTouchScreenCalibAppUi::~CTouchScreenCalibAppUi()");

    if (iTouchScreenCalibView)

        {

        TRACES("CTouchScreenCalibAppUi::~CTouchScreenCalibAppUi(): delete iTouchScreenCalibView");

        RemoveFromStack( iTouchScreenCalibView );

        delete iTouchScreenCalibView;

        }

    if (iTouchScreenCalibPubSubObserver)

        {

        TRACES("CTouchScreenCalibAppUi::~CTouchScreenCalibAppUi(): delete iTouchScreenCalibPubSubObserver");

        delete iTouchScreenCalibPubSubObserver;

        }

    TRACES("CTouchScreenCalibAppUi::~CTouchScreenCalibAppUi(): End");

    }

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

// CTouchScreenCalibAppUi::NextCalibrationStepL()

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

void CTouchScreenCalibAppUi::NextCalibrationStepL()

    {

    TRACES("CTouchScreenCalibAppUi::NextCalibrationStepL()");

    TRACES2("CTouchScreenCalibAppUi::NextCalibrationStepL(): TapPoint1: %d %d",iTapPoints.iTl.iX, iTapPoints.iTl.iY);

    TRACES2("CTouchScreenCalibAppUi::NextCalibrationStepL(): TapPoint2: %d %d",iTapPoints.iTr.iX, iTapPoints.iTr.iY);

    TRACES2("CTouchScreenCalibAppUi::NextCalibrationStepL(): TapPoint3: %d %d",iTapPoints.iBr.iX, iTapPoints.iBr.iY);

    TRACES2("CTouchScreenCalibAppUi::NextCalibrationStepL(): TapPoint4: %d %d",iTapPoints.iBl.iX, iTapPoints.iBl.iY);

    iCurrentCalibrationStep++;

    TRACES1("CTouchScreenCalibAppUi::NextCalibrationStepL(): CurrentCalibrationStep: %d",iCurrentCalibrationStep);

    if (iCurrentCalibrationStep > 4)

        {

        TRACES("CTouchScreenCalibAppUi::NextCalibrationStepL(): Calibration succesfully completed. Save it and exit application.");

        SaveCalibration();

        iCalibrationDone = ETrue;

        iTouchScreenCalibView->EndTargetAnimation();

        iTouchScreenCalibView->SetWinPriority(ECoeWinPriorityNormal);

        TRACES("CTouchScreenCalibAppUi::NextCalibrationStepL(): Show 'Calibration Done' note");

        HBufC* noteText = CEikonEnv::Static()->AllocReadResourceLC(R_QTN_TOUCH_SCREEN_CALI_DONE );

        CAknInformationNote* note =

            new( ELeave ) CAknInformationNote( ETrue );

        note->ExecuteLD( *noteText );

        CleanupStack::PopAndDestroy( noteText );

        if ( FirstBoot() )

            {

            iTouchScreenCalibView->DrawEndingBackground();

#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION

            RProperty::Set( KPSUidTouchScreenCalibration, KPSTouchScreenCalibration, ETouchScreenCalibrationOk );    

#else //RD_STARTUP_ANIMATION_CUSTOMIZATION    

            RProperty::Set( KPSUidStartup, KPSTouchScreenCalibration, ETouchScreenCalibrationOk );    

#endif //RD_STARTUP_ANIMATION_CUSTOMIZATION            

            iTouchScreenCalibView->SetWinPriority(0);

            }

        else

            {

            PrepareToExit();

            }

        }

    else

        {

        TRACES("CTouchScreenCalibAppUi::NextCalibrationStepL(): Update next step.");

        UpdateL();

        }

    TRACES("CTouchScreenCalibAppUi::NextCalibrationStepL(): End");

    }

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

// CTouchScreenCalibAppUi::SaveCalibration()

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

void CTouchScreenCalibAppUi::SaveCalibration()

    {

    TRACES("CTouchScreenCalibAppUi::SaveCalibration()");

    // Touch Screen driver supports only portrait orientation. If device is now in

    // landscape mode, convert points to portrait.

    TDigitizerCalibration tapPoints = ConvertToCorrectOrientation(iTapPoints,

                                                                  KConvertSaveCase);

    UserHal::SetXYInputCalibration(tapPoints);

    TRACES("CTouchScreenCalibAppUi::SaveCalibration(): End");

    }

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

// CTouchScreenCalibAppUi::ResetCalibrationStepsL()

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

void CTouchScreenCalibAppUi::ResetCalibrationStepsL()

    {

    iCurrentCalibrationStep = 0;

    ResetTapPoints();

    NextCalibrationStepL();

    }

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

// CTouchScreenCalibAppUi::HandleForegroundEventL(TBool aForeground)

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

void CTouchScreenCalibAppUi::HandleForegroundEventL( TBool aForeground )

    {

    // call super-class first

    CAknAppUi::HandleForegroundEventL( aForeground );

    TRACES1("CTouchScreenCalibAppUi::HandleForegroundEventL( %d )", aForeground);

    if ( aForeground )

        {

        // if we are coming to foreground

        UpdateL();

        }

    else

        {

        if (!FirstBoot())

            {

            // Take old calibration in use                

            TDigitizerCalibrationType caltype = ESaved;

            UserHal::RestoreXYInputCalibration(caltype);

            PrepareToExit();

            }

        }

    }

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

// CTouchScreenCalibAppUi::HandleKeyL(const TKeyEvent& aKeyEvent, TEventCode /*aType*/ )

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

void CTouchScreenCalibAppUi::HandleKeyL( const TKeyEvent& aKeyEvent, TEventCode /*aType*/ )

    {

    TRACES1("CTouchScreenCalibAppUi::HandleKeyL(): %d",aKeyEvent.iCode);

    if (aKeyEvent.iCode == EKeyYes) //Send key

        {

        TRACES("CTouchScreenCalibAppUi::HandleKeyL(): Send Key");

        if (FirstBoot()) // Restart calibration from step 1

            {

            TRACES("CTouchScreenCalibAppUi::HandleKey(): Go to first calibration step");

            ResetCalibrationStepsL();

            }

        else// Show "Calibration cancelled" Information note.

            {

            TRACES("CTouchScreenCalibAppUi::HandleKeyL(): Show cancel note");

            iCalibrationCancel = ETrue;

            iTouchScreenCalibView->EndAnimation();          

            iTouchScreenCalibView->SetWinPriority(ECoeWinPriorityNormal);

            HBufC* noteText = CEikonEnv::Static()->AllocReadResourceLC(R_QTN_TOUCH_SCREEN_CALI_CANCEL );

            CAknInformationNote* note =

                new( ELeave ) CAknInformationNote( ETrue );

            note->ExecuteLD( *noteText );

            CleanupStack::PopAndDestroy( noteText );

            // Take old calibration in use

            TDigitizerCalibrationType caltype = ESaved;

            UserHal::RestoreXYInputCalibration(caltype);

            PrepareToExit();

            }

        }

    else if ( aKeyEvent.iCode == EKeyNo || aKeyEvent.iCode == EKeyApplication0 

                     || ( aKeyEvent.iCode == EKeyNull && aKeyEvent.iScanCode == EStdKeyDevice7 ))

        {

        TRACES("CTouchScreenCalibAppUi::HandleKeyL(): End Key or App Key");

        if (!FirstBoot())

            {

            // Take old calibration in use                

            TDigitizerCalibrationType caltype = ESaved;

            UserHal::RestoreXYInputCalibration(caltype);

            PrepareToExit();

            }

        }

    TRACES("CTouchScreenCalibAppUi::HandleKeyL(): End");

    }

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

// CTouchScreenCalibAppUi::HandlePointerL()

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

void CTouchScreenCalibAppUi::HandlePointerL( TPoint aPos )

    {

    TRACES("CTouchScreenCalibAppUi::HandlePointerL()");

    switch(iCurrentCalibrationStep)

        {

        case 1:

            TRACES("CTouchScreenCalibAppUi::HandlePointerL(): case 1");

            iTapPoints.iTl.iX = aPos.iX;

            iTapPoints.iTl.iY = aPos.iY;

            break;

        case 2:

            TRACES("CTouchScreenCalibAppUi::HandlePointerL(): case 2");

            iTapPoints.iTr.iX = aPos.iX;

            iTapPoints.iTr.iY = aPos.iY;

            break;

        case 3:

            TRACES("CTouchScreenCalibAppUi::HandlePointerL(): case 4");

            iTapPoints.iBr.iX = aPos.iX;

            iTapPoints.iBr.iY = aPos.iY;

            break;

        case 4:

            TRACES("CTouchScreenCalibAppUi::HandlePointerL(): case 3");

            iTapPoints.iBl.iX = aPos.iX;

            iTapPoints.iBl.iY = aPos.iY;

            break;

        default:

            TRACES("CTouchScreenCalibAppUi::HandlePointerL(): case default");

            break;

        }

    TRACES("CTouchScreenCalibAppUi::HandlePointerL(): End: Continue calibration");

    NextCalibrationStepL();

    }

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

// CTouchScreenCalibAppUi::PrepareToExit()

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

void CTouchScreenCalibAppUi::PrepareToExit()

    {

    TRACES("CTouchScreenCalibAppUi::PrepareToExit()");

    if (!iExitting)

        {

        iExitting = ETrue;

        CEikAppUi::PrepareToExit();

        Exit();

        }

    TRACES("CTouchScreenCalibAppUi::PrepareToExit(): End");

    }

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

// CTouchScreenCalibAppUi::ResetTapPoints()

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

void CTouchScreenCalibAppUi::ResetTapPoints()

    {

    TRACES("CTouchScreenCalibAppUi::ResetTapPoints()");

    iTapPoints.iTl.iX = 0;

    iTapPoints.iTl.iY = 0;

    iTapPoints.iTr.iX = 0;

    iTapPoints.iTr.iY = 0;

    iTapPoints.iBr.iX = 0;

    iTapPoints.iBr.iY = 0;

    iTapPoints.iBl.iX = 0;

    iTapPoints.iBl.iY = 0;

    TRACES("CTouchScreenCalibAppUi::ResetTapPoints(): End");

    }

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

// CTouchScreenCalibAppUi::UpdateL()

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

void CTouchScreenCalibAppUi::UpdateL()

    {

    TRACES("CTouchScreenCalibAppUi::UpdateL()");

    TRACES1("CTouchScreenCalibAppUi::UpdateL(): iCurrentCalibrationStep: %d",iCurrentCalibrationStep);

    TAknLayoutText textLayout;

    textLayout.LayoutText(TRect(), AknLayoutScalable_Apps::main_touch_calib_pane_t1().LayoutLine());

    TRACES2("CTouchScreenCalibAppUi::UpdateL(): Text rect top:    X:%d Y:%d",textLayout.TextRect().iTl.iX, textLayout.TextRect().iTl.iY);

    TRACES2("CTouchScreenCalibAppUi::UpdateL(): Text rect:bottom: X:%d Y:%d",textLayout.TextRect().iBr.iX, textLayout.TextRect().iBr.iY);

    iTouchScreenCalibView->UpdateL(textLayout);

    TRACES("CTouchScreenCalibAppUi::UpdateL(): End");

    }

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

// CTouchScreenCalibAppUi::GetCalibrationStep()

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

TInt CTouchScreenCalibAppUi::GetCalibrationStep()

    {

    return iCurrentCalibrationStep;

    }

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

// CTouchScreenCalibAppUi::GetAnimImageRect()

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

TRect CTouchScreenCalibAppUi::GetAnimImageRect(TInt aPointNumber)

    {

    TRACES1("CTouchScreenCalibAppUi::GetAnimImageRect(%d)", aPointNumber);

    TRect rect;

    TInt width(0);

    TInt height(0);

    // If aPointNumber is 0, return current calibration point.

    if (aPointNumber == 0)

        {

        aPointNumber = GetCalibrationStep();

        }

    switch (aPointNumber)

        {

        case 1:

            width = iTouchScreenCalibLayout.iAnimImageLayout1.Rect().iBr.iX -

                         iTouchScreenCalibLayout.iAnimImageLayout1.Rect().iTl.iX;

            height= iTouchScreenCalibLayout.iAnimImageLayout1.Rect().iBr.iY -

                         iTouchScreenCalibLayout.iAnimImageLayout1.Rect().iTl.iY;

            rect = TRect(TPoint( iCalibrationPoints.iTl.iX - (width/2),

                                 iCalibrationPoints.iTl.iY - (height/2)),

                         TPoint( iCalibrationPoints.iTl.iX + (width/2),

                                 iCalibrationPoints.iTl.iY + (height/2)));

            break;

        case 2:

            width = iTouchScreenCalibLayout.iAnimImageLayout2.Rect().iBr.iX -

                         iTouchScreenCalibLayout.iAnimImageLayout2.Rect().iTl.iX;

            height= iTouchScreenCalibLayout.iAnimImageLayout2.Rect().iBr.iY -

                         iTouchScreenCalibLayout.iAnimImageLayout2.Rect().iTl.iY;

            rect = TRect(TPoint( iCalibrationPoints.iTr.iX - (width/2),

                                 iCalibrationPoints.iTr.iY - (height/2)),

                         TPoint( iCalibrationPoints.iTr.iX + (width/2),

                                 iCalibrationPoints.iTr.iY + (height/2)));

            break;

        case 3:

            width = iTouchScreenCalibLayout.iAnimImageLayout3.Rect().iBr.iX -

                         iTouchScreenCalibLayout.iAnimImageLayout3.Rect().iTl.iX;

            height= iTouchScreenCalibLayout.iAnimImageLayout3.Rect().iBr.iY -

                         iTouchScreenCalibLayout.iAnimImageLayout3.Rect().iTl.iY;

            rect = TRect(TPoint( iCalibrationPoints.iBr.iX - (width/2),

                                 iCalibrationPoints.iBr.iY - (height/2)),

                         TPoint( iCalibrationPoints.iBr.iX + (width/2),

                                 iCalibrationPoints.iBr.iY + (height/2)));

            break;

        case 4:

            width = iTouchScreenCalibLayout.iAnimImageLayout4.Rect().iBr.iX -

                         iTouchScreenCalibLayout.iAnimImageLayout4.Rect().iTl.iX;

            height= iTouchScreenCalibLayout.iAnimImageLayout4.Rect().iBr.iY -

                         iTouchScreenCalibLayout.iAnimImageLayout4.Rect().iTl.iY;

            rect = TRect(TPoint( iCalibrationPoints.iBl.iX - (width/2),

                                 iCalibrationPoints.iBl.iY - (height/2)),

                         TPoint( iCalibrationPoints.iBl.iX + (width/2),

                                 iCalibrationPoints.iBl.iY + (height/2)));

            break;

        default:

            break;

        }

    TRACES("CTouchScreenCalibAppUi::GetAnimImageRect(): End");

    return rect;

    }

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

// CTouchScreenCalibAppUi::HandleResourceChange(...)

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

void CTouchScreenCalibAppUi::HandleScreenDeviceChangedL()

    {

    TRACES("CTouchScreenCalibAppUi::HandleResourceChange()");

    CAknAppUiBase::HandleScreenDeviceChangedL();

    if (!iCalibrationDone && !iCalibrationCancel )

        {

        TRACES("CTouchScreenCalibAppUi::HandleResourceChange(): Restart calibration");

        iCalibrationPoints = CalibrationPoints();

        if (iTouchScreenCalibView)

            {

            RemoveFromStack( iTouchScreenCalibView );

            delete iTouchScreenCalibView;

            iTouchScreenCalibView = NULL;

            }

        iTouchScreenCalibView = CTouchScreenCalibView::NewL( this );

        AddToStackL( iTouchScreenCalibView );

        ResetCalibrationStepsL();

        }

    else

        {

        TRACES("CTouchScreenCalibAppUi::HandleResourceChange(): Update ending background");

        iTouchScreenCalibView->DrawEndingBackground();

        }

    TRACES("CTouchScreenCalibAppUi::HandleResourceChange(): End");

    }

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

// CTouchScreenCalibAppUi::CalibrationPoints();

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

TDigitizerCalibration CTouchScreenCalibAppUi::CalibrationPoints()

    {

    TRACES("CTouchScreenCalibAppUi::CalibrationPoints()");

    TDigitizerCalibration calibrationPoints;

#if defined(__WINS__)

    // Dummy values for emulator for testing purposes

    TRect rect = iAvkonAppUi->ApplicationRect();

    TRACES2("CTouchScreenCalibAppUi::CalibrationPoints(): Window resolution: (%d. %d)",rect.iBr.iX,rect.iBr.iY);

    calibrationPoints.iTl.iX = rect.iTl.iX+50;

    calibrationPoints.iTl.iY = rect.iTl.iY+50;

    calibrationPoints.iTr.iX = rect.iBr.iX-50;

    calibrationPoints.iTr.iY = rect.iTl.iY+50;

    calibrationPoints.iBr.iX = rect.iBr.iX-50;

    calibrationPoints.iBr.iY = rect.iBr.iY-50;

    calibrationPoints.iBl.iX = rect.iTl.iX+50;

    calibrationPoints.iBl.iY = rect.iBr.iY-50;

#else

    UserHal::CalibrationPoints(calibrationPoints);

#endif

    // Orientation in driver level could be different than window orientation. Convert

    // points to correct orientation.

    if (calibrationPoints.iBr.iX > calibrationPoints.iBr.iY )

        {

        TRACES("CTouchScreenCalibAppUi::CalibrationPoints(): Native orientation: landscape");

        iNativeOrientation = KLandscapeOrientation;

        }

    else

        {

        TRACES("CTouchScreenCalibAppUi::CalibrationPoints(): Native orientation: portrait");

        iNativeOrientation = KPortraitOrientation;