/*

* Copyright (c) 2002-2005 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:  common layout window for UI interface of VKB and HWR

*

*/

// System includes

#include <coemain.h>

#include <AknFepGlobalEnums.h>

#include <aknfeppeninputenums.h>

#include <peninputpluginutils.h>

#include <peninputcmdparam.h>            // Use global signal

#include <peninputlayoutmultilineicf.h>

#include <peninputeventbutton.h>

#include <peninputmultimodebutton.h>

#include <peninputdragbutton.h>

#include <peninputlayoutchoicelist.h>

#include <peninputlayout.h>

#include <peninputrangebar.h>

#include <bautils.h>

#include <AknIconUtils.h>

#include <AknLayoutDef.h>

#include <AknUtils.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknsUtils.h>

//#include <peninputcmdparam.h>

#include <aknFepVietnameseInputTables.h>

// User includes

#include "peninputdataconverter.h"

#include "peninputrangebarinfo.h"

#include "peninputlayoutwindowext.h"

#include "peninputclientlayoutinfo.h"

#include "peninputdataprovider.h"

#include "peninputlayoutcontext.h"

#include "peninputvkbctrlext.h"

#include "peninputnumerickeymappingmgr.h"

#include "peninputgenericvkb.hrh"

// Constants

const TInt KIntLengthForByte = 8;

const TInt KPeninputLayoutWindowUnitWidth = 12;

const TInt KInvalidIndex = -1;

//const TInt32 KInvalidResId = -1;

//const TInt KInvalidImg = -1 ;

const TUint32 KDefaultTextColor = 0x000000;

const TUint32 KDefaultShadowTextColor = 0xffffff;

//const TInt KNotSupportSkin = -1;

const TInt KIntSizeToInt16 = 2;

const TInt KMaxNumericString = 32;

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

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

// CPeninputLayoutWindowExt::CPeninputLayoutWindowExt

// (other items were commented in a header)

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

//

EXPORT_C CPeninputLayoutWindowExt::CPeninputLayoutWindowExt( 

    CFepUiLayout* aUiLayout, MPeninputLayoutContext* aLayoutContext )

    : CAknFepCtrlBaseWindowExt( aUiLayout, EPeninutWindowCtrlIdBaseWindow ), 

     iConfigInfo( NULL ), iLayoutContext( aLayoutContext ),

    iLastUsedTotalColumns( KPeninputLayoutWindowUnitWidth ),

    iFirstTimeConstruct( ETrue ),

    iSwitchFontSet(EFalse),

    iUnitSizeChange(EFalse)

    { 

    }

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

// CPeninputLayoutWindowExt::ConstructL

// (other items were commented in a header)

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

//

EXPORT_C void CPeninputLayoutWindowExt::ConstructL()

    {

    BaseConstructL();  

    if( iLayoutContext->LayoutType() == EPluginInputModeVkb ||

        iLayoutContext->LayoutType() == EPluginInputModeFSQ )

        {

        iVkbLayout = CAknFepCtrlVkbLayout::NewL(); 

        }

    else

        {

        iVkbLayout = NULL;

        }

    CCoeEnv* coeEnv = CCoeEnv::Static();

    // Set up resources

    TFileName resFileName = GetWindowResFileName();

    BaflUtils::NearestLanguageFile(coeEnv->FsSession(), resFileName );

    iWinResId = coeEnv->AddResourceFileL( resFileName );

    //TResourceReader reader;

    //coeEnv->CreateResourceReaderLC( reader, GetWindowResId() );

    SetResourceId( GetWindowResId() );

    ConstructFromResourceL();

    if (!iKeyMappingMgr)

        {

        // if key mapping mgr is not constructed in ConstructFromResourceL, need to 

        // construct it here

        TResourceReader resReader;

        CCoeEnv::Static()->CreateResourceReaderLC(resReader, GetNumKeymappingResId());

        iKeyMappingMgr = CPeninputNumericKepMappingMgr::NewL(resReader);

        CleanupStack::PopAndDestroy(1);

        }

    CreateAllControlsL();

    SetControlsFont();

    }

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

// CPeninputLayoutWindowExt::~CPeninputLayoutWindowExt

// (other items were commented in a header)

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

//

EXPORT_C CPeninputLayoutWindowExt::~CPeninputLayoutWindowExt()

    {

    delete iConfigInfo;

    delete iKeyMappingMgr;

    delete iVkbLayout;    

    // Delete resource file from CoeEnv

    CCoeEnv::Static()->DeleteResourceFile( iWinResId );

    CCoeEnv::Static()->DeleteResourceFile( iConfigResId );

    delete iToneSet;   

    }

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

