textinput/peninputgenerichwr/src/peninputgenerichwrdatamgr.cpp
changeset 0 eb1f2e154e89
equal deleted inserted replaced
-1:000000000000 0:eb1f2e154e89
       
     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:  peninput hwr data manager
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 // System includes
       
    20 #include <peninputdataconverter.h>
       
    21 #include <centralrepository.h>
       
    22 #include <settingsinternalcrkeys.h>
       
    23 #include <peninputlayoutcontext.h>
       
    24 #include <peninputcommonlayoutglobalenum.h>
       
    25 
       
    26 // User includes
       
    27 #include "peninputgenerichwr.hrh"
       
    28 #include "peninputgenerichwrdatamgr.h"
       
    29 #include "peninputgenericrecognizer.h"
       
    30 #include "AknsUtils.h"
       
    31 #include "peninputpluginutils.h"
       
    32 
       
    33 // Constants
       
    34 const TInt KGuideLineOn = 1;
       
    35 enum
       
    36     {
       
    37     EHwrWritingSpeedVeryFast    = 300 * 1000,
       
    38     EHwrWritingSpeedFast        = 400 * 1000,
       
    39     EHwrWritingSpeedNormal      = 550 * 1000,
       
    40     EHwrWritingSpeedSlow        = 700 * 1000,
       
    41     EHwrWritingSpeedVerySlow    = 1000 * 1000
       
    42     };
       
    43 
       
    44 
       
    45 // ======== MEMBER FUNCTIONS ========
       
    46 
       
    47 // ---------------------------------------------------------------------------
       
    48 // CPeninputGenericHwrDataMgr::NewL
       
    49 // (other items were commented in a header)
       
    50 // ---------------------------------------------------------------------------
       
    51 //    
       
    52 CPeninputGenericHwrDataMgr* CPeninputGenericHwrDataMgr::NewL( 
       
    53     MPeninputLayoutContext* aContext ,CPtiEngine* aPtiEngine)
       
    54     {
       
    55     CPeninputGenericHwrDataMgr* self = NewLC( aContext ,aPtiEngine );
       
    56     CleanupStack::Pop( self );
       
    57       
       
    58     return self;
       
    59     }
       
    60     
       
    61 // ---------------------------------------------------------------------------
       
    62 // CPeninputGenericHwrDataMgr::NewLC
       
    63 // (other items were commented in a header)
       
    64 // ---------------------------------------------------------------------------
       
    65 //  
       
    66 CPeninputGenericHwrDataMgr* CPeninputGenericHwrDataMgr::NewLC( 
       
    67     MPeninputLayoutContext* aContext ,CPtiEngine* aPtiEngine)
       
    68     {
       
    69     CPeninputGenericHwrDataMgr* self = 
       
    70         new ( ELeave ) CPeninputGenericHwrDataMgr( aContext );
       
    71     self->iPtiEngine = aPtiEngine;
       
    72     CleanupStack::PushL( self );
       
    73     self->ConstructL(); 
       
    74 
       
    75     return self;
       
    76     }
       
    77 
       
    78 // ---------------------------------------------------------------------------
       
    79 // CPeninputGenericHwrDataMgr::CPeninputGenericHwrDataMgr
       
    80 // (other items were commented in a header)
       
    81 // ---------------------------------------------------------------------------
       
    82 //  
       
    83 CPeninputGenericHwrDataMgr::CPeninputGenericHwrDataMgr( 
       
    84     MPeninputLayoutContext* aContext ) 
       
    85     : CPeninputDataMgr( aContext )
       
    86     {
       
    87     }
       
    88 
       
    89 // ---------------------------------------------------------------------------
       
    90 // CPeninputGenericHwrDataMgr::~CPeninputGenericHwrDataMgr
       
    91 // (other items were commented in a header)
       
    92 // ---------------------------------------------------------------------------
       
    93 //      
       
    94 CPeninputGenericHwrDataMgr::~CPeninputGenericHwrDataMgr()
       
    95     {
       
    96     if( iOwnPtiEngine )
       
    97         {
       
    98         delete iPtiEngine;
       
    99         }
       
   100     delete iPenData.iRecognizer; 
       
   101     }
       
   102 
       
   103 // ---------------------------------------------------------------------------
       
   104 // CPeninputGenericHwrDataMgr::GetPenTrailColor
       
   105 // (other items were commented in a header)
       
   106 // ---------------------------------------------------------------------------
       
   107 //      
       
   108 TRgb CPeninputGenericHwrDataMgr::GetPenTrailColor()
       
   109     {
       
   110     TInt newValue = 0; 
       
   111     
       
   112     iGSRepository->Get( KSettingsPenColor, newValue );
       
   113     
       
   114     if (!AknPenInputTrailColorUtils::CheckColorInColorTable(newValue))
       
   115         {
       
   116         newValue = AknPenInputTrailColorUtils::GetTrailColorByTheme();
       
   117         }
       
   118     return TRgb(newValue);
       
   119     }
       
   120 // ---------------------------------------------------------------------------
       
   121 // CPeninputGenericHwrDataMgr::InitMore
       
   122 // (other items were commented in a header)
       
   123 // ---------------------------------------------------------------------------
       
   124 //  
       
   125 void CPeninputGenericHwrDataMgr::InitMore()
       
   126     {
       
   127     // Read pen data
       
   128     if ( iGSRepository )
       
   129         {
       
   130         TInt newValue;                
       
   131         // Read guide line on/off flag, don't remove these code
       
   132         newValue = KGuideLineOn;
       
   133         iPenData.iGuideLineOn = iGSRepository->Get( KSettingsPenInputGuideLine, newValue );
       
   134         iPenData.iGuideLineOn = newValue;
       
   135         
       
   136         iPenData.iPenColor = GetPenTrailColor();
       
   137         
       
   138         newValue = 1;
       
   139         iGSRepository->Get( KSettingsPenWidth, newValue );        
       
   140         iPenData.iPenSize = TSize( newValue, newValue );
       
   141         
       
   142         newValue = 2;
       
   143         iGSRepository->Get( KSettingsWritingSpeed, newValue );        
       
   144         iPenData.iFadingSpeed = newValue;
       
   145         iPenData.iWritingSpeed = TransferWritingSpeed( newValue );
       
   146         }
       
   147     
       
   148     if( !iPtiEngine )    
       
   149         {
       
   150         TRAP_IGNORE( iPtiEngine = CPtiEngine::NewL( ETrue ));
       
   151         iOwnPtiEngine = ETrue; 
       
   152         }
       
   153         
       
   154     TRAP_IGNORE( iPenData.iRecognizer = CPeninputGenericRecognizer::NewL(iPtiEngine) );
       
   155     iPenData.iRecognizer->EnableWordRecognition( ETrue );    
       
   156     iReserve_1 = &iPenData;
       
   157     }
       
   158 
       
   159 // ---------------------------------------------------------------------------
       
   160 // CPeninputGenericHwrDataMgr::HandleGSRepositoryChange
       
   161 // (other items were commented in a header)
       
   162 // ---------------------------------------------------------------------------
       
   163 //  
       
   164 void CPeninputGenericHwrDataMgr::HandleGSRepositoryChange( TInt aChangedKey )
       
   165     {
       
   166     TInt newValue = 0;
       
   167     
       
   168     switch ( aChangedKey )
       
   169         {
       
   170         case KSettingsPenColor:
       
   171         	  {
       
   172             iGSRepository->Get( KSettingsPenColor, newValue ); 
       
   173             iPenData.iPenColor = newValue;           
       
   174             iContext->SendEventToWindow( EPeninputLayoutHwrEventPenColorChange, 
       
   175                 NULL ); 
       
   176             }
       
   177             break;
       
   178         case KSettingsPenWidth:
       
   179         	  {
       
   180             iGSRepository->Get( KSettingsPenWidth, newValue );        
       
   181             iPenData.iPenSize = TSize( newValue, newValue );            
       
   182             iContext->SendEventToWindow( EPeninputLayoutHwrEventPenSizeChange, 
       
   183                 NULL );
       
   184             }
       
   185             break; 
       
   186         case KSettingsWritingSpeed:
       
   187         	  {
       
   188             iGSRepository->Get( KSettingsWritingSpeed, newValue );                    
       
   189             iPenData.iFadingSpeed = newValue;
       
   190             iPenData.iWritingSpeed = TransferWritingSpeed( newValue );
       
   191             iContext->SendEventToWindow
       
   192                 ( EPeninputLayoutHwrEventWritingSpeedChange, NULL );
       
   193             }
       
   194             break;
       
   195         case KSettingsPenInputGuideLine:
       
   196         	  {
       
   197             iGSRepository->Get( KSettingsPenInputGuideLine, newValue ); 
       
   198             if ( newValue != iPenData.iGuideLineOn )
       
   199                 {
       
   200                 iPenData.iGuideLineOn = newValue;
       
   201                 iContext->SendEventToWindow
       
   202                     ( EPeninputLayoutHwrEventGuideLineChanged, NULL );
       
   203                 } 
       
   204             //inform engine about then change in guideline.
       
   205             if(iPenData.iRecognizer != NULL)
       
   206                 {
       
   207                 iPenData.iRecognizer->EnableGuideline(iPenData.iGuideLineOn == 1? ETrue : EFalse);
       
   208                 }
       
   209             }
       
   210             break;
       
   211         default:
       
   212             break;
       
   213         }
       
   214     }
       
   215 
       
   216 // ---------------------------------------------------------------------------
       
   217 // CPeninputGenericHwrDataMgr::Reset
       
   218 // (other items were commented in a header)
       
   219 // ---------------------------------------------------------------------------
       
   220 //  
       
   221 void CPeninputGenericHwrDataMgr::Reset()
       
   222     {
       
   223     }
       
   224 
       
   225 // ---------------------------------------------------------------------------
       
   226 // CPeninputGenericHwrDataMgr::TransferWritingSpeed
       
   227 // (other items were commented in a header)
       
   228 // ---------------------------------------------------------------------------
       
   229 //  
       
   230 TInt CPeninputGenericHwrDataMgr::TransferWritingSpeed( TInt aWritingSpeed )
       
   231     {
       
   232     TInt speed;
       
   233     
       
   234     switch ( aWritingSpeed )
       
   235         {
       
   236         case 1: 
       
   237             {
       
   238             speed = EHwrWritingSpeedVeryFast;
       
   239             }
       
   240             break;
       
   241         case 2: 
       
   242             {
       
   243             speed = EHwrWritingSpeedFast;
       
   244             }
       
   245             break;
       
   246         case 3: 
       
   247             {
       
   248             speed = EHwrWritingSpeedNormal;
       
   249             }
       
   250             break;
       
   251         case 4: 
       
   252             {
       
   253             speed = EHwrWritingSpeedSlow;
       
   254             }
       
   255             break;
       
   256         case 5:
       
   257             { 
       
   258             speed = EHwrWritingSpeedVerySlow;
       
   259             }
       
   260             break;
       
   261         default:
       
   262             {
       
   263             speed = EHwrWritingSpeedNormal;
       
   264             }
       
   265             break;
       
   266         }
       
   267         
       
   268     return speed;    
       
   269     }
       
   270 
       
   271 // ---------------------------------------------------------------------------
       
   272 // CPeninputGenericHwrDataMgr::SetData
       
   273 // (other items were commented in a header)
       
   274 // ---------------------------------------------------------------------------
       
   275 //   
       
   276 void CPeninputGenericHwrDataMgr::SetData( TPeninputDataType aDataType, 
       
   277                                          TAny* aData )
       
   278     {
       
   279     switch ( aDataType )
       
   280         {
       
   281         case EAkninputDataTypeInputArea:
       
   282             {
       
   283             iInputArea = *(TSize*)aData;
       
   284             }   
       
   285             break;
       
   286          default:
       
   287             {
       
   288             CPeninputDataMgr::SetData( aDataType, aData );
       
   289             }
       
   290         }
       
   291     NotifyEngine( aDataType, aData ) ;    
       
   292     }
       
   293 
       
   294  
       
   295  // ---------------------------------------------------------------------------
       
   296 // CPeninputGenericHwrDataMgr::NotifyEngine
       
   297 // (other items were commented in a header)
       
   298 // ---------------------------------------------------------------------------
       
   299 //   
       
   300 TAny* CPeninputGenericHwrDataMgr::RequestData( TPeninputDataType aDataType )
       
   301     {
       
   302     switch ( aDataType )
       
   303         {
       
   304         case EAkninputDataTypeGuideLineTop: 
       
   305             {
       
   306             iPenData.iRecognizer->GetTopGuideLinePos( iHelpLine );
       
   307             return &iHelpLine;
       
   308             }
       
   309         case EAkninputDataTypeGuideLineBottom:
       
   310             {
       
   311             iPenData.iRecognizer->GetBottomGuideLinePos( iBaseLine );
       
   312             return &iBaseLine;
       
   313             }
       
   314         case EPeninputDataTypePenTailColor:
       
   315             {
       
   316             iPenData.iPenColor = GetPenTrailColor();
       
   317             return &iPenData.iPenColor;
       
   318             }
       
   319             
       
   320          default:
       
   321             {
       
   322             return CPeninputDataMgr::RequestData( aDataType );
       
   323             }
       
   324         }
       
   325     }
       
   326     
       
   327 // ---------------------------------------------------------------------------
       
   328 // CPeninputGenericHwrDataMgr::NotifyEngine
       
   329 // (other items were commented in a header)
       
   330 // ---------------------------------------------------------------------------
       
   331 //      
       
   332 void CPeninputGenericHwrDataMgr::NotifyEngine( TPeninputDataType aType, 
       
   333                                                TAny* aData )
       
   334     {
       
   335     // Call the function in base class, which will store data to CenRep
       
   336     CPeninputDataMgr::NotifyEngine( aType, aData );
       
   337       
       
   338     TInt* data = ( TInt* ) aData;
       
   339     
       
   340     // Notify engine, when language, range, case changed
       
   341     switch ( aType )
       
   342         {
       
   343         case EPeninputDataTypeCase: 
       
   344             {
       
   345             iPenData.iRecognizer->SetCase( *data );
       
   346             }
       
   347             break;
       
   348         case EPeninputDataTypeInputLanguage: 
       
   349             {
       
   350             iPenData.iRecognizer->SetLanguage( *data );
       
   351             }
       
   352             break;
       
   353         case EPeninputDataTypeCurrentRange: 
       
   354             {
       
   355             iPenData.iRecognizer->SetMode( *data );
       
   356             }
       
   357             break;
       
   358         case EPeninputDataTypeNumericKeymap:
       
   359             {
       
   360             iPenData.iRecognizer->SetNumberMode
       
   361                 ( ( TAknEditorNumericKeymap )*data );
       
   362             }
       
   363             break;     
       
   364         case EAknFepDataTypeUseDefinedResource:
       
   365             {
       
   366             HBufC* res = (HBufC*)RequestData(EAknFepDataTypeUseDefinedResource);
       
   367             iPenData.iRecognizer->SetPermittedCharSet(*res);
       
   368             }
       
   369             break;
       
   370         case EAkninputDataTypeInputArea:
       
   371             {
       
   372             iPenData.iRecognizer->SetInputAreaSize( *(TSize*)data );
       
   373             }   
       
   374         break;
       
   375         default:
       
   376             break;
       
   377         }    
       
   378     }
       
   379 //End of file