/*

* Copyright (c) 2007 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:  Implement of class CTruiShortcutEditContainer

*

*/

#include <eikedwin.h>

#include <aknbutton.h>

#include <eiklabel.h>

#include <barsread.h>

#include <aknnavide.h>

#include <aknnotewrappers.h> 

#include <trui.rsg>

#include <AknsBasicBackgroundControlContext.h>

#include <AknsDrawUtils.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <avkon.rsg>

#include <layoutmetadata.cdl.h>

#include <akntoolbar.h>

#include <aknSctDialog.h>

#include "truicontainerbase.h"

#include "truishortcuteditcontainer.h"

#include "truihwrbox.h"

#include "truiengine.h"

#include "truiappui.h"

#include "truishortcutsview.h"

#include "truiapplication.h"

#include "truiappradiobutton.h"

#include "truishortcutsview.h"

#include "truiapplication.h"

#include "truishortcutedittextview.h"

#include "trui.hrh"

#include "truishortcuteditview.h"

const TInt KSimilarMsgLength = 160;

// The maximum number of lines for tips

const TInt KIndicatorBufSize = 2;

// The index of each item in radio button groups

const TInt KOwnIndex = 0;

const TInt KPresetIndex = 1;

// Layout for portrait

const TPoint KLabelTipPosPortrait = TPoint( 0, 0 );

const TSize KLabelTipSizePortrait = TSize( 360, 60 );

const TPoint KRadioPosPortrait = TPoint( 5, 73 );

const TSize KRadioSizePortrait = TSize( 196, 99 );

const TPoint KLeftBtnPosPotrait = TPoint( 115, 160 );

const TPoint KIndicatorPosPotrait = TPoint( 165, 160 );

const TPoint KRightBtnPosPotrait = TPoint( 215, 160 );

const TPoint KHwrBoxPosPortrait = TPoint( 90, 215 );

const TSize KButtonSize = TSize( 50, 50 );

// Layout for landscape

const TPoint KRadioPosLandscape = TPoint( 5, 18 );

const TPoint KLabelTipPosLandscape = TPoint( 5, 120 );

const TSize KLabelTipSizeLandscape = TSize( 250, 120 );

const TPoint KLeftBtnPos = TPoint( 300, 15 );

const TPoint KRightBtnPos = TPoint( 400, 15 );

const TPoint KIndicatorPosLandscape = TPoint( 350, 15 );

const TSize KHwrBoxSizeLandscape = TSize( 200, 200 );

const TPoint KHwrBoxPosLandscape = TPoint( 275, 80 );

const TInt KTooltipPopupTimeOut = 0;

const TInt KTooltipStayTimeOut = 3000;

const TInt KSctBufferSize = 32;

const TInt KHwrTooltipY = 20;

_LIT( KActiveCharFormat, "%c" );

// Varity of landscape for common components

const TInt KVarityLandscape = 3;

// Varity of portrait for common components

const TInt KVarityPortrait = 2;

const TInt KVarityListPane = 1;

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

CTruiShortcutEditContainer::CTruiShortcutEditContainer()

    {  

    iActiveCharPos = KErrNotFound;

    }