// CPeninputLayoutWindowExt::SizeChanged

// (other items were commented in a header)

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

//

EXPORT_C void CPeninputLayoutWindowExt::SizeChanged( TBool /*aLandscapeStyle*/ )

    {

    iLangOrSizeChanged = ETrue;    

    ReadLafForShadow();

	ResetLastColRow();

    if ( iConfigInfo )

        {        

        ChangeClientSize();        

        }

    //ReadLafForShadow( rect );

    TInt style = EPeninputPositionChangeBrJustify;

    TBuf<KIntSizeToInt16> bufStyle;

    bufStyle = ( TUint16* )&style;

    HandleControlEvent(EPeninputLayoutEventMovePosition, NULL, bufStyle);           

    iLangOrSizeChanged = EFalse;

    }

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

// CPeninputLayoutWindowExt::ReadLafForShadow

// (other items were commented in a header).

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

//

void CPeninputLayoutWindowExt::ReadLafForShadow()

    {

    TAknWindowLineLayout shadowPane;

    TAknWindowLineLayout shadowTl;

    TAknWindowLineLayout shadowBr;

    TAknLayoutRect shadowRect;

    TAknLayoutRect shadowTlRect;

    TAknLayoutRect shadowBrRect;

    shadowPane = AknLayoutScalable_Avkon::bg_popup_fep_shadow_pane(1).LayoutLine();

    shadowRect.LayoutRect(TRect(), shadowPane);

    shadowTl = AknLayoutScalable_Avkon::bg_popup_fep_shadow_pane_g1().LayoutLine();

    shadowTlRect.LayoutRect(shadowRect.Rect(), shadowTl);

    shadowBr = AknLayoutScalable_Avkon::bg_popup_fep_shadow_pane_g8().LayoutLine();

    shadowBrRect.LayoutRect(shadowRect.Rect(), shadowBr);

    iShadowTlWidth = shadowTlRect.Rect().Size().iWidth;

    iShadowTlHeight = shadowTlRect.Rect().Size().iHeight;

    iShadowBrWidth = shadowBrRect.Rect().Size().iWidth;

    iShadowBrHeight = shadowBrRect.Rect().Size().iHeight;

    }

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

// CPeninputLayoutWindowExt::SizeChanged

// (other items were commented in a header).

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

//

EXPORT_C void CPeninputLayoutWindowExt::SizeChangedForBaseWindow( TInt /*aTotalColumns*/ )

    {

    }

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

// CPeninputLayoutWindowExt::HandleControlEvent

// (other items were commented in a header)

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

//

