/*

* Copyright (c) 2009 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:  Implementation of main window of finger hwr.

*

*/

// INCLUDE

#include <peninputfingerhwrcn.rsg>

#include <aknlayoutscalable_apps.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <peninputlayoutmultilineicf.h>

#include <peninputdropdownlist.h>

#include <peninputrepeatbutton.h>

#include <AknLayoutDef.h>

#include <AknUtils.h>

#include <AknsUtils.h>

#include <AknIconUtils.h>

#include <coemain.h>

#include <s32mem.h>

#include <peninputlayoutchoicelist.h>

#include <aknfeppeninputenums.h>

#include <AknFepGlobalEnums.h>

#include <peninputlayoutinputmodechoice.h>

#include <peninputrepeatbutton.h>

#include <peninputlayout.h>

#include <peninputlayoutbubblectrl.h>

#include <peninputlayoutvkb.h>

#include <peninputmultiimagebutton.h>

#include "peninputfingerhwrwnd.h"

#include "peninputfingerhwrlafmanager.h"

#include "peninputfingerhwrevent.h"

#include "peninputfingerhwrcontrolid.h"

#include "peninputfingerhwrstoreconstants.h"

#include "peninputfingerhwrlayout.h"

#include "peninputfingerhwrdatastore.h"

#include "peninputlayouthwrwnd.h"

#include "peninputmultipagevkb.h"

#include "peninputfingerhwrrangeselector.h"

#include "hbufcarray.h"

const TUint32 KDefaultTextColor = 0x000000;

const TUint KDefaultFrameColor = 0x000000;

const TUint32 KDefaultWriteBoxBgColor = 0xdddddd;

const TUint32 KDefaultWriteBoxFrameColor = 0x000000;

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

// Symbian Constructor

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

//

CPeninputFingerHwrWnd* CPeninputFingerHwrWnd::NewL( CFepUiLayout* aFepUiLayout,

    TInt aControlId, TBool aLandscapeStyle )

    {

    CPeninputFingerHwrWnd* self = NewLC( aFepUiLayout, aControlId, aLandscapeStyle );

    CleanupStack::Pop( self );

    return self;

    }

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

// Symbian Constructor

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

//

CPeninputFingerHwrWnd* CPeninputFingerHwrWnd::NewLC( CFepUiLayout* aFepUiLayout, 

    TInt aControlId, TBool aLandscapeStyle )

    {

    CPeninputFingerHwrWnd* self = new ( ELeave ) CPeninputFingerHwrWnd( aFepUiLayout, aControlId );

    CleanupStack::PushL( self );

    self->ConstructL( aLandscapeStyle );

    return self;

    }

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

// c++ destructor

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

//

CPeninputFingerHwrWnd::~CPeninputFingerHwrWnd()

    {

    //delete by it's owner

    iContextField    = NULL;

#ifndef RD_INTELLIGENT_TEXT_INPUT    

    iFixEngSymbolList1 = NULL;

    iFixEngSymbolList2 = NULL;

#endif

    iCandidateList   = NULL;

    iPredictList     = NULL;

    iWritingBox      = NULL;

    iCloseBtn        = NULL;

    iOptionBtn       = NULL;

    iImeSwitchBtn    = NULL;

    iBackspaceBtn    = NULL;

    iArrowLeftBtn    = NULL; 

    iArrowRightBtn   = NULL;

    iArrowUpBtn      = NULL;

    iArrowDownBtn    = NULL; 

    iRangeSpecialBtn = NULL;

    iRangeSelector   = NULL;

    iSctPage0Btn = NULL;

    iSctPage1Btn = NULL;

    iSctPage2Btn = NULL;

    iVirtualNumpad = NULL;

    iVirtualSctpad = NULL;    

    iVirtualSctpadFix = NULL;

    iRangeSelector = NULL;

    iInputModeSwitch = NULL; 

    delete iLafManager;

    iLafManager = NULL;

    }

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

// Construct control from resource.

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

//