void CTruiShortcutEditContainer::ConstructL( const TRect& aRect )

    {    

    // Initialize control array

    InitComponentArrayL();

    // Set parent control or owning window

    CreateWindowL();

    iBackGround = CAknsBasicBackgroundControlContext::NewL

                  ( KAknsIIDQsnBgAreaMain, Rect(), EFalse);

    // Initialize controls

    InitializeControlsL();       

#ifdef TRAININGUI_FOR_PRESET

    // Get all presets from Engine

    HBufC* presetHBuf = iEikonEnv->AllocReadResourceLC( R_TRUI_PRESET_SYMBOLS );

    for ( TInt i = 0; i < presetHBuf->Length(); i++ )

        {

        iPresets.Append( ( *presetHBuf )[i] );

        }

    CleanupStack::PopAndDestroy( presetHBuf );        

#endif

    // Load setting data

    CTruiShortcutEditView* view = static_cast<CTruiShortcutEditView*>

                           ( iAppUi->View( KTruiShortcutEditViewId ) );

    if ( view->PreviousViewId() == TVwsViewId( KUidtruiApp, KTruiShortcutsViewId ) )

        {

        // Edit old shortcut

        iEngine->GetShortcutModelL( iEngine->Shortcut(), 

                                    iHwrBox->Model(), 

                                    iUnicode );

        // Backup shortcut model

        BackupShortcutModel( iHwrBox->Model(), iUnicode );

        // Load the current active char whether is own or preset.

        iShortcutType = iUnicode ? KPresetIndex : KOwnIndex;

        iIsEmptyHwrBox = iUnicode ? ETrue : EFalse;

#ifdef TRAININGUI_FOR_PRESET

        if ( iUnicode )

            {

            // Edit preset shortcut

            iActiveCharPos = iPresets.Find( iUnicode );

            }

        else

            {

            // Edit own shortcut, get the first available preset shortcut

            if ( FindFirstAvailableCharL( 0, iPresets.Count() - 1, 1, iUnicode ) )

                {

                iActiveCharPos = iPresets.Find( iUnicode );

                }

            else

                {        

                iActiveCharPos = KErrNotFound;

                }            

            }

#endif

        }

    else

        {

        // Create new shortcut        

        // Load the current active char whether is own or preset.

        iShortcutType = KOwnIndex;

        iIsEmptyHwrBox = ETrue;

#ifdef TRAININGUI_FOR_PRESET

        if ( FindFirstAvailableCharL( 0, iPresets.Count() - 1, 1, iUnicode ) )

            {

            iActiveCharPos = iPresets.Find( iUnicode );

            }

        else

            {        

            iActiveCharPos = KErrNotFound;

            }

#endif

        }

    // Set radio button

    iRadioButtonContainer->HandlePointerRadioButtonL( iShortcutType, 

                                                      EEventRequestFocus );

    SetRect( aRect );

    ActivateL();

    }

CTruiShortcutEditContainer* CTruiShortcutEditContainer::NewL( const TRect& aRect )

    {

    CTruiShortcutEditContainer* self = CTruiShortcutEditContainer::NewLC( aRect );

    CleanupStack::Pop( self );

    return self;

    }

CTruiShortcutEditContainer* CTruiShortcutEditContainer::NewLC( const TRect& aRect )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aRect );

    return self;

    }

CTruiShortcutEditContainer::~CTruiShortcutEditContainer()

    {

    delete iBackGround;

    delete iLabeltext;

    delete iWrappedLabelText;

    iModelBak.Close();

    iPresets.Close();

    iLineWidthArray.Close();

    }

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

// Create controls to be displayed in this container.

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

//

void CTruiShortcutEditContainer::InitializeControlsL()

    {

    // Create fixed toolbar

    CAknToolbar* toolbar = iAppUi->View( KTruiShortcutEditViewId )->Toolbar();

    // Get Clear button from toolbar    

    CAknButton* clearButton = static_cast<CAknButton*>

                    ( toolbar->ControlOrNull( EShortcutEditViewDelete ) );

    CreateRadioButtonL();         

    CcnstructButtonL();

    CreateLabelL();

    CreateHwrBoxL();

    }

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

// From class CCoeControl.

// Responds to changes to the size and position of the contents of this control.

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

//

void CTruiShortcutEditContainer::SizeChanged()

    {

    TInt varity = Layout_Meta_Data::IsLandscapeOrientation() ? KVarityLandscape

                                                             : KVarityPortrait;

    DoSizeChanged( varity );

    // Set hwrbox's rect to engine and set guiding line to hwrbox

    iHwrBox->SetDisplayBottomGuideLine( ETrue );

    TBool isDisplayTopGuideLine = ( iEngine->CurrentLanguageScript() 

                             == EMainViewSubmenuHebrew ) ? ETrue : EFalse;

    iHwrBox->SetDisplayTopGuideLine( isDisplayTopGuideLine );

    if ( varity == KVarityLandscape )

        {

        DoLayoutLandscape();

        }

    else if ( varity == KVarityPortrait )  

        {

        DoLayoutPortait();

        }

    if ( iBackGround )

        {

        iBackGround->SetRect( Rect() );

        }    

    }

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

// Layout under landscape condition.

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

//    

void CTruiShortcutEditContainer::DoLayoutLandscape()

    {    

#ifdef TRAININGUI_FOR_PRESET  

    iRadioButtonContainer->SetRect( TRect( KRadioPosLandscape, 

                                           KRadioSizePortrait ) );

    iLeftBtn->SetRect( TRect( KLeftBtnPos, KButtonSize ) );

    iRightBtn->SetRect( TRect( KRightBtnPos, KButtonSize ) );

    iIndicator->SetRect( TRect( KIndicatorPosLandscape, KButtonSize ) );

#endif

    }

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

