1 /*

     2 * Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0""

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  common layout window for UI interface of VKB and HWR

    15 *

    16 */

    17 

    18 

    19 // System includes

    20 #include <coemain.h>

    21 

    22 #include <AknFepGlobalEnums.h>

    23 #include <aknfeppeninputenums.h>

    24 #include <peninputpluginutils.h>

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

    26 #include <peninputinputcontextfield.h>

    27 #include <peninputeventbutton.h>

    28 #include <peninputmultimodebutton.h>

    29 #include <peninputdragbutton.h>

    30 #include <peninputlayoutchoicelist.h>

    31 #include <peninputlayout.h>

    32 #include <peninputrangebar.h>

    33 #include <bautils.h>

    34 #include <AknIconUtils.h>

    35 #include <AknLayoutDef.h>

    36 #include <AknUtils.h>

    37 #include <aknlayoutscalable_avkon.cdl.h>

    38 #include <AknsUtils.h>

    39 #include <peninputlayoutmultilineicf.h>

    40 #include <peninputrepeatbutton.h>

    41 

    42 // User includes

    43 #include "peninputdataconverter.h"

    44 #include "peninputrangebarinfo.h"

    45 #include "peninputlayoutwindow.h"

    46 #include "peninputclientlayoutinfo.h"

    47 #include "peninputdataprovider.h"

    48 #include "peninputlayoutcontext.h"

    49 #include "peninputvkbctrlext.h"

    50 #include "peninputnumerickeymappingmgr.h"

    51 

    52 // Constants

    53 const TInt KIntLengthForByte = 8;

    54 const TInt KPeninputLayoutWindowRegionCount = 8;

    55 const TInt KPeninputLayoutWindowUnitWidth = 12;

    56 const TInt KInvalidIndex = -1;

    57 

    58 const TInt32 KInvalidResId = -1;

    59 const TInt KInvalidImg = -1 ;

    60 const TUint32 KDefaultTextColor = 0x000000;

    61 const TUint32 KDefaultShadowTextColor = 0xffffff;

    62 const TInt KNotSupportSkin = -1;

    63 

    64 const TInt KIntSizeToInt16 = 2;

    65 

    66 

    67 

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

    69 

    70 // ------------------------------------------------------------------------

    71 // CPeninputLayoutWindow::CPeninputLayoutWindow

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

    73 // ------------------------------------------------------------------------

    74 //

    75 EXPORT_C CPeninputLayoutWindow::CPeninputLayoutWindow( 

    76     CFepUiLayout* aUiLayout, MPeninputLayoutContext* aLayoutContext )

    77     : CAknFepCtrlBaseWindow( aUiLayout, EPeninutWindowCtrlIdBaseWindow ), 

    78      iConfigInfo( NULL ), iLayoutContext( aLayoutContext ),

    79     iLastUsedTotalColumns( KPeninputLayoutWindowUnitWidth ),

    80     iFirstTimeConstruct( ETrue ),

    81     iSwitchFontSet(EFalse),

    82     iUnitSizeChange(EFalse)

    83     { 

    84     }

    85 

    86 // ---------------------------------------------------------------------------

    87 // CPeninputLayoutWindow::ConstructL

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

    89 // ---------------------------------------------------------------------------

    90 //

    91 EXPORT_C void CPeninputLayoutWindow::ConstructL()

    92     {

    93     BaseConstructL();  

    94 

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

    96         {

    97         iVkbLayout = CAknFepCtrlVkbLayout::NewL(); 

    98         }

    99     else

   100         {

   101         iVkbLayout = NULL;

   102         }

   103         

   104     CCoeEnv* coeEnv = CCoeEnv::Static();

   105     	

   106     // Set up resources

   107     TFileName resFileName = GetWindowResFileName();

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

   109     iWinResId = coeEnv->AddResourceFileL( resFileName );

   110         

   111     TResourceReader reader;

   112     

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

   114     SetResourceId( GetWindowResId() );

   115     ConstructFromResourceL();

   116     // Pop and destroy reader

   117     CleanupStack::PopAndDestroy( 1 );

   118     MoveButton()->AddEventObserver( UiLayout() );

   119     iCtrlPool = CPeninputCtrlPool::NewL();

   120     

   121     CreateAllControlsL();

   122     SetControlsFont();

   123     }

   124 

   125 // ---------------------------------------------------------------------------

   126 // CPeninputLayoutWindow::~CPeninputLayoutWindow

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

   128 // ---------------------------------------------------------------------------

   129 //

   130 EXPORT_C CPeninputLayoutWindow::~CPeninputLayoutWindow()

   131     {

   132     delete iCtrlPool;

   133     delete iConfigInfo;

   134     delete iKeyMappingMgr;

   135     delete iVkbLayout;    

   136     // Delete resource file from CoeEnv

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

   138     

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

   140         

   141     }

   142     

   143 // ---------------------------------------------------------------------------

   144 // CPeninputLayoutWindow::ConstructFromResourceL

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

   146 // ---------------------------------------------------------------------------

   147 //

   148 EXPORT_C void CPeninputLayoutWindow::ConstructFromResourceL( 

   149     TResourceReader& aResReader )

   150     {

   151     TInt supportskin = aResReader.ReadInt16();

   152 

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

   154         {

   155     	UiLayout()->AddControlL(this);

   156         }

   157     

   158     const TInt32 moveBtnResId = aResReader.ReadInt32();

   159     const TInt32 closeBtnResId = aResReader.ReadInt32();

   160     const TInt32 icfResId = aResReader.ReadInt32();

   161     const TInt32 optionBtnResId = aResReader.ReadInt32();

   162     const TInt32 keymappingResId = aResReader.ReadInt32();

   163     const TInt32 shadowResId = aResReader.ReadInt32();

   164     const TInt32 arrowLeftResId = aResReader.ReadInt32();

   165     const TInt32 arrowRightResId = aResReader.ReadInt32();

   166     const TInt32 bgImageResId = aResReader.ReadInt32();

   167         

   168     TResourceReader resReader;

   169     

   170     TBool multiLine = EFalse;

   171     

   172     if (iFirstTimeConstruct)

   173         {       

   174         // Read bitmaps of close and move button   

   175         CCoeEnv::Static()->CreateResourceReaderLC( resReader, moveBtnResId );

   176         MoveButton()->SetResourceId( moveBtnResId );

   177         MoveButton()->ConstructFromResourceL();

   178         CleanupStack::PopAndDestroy( 1 );

   179         

   180         CCoeEnv::Static()->CreateResourceReaderLC( resReader, closeBtnResId );

   181         CloseButton()->SetResourceId( closeBtnResId );

   182         CloseButton()->ConstructFromResourceL();

   183         CleanupStack::PopAndDestroy( 1 );

   184 

   185         // Read information of key mapping 

   186         CCoeEnv::Static()->CreateResourceReaderLC( resReader, keymappingResId );

   187         iKeyMappingMgr = CPeninputNumericKepMappingMgr::NewL( resReader );

   188         CleanupStack::PopAndDestroy( 1 );          

   189             

   190         

   191         multiLine = IsMultiLineIcf();

   192         

   193         // Add input context field into the headpane

   194         if (multiLine)

   195         	{

   196         	AddMultiContextFieldL();	

   197         	}

   198         else

   199         	{

   200         	AddContextFieldL();	

   201         	}

   202         

   203         

   204         // Add touch input button into the headpane

   205         AddTouchInputButtonL( optionBtnResId ); 

   206         }

   207     else

   208     	{

   209     	multiLine = IsMultiLineIcf();

   210     	CControlGroup::ConstructFromResourceL();

   211     	}    

   212     

   213     // Read information of shadow 

   214     CCoeEnv::Static()->CreateResourceReaderLC( resReader, shadowResId );

   215     ReadShadowInfoL( resReader ); 

   216     CleanupStack::PopAndDestroy( 1 ); 

   217      

   218     if (!multiLine)

   219     	{    

   220 	    //Read resource of icf

   221 	    CCoeEnv::Static()->CreateResourceReaderLC( resReader, icfResId );  

   222     	ReadIcfInfo( resReader );     	

   223 	    CleanupStack::PopAndDestroy( 1 );

   224     	}

   225     else

   226     	{

   227     	ReadMultiLineIcfInforL(icfResId);	

   228     	}    

   229 	

   230 	// Read background image resource

   231 	ReadBackgroundInfoL( bgImageResId );	    	

   232     iFirstTimeConstruct = EFalse;       

   233     }

   234 

   235 // -----------------------------------------------------------------------------

   236 // CPeninputLayoutWindow::ConstructFromResourceL

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

   238 // -----------------------------------------------------------------------------

   239 //

   240 EXPORT_C void CPeninputLayoutWindow::ConstructFromResourceL()

   241     {    

   242     if (iResourceId == KInvalidResId)

   243     	{

   244         User::Leave(KErrArgument);

   245     	}

   246 

   247     TResourceReader reader;

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

   249 

   250     TInt supportskin = reader.ReadInt16();

   251     

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

   253         {

   254     	UiLayout()->AddControlL(this);

   255         }

   256 

   257     const TInt32 moveBtnResId = reader.ReadInt32();

   258     const TInt32 closeBtnResId = reader.ReadInt32();

   259     const TInt32 icfResId = reader.ReadInt32();

   260     const TInt32 optionBtnResId = reader.ReadInt32();

   261     const TInt32 keymappingResId = reader.ReadInt32();

   262     const TInt32 shadowResId = reader.ReadInt32();

   263     const TInt32 arrowLeftResId = reader.ReadInt32();

   264     const TInt32 arrowRightResId = reader.ReadInt32();

   265     const TInt32 bgImageResId = reader.ReadInt32();

   266     

   267     

   268     TResourceReader resReader;

   269     TBool multiLine = EFalse;

   270         

   271     if (iFirstTimeConstruct)

   272         {       

   273         // Read bitmaps of close and move button   

   274         CCoeEnv::Static()->CreateResourceReaderLC( resReader, moveBtnResId );

   275         MoveButton()->SetResourceId( moveBtnResId );

   276         MoveButton()->ConstructFromResourceL();

   277         CleanupStack::PopAndDestroy( 1 );

   278         

   279         CCoeEnv::Static()->CreateResourceReaderLC( resReader, closeBtnResId );

   280         CloseButton()->SetResourceId( closeBtnResId );

   281         CloseButton()->ConstructFromResourceL();

   282         CleanupStack::PopAndDestroy( 1 );

   283 

   284         // Read information of key mapping 

   285         CCoeEnv::Static()->CreateResourceReaderLC( resReader, keymappingResId );

   286         iKeyMappingMgr = CPeninputNumericKepMappingMgr::NewL( resReader );

   287         CleanupStack::PopAndDestroy( 1 );          

   288             

   289         multiLine = IsMultiLineIcf();

   290         

   291         // Add input context field into the headpane

   292         if (multiLine)

   293         	{

   294         	AddMultiContextFieldL();	

   295         	}

   296         else

   297         	{

   298         	AddContextFieldL();	

   299         	}

   300         

   301         // Add touch input button into the headpane

   302         AddTouchInputButtonL( optionBtnResId ); 

   303         }

   304     else

   305     	{

   306     	multiLine = IsMultiLineIcf();

   307     	CControlGroup::ConstructFromResourceL();

   308     	}    

   309     

   310     // Read information of shadow 

   311     CCoeEnv::Static()->CreateResourceReaderLC( resReader, shadowResId );

   312     ReadShadowInfoL( resReader ); 

   313     CleanupStack::PopAndDestroy( 1 );  

   314     

   315     if (!multiLine)

   316     	{    

   317 	    //Read resource of icf

   318 	    CCoeEnv::Static()->CreateResourceReaderLC( resReader, icfResId );  

   319     	ReadIcfInfo( resReader );     	

   320 	    CleanupStack::PopAndDestroy( 1 );

   321     	}

   322     else

   323     	{

   324     	ReadMultiLineIcfInforL(icfResId);	

   325     	}  

   326     

   327     CleanupStack::PopAndDestroy(); // reader

   328 

   329 	// Read background image resource

   330 	ReadBackgroundInfoL( bgImageResId );

   331 	

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

   333         {

   334         iVkbLayout->ConstructFromResourceL();

   335         }

   336         

   337     iFirstTimeConstruct = EFalse;   	        

   338     }

   339 

   340 // ---------------------------------------------------------------------------

   341 // CPeninputLayoutWindow::SizeChanged

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

   343 // ---------------------------------------------------------------------------

   344 //

   345 EXPORT_C void CPeninputLayoutWindow::SizeChanged( TBool /*aLandscapeStyle*/ )

   346     {

   347     iLangOrSizeChanged = ETrue;    

   348     ChangeUnitSize();

   349     

   350     ReadLafForShadow();

   351     

   352     if ( iConfigInfo )

   353         {

   354         ChangeClientSize();        

   355         // Change the size of base window

   356         SizeChangedForBaseWindow( iLastUsedTotalColumns );

   357         

   358         }

   359     

   360     TInt style = EPeninputPositionChangeBrJustify;

   361     TBuf<KIntSizeToInt16> bufStyle;

   362     bufStyle = ( TUint16* )&style;

   363     HandleControlEvent(EPeninputLayoutEventMovePosition, NULL, bufStyle);           

   364         

   365     iLangOrSizeChanged = EFalse;

   366     }

   367 

   368 // ---------------------------------------------------------------------------

   369 // CPeninputLayoutWindow::ReadLafForShadow

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

   371 // ---------------------------------------------------------------------------

   372 //

   373 void CPeninputLayoutWindow::ReadLafForShadow()

   374     {

   375     if(!CPeninputDataConverter::AnyToInt

   376         (iLayoutContext->RequestData(EAkninputDataTypeSizeChanging)))

   377         {

   378         return;

   379         }

   380     

   381     TRect anyRect;

   382     

   383     TAknWindowLineLayout shadowPane;

   384     TAknWindowLineLayout shadowTl;

   385     TAknWindowLineLayout shadowBr;

   386     TAknLayoutRect shadowRect;

   387     TAknLayoutRect shadowTlRect;

   388     TAknLayoutRect shadowBrRect;

   389 

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

   391     shadowRect.LayoutRect(anyRect, shadowPane);

   392 

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

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

   395 

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

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

   398     

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

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

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

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

   403     

   404     //TRect newWinRect = Rect();

   405     //newWinRect.iTl = ShadowRect().iTl + TPoint(iShadowTlWidth, iShadowTlHeight);

   406     //SetRect( newWinRect );

   407     }

   408     

   409 // ---------------------------------------------------------------------------

   410 // CPeninputLayoutWindow::SizeChanged

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

   412 // ---------------------------------------------------------------------------

   413 //

   414 void CPeninputLayoutWindow::SizeChangedForBaseWindow( TInt aTotalColumns )

   415     {

   416     //only responsible for controls that layout window managed

   417     //if ( ( aTotalColumns != iLastUsedTotalColumns ) || iLangOrSizeChanged  )

   418         {

   419         TRect wndRect = Rect();

   420         TRect rtTitleBar = TitleBar()->Rect();

   421                

   422         TInt UnitWidth = *( static_cast<TInt*>( iLayoutContext->RequestData

   423             ( EPeninputDataTypeUnitWidth ) ) );

   424             

   425         TInt UnitHeight = *( static_cast<TInt*>( iLayoutContext->RequestData

   426             ( EPeninputDataTypeUnitHeight ) ) );

   427             

   428         TInt moveBtnColumns = 1;

   429         TInt closeBtnColumns = 1;

   430         TInt optionBtnColumns = 1;

   431         TInt headerPaneColumns;

   432         TInt icfColumns;

   433         

   434         //Call SetRect function of dragbutton

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

   436             {

   437             moveBtnColumns = 2;

   438             closeBtnColumns = 2;

   439             }

   440         

   441         TRect rectClose ( rtTitleBar.iTl,  TSize( closeBtnColumns * UnitWidth, UnitHeight ) );

   442 		TRect innerRect;

   443 		AknPenImageUtils::CalculateGraphicRect( rectClose, innerRect );        

   444         CloseButton()->SizeChanged( rectClose, innerRect, ETrue );

   445 

   446         //Call SetRect function of Head pane

   447         headerPaneColumns = aTotalColumns - moveBtnColumns - closeBtnColumns;

   448         TRect rectHeader ( TPoint(rectClose.iBr.iX, rectClose.iTl.iY ), 

   449                            TSize( headerPaneColumns * UnitWidth, UnitHeight ) );

   450         HeaderPane()->SetRect( rectHeader );

   451 

   452         //Call SetRect function of input context field

   453         icfColumns = headerPaneColumns - optionBtnColumns;

   454         TRect rectIcf( rectHeader.iTl, 

   455                        TSize( icfColumns * UnitWidth, UnitHeight ) );

   456         if(ConfigInfo()->Language() == ELangArabic)        

   457             {

   458             rectIcf.iTl.iX = rectIcf.iTl.iX + UnitWidth;

   459             }        

   460         if(IsMultiLineIcf())

   461         	{

   462         	iMultiLineIcf->SetRect( rectIcf );	

   463         	}

   464         else

   465         	{

   466         	iInputContextField->SetRect( rectIcf );	

   467         	}

   468         if(ConfigInfo()->Language() == ELangArabic) 

   469             {

   470             TRect rectBackspace(rectHeader.iTl, TSize(UnitWidth, UnitHeight));

   471             AknPenImageUtils::CalculateGraphicRect( rectBackspace, innerRect );

   472             iBackspaceButton->SizeChanged(rectBackspace, innerRect, ETrue);

   473             }

   474         //set the rect of option button

   475         TRect rectOption ( TPoint( rectIcf.iBr.iX, rectIcf.iTl.iY ),

   476                            TSize( optionBtnColumns * UnitWidth, UnitHeight ) );

   477         AknPenImageUtils::CalculateGraphicRect( rectOption, innerRect ); 

   478         iTouchInputOptionButton->SizeChanged( rectOption, innerRect, ETrue );

   479 

   480         //Call SetRect function of close button

   481         TRect rectMove ( TPoint( rectHeader.iBr.iX, rectHeader.iTl.iY),

   482                          TSize( closeBtnColumns * UnitWidth, UnitHeight ) );

   483         AknPenImageUtils::CalculateGraphicRect( rectMove, innerRect ); 

   484         MoveButton()->SizeChanged( rectMove, innerRect, ETrue );

   485 

   486         SetControlsFont();            

   487         iLastUsedTotalColumns = aTotalColumns;                           

   488         }

   489     }

   490 // ---------------------------------------------------------------------------

   491 // CPeninputLayoutWindow::HandleControlEvent

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

   493 // ---------------------------------------------------------------------------

   494 //

   495 EXPORT_C void CPeninputLayoutWindow::HandleControlEvent( TInt aEventType,

   496     CFepUiBaseCtrl* aCtrl, const TDesC& aEventData )

   497     {

   498     // Call this function in base class

   499     CAknFepCtrlBaseWindow::HandleControlEvent( aEventType, 

   500         aCtrl, aEventData );

   501     

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

   503     

   504     switch ( aEventType )

   505         {

   506         case EPeninputLayoutEventSwitchLanguage:

   507             {

   508             TRAP_IGNORE( ChangeInputLanguageL( *data ) );                

   509             }

   510             break;

   511         case EPeninputLayoutEventRange: 

   512             {

   513             HandleRangeEvent( *data );

   514             }

   515             break;

   516         case EPeninputLayoutEventRangeLoop:

   517             {

   518             HandleRangeLoopEvent( *data );

   519             }

   520             break;

   521         case EPeninputLayoutEventShift: 

   522             {

   523             HandleShiftBtnClicked();

   524             }

   525             break;

   526         case EPeninputLayoutEventCapslock:

   527             {

   528             HandleCapslockBtnClicked();

   529             } 

   530             break;

   531         case EPeninputLayoutEventMovePosition:

   532             {

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

   534             ChangeLayoutPosition( style );

   535             }

   536             break;

   537         case EPeninputLayoutEventSetPermittedRange:

   538             {

   539             if ( *data & ERangeNative )

   540                 {

   541                 *data = *data | ERangeAccent | ERangeNativeNumber 

   542                     | ERangeMixedText | ERangeMixedNumber;

   543                 }

   544             else if(*data & ERangeEnglish)

   545                 {

   546                 *data = *data | ERangeAccent;

   547                 }

   548             /*    

   549             if ( *data & ERangeNative )

   550                 {

   551                 *data = *data | ERangeNativeNumber 

   552                     | ERangeMixedText | ERangeMixedNumber;

   553                 }

   554             */    

   555             // Update data:range

   556             iLayoutContext->SetData( EPeninputDataTypePermittedRange, data );

   557             

   558             // Set range of range bar component

   559             CFepUiBaseCtrl* bar = 

   560                 iCtrlPool->Control( EPeninutWindowCtrlIdRangeBar );

   561             if ( bar ) 

   562                 {

   563                 CAknFepCtrlRangeBar* rangebar = 

   564                     static_cast<CAknFepCtrlRangeBar*>( bar );

   565                 rangebar->SetPermittedRanges( *data );             

   566                 }                     

   567             }

   568             break;  

   569         case EPeninputLayoutEventSetPermittedCase:

   570             {

   571             // Update data:case

   572             iLayoutContext->SetData( EPeninputDataTypePermittedCase, data );

   573             

   574             // Set range of case

   575             CFepUiBaseCtrl* bar = 

   576                 iCtrlPool->Control( EPeninutWindowCtrlIdRangeBar );

   577             if ( bar ) 

   578                 {

   579                 CAknFepCtrlRangeBar* rangebar = 

   580                     static_cast<CAknFepCtrlRangeBar*>( bar );

   581             

   582                 rangebar->SetPermittedCase( ERangeEnglish, ECaseUpper, 

   583                     ( *data & ECaseUpper) != 0 );

   584                 rangebar->SetPermittedCase( ERangeEnglish, ECaseLower, 

   585                     ( *data & ECaseLower) != 0 );

   586                 rangebar->SetPermittedCase( ERangeEnglish, ECaseText, 

   587                     ( *data & ECaseText) != 0 );

   588                 }

   589             }

   590             break;

   591         case EPeninputLayoutEventSetCase:

   592             {

   593             DoCaseChange( *data );

   594             }

   595             break;

   596         case EEventSizeChanged:

   597             {

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

   599             if(aCtrl == iInputContextField ||

   600                aCtrl == iMultiLineIcf )

   601                 {

   602                 iLayoutContext->Sendkey( ESignalLayoutICFLengthChanged, KNullDesC );

   603                 }

   604             }

   605             break;

   606         default:

   607             break;

   608         }   

   609     }

   610 

   611 // ---------------------------------------------------------------------------

   612 // CPeninputLayoutWindow::SetEditorTextL

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

   614 // ---------------------------------------------------------------------------

   615 //

   616 EXPORT_C void CPeninputLayoutWindow::SetEditorTextL( 

   617     const TFepInputContextFieldData& aData )

   618     {

   619     if(IsMultiLineIcf())

   620     	{

   621     	if (iMultiLineIcf)

   622     		{

   623     	    iMultiLineIcf->SetTextL( aData );			

   624     		}

   625     	}

   626     else

   627     	{

   628     	if (iInputContextField)

   629     		{

   630     		iInputContextField->SetTextL( aData );

   631     		}

   632     		

   633     	}     

   634     }  

   635 

   636 // ---------------------------------------------------------------------------

   637 // CPeninputLayoutWindow::SetEditorTextL

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

   639 // ---------------------------------------------------------------------------

   640 //

   641 EXPORT_C void CPeninputLayoutWindow::SetTextIsSecret( TBool aData )

   642     {

   643     if(IsMultiLineIcf())

   644     	{

   645     	if (iMultiLineIcf)

   646     		{

   647     	    iMultiLineIcf->SetTextIsSecret( aData );			

   648     		}

   649     	}

   650     else

   651     	{

   652     	if (iInputContextField)

   653     		{

   654     		iInputContextField->SetTextIsSecret( aData );

   655     		}

   656     	}    

   657     }  

   658     

   659 void CPeninputLayoutWindow::SetNumberGrouping( TBool aData )

   660     {

   661     if(IsMultiLineIcf())

   662     	{

   663     	if (iMultiLineIcf)

   664     		{

   665     	    iMultiLineIcf->SetNumberGrouping( aData );			

   666     		}

   667     	}   

   668     } 

   669     

   670 

   671 // ---------------------------------------------------------------------------

   672 // CPeninputLayoutWindow::DoClose

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

   674 // ---------------------------------------------------------------------------

   675 //

   676 EXPORT_C TBool CPeninputLayoutWindow::DoClose()

   677     {

   678     // Send EVkbEventWindowClose to layout

   679     this->ReportEvent( EPeninputLayoutEventClose, KNullDesC );

   680     

   681     // Return true which will permit the window close

   682     return EFalse;

   683     }

   684 

   685 // ---------------------------------------------------------------------------

   686 // CPeninputLayoutWindow::AddContextFieldL

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

   688 // ---------------------------------------------------------------------------

   689 //

   690 void CPeninputLayoutWindow::AddContextFieldL()

   691     {       

   692     // Get reference CControlGroup of headerPane

   693     CControlGroup* headerPane = HeaderPane();

   694     

   695     User::LeaveIfNull( headerPane );

   696 

   697     // Input context field

   698     iInputContextField = CFepInputContextField::NewL( TRect(), 

   699         UiLayout(), EPeninutWindowCtrlIdInputContextField );    

   700         

   701     // Transfer to headerPane

   702     headerPane->AddControlL( iInputContextField );

   703     iInputContextField->SetFocus(ETrue);

   704     

   705     // Add layout as event observer

   706     iInputContextField->AddEventObserver( UiLayout() );

   707     }

   708     

   709 // ---------------------------------------------------------------------------

   710 // CPeninputLayoutWindow::AddTouchInputButtonL

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

   712 // ---------------------------------------------------------------------------

   713 //

   714 void CPeninputLayoutWindow::AddTouchInputButtonL( TInt aResID )

   715     {

   716     // Get reference CControlGroup of headerPane

   717     CControlGroup* headerPane = HeaderPane();

   718     

   719     User::LeaveIfNull( headerPane );

   720         

   721     // Create Touch Input Option

   722     iTouchInputOptionButton = CAknFepCtrlEventButton::NewL( UiLayout(),

   723         EPeninutWindowCtrlIdOptionBtn, EPeninputLayoutEventOption, 0,

   724         									  KAknsIIDQsnFrFunctionButtonNormal,

   725         									  KAknsIIDQsnFrFunctionButtonPressed,

   726         									  KAknsIIDQsnFrFunctionButtonInactive );

   727         

   728     // Read resource

   729     TResourceReader reader;

   730     

   731     CCoeEnv::Static()->CreateResourceReaderLC( reader, aResID );    

   732     iTouchInputOptionButton->SetResourceId( aResID );    

   733     iTouchInputOptionButton->ConstructFromResourceL();  

   734     // Pop and destroy reader

   735     CleanupStack::PopAndDestroy( 1 );

   736     

   737     // Add into the group                                                   

   738     headerPane->AddControlL( iTouchInputOptionButton );

   739     iTouchInputOptionButton->AddEventObserver( UiLayout() );

   740     }

   741 

   742 // ---------------------------------------------------------------------------

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

   744 // CPeninputLayoutWindow::ConfigInfo

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

   746 // ---------------------------------------------------------------------------

   747 //

   748 EXPORT_C CPeninputLayoutConfig* CPeninputLayoutWindow::ConfigInfo() const

   749     {

   750     return iConfigInfo;

   751     }

   752 

   753 // ---------------------------------------------------------------------------

   754 // CPeninputLayoutWindow::CheckResourceExist

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

   756 // ---------------------------------------------------------------------------

   757 //

   758 TBool CPeninputLayoutWindow::CheckResourceExist( const TDesC& aFileName )

   759     {

   760     RFile file;

   761     

   762     if ( !aFileName.Length() )

   763         {

   764         return EFalse;

   765         }

   766         

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

   768     

   769     if ( rs == KErrNotFound )

   770         {

   771         return EFalse;  

   772         }

   773     else

   774         {

   775         file.Close();

   776         

   777         return ETrue;

   778         }

   779     }

   780   

   781 // ---------------------------------------------------------------------------

   782 // CPeninputLayoutWindow::ChangeInputLanguageL

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

   784 // ---------------------------------------------------------------------------

   785 //

   786 EXPORT_C void CPeninputLayoutWindow::ChangeInputLanguageL( TInt aLangID )

   787     {

   788     // Determine whether a new language id is same as existing one, 

   789     if ( ConfigInfo() )

   790         {

   791         // If language not changed, exit this function

   792         if ( ConfigInfo()->Language() == aLangID )

   793             {

   794             return;

   795             }

   796         }

   797 

   798     // First check file exist or not

   799     TBool found = CheckResourceExist( GetWindowConfigResFileName( aLangID ) );

   800     if ( !found )

   801         {

   802         aLangID = ELangEnglish;        

   803         found = CheckResourceExist( GetWindowConfigResFileName( aLangID ) );

   804         }

   805         

   806     if ( found ) 

   807         {

   808         // Store language

   809         iLayoutContext->SetData( EPeninputDataTypeInputLanguage, &aLangID );

   810    

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

   812             {       

   813             CFepUiBaseCtrl* ctrl = 

   814                 iCtrlPool->Control( EPeninutWindowCtrlIdVkbCtrl );

   815             if ( ctrl )

   816                 {

   817                 ( static_cast<CPeninputVkbCtrlExt*>( ctrl ) )->Reset();

   818                 }

   819             } 

   820 

   821          ( const_cast<RPointerArray<CFepUiBaseCtrl>&>

   822              ( ClientPane()->ControlList() ) ).Reset();

   823 

   824         // Re-construct config info 

   825         if ( iConfigInfo )

   826             {

   827             delete iConfigInfo;

   828             iConfigInfo = NULL;

   829             }

   830             

   831         if (iConfigResId)

   832             {

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

   834             }

   835             

   836         // construct resource utils

   837         

   838         CCoeEnv* coeEnv = CCoeEnv::Static();

   839         

   840         // Set up resources

   841         TFileName resFileName = GetWindowConfigResFileName( aLangID );

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

   843         iConfigResId = coeEnv->AddResourceFileL( resFileName );

   844         

   845         TResourceReader reader;

   846 

   847         coeEnv->CreateResourceReaderLC( reader, GetWindowConfigResId() );  

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

   849             {

   850             iVkbLayout->Reset(); 

   851             }

   852         iConfigInfo = CPeninputLayoutConfig::NewL( *iVkbLayout, reader ); 

   853         

   854         // Pop and destroy reader

   855         CleanupStack::PopAndDestroy( 1 ); 

   856         	       

   857         // Re-construct rangebar

   858         ChangeRangeBarL();

   859 

   860         iLangOrSizeChanged = ETrue;

   861         //ChangeClientSize();

   862         

   863         TBuf<10> iISOCode;

   864         AknPenInputUtils::GetISOLanguageCode

   865             ( static_cast<TLanguage>(aLangID), iISOCode );

   866         CFepUiBaseCtrl* langBtn = 

   867             iCtrlPool->Control( EPeninutWindowCtrlIdInputLangSwitcherBtn );

   868             

   869         if ( langBtn )

   870             {

   871             ( static_cast<CAknFepCtrlEventButton*>( langBtn ) )->SetText

   872                 ( iISOCode );

   873             UpdateArea(( static_cast<CAknFepCtrlButton*>( langBtn ) )->Rect(), 

   874                 ETrue );

   875             }

   876 	    TInt range = -1;

   877 	    iLayoutContext->SetData( EPeninputDataTypeCurrentRange, &range );

   878 	    iLayoutContext->SetData( EPeninputDataTypeClientLayout, &range );

   879 	    

   880 	    iMultiLineIcf->SetLanguageId( aLangID );

   881         } 

   882     else

   883         {

   884         // Report error, do nothing

   885         }

   886     }

   887 

   888 // ---------------------------------------------------------------------------

   889 // CPeninputLayoutWindow::ChangeRangeBarL

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

   891 // ---------------------------------------------------------------------------

   892 //

   893 void CPeninputLayoutWindow::ChangeRangeBarL()

   894     {

   895     // Read range bar from config into and reconstruct range button

   896     if ( iConfigInfo )

   897         {

   898         TInt resid = iConfigInfo->RangebarResId();

   899         CFepUiBaseCtrl* bar = 

   900             iCtrlPool->Control( EPeninutWindowCtrlIdRangeBar );

   901             

   902         if ( bar ) 

   903             {

   904             CAknFepCtrlRangeBar* rangebar = 

   905                 static_cast<CAknFepCtrlRangeBar*>( bar );

   906             

   907             CAknFepCtrlRangeBar::TRangeBarActionStyle style = 

   908                 ( CAknFepCtrlRangeBar::TRangeBarActionStyle )

   909                 iConfigInfo->RangeBarInfo()->RangeStyle();

   910                 

   911             rangebar->SetActionStyle( style );

   912                             

   913             TResourceReader reader;

   914             

   915             CCoeEnv::Static()->CreateResourceReaderLC( reader, resid ); 

   916             

   917             rangebar->ConstructFromResourceL( reader );

   918             

   919             // Pop and destroy reader

   920             CleanupStack::PopAndDestroy( 1 );

   921             }

   922         }

   923     }

   924   

   925 // ---------------------------------------------------------------------------

   926 // CPeninputLayoutWindow::ChangeRange

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

   928 // ---------------------------------------------------------------------------

   929 //

   930 EXPORT_C void CPeninputLayoutWindow::ChangeRange( TInt aRange, TInt aVkbLayoutId, TBool aNotify )

   931     {

   932     TInt curRange = CPeninputDataConverter::AnyToInt

   933         ( iLayoutContext->RequestData( EPeninputDataTypeCurrentRange ) );    

   934 

   935 

   936     CFepUiBaseCtrl* bar = 

   937         iCtrlPool->Control( EPeninutWindowCtrlIdRangeBar );

   938     CAknFepCtrlRangeBar* rangebar = 

   939         static_cast<CAknFepCtrlRangeBar*>( bar );

   940         

   941     if ( rangebar )

   942         {

   943         rangebar->ActiveRange( aRange );

   944         }

   945             

   946     if ( ( curRange != aRange ) || ( iLangOrSizeChanged ) )

   947         {

   948         // Change client layout

   949         //UiLayout()->LayoutOwner()->Hide(ETrue);

   950         CPeninputRangeBarInfo* rangeBar = iConfigInfo->RangeBarInfo();

   951         CPeninputRangeInfo* rangeInfo = rangeBar->FindRange( aRange );

   952         

   953         if ( !rangeInfo )

   954             {

   955             aRange = ERangeNumber;

   956             rangeInfo = rangeBar->FindRange( ERangeNumber );

   957             }

   958 

   959         // Get the whole columns    

   960         

   961         iUnitSizeChange = ReconfigUnitSize(rangeInfo->ClientLayoutId());

   962         /*if (iUnitSizeChange)

   963       	    {

   964        	    UiLayout()->LayoutOwner()->Hide(ETrue);

   965        	    }

   966        	    */

   967         ChangeClientLayout( rangeInfo->ClientLayoutId() );

   968         

   969         CPeninputClientLayoutInfo* clientLayout = 

   970             ConfigInfo()->FindClientLayoutInfo( rangeInfo->ClientLayoutId() );

   971         if ( clientLayout )

   972             {

   973             SizeChangedForBaseWindow( clientLayout->Columns() );

   974             }

   975         	

   976         // Update data:range

   977         iLayoutContext->SetData( EPeninputDataTypeCurrentRange, &aRange );

   978           

   979         // Notify fep the new range

   980         if ( aNotify )

   981             {

   982             TBuf<KIntLengthForByte> buf;

   983             CPeninputDataConverter::IntToDesc( aRange, buf );

   984             iLayoutContext->Sendkey( ESignalRange, buf );

   985             }

   986 

   987         // Change vkb layout

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

   989             {

   990             if ( ( aRange == ERangeEnglish ) || ( aRange == ERangeAccent ) 

   991                 || ( ConfigInfo()->CaseSensitive() 

   992                 && ( aRange == ERangeNative ) ) )

   993                 {

   994                 // Change shift and capslock button status according to the current case

   995                 TInt curCase = CPeninputDataConverter::AnyToInt

   996                     ( iLayoutContext->RequestData( EPeninputDataTypeCase ) );

   997                 TInt shfit;  

   998                 TInt capslock;  

   999                 

  1000                 CPeninputDataConverter::ShiftCapslockByCase( curCase, 

  1001                     shfit, capslock );      

  1002 

  1003                 iLayoutContext->SetData( EPeninputDataTypeShiftDown, &shfit );

  1004                 ChangeButtonStatus( shfit, EPeninutWindowCtrlIdShiftBtn );

  1005                 iLayoutContext->SetData( EPeninputDataTypeCapslockDown, &capslock );

  1006                 ChangeButtonStatus( capslock, EPeninutWindowCtrlIdCapslockBtn );                

  1007                 

  1008                 TInt caseid = CaseByShiftCapslockStatus();

  1009                 TInt vkblayoutid = 

  1010                     ConfigInfo()->ShiftCapsSingleVkbLayoutId( aRange, caseid );

  1011                                 

  1012                 if ( aRange == ERangeAccent ) 

  1013                     {

  1014                     TInt curAccentIndex = CPeninputDataConverter::AnyToInt

  1015                         ( iLayoutContext->RequestData( EPeninputDataTypeCurrentAccent ) );

  1016                     vkblayoutid = vkblayoutid + curAccentIndex * 2;

  1017                     }      

  1018                     

  1019                 // Change vkb layout

  1020                 ChangeVkbLayout( vkblayoutid );

  1021                 }

  1022             else

  1023                 {

  1024                 TInt flag = 0;

  1025                 

  1026                 iLayoutContext->SetData( EPeninputDataTypeShiftDown, &flag );

  1027                 ChangeButtonStatus( 0, EPeninutWindowCtrlIdShiftBtn );

  1028                 iLayoutContext->SetData( EPeninputDataTypeCapslockDown, &flag );

  1029                 ChangeButtonStatus( 0, EPeninutWindowCtrlIdCapslockBtn );

  1030      

  1031                 // Change vkb layout

  1032                 if ( aVkbLayoutId )

  1033                     {

  1034                     ChangeVkbLayout( aVkbLayoutId );                   

  1035                     }

  1036                 else

  1037                     {

  1038                     ChangeVkbLayout( rangeInfo->VkbLayoutId() );  

  1039                     }                

  1040                 }

  1041 

  1042             }

  1043             

  1044         /*if (iUnitSizeChange)

  1045             {

  1046         	//SizeChanged(ETrue);

  1047         	const TRect rect = ChangeUnitSize();

  1048             ReadLafForShadow( rect );

  1049             if ( iConfigInfo )

  1050                 {

  1051                 // Change the size of base window

  1052                 SizeChangedForBaseWindow( iLastUsedTotalColumns );

  1053                 ChangeClientSize();        

  1054                 }

  1055         	UiLayout()->LayoutOwner()->Hide(EFalse);

  1056         	iUnitSizeChange = EFalse;

  1057             }*/

  1058 

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

  1060               && ( curRange == ERangeNumber ) && ( curRange == aRange ) )

  1061             {

  1062             // Dimmed some keys if needed  

  1063             DimKeys();                 

  1064             } 

  1065                            

  1066         UiLayout()->Draw();    

  1067         }

  1068         

  1069     }

  1070 

  1071 // ---------------------------------------------------------------------------

  1072 // CPeninputLayoutWindow::ChangeClientLayout

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

  1074 // ---------------------------------------------------------------------------

  1075 //

  1076 EXPORT_C void CPeninputLayoutWindow::ChangeClientLayout( TInt aClientLayoutId )

  1077     {

  1078     TInt curClientId = CPeninputDataConverter::AnyToInt

  1079         ( iLayoutContext->RequestData( EPeninputDataTypeClientLayout ) );

  1080 

  1081     if ( ( curClientId != aClientLayoutId ) || ( iLangOrSizeChanged ) )

  1082         {

  1083         // Re-Orginize all controls according to the configuration

  1084         ReorganizeControls( aClientLayoutId, ETrue );

  1085       

  1086         // Update data:client layout id

  1087         iLayoutContext->SetData( EPeninputDataTypeClientLayout, 

  1088                                  &aClientLayoutId );

  1089                                  

  1090         // Reset lang changed flag

  1091         if ( ( iLangOrSizeChanged ) 

  1092             && ( iLayoutContext->LayoutType() != EPluginInputModeVkb ) )

  1093             {

  1094             iLangOrSizeChanged = EFalse;

  1095             }

  1096 

  1097         //iUnitSizeChange = ReconfigUnitSize(aClientLayoutId); 

  1098         }

  1099     }

  1100 

  1101 // ---------------------------------------------------------------------------

  1102 // CPeninputLayoutWindow::ChangeVkbLayout

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

  1104 // ---------------------------------------------------------------------------

  1105 //

  1106 EXPORT_C void CPeninputLayoutWindow::ChangeVkbLayout( TInt aVkbLayoutId )

  1107     {

  1108     TInt latchedFlag = CPeninputDataConverter::AnyToInt(

  1109                        iLayoutContext->RequestData(EAkninputDataTypeLatchedSet));

  1110     // If the DeadKey is latched, cancel it and then change the VKB layout

  1111     if(latchedFlag)

  1112         {

  1113         RPointerArray<CPeninputVkbLayoutInfo> vkbListInfo;

  1114         RPointerArray<CPeninputVkbKeyInfo> keyInfoList;

  1115         

  1116         vkbListInfo = iVkbLayout->VkbLayoutInfoList();

  1117         TInt vkbListNum = vkbListInfo.Count();

  1118         

  1119         CVirtualKey* pKey;

  1120         TBool deadKeyChange = EFalse;

  1121         // Find the latched DeadKey in all the Vkb layout

  1122         for(TInt i = 0; i < vkbListNum; i++)

  1123             {

  1124             // Get key info list in one VKB layout

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

  1126             TInt keyListNum = keyInfoList.Count();

  1127             for(TInt j = 0; j < keyListNum; j++)

  1128                 {

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

  1130                 if(pKey->Latched())

  1131                     {

  1132                     // Unlatch the DeadKey

  1133                     pKey->SetLatched(EFalse);

  1134