void CPeninputFingerHwrWnd::ConstructFromResourceL()

    {

    if ( iResourceId == KInvalidResId )

        {

        User::Leave( KErrArgument );

        }

    TResourceReader reader;

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

    TInt supportskin = reader.ReadInt16();

    if ( iFirstTimeConstruct && ( supportskin != KNotSupportSkin ) )

        {

        UiLayout()->AddControlL( this );

        }

    // read shadow resources

    TInt32 shadow = reader.ReadInt32();

    ReadShadowInfoL( shadow );

    // read icf resource

    TInt32 icf = reader.ReadInt32();

    ReadICFInfoL( icf );

    if ( iFirstTimeConstruct )

        {

        const TInt32 boxwndResId = reader.ReadInt32();

        const TInt32 bgImageResId = reader.ReadInt32();

        ReadWritingBoxInfoL( boxwndResId );

        ReadBackgroundInfoL( bgImageResId );

        }

    else

        {

        CControlGroup::ConstructFromResourceL();

        const TInt32 boxwndResId = reader.ReadInt32();

        const TInt32 bgImageResId = reader.ReadInt32();

        ReadWritingBoxInfoL( boxwndResId );

        ReadBackgroundInfoL( bgImageResId );

        }    

    CleanupStack::PopAndDestroy(); // reader

    // read keypad image info

    if ( iVirtualNumpad )

        {

        TSize keysize = iLafManager->VirtualNumpadCellSize().Size();

        LoadVkbKeyImageL( iVirtualNumpad, R_FINGER_HWR_NUMPAD_IMAGE, keysize );

        RArray<TRect> rects;

        CleanupClosePushL( rects );

        iLafManager->GetVirtualKeyRects( rects );

        LoadVirtualNumpadKeysL( R_FINGER_HWR_NUMPAD, rects );

        CleanupStack::PopAndDestroy(); //rects

        }

    if ( iVirtualSctpad )

        {

        TSize keysize = iLafManager->VirtualSctpadCellSize().Size();

        LoadVkbKeyImageL( iVirtualSctpad, R_FINGER_HWR_SCTPAD_IMAGE, keysize );

        RArray<TRect> rects;

        CleanupClosePushL( rects );

        iLafManager->GetVirtualKeyRects( rects );

        LoadVirtualSctpadKeysL( R_FINGER_HWR_SCTPAD, rects );

        CleanupStack::PopAndDestroy(); //rects

        }

    if ( iVirtualSctpadFix )

        {

        TSize keysize = iLafManager->FixVirtualSctpadCellSize().Size();

        LoadVkbKeyImageL( iVirtualSctpadFix, R_FINGER_HWR_SCTPAD_IMAGE, keysize );

        RArray<TRect> rects;

        CleanupClosePushL( rects );

        iLafManager->GetFixVirtualKeyRects( rects );

        LoadFixVirtualSctpadKeysL( R_FINGER_HWR_SCTPAD_FIX, rects );

        CleanupStack::PopAndDestroy(); //rects        

        }

    if (!iFirstTimeConstruct)

    	{

    	Draw();

    	}

    iFirstTimeConstruct = EFalse;  

    }

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

// Draw window.

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

//

void CPeninputFingerHwrWnd::Draw()

    { 

    DrawOpaqueMaskBackground( Rect() );

    if( BackgroundBmp() && BackgroundBmp()->SizeInPixels() != Rect().Size() )

        {

    	AknIconUtils::SetSize(BackgroundBmp(), Rect().Size(), EAspectRatioNotPreserved);

        }

	DrawBackground();    

    CControlGroup::Draw();

    UpdateArea( Rect(), EFalse );

    }

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

// Resize.

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

//

