/*

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

*

*/

// INCLUDE

#include <coemain.h>

#include <s32mem.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknLayoutDef.h>

#include <AknUtils.h>

#include <AknsUtils.h>

#include <akniconutils.h>

#include <AknFepGlobalEnums.h>

#include <aknfeppeninputenums.h>

#include <peninputfingerhwrarwnd.rsg>

#include <peninputlayoutmultilineicf.h>

#include <peninputdropdownlist.h>

#include <peninputrepeatbutton.h>

#include <peninputlayoutbubblectrl.h>

// USER INCLUDES

#include "peninputfingerhwrarwnd.h"

#include "peninputfingerhwrarlafmanager.h"

#include "peninputfingerhwrarevent.h"

#include "peninputfingerhwrarcontrolid.h"

#include "peninputfingerhwrarstoreconstants.h"

#include "peninputfingerhwrarmultipagevkb.h"

#include "peninputfingerhwrarlayout.h"

#include "peninputfingerhwrardatastore.h"

#include "peninputfingerhwrarsymboltable.h"

#include "peninputfingerhwrarnumsymboltable.h"

#include "peninputfingerhwrarindicator.h"

#include "peninputfingerhwrarwritingwnd.h"

const TUint32 KDefaultTextColor          = 0x000000;

const TUint   KDefaultFrameColor         = 0x000000;

const TUint32 KDefaultWriteBoxBgColor    = 0xdddddd;

const TUint32 KDefaultWriteBoxFrameColor = 0x000000;

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

// Symbian Constructor

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

//

CPeninputFingerHwrArWnd* CPeninputFingerHwrArWnd::NewL( CFepUiLayout* aFepUiLayout,

    TInt aControlId, TBool aLandscapeStyle )

    {

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

    CleanupStack::Pop( self );

    return self;

    }

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

// Symbian Constructor

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

//

CPeninputFingerHwrArWnd* CPeninputFingerHwrArWnd::NewLC( CFepUiLayout* aFepUiLayout, 

    TInt aControlId, TBool aLandscapeStyle )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aLandscapeStyle );

    return self;

    }

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

// c++ destructor

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

//

CPeninputFingerHwrArWnd::~CPeninputFingerHwrArWnd()

    {

    #ifdef RD_TACTILE_FEEDBACK

    if(UiLayout())

        {

		UiLayout()->DeRegisterFeedbackArea(reinterpret_cast<TInt>(iWritingBox),

	                                 iWritingBox->Rect());

		}

	#endif								 

    delete iLafManager;

    }

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

// Construct control from resource.

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

//

void CPeninputFingerHwrArWnd::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 ( iNumSymbolTable )

        {

        iNumSymbolTable->LoadVkbKeyImageL(R_FINGER_HWR_NUMPAD_IMAGE, keysize );

        RArray<TRect> rects;

        CleanupClosePushL( rects );

        LoadNumSymbolVirtualKeysL( R_FINGER_HWR_NUMPAD, rects );

        CleanupStack::PopAndDestroy(); //rects

        }

    if ( iSymbolTable )

        {

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

        iSymbolTable->LoadVkbKeyImageL(R_FINGER_HWR_SCTPAD_IMAGE, keysize );

        RArray<TRect> rects;

        CleanupClosePushL( rects );

        iLafManager->GetVirtualKeyRects( rects );

        if(iLafManager->IsLandscape())

            {

            LoadSymbolVirtualKeysL(R_ARABIC_FINGER_HWR_LANDSCAPE_SYMBOL_TABLE, rects);

            }

        else

            {

            LoadSymbolVirtualKeysL(R_ARABIC_FINGER_HWR_PORTRAIT_SYMBOL_TABLE, rects);

            }        

        CleanupStack::PopAndDestroy(); //rects

        }

    if (!iFirstTimeConstruct)

    	{

    	Draw();

    	}

    iFirstTimeConstruct = EFalse;  

    }

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

// Draw window.

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

//

void CPeninputFingerHwrArWnd::Draw()

    {

    if(AbleToDraw())

        {

		DrawOpaqueMaskBackground( Rect() );

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

			{

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

			}

		DrawBackground();    

		CControlGroup::Draw();

		// Update whole area

		UpdateArea( Rect(), EFalse );

		}

    }

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

// Resize.

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

//

void CPeninputFingerHwrArWnd::SizeChangedL()

    {

    iLafManager->ReadLafInfo();

    ResetLayoutL();

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

            iLafManager->CandidateUnitHeight(), 

            iLafManager->CandidateUnitWidth(), 

            iLafManager->CandidateLTPos(), 

            3/*KCandidateCountPerRow*/,

            2 );

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

    CalculateGuideLinePos();

    Draw();

}

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

// Handle window open

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

//

void CPeninputFingerHwrArWnd::HandleWindowOpenCommandL()

    {

    CalculateGuideLinePos();

    }

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

// accept editor's text alignment.

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

//

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

    {

    if ( iContextField )

        {

        iContextField->SetTextAlignmentL( aAlignment, aLangId );

        }

    }

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

// accept editor's text

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

//

void CPeninputFingerHwrArWnd::SetEditorTextL( const TFepInputContextFieldData& aData )

    {

    if ( iContextField )

        {

        iContextField->SetTextL( aData );

        }

    }

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

// accept editor's promopt txt.

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

//