EXPORT_C void CPeninputLayoutWindowExt::HandleControlEvent( TInt aEventType,

    CFepUiBaseCtrl* aCtrl, const TDesC& aEventData )

    {

    // Call this function in base class

    CAknFepCtrlBaseWindowExt::HandleControlEvent( aEventType, 

        aCtrl, aEventData );

    TInt* data = ( TInt* ) aEventData.Ptr(); 

    switch ( aEventType )

        {

        case EEventButtonUp:

        	{

        	// check current range

		    TInt curRange = CPeninputDataConverter::AnyToInt

		        ( iLayoutContext->RequestData( EPeninputDataTypeCurrentRange ) );		    

        	if( aCtrl->ControlId() == EPeninutWindowCtrlIdShiftBtn)

	        	{

	        	  if ( ( curRange == ERangeEnglish )  || ( curRange == ERangeAccent ) 

        			   || ( ConfigInfo()->CaseSensitive() && ( curRange == ERangeNative ) ) )

	        	  	{

	        		CAknFepCtrlMultiModeButton* button = 

					static_cast<CAknFepCtrlMultiModeButton*>( aCtrl );

		        	TInt realCase = button->GetRealCaseByMode( button->CurrentMode() );	     	       		

					HandleMergedBtnClicked( realCase );

	        		}

		       	else

		       		{

		       		HandleShiftAndCapslockBtnClicked();

		       		TInt shiftStatus = CPeninputDataConverter::AnyToInt

				        ( iLayoutContext->RequestData( EPeninputDataTypeShiftDown ) );

				    ChangeMergedButtonStatus( shiftStatus, 0 );

		       		}				

	        	}

        	}

        	break;

        case EPeninputLayoutEventSwitchLanguage:

            {

            TRAP_IGNORE( ChangeInputLanguageL( *data ) );                

            }

            break;

        case EPeninputLayoutEventRange: 

            {

            HandleRangeEvent( *data );

            }

            break;

        case EPeninputLayoutEventRangeLoop:

            {

            HandleRangeLoopEvent( *data );

            }

            break;

        case EPeninputLayoutEventShift: 

            {

            HandleShiftAndCapslockBtnClicked();

       		TInt shiftStatus = CPeninputDataConverter::AnyToInt

		        ( iLayoutContext->RequestData( EPeninputDataTypeShiftDown ) );

		    ChangeMergedButtonStatus( shiftStatus, 0 );

            }

            break;

        case EPeninputLayoutEventCapslock:

            {

            HandleCapslockBtnClicked();

            } 

            break;

        case EPeninputLayoutEventMovePosition:

            {

            TInt style = *( ( TUint16* ) aEventData.Ptr() );

            ChangeLayoutPosition( style );

            }

            break;

        case EPeninputLayoutEventSetPermittedRange:

            {

            if ( *data & ERangeNative )

                {

                *data = *data | ERangeAccent | ERangeNativeNumber 

                    | ERangeMixedText | ERangeMixedNumber;

                }

            else if(*data & ERangeEnglish)

                {

                *data = *data | ERangeAccent;

                }

            iLayoutContext->SetData( EPeninputDataTypePermittedRange, data );

            // Set range of range bar component

            CFepUiBaseCtrl* bar = 

                Control( EPeninutWindowCtrlIdRangeBar );

            if ( bar ) 

                {

                CAknFepCtrlRangeBar* rangebar = 

                    static_cast<CAknFepCtrlRangeBar*>( bar );

                rangebar->SetPermittedRanges( *data );             

                }                     

            }

            break;  

        case EPeninputLayoutEventSetPermittedCase:

            {

            // Update data:case

            iLayoutContext->SetData( EPeninputDataTypePermittedCase, data );

            // Set range of case

            CFepUiBaseCtrl* bar = 

                Control( EPeninutWindowCtrlIdRangeBar );

            if ( bar ) 

                {

                CAknFepCtrlRangeBar* rangebar = 

                    static_cast<CAknFepCtrlRangeBar*>( bar );

                rangebar->SetPermittedCase( ERangeEnglish, ECaseUpper, 

                    ( *data & ECaseUpper) != 0 );

                rangebar->SetPermittedCase( ERangeEnglish, ECaseLower, 

                    ( *data & ECaseLower) != 0 );

                rangebar->SetPermittedCase( ERangeEnglish, ECaseText, 

                    ( *data & ECaseText) != 0 );

                }

            }

            break;

        case EPeninputLayoutEventSetCase:

            {

            DoCaseChange( *data );

            }

            break;

        case EEventSizeChanged:

            {

            //if icf editor size changed, we need to inform owner

            if(aCtrl->ControlId() == EPeninutWindowCtrlIdInputContextField ||  

               aCtrl->ControlId() == EPeninputWindowCtrlIdMultiLineICF)

                {

                iLayoutContext->Sendkey( ESignalLayoutICFLengthChanged, KNullDesC );

                }

            }

            break;

        default:

            break;

        }   

    }

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

// CPeninputLayoutWindowExt::SetEditorTextL

// (other items were commented in a header)

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

//

EXPORT_C void CPeninputLayoutWindowExt::SetEditorTextL( 

    const TFepInputContextFieldData& aData )

    {

    if (Control(EPeninutWindowCtrlIdInputContextField))

        {

        static_cast<CFepInputContextField*>( Control(EPeninutWindowCtrlIdInputContextField))->SetTextL( aData );

        return;

        }

    if (Control(EPeninputWindowCtrlIdMultiLineICF))

        {

        CFepLayoutMultiLineIcf* multiIcf = 

            static_cast<CFepLayoutMultiLineIcf*>( Control(EPeninputWindowCtrlIdMultiLineICF));

        multiIcf->SetTextL( aData );

        if ( iLayoutContext->LayoutType() == EPluginInputModeVkb || 

             iLayoutContext->LayoutType() == EPluginInputModeFSQ )

            {

            TInt lang = CPeninputDataConverter::AnyToInt

                    ( iLayoutContext->RequestData( EPeninputDataTypeInputLanguage ) );

            TInt curRange = CPeninputDataConverter::AnyToInt

        		    ( iLayoutContext->RequestData( EPeninputDataTypeCurrentRange ) );

            if ( lang == ELangVietnamese && curRange == ERangeEnglish )  

                {

                TBuf<1> preData;

                multiIcf->ExtractText( preData, aData.iCurSel.LowerPos()-1, 1 );

                iVowelChar = EFalse;

                if ( KNullDesC() != preData )

                    {

                    for (TUint i = 0; i < sizeof(VietVowelList) / sizeof(TText); ++i)

                        {

                        TBuf<1> buf;

                        buf.Append( VietVowelList[i] );

                        if (preData == buf)

                            {

                            iVowelChar = ETrue;

                            break;

                            }

                        }

                    }

                CPeninputVkbCtrlExt* vkbCtrl = static_cast<CPeninputVkbCtrlExt*>

                    ( Control( EPeninutWindowCtrlIdVkbCtrl ) );

                vkbCtrl->DimKeySet( iToneSet, !iVowelChar );

                }

            }

        }

    }  

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