void CPeninputFingerHwrWnd::SizeChangedL( TBool /*aLandscapeStyle*/ )

    {

    iLafManager->ReadLafInfo();

    ResetLayoutL();

    if ( iLafManager->IsLandscape() )

        {

        iPredictList->SetCandExpandType( CFepCtrlDropdownList::ECandExpandUpward );

        }

    else

        {

        iPredictList->SetCandExpandType( CFepCtrlDropdownList::ECandExpandDownward );

        }    

    iCandidateList->SizeChanged( iLafManager->CandidateUnitWidth(),

            iLafManager->CandidateUnitHeight(), 

            iLafManager->CandidateUnitWidth(), 

            iLafManager->CandidateLTPos(), 

            KCandidateCountPerRow,

            1 );

    iPredictList->SizeChanged( iLafManager->CandidateUnitWidth(),

            iLafManager->CandidateUnitHeight(),

            iLafManager->CandidateUnitWidth(), 

            iLafManager->PredictiveLTPos(),

            KPredictiveCountPerRow,

            KPredictiveRowCount );

    if ( iFixEngSymbolList1 )

        {

        iFixEngSymbolList1->SizeChanged( iLafManager->CandidateUnitWidth(),

                iLafManager->CandidateUnitHeight(), 

                iLafManager->CandidateUnitWidth(), 

                iLafManager->CandidateLTPos(), 

                KCandidateCountPerRow,

                1 );        

        }

    if ( iFixEngSymbolList2 )

        {

        iFixEngSymbolList2->SizeChanged( iLafManager->CandidateUnitWidth(),

                iLafManager->CandidateUnitHeight(), 

                iLafManager->CandidateUnitWidth(), 

                iLafManager->PredictiveLTPos(), 

                KPredictiveCountPerRow,

                1 );             

        }

    iContextField->SetTextMargin ( iLafManager->IcfLeftMargin(),

            iLafManager->IcfRightMargin(),

            iLafManager->IcfTopMargin(),

            iLafManager->IcfBottomMargin() );

    iContextField->SetLineSpace( iLafManager->IcfLineSpaceMargin() );                          

    iContextField->SizeChangedL( iLafManager->IcfRect(), 

            iLafManager->IcfTextHeight(),

            iLafManager->IcfFont()->FontMaxHeight(),

            iLafManager->IcfFont() );

}

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

// accept editor's text alignment.

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

//

void CPeninputFingerHwrWnd::SetTextAlignmentL( TInt aAlignment, TInt aLangId )  

    {

    if ( iContextField )

        {

        iContextField->SetTextAlignmentL( aAlignment, aLangId );

        }

    }

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

// accept editor's text

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

//

void CPeninputFingerHwrWnd::SetEditorTextL( const TFepInputContextFieldData& aData )

    {

    if ( iContextField )

        {

        iContextField->SetTextL( aData );

        }

    }

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

// accept editor's promopt txt.

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

//

void CPeninputFingerHwrWnd::SetPromptTextL( TUint8* aPromoptData )

    {

    RDesReadStream readStream;

    TPtr8 countPtr( aPromoptData, 2*sizeof( TInt ), 2*sizeof( TInt ) );

    readStream.Open( countPtr );

    CleanupClosePushL( readStream );

    const TInt dataCount = readStream.ReadInt32L();

    const TInt textCount = readStream.ReadInt32L();

    CleanupStack::PopAndDestroy( &readStream );

    TPtr8 ptr( aPromoptData+2*sizeof( TInt ), dataCount+textCount, dataCount+textCount );            

    readStream.Open( ptr );

    CleanupClosePushL( readStream );

    HBufC8* dataBuf = HBufC8::NewLC( dataCount );

    TPtr8 dataBufPtr = dataBuf->Des();

    readStream.ReadL( dataBufPtr, dataCount );

    TFepPromptText* pIcfData = reinterpret_cast<TFepPromptText*>( const_cast<TUint8*>( dataBufPtr.Ptr() ) );

    HBufC* textBuf;

    if ( textCount > 0 )

        {

        textBuf = HBufC::NewLC( textCount/2 );

        TPtr textBufPtr = textBuf->Des();

        readStream.ReadL( textBufPtr, textCount/2 );

        iContextField->SetPromptTextL( textBuf->Des(), ETrue );

        CleanupStack::PopAndDestroy( textBuf );

        }

    else

        {

        iContextField->SetPromptTextL( KNullDesC, ETrue );

        }

    CleanupStack::PopAndDestroy( dataBuf );

    CleanupStack::PopAndDestroy( &readStream );        

    }

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

// Dim option button

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

//

void CPeninputFingerHwrWnd::SetEnableSettingBtn(const TBool aEnable)

    {

    if ( aEnable )    

        {

        iOptionBtn->SetDimmed(EFalse);

        }

    else

        {

        iOptionBtn->SetDimmed(ETrue);

        iOptionBtn->SetActive(EFalse);

        }

    }

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