// Layout under portait condition.

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

//    

void CTruiShortcutEditContainer::DoLayoutPortait()

    {

#ifdef TRAININGUI_FOR_PRESET

    iRadioButtonContainer->SetRect( TRect( KRadioPosPortrait, 

                                           KRadioSizePortrait ) );    

    iLeftBtn->SetRect( TRect( KLeftBtnPosPotrait, KButtonSize ) );

    iRightBtn->SetRect( TRect( KRightBtnPosPotrait, KButtonSize ) );

    iIndicator->SetRect( TRect( KIndicatorPosPotrait, KButtonSize ) );

#endif

    }    

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

// Save own shortcut.

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

//

void CTruiShortcutEditContainer::SaveOwnShortcutL( const TDesC& aShortcut, 

                                                   RArray<TPoint>& aModel,

                                                   TDes& aErrMsg )

    {

    // Ensure the shortcut doesn't exist.

    if ( iEngine->CheckShortcutModel( aShortcut ) )

        {

        iEngine->DeleteShortcut( aShortcut );

        }

    if ( aModel.Count() )

        {

        iEngine->SaveShortcutL( aShortcut, aModel, aErrMsg );

        }

    }    

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

// Save preset shortcut.

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

//

void CTruiShortcutEditContainer::SavePresetShortcutL( const TDesC& aShortcut, 

                                                      TUint aUnicode )

    {

    // Ensure the shortcut doesn't exist.

    if ( iEngine->CheckShortcutModel( aShortcut ) )

        {

        iEngine->DeleteShortcut( aShortcut );

        }

    // Check if aUnicode is in use.

    RArray<TPoint> presetModel;

    CleanupClosePushL( presetModel );

    TBuf<KSimilarMsgLength> msg;

    iEngine->GetPresetSymbolByUnicodeL( aUnicode, presetModel, msg );

    if ( msg.Length() > 0 )

        {

        // In use, being assigned to some shortcut.

        User::Leave( KErrInUse );

        }

    CleanupStack::PopAndDestroy( &presetModel );

    iEngine->SavePresetShortcutL( aUnicode, aShortcut );

    }

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

// Backup shortcut model. It is probably to be restored when press Back to exit.

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

//

void CTruiShortcutEditContainer::BackupShortcutModel

                                 ( const RArray<TPoint>& aOriginalModel,

                                   TUint aOriginalUnicode )

    {

    iUnicodeBak = aOriginalUnicode;

    if ( !iUnicodeBak )

        {

        // If old shortcut is own, it is necessary to store trails.

        // If it is preset, backup is unecessary

        for ( TInt i = 0; i < aOriginalModel.Count(); i++ )

            {

            iModelBak.Append( aOriginalModel[i] );

            }        

        }    

    }

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

// Set active char.

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

//

void CTruiShortcutEditContainer::SetActiveCharL( TUint aUnicode )

    {

    // Set active indicator

    TBuf<KIndicatorBufSize> preset;

    // Preset symbol

    preset.Format( KActiveCharFormat, aUnicode );

    iIndicator->SetTextL( preset );        

    iIndicator->DrawNow();    

    // Clear hwrbox and stop playing animation    

    iHwrBox->ClearExistModel();

    // Get model

    TBuf<KSimilarMsgLength> similarMsg;

    iEngine->GetPresetSymbolByUnicodeL( aUnicode, iHwrBox->Model(),

                                        similarMsg );

    // Play animation in HwrBox 

    iHwrBox->ModelIsReady( ETrue );

    if ( iShortcutType == KPresetIndex )

        {

        // As for preset, need to scale trails size firstly

        iHwrBox->PlayAnimation( ETrue, CTruiContainerBase::OriginSymbolSize() );

        }

    else

        {

        iHwrBox->PlayAnimation();

        }    

    }

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

// Find the first available preset symbol.

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

//