void CPeninputFingerHwrArWnd::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);

        const HBufC* icfPromptText = iContextField->PromptText();

        if (!icfPromptText || icfPromptText->Compare(textBuf->Des()) != 0 )

            {

            iContextField->SetPromptTextL( textBuf->Des(), pIcfData->iCleanContent );    

            }

        CleanupStack::PopAndDestroy(textBuf);

        }

    else

        {

        iContextField->SetPromptTextL(KNullDesC, pIcfData->iCleanContent);

        }

    CleanupStack::PopAndDestroy(dataBuf);

    CleanupStack::PopAndDestroy(&readStream);      

    }

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

// Dim option button

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

//

void CPeninputFingerHwrArWnd::SetEnableSettingBtn(const TBool aEnable)

    {

    if ( aEnable )    

        {

        iOptionBtn->SetDimmed(EFalse);

        }

    else

        {

        iOptionBtn->SetDimmed(ETrue);

        iOptionBtn->SetActive(EFalse);

        }

    }

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

// accept editor's bubble text.

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

//

void CPeninputFingerHwrArWnd::SetBubbleTextL( const TDesC& aInfo )

    {

    if ( aInfo.Length() > 0 )

        {

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

        }

    else

        {

        iContextField->HideBubble();

        }    

    }

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

// get strokes from hwr writing box.

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

//

const RArray<TPoint>& CPeninputFingerHwrArWnd::StrokeList()

    {

    return iWritingBox->StrokeList();

    }

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

// set end mark of hwr

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

//

void CPeninputFingerHwrArWnd::SetStrokeEndMark( const TPoint& aEndMark )

    {

    iWritingBox->SetStrokeEndMark( aEndMark );

    }

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

// set guide line on or off.

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

//

void CPeninputFingerHwrArWnd::SetGuideLineOn(const TBool aGuideLineOn)

    {

    iGuideLineOn = aGuideLineOn;

	DrawGuideLine();

    }

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

// set pen color of hwr writing.

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

//

void CPeninputFingerHwrArWnd::SetBoxPenColor( const TInt aPenColor )

    {

    iWritingBox->SetPenColor( aPenColor );

    }

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

// set pen size of hwr writing.

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

//  

void CPeninputFingerHwrArWnd::SetBoxPenSize( const TSize aPenSize )

    {

    iWritingBox->SetPenSize( aPenSize );

    }

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

// set writing speed hwr writing.

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

//

void CPeninputFingerHwrArWnd::SetBoxWritingSpeed( TTimeIntervalMicroSeconds32& aCharDelay )

    {

    iWritingBox->SetCharacterDelay( aCharDelay );

    TInt strokeDelay = aCharDelay.Int()/5;

    TTimeIntervalMicroSeconds32 sDelay(strokeDelay);

    iWritingBox->SetStrokeDelay( sDelay);   

    }

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

// retrieve rect of hwr writingbox.

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

//

TRect CPeninputFingerHwrArWnd::WritingBoxRect()

    {

    return iWritingBox->Rect();

    }

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

// Cancel wrting

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

//

void CPeninputFingerHwrArWnd::CancelWriting()

    {

    iWritingBox->CancelCharWriting();

    }

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

// Change SCT page.

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

//

void CPeninputFingerHwrArWnd::ShowSymbolPage( TInt aPageNo, TInt aPos )

    {

    iSymbolTable->NavigatePage(aPageNo,aPos);

    }

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

// retrieve the ICF control.

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

//

CFepLayoutMultiLineIcf* CPeninputFingerHwrArWnd::Icf()

    {

    return iContextField;

    }

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

// retrieve the candicate list control.

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

//

CFepCtrlDropdownList* CPeninputFingerHwrArWnd::CandidateList()

    {

    return iCandidateList;

    }

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

// Open the candidate list

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

//	

void CPeninputFingerHwrArWnd::OpenCandidateList()

    {

    CPeninputFingerHwrArLayout* hwrLayout = NULL;

    hwrLayout = static_cast<CPeninputFingerHwrArLayout*>( UiLayout() );

    CPeninputFingerHwrArDataStore& datastore = hwrLayout->DataStore();

    const RPointerArray<HBufC>& candidates = datastore.Candidate();

    if(candidates.Count() > 0)

        {

        CFepCtrlDropdownList::TListType unexpandable = CFepCtrlDropdownList::EListExpandableMultiRowWithoutIconWithBubble;

        iCandidateList->Hide( EFalse );

        TRAP_IGNORE(iCandidateList->SetCandidatesL( candidates, unexpandable ));

        iCandidateList->SetHighlightCell( 0, datastore.Highlight() ); 		   

        iArrowLeftBtn->Hide(ETrue);

        iArrowRightBtn->Hide(ETrue);

        iSpaceBtn->Hide(ETrue);

        iEnterBtn->Hide(ETrue);

        }	

	}

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

// Close the candidate list

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

//	

void CPeninputFingerHwrArWnd::CloseCandidateList()

    {

	iCandidateList->ResetAndClear(CFepCtrlDropdownList::EListExpandableMultiRowWithoutIconWithBubble);

	// hide all the dropdown list in standby state

	iCandidateList->Hide( ETrue );

    iArrowLeftBtn->Hide(EFalse);

    iArrowRightBtn->Hide(EFalse);

    iSpaceBtn->Hide(EFalse);

    iEnterBtn->Hide(EFalse);

	}

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

// dim arrow buttons.

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

//

void CPeninputFingerHwrArWnd::DimArrowKeys( TBool aDimArrow )

   {

   iArrowLeftBtn->SetDimmed( aDimArrow );   

   iArrowRightBtn->SetDimmed( aDimArrow );