// accept editor's bubble text.

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

//

void CPeninputFingerHwrWnd::SetBubbleTextL( const TDesC& aInfo )

    {

    if ( aInfo.Length() > 0 )

        {

        iContextField->ShowBubble( aInfo, iContextField->MsgBubbleCtrl()->Rect() );

        }

    else

        {

        iContextField->HideBubble();

        }    

    }

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

// accept editor's char ranges restriction.

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

//

void CPeninputFingerHwrWnd::SetPermittedRanges( const TInt aPermittedRanges )

    {

    if(aPermittedRanges == 0)

        return;

    iPermittedRanges = aPermittedRanges;

    iRangeSelector->SetPermittedRanges( aPermittedRanges );    

    }

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

// accept editor's number mapping restriction.

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

//

void CPeninputFingerHwrWnd::SetNumericMapping( const TDesC& aNumMapping )

    {

    //format of aNumMapping is "0123456789******"

    //char offset in aNumMapping

    //cell 0 using aNumMapping[KNumOffsets[0]]

    //cell 1 using aNumMapping[KNumOffsets[1]]

    const TInt KNumOffsets[] = 

        {

         1,  2,  3, 15,

         4,  5,  6, 14,

         7,  8,  9, 13,

        10,  0, 11, 12

        };

    TInt maxMappingItemCount = sizeof(KNumOffsets)/sizeof(TInt);

    TInt mappingItemCount = aNumMapping.Length();

    //numberpad

    TInt keyCount = iVirtualNumpad->KeyArray().Count();

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

        {

        CVirtualKey* vk = iVirtualNumpad->KeyArray()[i];

        TInt offset = ( i < maxMappingItemCount ) ? KNumOffsets[i] : -1;

        if ( offset > -1  && offset < mappingItemCount )

            {

            TUint16 unicode = aNumMapping[offset];

            vk->SetKeyData( aNumMapping.Mid( offset,1 ) );

            vk->SetKeyScancode( unicode );

            vk->SetDimmed( EFalse );

            }

        else

            {

            vk->SetKeyData( KNullDesC );

            vk->SetKeyScancode( 0xFFFF );

            vk->SetDimmed( EFalse );

            }

        }

    //sctpad

    keyCount = iVirtualSctpad->KeyArray().Count();

    if ( iPermittedRanges == ERangeNumber )

        {

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

            {

            CVirtualKey* vk = iVirtualSctpad->KeyArray()[i];

            TInt pos = aNumMapping.Find( vk->KeyUnicodes() );

            vk->SetDimmed( pos == KErrNotFound );

            }

        }

    else

        {

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

            {

            CVirtualKey* vk = iVirtualSctpad->KeyArray()[i];

            vk->SetDimmed( EFalse );

            }        

        }

    //sync feedback

    UpdateAllVirtualKeysFeedback( CurrentCharRange() );

    }

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

// accept editor's input language.

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

//

void CPeninputFingerHwrWnd::SetInputLanguage( const TInt aLanguageId )

    {

	if ( iContextField )

		{

		iContextField->SetLanguageId( aLanguageId );

		}

    // special punctuations

    const TInt KSpecialPuncPos[] = { 14, 15 };

    const TInt KSpecialChsPunc[] = { 0x300A, 0x300B };

    const TInt KSpecialChtPunc[] = { 0x300C, 0x300D };

    TBool isCht = ( ELangHongKongChinese == aLanguageId ) || 

                  ( ELangTaiwanChinese == aLanguageId );

    TInt specialPuncCount = sizeof(KSpecialPuncPos)/sizeof(TInt);

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

        {

        TInt keypos = KSpecialPuncPos[i];        

        TInt charcode = isCht ? KSpecialChtPunc[i] : KSpecialChsPunc[i];

        CVirtualKey* vk = iVirtualSctpad->KeyArray()[keypos];

        if ( vk )

            {

            TBuf<1> buf;

            buf.Append( charcode );

            vk->SetKeyData( buf );

            vk->SetKeyScancode( charcode );