TBool CTruiShortcutEditContainer::FindFirstAvailableCharL( TInt aStartPos, 

                                                           TInt aEndPos,

                                                           TInt aDirection, 

                                                           TUint& aUnicode )

    {

    while ( aStartPos != aEndPos && aStartPos < iPresets.Count() )

        {

        if ( !CheckPresetSymbolInUseL( iPresets[aStartPos] ) )

            {            

            aUnicode = iPresets[aStartPos];

            return ETrue;

            }

        else

            {

            // In use

            if ( iUnicodeBak == iPresets[aStartPos] )

                {

                // But the preset symbol is the old preset 

                // which users are editting, 

                // Still display the symbol in indicator                

                aUnicode = iPresets[aStartPos];

                return ETrue;

                }

            }

        if ( aDirection )

            {

            // Go right           

            aStartPos = ( ++aStartPos + iPresets.Count() ) % iPresets.Count();

            }

        else

            {

            // Go left

            aStartPos = ( --aStartPos + iPresets.Count() ) % iPresets.Count();

            }                    

        }

    if ( aEndPos < iPresets.Count() && !CheckPresetSymbolInUseL( iPresets[aEndPos] ) )

        {

        aUnicode = iPresets[aEndPos];

        return ETrue;

        }      

    return EFalse;           

    }

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

// Return if the preset is in use.

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

//

TBool CTruiShortcutEditContainer::CheckPresetSymbolInUseL( TUint aUnicode )

    {

    // Check if iUnicode is in use

    RArray<TPoint> presetModels;

    CleanupClosePushL( presetModels );

    TBuf<KSimilarMsgLength> similarMsg;      

    iEngine->GetPresetSymbolByUnicodeL( aUnicode,

                                        presetModels,

                                        similarMsg );

    CleanupStack::PopAndDestroy( &presetModels );

    if ( similarMsg.Length() )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// Do something to response to size changed.

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

// 

void CTruiShortcutEditContainer::DoSizeChanged( TInt aVarity )

    {

    TRect rect = Rect();

    TAknWindowComponentLayout main_pane_layout = 

                            AknLayoutScalable_Apps::main_hwr_training_pane();

    TAknLayoutRect main_pane_layout_rect;

    main_pane_layout_rect.LayoutRect( rect, main_pane_layout );

    TRect main_pane_rect = main_pane_layout_rect.Rect();

    // hwr_training_write_pane

    TAknWindowComponentLayout write_pane_layout = 

               AknLayoutScalable_Apps::hwr_training_write_pane( aVarity );

    TAknLayoutRect write_pane_layout_rect;

    write_pane_layout_rect.LayoutRect( main_pane_rect, write_pane_layout );

    iHwrBox->SetRect( write_pane_layout_rect.Rect() );

    TPoint hwrPos = iHwrBox->PositionRelativeToScreen();

    iHwrBox->SetTooltipPosition( hwrPos + TPoint( iHwrBox->Size().iWidth, KHwrTooltipY ) );

    // hwr_training_instruct_pane

    TAknWindowComponentLayout instruct_pane_layout = 

               AknLayoutScalable_Apps::hwr_training_instruct_pane( aVarity );

    TAknLayoutRect instruct_pane_layout_rect;

    instruct_pane_layout_rect.LayoutRect( main_pane_rect, instruct_pane_layout );    

    // count of text rows

    TInt count = AknLayoutScalable_Apps::

                 list_single_hwr_training_instruct_pane_ParamLimits( KVarityListPane )

                 .LastRow() + 1;

    // array contains all text rows in help screen

    RArray<TAknTextComponentLayout> textLayoutArray;

    iLineWidthArray.Reset();

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

        {

        // pane area for each row

        TAknWindowComponentLayout each_row_layout =  

            AknLayoutScalable_Apps::list_single_hwr_training_instruct_pane

            ( KVarityListPane, 0, i );

        TAknLayoutRect each_row_layout_rect;

        each_row_layout_rect.LayoutRect( instruct_pane_layout_rect.Rect(), 

                                         each_row_layout );

        iLineWidthArray.Append( each_row_layout_rect.Rect().Width() );

        // smaller pane for text itself

        TAknTextComponentLayout each_row_text_layout =  

            AknLayoutScalable_Apps::list_single_hwr_training_instruct_pane_t1();

        // composition of two latter componets

        TAknTextComponentLayout textCompCompositionWiz = 

            TAknWindowComponentLayout::ComposeText(

                each_row_layout, each_row_text_layout );

        TRAPD(error, textLayoutArray.AppendL( textCompCompositionWiz ) );

        // if error in append function, then just exit the loop      

        if ( error != KErrNone )

            {

            break;

            }

        }       

    iMultilineLayout = TAknTextComponentLayout::Multiline( textLayoutArray ); 

    if ( iLabeltext && iWrappedLabelText )

        {

        // Be ready to show label

        TAknLayoutText multilineTextLayout;

        multilineTextLayout.LayoutText( instruct_pane_layout_rect.Rect(), iMultilineLayout );