// CPeninputLayoutWindowExt::SetEditorTextL

// (other items were commented in a header)

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

//

EXPORT_C void CPeninputLayoutWindowExt::SetTextIsSecret( TBool aData )

    {

    if ( Control(EPeninutWindowCtrlIdInputContextField))

        {

        static_cast<CFepInputContextField*>

        (Control(EPeninutWindowCtrlIdInputContextField))->SetTextIsSecret( aData );

        }

    else if (Control(EPeninputWindowCtrlIdMultiLineICF))

        {

        static_cast<CFepLayoutMultiLineIcf*>

        (Control(EPeninputWindowCtrlIdMultiLineICF))->SetTextIsSecret( aData );

        }

    }  

void CPeninputLayoutWindowExt::SetNumberGrouping( TBool aData )

    {

    if (Control(EPeninputWindowCtrlIdMultiLineICF))

        {

        static_cast<CFepLayoutMultiLineIcf*>

        (Control(EPeninputWindowCtrlIdMultiLineICF))->SetNumberGrouping( aData );

        }

    }

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

// CPeninputLayoutWindowExt::DoClose

// (other items were commented in a header)

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

//

EXPORT_C TBool CPeninputLayoutWindowExt::DoClose()

    {

    // Send EVkbEventWindowClose to layout

    this->ReportEvent( EPeninputLayoutEventClose, KNullDesC );

    // Return true which will permit the window close

    return EFalse;

    }

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

// Get layout config method. It does a lasy initialization for a instance of

// CPeninputLayoutWindowExt::ConfigInfo

// (other items were commented in a header)

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

//

EXPORT_C CPeninputLayoutConfig* CPeninputLayoutWindowExt::ConfigInfo() const

    {

    return iConfigInfo;

    }

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

// CPeninputLayoutWindowExt::CheckResourceExist

// (other items were commented in a header)

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

//

TBool CPeninputLayoutWindowExt::CheckResourceExist( const TDesC& aFileName )

    {

    RFile file;

    if ( !aFileName.Length() )

        {

        return EFalse;

        }

    TInt rs = file.Open( CCoeEnv::Static()->FsSession(), aFileName, EFileRead );

    if ( rs == KErrNotFound )

        {

        return EFalse;  

        }

    else

        {

        file.Close();

        return ETrue;

        }

    }

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

// CPeninputLayoutWindowExt::CancelDeadKey

// (other items were commented in a header)

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

//

void CPeninputLayoutWindowExt::CancelDeadKey()

	{

    // Get the dead key status

	TInt latchedFlag = CPeninputDataConverter::AnyToInt(

		iLayoutContext->RequestData( EAkninputDataTypeLatchedSet ));

	// If the DeadKey is latched, cancel it

	if ( latchedFlag )

		{

		RPointerArray<CPeninputVkbLayoutInfo> vkbListInfo;

		RPointerArray<CPeninputVkbKeyInfo> keyInfoList;

		// Get the vkb layout list supportted by current writing language

		vkbListInfo = iVkbLayout->VkbLayoutInfoList();

		TInt vkbListNum = vkbListInfo.Count();

		CVirtualKey* pKey;

		TBool deadKeyChange = EFalse;

		// Find the latched DeadKey in all kinds of vkb layout 

		// which supportted by current writing language

		for ( TInt i = 0; i < vkbListNum && !deadKeyChange ; i++ )

			{

			// Get the key info list in one vkb layout

			keyInfoList = vkbListInfo[i]->KeyInfoList();

			TInt keyListNum = keyInfoList.Count();

			for ( TInt j = 0; j < keyListNum && !deadKeyChange ; j++ )

				{

				pKey = keyInfoList[j]->Key();

				// If the Dead key is latched

				if ( pKey->Latched())

					{