1 /*

     2 * Copyright (c) 2007 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:  Implement of class CTruiMainView

    15 *

    16 */

    17 

    18 

    19 #include <aknViewAppUi.h>

    20 #include <eikmenup.h>

    21 #include <trui.rsg>

    22 #include <akntoolbar.h>

    23 #include <aknnavide.h>

    24 #include <akntabgrp.h>

    25 

    26 #include "truimainview.h"

    27 #include "truimainviewcontainer.h"

    28 #include "trui.hrh"

    29 #include "truiappui.h"

    30 #include "truiengine.h"

    31 #include "truishortcutsview.h"

    32 

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

    34 

    35 CTruiMainView::CTruiMainView()

    36     {

    37     }

    38 

    39 void CTruiMainView::ConstructL()

    40     {

    41     BaseConstructL( R_TRUI_MAINVIEW );

    42     }

    43 

    44 CTruiMainView* CTruiMainView::NewL()

    45     {

    46     CTruiMainView* self = CTruiMainView::NewLC();

    47     CleanupStack::Pop( self );

    48     return self;

    49     }

    50 

    51 CTruiMainView* CTruiMainView::NewLC()

    52     {

    53     CTruiMainView* self = new( ELeave ) CTruiMainView;

    54     CleanupStack::PushL( self );

    55     self->ConstructL();

    56     return self;

    57     }

    58 

    59 CTruiMainView::~CTruiMainView()

    60     {

    61     }

    62     

    63 // ---------------------------------------------------------------------------

    64 // From class CAknView.

    65 // Returns views id.

    66 // ---------------------------------------------------------------------------

    67 //

    68 TUid CTruiMainView::Id() const

    69     {

    70     return KTruiMainViewId;    

    71     }

    72     

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

    74 // From class CAknView.

    75 // Command handling function.

    76 // ---------------------------------------------------------------------------

    77 //

    78 void CTruiMainView::HandleCommandL( TInt aCommand )

    79     {

    80     switch ( aCommand )

    81         {

    82         case EMainViewCharGrid:

    83             {

    84             // Handle menu item command "Character Grid"

    85             iContainer->HandleChooseCharEventL();             

    86             }

    87             break;

    88         case EMainViewSubmenuWestern:

    89         case EMainViewSubmenuCyrillic:

    90         case EMainViewSubmenuGreek:

    91         case EMainViewSubmenuHebrew:

    92             {

    93             iContainer->HandleLanguageScriptChangedL( aCommand );

    94             }

    95             break;

    96         case EMainViewSubmenuLatinLowerLetter:

    97         case EMainViewSubmenuLatinUpperLetter:

    98         case EMainViewSubmenuLatinAccent:

    99         case EMainViewSubmenuDigital:

   100         case EMainViewSubmenuSymbols:

   101         case EMainViewSubmenuCyrillicLowerLetters:

   102         case EMainViewSubmenuCyrillicUpperLetters:

   103         case EMainViewSubmenuCyrillicAccent:        

   104         case EMainViewSubmenuGreekLowerLetters:

   105         case EMainViewSubmenuGreekUpperLetters:       

   106         case EMainViewSubmenuHebrewLetters:        

   107             {

   108             // Handle character range changed

   109             // Get range index in menu pane by range Id

   110             CTruiAppUi* appui = static_cast<CTruiAppUi*>( AppUi() );

   111             CTruiEngine* engine = appui->HwrEngine();

   112             const RArray<TInt>& rangeIdArray = 

   113                                 engine->GetCurrentSupportedRangesId();

   114             TInt indexOfMenuItems = rangeIdArray.Find( aCommand );

   115             if ( indexOfMenuItems != KErrNotFound )

   116                 {

   117                 // Set current character range by index in Engine

   118                 engine->SetCharacterRangeByIndexL( indexOfMenuItems );

   119 

   120                 // Call iContainer->HandleCharRangeChanged to handle it.

   121                 iContainer->HandleCharRangeChangedL( indexOfMenuItems, 

   122                                                      aCommand );

   123                 }	        

   124             }

   125 	        break;

   126         case EMainViewDeleteCurrentModel:

   127             {

   128             iContainer->DeleteModelL();

   129             }

   130             break;

   131         case EMainViewDeleteAllModel:

   132             {

   133             iContainer->DeleteAllModelL();

   134             break;

   135             }

   136         case EMainViewPreviewModel:

   137             {

   138             iContainer->PreviewCharacterModel();

   139             break;

   140             }

   141         case EMainViewToShortcutsView:

   142             {

   143             CTruiAppUi* appui = static_cast<CTruiAppUi*>( AppUi() );

   144             CAknNavigationDecorator* naviDecorator = appui->GetNaviDecorator();

   145             CAknTabGroup* tabGroup = static_cast<CAknTabGroup*>

   146                                     ( naviDecorator->DecoratedControl() );

   147             tabGroup->SetActiveTabById( ENavigationPaneShortcutsViewTab );

   148             // Switch to local view.

   149             appui->ActivateLocalViewL( KTruiShortcutsViewId );

   150             break;

   151             }

   152         case EAknSoftkeyExit:

   153             {

   154             iContainer->PrepareToExitL();

   155             AppUi()->HandleCommandL( aCommand );

   156             }

   157             break;

   158         default:

   159             {

   160             AppUi()->HandleCommandL( aCommand );            

   161             }                    

   162         }

   163     }

   164     

   165 // ---------------------------------------------------------------------------

   166 // From class CAknView.

   167 // Carried out when View is activated

   168 // ---------------------------------------------------------------------------

   169 //

   170 void CTruiMainView::DoActivateL( const TVwsViewId& /*aPrevViewId*/,

   171                   TUid /*aCustomMessageId*/,

   172                   const TDesC8& /*aCustomMessage*/ )

   173     {

   174     // Set title pane

   175     CTruiAppUi* appui = static_cast<CTruiAppUi*>( AppUi() );

   176     HBufC* titleText = 

   177            iEikonEnv->AllocReadResourceLC( R_TRUI_MAINVIEW_TITLEPANE_TEXT );

   178     appui->ShowTitlePaneL( *titleText );

   179     CleanupStack::PopAndDestroy( titleText );

   180 

   181     iContainer = CTruiMainViewContainer::NewL( ClientRect() );

   182     iContainer->SetMopParent( this );

   183     AppUi()->AddToStackL( *this, iContainer );    

   184     iContainer->SetView( this );

   185 

   186     // Set toolbar

   187     CAknToolbar* toolbar = Toolbar();

   188     if ( toolbar )

   189         {

   190         toolbar->SetToolbarObserver( this );

   191         toolbar->SetToolbarVisibility( ETrue, EFalse );

   192         }

   193     }

   194 

   195 // ---------------------------------------------------------------------------

   196 // From class CAknView.

   197 // Carried out when View is deactivated

   198 // ---------------------------------------------------------------------------

   199 //

   200 void CTruiMainView::DoDeactivate()

   201     {

   202     if ( iContainer )

   203         {        

   204         AppUi()->RemoveFromStack( iContainer );

   205         delete iContainer;

   206         iContainer = NULL;

   207         }        

   208     }

   209 

   210 // ---------------------------------------------------------------------------

   211 // From class MAknToolbarObserver.

   212 // Handles toolbar events for a certain toolbar item.

   213 // ---------------------------------------------------------------------------

   214 //

   215 void CTruiMainView::OfferToolbarEventL( TInt aCommand )

   216     {

   217     switch ( aCommand )

   218         {

   219         case EMainViewButtonIdGrid:

   220             {

   221             // Open SCT

   222             iContainer->HandleChooseCharEventL();

   223             break;

   224             }

   225         case EMainViewButtonIdPreview:

   226             {

   227             // Preview character animation

   228             iContainer->PreviewCharacterModel();

   229             break;

   230             }

   231         case EMainViewButtonIdDelete:

   232             {

   233             // Clear HWR box and delete character model

   234             iContainer->DeleteModelL();

   235             break;

   236             }

   237         }

   238     }

   239     

   240 // ---------------------------------------------------------------------------

   241 // Dynamically initialises a menu pane.

   242 // ---------------------------------------------------------------------------

   243 //

   244 void CTruiMainView::DynInitMenuPaneL( TInt aResourceId, 

   245                                       CEikMenuPane* aMenuPane )

   246     {

   247     // Get engine

   248     CTruiAppUi* appui = static_cast<CTruiAppUi*>( AppUi() );

   249     CTruiEngine* engine = appui->HwrEngine();

   250     

   251     if ( aResourceId == R_TRUI_MAINVIEW_MENUPANE )

   252         {

   253         // Get language script from engine

   254         // Determine whether "Language script" will be displayed.

   255         aMenuPane->SetItemDimmed( EMainViewLanguageScript, 

   256                             ( engine->SupportedLanguageScript().Count() <= 1 ) );

   257         

   258         // Determine whether "Delete model" will be displayed

   259         iDimAllDelete = iContainer->IsAllDelete();

   260                        

   261         TBool isDimmed = ( iContainer->IsButtonDimmed() && iDimAllDelete ) 

   262                          ? ETrue: EFalse;

   263         aMenuPane->SetItemDimmed( EMainViewDeleteModel, isDimmed );

   264         

   265         // Determine whether "Preview model" will be displayed.

   266         TBool isPreviewDimmed = iContainer->IsButtonDimmed() ? ETrue: EFalse;

   267         aMenuPane->SetItemDimmed( EMainViewPreviewModel, isPreviewDimmed );

   268         }    

   269     if ( aResourceId == R_TRUI_MAINVIEW_MENU_LANGUAGESCRIPT_CASCADE )

   270         {        

   271         // Set which items will be displayed by supported language script

   272         const RArray<TInt>& languageScriptId = 

   273                                            engine->SupportedLanguageScript();

   274         aMenuPane->SetItemDimmed( EMainViewSubmenuWestern, ETrue );

   275         aMenuPane->SetItemDimmed( EMainViewSubmenuCyrillic, ETrue );

   276         aMenuPane->SetItemDimmed( EMainViewSubmenuGreek, ETrue );

   277         aMenuPane->SetItemDimmed( EMainViewSubmenuHebrew, ETrue );

   278         for ( TInt i = 0; i < languageScriptId.Count(); i++ )

   279             {

   280             aMenuPane->SetItemDimmed( languageScriptId[i], EFalse );

   281             }

   282         

   283         if ( IsMenuItemDimmed( aMenuPane, EMainViewSubmenuWestern ) )

   284             {

   285             aMenuPane->DeleteMenuItem( EMainViewSubmenuWestern );

   286             }

   287         if ( IsMenuItemDimmed( aMenuPane, EMainViewSubmenuCyrillic ) )

   288             {

   289             aMenuPane->DeleteMenuItem( EMainViewSubmenuCyrillic );

   290             }

   291         if ( IsMenuItemDimmed( aMenuPane, EMainViewSubmenuGreek ) )

   292             {

   293             aMenuPane->DeleteMenuItem( EMainViewSubmenuGreek );

   294             }

   295         if ( IsMenuItemDimmed( aMenuPane, EMainViewSubmenuHebrew ) )

   296             {

   297             aMenuPane->DeleteMenuItem( EMainViewSubmenuHebrew );

   298             }

   299         

   300         // Set which item will be indicated by current language script         

   301         aMenuPane->SetItemButtonState( engine->CurrentLanguageScript(), 

   302                                        EEikMenuItemSymbolOn );

   303         

   304         // Set current selected item

   305         TInt pos;

   306         aMenuPane->ItemAndPos( engine->CurrentLanguageScript(), pos );

   307         aMenuPane->SetSelectedItem( pos );

   308         }

   309     if ( aResourceId == R_TRUI_MAINVIEW_MENU_CHARRANGE_CASCADE )

   310         {

   311         // Get language script from model      

   312         // Init character range submenu                     

   313         InitCharRangeSubMenuL( engine->CurrentLanguageScript(), aMenuPane );

   314         

   315         if ( engine->CurrentLanguageScript() == EMainViewSubmenuCyrillic )

   316             {

   317             // Dim cyrillic accent range

   318             aMenuPane->SetItemDimmed( EMainViewSubmenuCyrillicAccent, ETrue );

   319             }

   320 

   321         // Get the current item's Id

   322         TInt rangeId = engine->GetCurrentCharacterRange();

   323         

   324         // Set which item to be indicated       

   325         aMenuPane->SetItemButtonState( rangeId, EEikMenuItemSymbolOn );

   326         

   327         // Set which item to be highlighted

   328         const RArray<TInt>& rangeIdArray = 

   329                                       engine->GetCurrentSupportedRangesId();

   330         TInt indexOfMenuItems = rangeIdArray.Find( rangeId );

   331         if ( indexOfMenuItems != KErrNotFound )

   332             {

   333             aMenuPane->SetSelectedItem( indexOfMenuItems );

   334             }

   335         }

   336     if ( aResourceId == R_TRUI_MAINVIEW_MENU_DELETE_CASCADE )

   337         {

   338         aMenuPane->SetItemDimmed( EMainViewDeleteCurrentModel, 

   339                                   iContainer->IsButtonDimmed() );

   340         aMenuPane->SetItemDimmed( EMainViewDeleteAllModel, iDimAllDelete );

   341         }

   342     }

   343 

   344 // ---------------------------------------------------------------------------

   345 // Dynamically initialises the character range menu pane.

   346 // ---------------------------------------------------------------------------

   347 //

   348 void CTruiMainView::InitCharRangeSubMenuL( TInt aScriptId,

   349                                            CEikMenuPane* aMenuPane)

   350     {

   351     // Get the corrent reource ID of MENU_ITEMS by 

   352     TInt reourceId = MenuItemsReourceId( aScriptId );

   353     // Add these menu items into menu pane

   354     aMenuPane->AddMenuItemsL( reourceId );    

   355     }

   356     

   357 // ---------------------------------------------------------------------------

   358 // Get reource ID of menu items for initializing menu pane.

   359 // ---------------------------------------------------------------------------

   360 //

   361 TInt CTruiMainView::MenuItemsReourceId( TInt aScriptId )

   362     {

   363     TInt reourceId;

   364     switch ( aScriptId )

   365         {

   366         case EMainViewSubmenuWestern:

   367             {

   368             reourceId = R_TRUI_MAINVIEW_SUBMENU_CHARRANGE_LATIN;

   369             }

   370             break;            

   371         case EMainViewSubmenuCyrillic:

   372             {

   373             reourceId = R_TRUI_MAINVIEW_SUBMENU_CHARRANGE_CYRILLIC;

   374             }

   375             break;                    

   376         case EMainViewSubmenuGreek:

   377             {

   378             reourceId = R_TRUI_MAINVIEW_SUBMENU_CHARRANGE_GREEK;

   379             }

   380             break;        

   381         case EMainViewSubmenuHebrew:

   382             {

   383             reourceId = R_TRUI_MAINVIEW_SUBMENU_CHARRANGE_HEBREW;

   384             }        

   385             break;

   386         default:

   387             reourceId = 0;

   388             break;            

   389         }

   390     return reourceId;            

   391     }   

   392 

   393 // ---------------------------------------------------------------------------

   394 // Check menu item dimmed by menu item id.

   395 // ---------------------------------------------------------------------------

   396 //

   397 TBool CTruiMainView::IsMenuItemDimmed( CEikMenuPane* aMenuPane, TInt aMenuItemId )

   398     {

   399     CEikMenuPaneItem::SData& itemdata = aMenuPane->ItemData( aMenuItemId );    

   400     return ( itemdata.iFlags & EEikMenuItemDimmed == EEikMenuItemDimmed );    

   401     }