mpxplugins/viewplugins/views/commoncontainer/src/mpxcommoncontaineravkonimp.cpp
changeset 0 ff3acec5bc43
child 21 a1247965635c
equal deleted inserted replaced
-1:000000000000 0:ff3acec5bc43
       
     1 /*
       
     2 * Copyright (c) 2006 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:  Implementation of common container for AVKON platform.
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 
       
    20 // INCLUDE FILES
       
    21 #include <barsread.h>
       
    22 #include <stringloader.h>
       
    23 #include <akniconarray.h>
       
    24 #include <gulicon.h>
       
    25 #include <featmgr.h>
       
    26 #include <aknsfld.h>
       
    27 #include <aknutils.h>
       
    28 #include <aknlists.h>
       
    29 #include <aknconsts.h>
       
    30 #include <avkon.mbg>
       
    31 #include <eikclbd.h>
       
    32 #include <eikcmobs.h>
       
    33 #include <bautils.h>
       
    34 
       
    35 #include <data_caging_path_literals.hrh>
       
    36 #include <mpxcommoncontainer.rsg>
       
    37 #include <mpxlog.h>
       
    38 #include <mpxuser.h>
       
    39 
       
    40 #include "mpxcommonlistboxarraybase.h"
       
    41 #include "mpxcommoncontaineravkonimp.h"
       
    42 #include "mpxcommoncontainer.hrh"
       
    43 #include <mpxlbxextendedfeatures.h>
       
    44 
       
    45 // CONSTANTS
       
    46 const TInt KMPXFindboxTextLimit = 40;
       
    47 
       
    48 _LIT( KMPXCommonContainerRscPath, "mpxcommoncontainer.rsc" );
       
    49 
       
    50 // ======== MEMBER FUNCTIONS ========
       
    51 
       
    52 // ---------------------------------------------------------------------------
       
    53 // C++ constructor can NOT contain any code that might leave.
       
    54 // ---------------------------------------------------------------------------
       
    55 //
       
    56 CMPXCommonContainerAvkonImp::CMPXCommonContainerAvkonImp() :
       
    57     iIsFindEnabled( ETrue ),
       
    58     iIsMarkingEnabled( ETrue ),
       
    59     iContainerActive( EFalse )
       
    60     {
       
    61     }
       
    62 
       
    63 // ---------------------------------------------------------------------------
       
    64 // Destructor
       
    65 // ---------------------------------------------------------------------------
       
    66 //
       
    67 CMPXCommonContainerAvkonImp::~CMPXCommonContainerAvkonImp()
       
    68     {
       
    69     MPX_FUNC( "CMPXCommonContainerAvkonImp::~CMPXCommonContainerAvkonImp" );    
       
    70     
       
    71     FeatureManager::UnInitializeLib();        
       
    72         
       
    73     if ( iResourceOffset )
       
    74         {
       
    75         iEikonEnv->DeleteResourceFile( iResourceOffset );
       
    76         }
       
    77         
       
    78     delete iListBox;
       
    79     delete iFindBox;
       
    80     delete iLbxExtFeat;
       
    81     }
       
    82 
       
    83 // ---------------------------------------------------------------------------
       
    84 // Return Coe Control
       
    85 // ---------------------------------------------------------------------------
       
    86 //
       
    87 CCoeControl* CMPXCommonContainerAvkonImp::CoeControl()
       
    88     {
       
    89     MPX_FUNC( "CMPXCommonContainerAvkonImp::CoeControl" );
       
    90     return this;
       
    91     }
       
    92 
       
    93 // ---------------------------------------------------------------------------
       
    94 // Set View Container
       
    95 // ---------------------------------------------------------------------------
       
    96 //
       
    97 void CMPXCommonContainerAvkonImp::SetViewContainer(
       
    98     MMPXViewContainer* aViewContainer )
       
    99     {
       
   100     MPX_FUNC( "CMPXCommonContainerAvkonImp::SetViewContainer" );
       
   101     iViewContainer = aViewContainer;
       
   102     }
       
   103 
       
   104 // ---------------------------------------------------------------------------
       
   105 // Set command observer for the container
       
   106 // ---------------------------------------------------------------------------
       
   107 //
       
   108 void CMPXCommonContainerAvkonImp::SetCommandObserver(    
       
   109     MEikCommandObserver* aCommandObserver )
       
   110     {
       
   111     MPX_FUNC( "CMPXCommonContainerAvkonImp::SetCommandObserver" );
       
   112     iView = aCommandObserver;
       
   113     }
       
   114 
       
   115 // ---------------------------------------------------------------------------
       
   116 // C++ constructor can NOT contain any code that might leave.
       
   117 // ---------------------------------------------------------------------------
       
   118 //
       
   119 void CMPXCommonContainerAvkonImp::SetListBoxObserver(
       
   120     MEikListBoxObserver* aListBoxObserver )
       
   121     {
       
   122     MPX_FUNC( "CMPXCommonContainerAvkonImp::SetListBoxObserver" );
       
   123     iListBoxObserver = aListBoxObserver;
       
   124     }
       
   125 
       
   126 // ---------------------------------------------------------------------------
       
   127 // Set layout for all elements and set sizes for icons.
       
   128 // ---------------------------------------------------------------------------
       
   129 //
       
   130 void CMPXCommonContainerAvkonImp::UpdateLayout()
       
   131     {        
       
   132     MPX_FUNC( "CMPXCommonContainerAvkonImp::UpdateLayout" );
       
   133     }
       
   134 
       
   135 // -----------------------------------------------------------------------------
       
   136 // Returns a pointer to the listboxarray
       
   137 // -----------------------------------------------------------------------------
       
   138 //
       
   139 CMPXCommonListBoxArrayBase* CMPXCommonContainerAvkonImp::ListBoxArray() const
       
   140     {
       
   141     ASSERT( iListBoxArray );
       
   142     return iListBoxArray;
       
   143     }
       
   144 
       
   145 // -----------------------------------------------------------------------------
       
   146 // Sets listbox array
       
   147 // -----------------------------------------------------------------------------
       
   148 //
       
   149 void CMPXCommonContainerAvkonImp::SetListBoxArrayL(
       
   150     CMPXCommonListBoxArrayBase* aListBoxArray )
       
   151     {
       
   152     iListBoxArray = aListBoxArray;
       
   153     if ( iListBoxArray )
       
   154         {
       
   155         CTextListBoxModel* listboxModel = iListBox->Model();
       
   156         listboxModel->SetItemTextArray( iListBoxArray );
       
   157         listboxModel->SetOwnershipType( ELbmOwnsItemArray );
       
   158         }
       
   159     }
       
   160 
       
   161 // -----------------------------------------------------------------------------
       
   162 // Return number of listbox items shown in the current listbox.
       
   163 // -----------------------------------------------------------------------------
       
   164 //
       
   165 TInt CMPXCommonContainerAvkonImp::CurrentListItemCount() const
       
   166     {
       
   167     MPX_FUNC( "CMPXCommonContainerAvkonImp::CurrentListItemCount" );
       
   168     ASSERT( iFindBoxFilterItems );
       
   169     return iFindBoxFilterItems->FilteredNumberOfItems();
       
   170     }
       
   171 
       
   172 // -----------------------------------------------------------------------------
       
   173 // Return total number of listbox items in the listbox.
       
   174 // -----------------------------------------------------------------------------
       
   175 //
       
   176 TInt CMPXCommonContainerAvkonImp::TotalListItemCount() const
       
   177     {
       
   178     MPX_FUNC( "CMPXCommonContainerAvkonImp::TotalListItemCount" );
       
   179     ASSERT( iFindBoxFilterItems );
       
   180     return iFindBoxFilterItems->NonFilteredNumberOfItems();
       
   181     }
       
   182 
       
   183 // -----------------------------------------------------------------------------
       
   184 // Gets top listbox item index (relative to the original listbox).
       
   185 // -----------------------------------------------------------------------------
       
   186 //
       
   187 TInt CMPXCommonContainerAvkonImp::TopLbxItemIndex() const
       
   188     {
       
   189     MPX_FUNC( "CMPXCommonContainerAvkonImp::TopLbxItemIndex" );
       
   190     ASSERT( iListBox );
       
   191     ASSERT( iFindBoxFilterItems );
       
   192     TInt topItem( iListBox->TopItemIndex() );
       
   193 
       
   194     // Make sure there's at least one item in the listbox
       
   195     if ( iFindBoxFilterItems->FilteredNumberOfItems() )
       
   196         {
       
   197         // Get the real listbox index
       
   198         topItem = iFindBoxFilterItems->FilteredItemIndex( topItem );
       
   199         }
       
   200     return topItem;
       
   201     }
       
   202     
       
   203 // -----------------------------------------------------------------------------
       
   204 // Gets bottom listbox item index (relative to the original listbox).
       
   205 // -----------------------------------------------------------------------------
       
   206 //
       
   207 TInt CMPXCommonContainerAvkonImp::BottomLbxItemIndex() const
       
   208     {
       
   209     MPX_FUNC( "CMPXCommonContainerAvkonImp::BottomLbxItemIndex" );
       
   210     ASSERT( iListBox );
       
   211     ASSERT( iFindBoxFilterItems );
       
   212     TInt bottomItem( iListBox->BottomItemIndex() );
       
   213 
       
   214     // Make sure there's at least one item in the listbox
       
   215     if ( iFindBoxFilterItems->FilteredNumberOfItems() )
       
   216         {
       
   217         // Get the real listbox index
       
   218         bottomItem = iFindBoxFilterItems->FilteredItemIndex( bottomItem );
       
   219         }
       
   220     return bottomItem;
       
   221     }    
       
   222 
       
   223 // -----------------------------------------------------------------------------
       
   224 // Gets current listbox item index (relative to the original listbox).
       
   225 // -----------------------------------------------------------------------------
       
   226 //
       
   227 TInt CMPXCommonContainerAvkonImp::CurrentLbxItemIndex() const
       
   228     {
       
   229     MPX_FUNC( "CMPXCommonContainerAvkonImp::CurrentLbxItemIndex" );    
       
   230     ASSERT( iListBox );
       
   231     ASSERT( iFindBoxFilterItems );
       
   232     TInt currentItem( iListBox->CurrentItemIndex() );
       
   233 
       
   234     // Make sure there's at least one item in the listbox
       
   235     if ( iFindBoxFilterItems->FilteredNumberOfItems() )
       
   236         {
       
   237         // Get the real listbox index
       
   238         currentItem = iFindBoxFilterItems->FilteredItemIndex( currentItem );
       
   239         }
       
   240     return currentItem;
       
   241     }
       
   242 
       
   243 // -----------------------------------------------------------------------------
       
   244 // Get current selected listbox items indices (relative to the original listbox)
       
   245 // -----------------------------------------------------------------------------
       
   246 //
       
   247 const CArrayFix<TInt>* CMPXCommonContainerAvkonImp::
       
   248     CurrentSelectionIndicesL() const
       
   249     {
       
   250     MPX_FUNC( "CMPXCommonContainerAvkonImp::CurrentSelectionIndicesL" );
       
   251     ASSERT( iListBox );
       
   252     ASSERT( iFindBoxFilterItems );
       
   253     const CArrayFix<TInt>* selectionArray( iListBox->SelectionIndexes() );
       
   254 
       
   255     if ( iFindBoxFilterItems->FilteredNumberOfItems() )
       
   256         {
       
   257         // Get the real listbox indices
       
   258         iFindBoxFilterItems->SelectionIndexes()->Reset();
       
   259         iFindBoxFilterItems->UpdateSelectionIndexesL();
       
   260         selectionArray = iFindBoxFilterItems->SelectionIndexes();
       
   261         }
       
   262     return selectionArray;
       
   263     }
       
   264 
       
   265 // -----------------------------------------------------------------------------
       
   266 // Get current selected listbox items indices (relative to the original listbox)
       
   267 // -----------------------------------------------------------------------------
       
   268 //
       
   269 void CMPXCommonContainerAvkonImp::SetCurrentSelectionIndicesL(
       
   270     CArrayFix<TInt>* aIndices ) const
       
   271     {
       
   272     MPX_FUNC( "CMPXCommonContainerAvkonImp::SetCurrentSelectionIndicesL" );    
       
   273     ASSERT( iListBox );
       
   274     iListBox->SetSelectionIndexesL( aIndices ); // ownership not transfered
       
   275     }
       
   276 
       
   277 // -----------------------------------------------------------------------------
       
   278 // Set top listbox item index.
       
   279 // -----------------------------------------------------------------------------
       
   280 //
       
   281 void CMPXCommonContainerAvkonImp::SetLbxTopItemIndex( TInt aIndex )
       
   282     {
       
   283     MPX_FUNC( "CMPXCommonContainerAvkonImp::SetLbxTopItemIndex" );
       
   284     ASSERT( iListBox );
       
   285     ASSERT( iFindBoxFilterItems );
       
   286     TInt index( iFindBoxFilterItems->VisibleItemIndex( aIndex ) );
       
   287     if ( index == KErrNotFound )
       
   288         {
       
   289         index = 0;
       
   290         }
       
   291     iListBox->SetTopItemIndex( index );
       
   292     }
       
   293 
       
   294 // -----------------------------------------------------------------------------
       
   295 // Set current listbox item index.
       
   296 // -----------------------------------------------------------------------------
       
   297 //
       
   298 void CMPXCommonContainerAvkonImp::SetLbxCurrentItemIndex( TInt aIndex )
       
   299     {
       
   300     MPX_FUNC( "CMPXCommonContainerAvkonImp::SetLbxCurrentItemIndex" );
       
   301     ASSERT( iListBox );
       
   302     ASSERT( iFindBoxFilterItems );
       
   303     TInt index( iFindBoxFilterItems->VisibleItemIndex( aIndex ) );
       
   304     if ( index == KErrNotFound )
       
   305         {
       
   306         index = 0;
       
   307         }
       
   308     iListBox->SetCurrentItemIndex( index );
       
   309     }
       
   310 
       
   311 // -----------------------------------------------------------------------------
       
   312 // Set current listbox item index and highlight it.
       
   313 // -----------------------------------------------------------------------------
       
   314 //
       
   315 void CMPXCommonContainerAvkonImp::SetLbxCurrentItemIndexAndDraw( 
       
   316     TInt aIndex )
       
   317     {
       
   318     MPX_FUNC( "CMPXCommonContainerAvkonImp::SetLbxCurrentItemIndexAndDraw" );
       
   319     ASSERT( iListBox );
       
   320     ASSERT( iFindBoxFilterItems );
       
   321     TInt index( iFindBoxFilterItems->VisibleItemIndex( aIndex ) );
       
   322     if ( index == KErrNotFound )
       
   323         {
       
   324         index = 0;
       
   325         }
       
   326     iListBox->SetCurrentItemIndexAndDraw( index );
       
   327     }
       
   328 
       
   329 // -----------------------------------------------------------------------------
       
   330 // Clear listbox selection.
       
   331 // -----------------------------------------------------------------------------
       
   332 //
       
   333 void CMPXCommonContainerAvkonImp::ClearLbxSelection()
       
   334     {
       
   335     MPX_FUNC( "CMPXCommonContainerAvkonImp::ClearLbxSelection" );
       
   336     ASSERT( iListBox );
       
   337     ASSERT( iFindBoxFilterItems );
       
   338     iListBox->ClearSelection();
       
   339     iFindBoxFilterItems->SelectionIndexes()->Reset();
       
   340     }
       
   341 
       
   342 // -----------------------------------------------------------------------------
       
   343 // Sets the text for an empty list box
       
   344 // -----------------------------------------------------------------------------
       
   345 //
       
   346 void CMPXCommonContainerAvkonImp::SetLbxEmptyTextL( const TDesC& aText )
       
   347     {
       
   348     ASSERT( iListBox );
       
   349     iListBox->View()->SetListEmptyTextL( aText );
       
   350     }
       
   351 
       
   352 // -----------------------------------------------------------------------------
       
   353 // Draws a list box item
       
   354 // -----------------------------------------------------------------------------
       
   355 //
       
   356 void CMPXCommonContainerAvkonImp::DrawLbxItem( TInt aIndex )
       
   357     {
       
   358     ASSERT( iListBox );
       
   359     TInt topIndex( TopLbxItemIndex() );
       
   360     TInt bottomIndex( BottomLbxItemIndex() );
       
   361     if ( aIndex >= topIndex && aIndex <= bottomIndex )
       
   362         {
       
   363         iListBox->DrawItem( aIndex );
       
   364         }
       
   365     }
       
   366 
       
   367 // -----------------------------------------------------------------------------
       
   368 // Set Find box's focus.
       
   369 // -----------------------------------------------------------------------------
       
   370 //
       
   371 void CMPXCommonContainerAvkonImp::SetFindBoxFocus( TBool aFocus )
       
   372     {
       
   373     MPX_FUNC( "CMPXCommonContainerAvkonImp::SetFindBoxFocus" );
       
   374     ASSERT( iFindBox );
       
   375     if ( aFocus )
       
   376         {
       
   377         iFindBox->MakeVisible( ETrue );
       
   378         }
       
   379     iFindBox->SetFocus( aFocus );
       
   380     }
       
   381 
       
   382 // -----------------------------------------------------------------------------
       
   383 // Handle listbox item addition.
       
   384 // -----------------------------------------------------------------------------
       
   385 //
       
   386 void CMPXCommonContainerAvkonImp::HandleLbxItemAdditionL()
       
   387     {
       
   388     MPX_FUNC( "CMPXCommonContainerAvkonImp::HandleLbxItemAdditionL" );
       
   389     ASSERT( iListBox );
       
   390     ASSERT( iFindBoxFilterItems );
       
   391     iFindBoxFilterItems->HandleItemArrayChangeL();
       
   392     iListBox->HandleItemAdditionL();
       
   393     }
       
   394     
       
   395 // -----------------------------------------------------------------------------
       
   396 // Handle listbox item addition, preserving the current display index
       
   397 // -----------------------------------------------------------------------------
       
   398 //
       
   399 void CMPXCommonContainerAvkonImp::HandleLbxItemAdditionPreserveIndexL()
       
   400     {        
       
   401     MPX_FUNC( "CMPXCommonContainerAvkonImp::HandleLbxItemAdditionPreserveIndexL" );
       
   402     TInt currentItem( CurrentLbxItemIndex() );
       
   403     TInt currentBottomIndex( BottomLbxItemIndex() );
       
   404     TInt topIndex( CalculateTopIndex( currentBottomIndex ) );
       
   405     HandleLbxItemAdditionL();
       
   406     if ( currentItem > 0 )
       
   407         {
       
   408         // only redraw if the selected index is > 0, since 
       
   409         // HandleLbxItemAdditionL already redraws it and set index
       
   410         // to 0
       
   411         SetLbxTopItemIndex( topIndex );
       
   412         SetLbxCurrentItemIndexAndDraw( currentItem );
       
   413         }
       
   414     }
       
   415 
       
   416 // -----------------------------------------------------------------------------
       
   417 // Handle listbox item removal.
       
   418 // -----------------------------------------------------------------------------
       
   419 //
       
   420 void CMPXCommonContainerAvkonImp::HandleLbxItemRemovalL()
       
   421     {
       
   422     MPX_FUNC( "CMPXCommonContainerAvkonImp::HandleLbxItemRemovalL" );
       
   423     ASSERT( iListBox );
       
   424     iListBox->HandleItemRemovalL();
       
   425     }
       
   426     
       
   427 // -----------------------------------------------------------------------------
       
   428 // Show/hide find box.
       
   429 // -----------------------------------------------------------------------------
       
   430 //
       
   431 void CMPXCommonContainerAvkonImp::SetFindBoxVisibilityL( TBool aIsVisible )
       
   432     {
       
   433     MPX_FUNC( "CMPXCommonContainerAvkonImp::SetFindBoxVisibilityL" );
       
   434     ASSERT( iListBox );
       
   435     ASSERT( iFindBox );
       
   436     if (aIsVisible != iFindBox->IsVisible())
       
   437         {
       
   438         iFindBox->MakeVisible( aIsVisible );
       
   439         iFindBox->SetFocus( aIsVisible );
       
   440         if ( !aIsVisible )
       
   441             {
       
   442             iFindBox->ResetL();
       
   443             iFindBoxFilterItems->HandleOfferkeyEventL();
       
   444             iListBox->SetFocus( ETrue );
       
   445             }
       
   446         SizeChanged();
       
   447         DrawDeferred();
       
   448         }
       
   449     }
       
   450 
       
   451 // -----------------------------------------------------------------------------
       
   452 // Determine find box visibility
       
   453 // -----------------------------------------------------------------------------
       
   454 //
       
   455 TBool CMPXCommonContainerAvkonImp::FindBoxVisibility()
       
   456     {
       
   457     MPX_FUNC( "CMPXCommonContainerAvkonImp::FindBoxVisibility" );
       
   458     ASSERT( iFindBox );
       
   459     return iFindBox->IsVisible();
       
   460     }
       
   461 
       
   462 // -----------------------------------------------------------------------------
       
   463 // Restore the PopupCBA of find box
       
   464 // -----------------------------------------------------------------------------
       
   465 //
       
   466 void CMPXCommonContainerAvkonImp::RestoreFindBoxPopupCBA()
       
   467     {
       
   468     MPX_FUNC( "CMPXCommonContainerAvkonImp::RestoreFindBoxPopupCBA" );
       
   469     ASSERT( iFindBox );
       
   470     iFindBox->SetFocus( ETrue );
       
   471     iFindBox->SetFocus( EFalse );
       
   472     }
       
   473     
       
   474 // -----------------------------------------------------------------------------
       
   475 // Calculate the top index of the visible items
       
   476 // -----------------------------------------------------------------------------
       
   477 //    
       
   478 TInt CMPXCommonContainerAvkonImp::CalculateTopIndex( TInt aBottomIndex )
       
   479     {
       
   480     MPX_FUNC( "CMPXCommonContainerAvkonImp::CalculateTopIndex" );
       
   481     ASSERT( iListBox );
       
   482     TInt numItems( iListBox->View()->NumberOfItemsThatFitInRect( 
       
   483         iListBox->View()->ViewRect() ) - 1 ); // to make it 0 based
       
   484     return ( ( aBottomIndex > numItems ) ? aBottomIndex - numItems : 0 );
       
   485     }
       
   486 
       
   487 // ---------------------------------------------------------------------------
       
   488 // Symbian 2nd phase constructor can leave.
       
   489 // ---------------------------------------------------------------------------
       
   490 //
       
   491 void CMPXCommonContainerAvkonImp::ConstructContainerL( TMPXCommonContainerCollectionType /*aCollectionType*/ )
       
   492     {
       
   493     MPX_FUNC( "CMPXCommonContainerAvkonImp::ConstructContainerL" );    
       
   494     
       
   495     CCoeEnv* coeEnv( iEikonEnv );
       
   496     TParse parse;
       
   497     parse.Set( KMPXCommonContainerRscPath, &KDC_APP_RESOURCE_DIR, NULL );
       
   498     TFileName resourceFile( parse.FullName() );
       
   499     User::LeaveIfError( MPXUser::CompleteWithDllPath( resourceFile ) );
       
   500     BaflUtils::NearestLanguageFile( coeEnv->FsSession(), resourceFile );
       
   501     iResourceOffset = coeEnv->AddResourceFileL( resourceFile );    
       
   502     
       
   503     CreateWindowL();
       
   504     
       
   505     CreateListBoxL();
       
   506     
       
   507     FeatureManager::InitializeLibL();
       
   508     
       
   509     ConstructFindBoxL( ETrue );                
       
   510     }
       
   511 
       
   512 // ---------------------------------------------------------------------------
       
   513 // Enable/disable find box  
       
   514 // ---------------------------------------------------------------------------
       
   515 //
       
   516 void CMPXCommonContainerAvkonImp::EnableFindBox( TBool aEnable )
       
   517     {
       
   518     MPX_FUNC( "CMPXCommonContainerAvkonImp::EnableFindBox" );    
       
   519     iIsFindEnabled = aEnable;
       
   520     if ( !aEnable )
       
   521         {
       
   522         TRAP_IGNORE(SetFindBoxVisibilityL( EFalse ));
       
   523         };
       
   524     }
       
   525 
       
   526 // ---------------------------------------------------------------------------
       
   527 // Enable/disable marking  
       
   528 // ---------------------------------------------------------------------------
       
   529 //
       
   530 void CMPXCommonContainerAvkonImp::EnableMarking( TBool aEnable )
       
   531     {
       
   532     MPX_FUNC( "CMPXCommonContainerAvkonImp::EnableMarking" );    
       
   533     iIsMarkingEnabled = aEnable;
       
   534     }
       
   535     
       
   536 // ---------------------------------------------------------------------------
       
   537 // Custom handling of commands for markable lists.
       
   538 // ---------------------------------------------------------------------------
       
   539 //
       
   540 void CMPXCommonContainerAvkonImp::HandleMarkableListProcessCommandL( TInt aCommand )
       
   541     {
       
   542     MPX_FUNC( "CMPXCommonContainerAvkonImp::HandleMarkableListProcessCommandL" );
       
   543     ASSERT( iListBox );
       
   544 
       
   545     // Handle in helper function
       
   546     AknSelectionService::HandleMarkableListProcessCommandL(
       
   547         aCommand,
       
   548         iListBox );
       
   549     }
       
   550 
       
   551 // ---------------------------------------------------------------------------
       
   552 // Custom handling of menu pane for markable lists
       
   553 // ---------------------------------------------------------------------------
       
   554 //
       
   555 void CMPXCommonContainerAvkonImp::HandleMarkableListDynInitMenuPane(
       
   556     TInt aResourceId,
       
   557     CEikMenuPane* aMenuPane )
       
   558     {
       
   559     MPX_FUNC( "CMPXCommonContainerAvkonImp::HandleMarkableListDynInitMenuPane" );
       
   560     ASSERT( iListBox );
       
   561     
       
   562     // Handle in helper function
       
   563     AknSelectionService::HandleMarkableListDynInitMenuPane(
       
   564         aResourceId,
       
   565         aMenuPane,
       
   566         iListBox );
       
   567     }
       
   568     
       
   569 // ---------------------------------------------------------------------------
       
   570 // Handles key events.
       
   571 // ---------------------------------------------------------------------------
       
   572 //
       
   573 TKeyResponse CMPXCommonContainerAvkonImp::HandleKeyEventL(
       
   574     const TKeyEvent& aKeyEvent,
       
   575     TEventCode aType )
       
   576     {
       
   577     ASSERT( iListBox );
       
   578     ASSERT( iFindBox );
       
   579     MPX_DEBUG5( "CMPXCommonContainerAvkonImp::HandleKeyEventL(iCode=%d, iScanCode=%d, iModifiers=0x%x, aType=%d)", 
       
   580         aKeyEvent.iCode, aKeyEvent.iScanCode, aKeyEvent.iModifiers, aType );
       
   581 
       
   582     TKeyResponse response( EKeyWasNotConsumed );
       
   583 
       
   584     // Pass the key event to the common container components
       
   585     if ( iIsFindEnabled &&
       
   586         ( ( iFindBox->IsVisible() ) || 
       
   587             ( aKeyEvent.iCode != EKeyBackspace ) ) )
       
   588         {
       
   589         TBool needRefresh( EFalse );
       
   590 
       
   591         if ( aKeyEvent.iCode == EKeyBackspace && 
       
   592             iFindBox->TextLength() == 0 )
       
   593             {
       
   594             // dismiss find box
       
   595             SetFindBoxVisibilityL( EFalse );
       
   596             response = EKeyWasConsumed;
       
   597             }
       
   598         else
       
   599             {
       
   600             // Offers the key event to find box.
       
   601             response = AknFind::HandleFindOfferKeyEventL( 
       
   602                 aKeyEvent, aType, this, iListBox, iFindBox, iIsFindPopup, 
       
   603                 needRefresh );
       
   604             }        
       
   605 
       
   606         if ( response == EKeyWasConsumed )
       
   607             {
       
   608             if ( needRefresh )
       
   609                 {
       
   610                 SizeChanged();
       
   611                 DrawNow();
       
   612                 }
       
   613             // If it's consumed by the findbox, there's no need to check
       
   614             // with listbox.
       
   615             return response;
       
   616             }
       
   617         }
       
   618     if ( ( aKeyEvent.iCode != EKeyLeftArrow ) && 
       
   619         ( aKeyEvent.iCode != EKeyRightArrow ) &&
       
   620         ( aKeyEvent.iCode != EKeyBackspace ) )
       
   621         {            
       
   622         // now it's iListBox's job to process the key event            
       
   623         if ( !iIsMarkingEnabled && 
       
   624             ( aKeyEvent.iCode == EKeyUpArrow || 
       
   625                 aKeyEvent.iCode == EKeyDownArrow ||
       
   626                 aKeyEvent.iCode == EKeyOK ) )
       
   627             {
       
   628             // if marking is not enabled, check if this is marking command 
       
   629             if ( aKeyEvent.iModifiers & EModifierLeftShift ||
       
   630                 aKeyEvent.iModifiers & EModifierRightShift ||
       
   631                 aKeyEvent.iModifiers & EModifierShift )
       
   632                 {
       
   633                 // strip the marking command, and let list box handle it
       
   634                 TKeyEvent modKeyEvent( aKeyEvent );
       
   635                 modKeyEvent.iModifiers &= ~EModifierLeftShift;
       
   636                 modKeyEvent.iModifiers &= ~EModifierRightShift;
       
   637                 modKeyEvent.iModifiers &= ~EModifierShift;
       
   638                 response = iLbxExtFeat->HandleLbxKeyEventL( modKeyEvent, aType );                    
       
   639                 }
       
   640             else
       
   641                 {
       
   642                 // not marking command
       
   643                 response = iLbxExtFeat->HandleLbxKeyEventL( aKeyEvent, aType );
       
   644                 }
       
   645             }
       
   646         else // marking is enabled
       
   647             {
       
   648             response = iLbxExtFeat->HandleLbxKeyEventL( aKeyEvent, aType );
       
   649     
       
   650 #ifdef __ENABLE_MSK
       
   651             // check for marking command 
       
   652             if ( ( aKeyEvent.iModifiers & EModifierLeftShift ||
       
   653                 aKeyEvent.iModifiers & EModifierRightShift ||
       
   654                 aKeyEvent.iModifiers & EModifierShift ||
       
   655                 aKeyEvent.iScanCode == EStdKeyDevice3 ||
       
   656                 iIsFindPopup ) && aType == EEventKeyUp )
       
   657                 {
       
   658                 // Update the middle softkey for marking commands
       
   659                 iView->ProcessCommandL( EMPXCmdCommonUpdateMiddleSoftKey );
       
   660                 }
       
   661 #endif // __ENABLE_MSK
       
   662             }
       
   663         }
       
   664         
       
   665     if ( response == EKeyWasNotConsumed && 
       
   666          aType == EEventKey && 
       
   667          aKeyEvent.iCode == EKeyBackspace && iView )
       
   668         {
       
   669         iView->ProcessCommandL( EMPXCmdCommonDelete );
       
   670         response = EKeyWasConsumed;
       
   671         }
       
   672     
       
   673     return response;
       
   674     }
       
   675 
       
   676 // ---------------------------------------------------------------------------
       
   677 // Activate container
       
   678 // ---------------------------------------------------------------------------
       
   679 //
       
   680 void CMPXCommonContainerAvkonImp::ActivateContainerL()
       
   681     {
       
   682     // Activate the container via Coe Control
       
   683     CCoeControl::ActivateL();
       
   684     iContainerActive = ETrue;
       
   685     }
       
   686 
       
   687 // ---------------------------------------------------------------------------
       
   688 // Deactivate container
       
   689 // ---------------------------------------------------------------------------
       
   690 //
       
   691 void CMPXCommonContainerAvkonImp::DeactivateContainerL()
       
   692     {
       
   693     iContainerActive = EFalse;
       
   694     }
       
   695 
       
   696 // ---------------------------------------------------------------------------
       
   697 // Return container state
       
   698 // ---------------------------------------------------------------------------
       
   699 //
       
   700 TBool CMPXCommonContainerAvkonImp::IsContainerActive()
       
   701     {
       
   702     return iContainerActive;
       
   703     }
       
   704 
       
   705 // ---------------------------------------------------------------------------
       
   706 // From MMPXCommonListBoxArrayObserver
       
   707 // Handle listbox array events.
       
   708 // ---------------------------------------------------------------------------
       
   709 //
       
   710 void CMPXCommonContainerAvkonImp::HandleListBoxArrayEventL( 
       
   711     MMPXCommonListBoxArrayObserver::TMPXCommonListBoxArrayEvents aEvent )
       
   712     {
       
   713     MPX_FUNC( "CMPXCommonContainerAvkonImp::HandleListBoxArrayEventL" );
       
   714     if ( aEvent == MMPXCommonListBoxArrayObserver::EMPXCommonListBoxArrayEventIconArrayChange )
       
   715         {
       
   716         delete iIconArray;
       
   717         iIconArray = NULL;
       
   718         CreateIconArrayL();
       
   719         static_cast<CEikColumnListBox*>( iListBox )->ItemDrawer()->ColumnData()->
       
   720             SetIconArray( iIconArray );
       
   721         }
       
   722     }
       
   723 
       
   724 // ---------------------------------------------------------------------------
       
   725 // From CCoeControl
       
   726 // Responds to changes to the size and position of the contents of this 
       
   727 // control.
       
   728 // ---------------------------------------------------------------------------
       
   729 //
       
   730 void CMPXCommonContainerAvkonImp::SizeChanged()
       
   731     {
       
   732     MPX_FUNC( "CMPXCommonContainerAvkonImp::SizeChanged" );
       
   733 
       
   734     if ( iIsFindPopup )
       
   735         {
       
   736         AknFind::HandlePopupFindSizeChanged( 
       
   737             this, 
       
   738             static_cast<CAknColumnListBox*>( iListBox ), 
       
   739             iFindBox );                
       
   740         }
       
   741     else
       
   742         {
       
   743         AknFind::HandleFixedFindSizeChanged( 
       
   744             this, 
       
   745             static_cast<CAknColumnListBox*>( iListBox ), 
       
   746             iFindBox );
       
   747         }
       
   748     }
       
   749 
       
   750 // ---------------------------------------------------------------------------
       
   751 // From CCoeControl
       
   752 // Gets the number of controls contained in a compound control.
       
   753 // ---------------------------------------------------------------------------
       
   754 //
       
   755 TInt CMPXCommonContainerAvkonImp::CountComponentControls() const
       
   756     {
       
   757     MPX_FUNC( "CMPXCommonContainerAvkonImp::CountComponentControls" );
       
   758     ASSERT( iListBox );
       
   759     ASSERT( iFindBox );
       
   760     return 2; // number of components
       
   761     }
       
   762 
       
   763 // ---------------------------------------------------------------------------
       
   764 // From CCoeControl
       
   765 // Gets an indexed component of a compound control.
       
   766 // ---------------------------------------------------------------------------
       
   767 //
       
   768 CCoeControl* CMPXCommonContainerAvkonImp::ComponentControl( TInt aIndex ) const
       
   769     {
       
   770     MPX_FUNC( "CMPXCommonContainerAvkonImp::ComponentControl" );
       
   771     CCoeControl* control( NULL );
       
   772     switch ( aIndex )
       
   773         {
       
   774         case 0:
       
   775             {
       
   776             control = iListBox; // Returns the pointer to listbox object.            
       
   777             break;
       
   778             }        
       
   779         case 1:
       
   780             {
       
   781             control = iFindBox; // Returns the pointer to findbox object.
       
   782             break;
       
   783             }
       
   784         default:
       
   785             {
       
   786             MPX_DEBUG1( "CMPXCommonContainerAvkonImp::ComponentControl out of range" );
       
   787             ASSERT( 0 );
       
   788             break;
       
   789             }
       
   790         }
       
   791     return control;
       
   792     }
       
   793 
       
   794 // ---------------------------------------------------------------------------
       
   795 // From CCoeControl
       
   796 // Handles key events.
       
   797 // ---------------------------------------------------------------------------
       
   798 //
       
   799 TKeyResponse CMPXCommonContainerAvkonImp::OfferKeyEventL(
       
   800     const TKeyEvent& aKeyEvent,
       
   801     TEventCode aType )
       
   802     {
       
   803     ASSERT( iViewContainer );
       
   804     MPX_DEBUG5( "CMPXCommonContainerAvkonImp::OfferKeyEventL(iCode=%d, iScanCode=%d, iModifiers=0x%x, aType=%d)", 
       
   805         aKeyEvent.iCode, aKeyEvent.iScanCode, aKeyEvent.iModifiers, aType );
       
   806 
       
   807     // Let the view container handle the key event.
       
   808     return iViewContainer->HandleKeyEventL( aKeyEvent, aType );
       
   809     }
       
   810 
       
   811 // ---------------------------------------------------------------------------
       
   812 // Gets the control's help context.
       
   813 // ---------------------------------------------------------------------------
       
   814 //
       
   815 void CMPXCommonContainerAvkonImp::GetHelpContext( 
       
   816     TCoeHelpContext& aContext ) const
       
   817     {
       
   818     ASSERT( iViewContainer );
       
   819     MPX_FUNC( "CMPXCommonContainerAvkonImp::GetHelpContext" );
       
   820     // Let the view container handle the help context retrieval
       
   821     iViewContainer->HandleHelpContext( aContext );
       
   822     }
       
   823 
       
   824 // ---------------------------------------------------------------------------
       
   825 // From CCoeControl
       
   826 // Handles a change to the control's resources.
       
   827 // ---------------------------------------------------------------------------
       
   828 //
       
   829 void CMPXCommonContainerAvkonImp::HandleResourceChange( TInt aType )
       
   830     {
       
   831     MPX_FUNC( "CMPXCommonContainerAvkonImp::HandleResourceChange" );
       
   832     CCoeControl::HandleResourceChange( aType );
       
   833     
       
   834     TRAP_IGNORE(
       
   835         if ( aType == KAknsMessageSkinChange )
       
   836             {
       
   837             delete iIconArray;
       
   838             iIconArray = NULL;
       
   839             CreateIconArrayL();          
       
   840             static_cast<CEikColumnListBox*>( iListBox )->ItemDrawer()->ColumnData()->
       
   841                 SetIconArray( iIconArray );
       
   842             }
       
   843         else if ( aType == KEikDynamicLayoutVariantSwitch && iView )
       
   844             {                        
       
   845             iView->ProcessCommandL( EMPXCmdCommonResourceChange );
       
   846             } );    
       
   847     }
       
   848 
       
   849 // ---------------------------------------------------------------------------
       
   850 // Create list box
       
   851 // ---------------------------------------------------------------------------
       
   852 //
       
   853 void CMPXCommonContainerAvkonImp::CreateListBoxL()
       
   854     {
       
   855     MPX_FUNC( "CMPXCommonContainerAvkonImp::CreateListBox" );
       
   856     
       
   857     iListBox = new ( ELeave ) CAknSingleGraphicStyleListBox();    
       
   858     iListBox->SetContainerWindowL( *this ); 
       
   859     iListBox->CreateScrollBarFrameL( ETrue );
       
   860     iListBox->ScrollBarFrame()->SetScrollBarVisibilityL( 
       
   861         CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto );
       
   862 
       
   863     TResourceReader reader;
       
   864     iCoeEnv->CreateResourceReaderLC( reader, R_MPX_COMMON_CONTAINER_LBX );
       
   865     // construct's iListBox from resource file
       
   866     iListBox->ConstructFromResourceL( reader );
       
   867     CleanupStack::PopAndDestroy(); // reader
       
   868     
       
   869     // Enable Marquee
       
   870     CEikColumnListBox* eikListbox = static_cast<CEikColumnListBox*>( iListBox );
       
   871     eikListbox->EnableExtendedDrawingL();
       
   872     eikListbox->ItemDrawer()->ColumnData()->EnableMarqueeL( ETrue );
       
   873     eikListbox->ItemDrawer()->ColumnData()->SetMarqueeParams(
       
   874         KMaxTInt, 6, 1000000); // Magic: loop forever, other params as default
       
   875 
       
   876     iListBox->SetListBoxObserver( iListBoxObserver );
       
   877 
       
   878     // Speed Scrolling
       
   879     delete iLbxExtFeat;
       
   880     iLbxExtFeat = NULL;
       
   881     iLbxExtFeat = CMPXLbxExtendedFeatures::NewL( iListBox, ETrue );
       
   882     iLbxExtFeat->EnableSpeedScrollL( ETrue );
       
   883     
       
   884     }
       
   885 
       
   886 // -----------------------------------------------------------------------------
       
   887 // Constructs Find box.
       
   888 // -----------------------------------------------------------------------------
       
   889 //
       
   890 void CMPXCommonContainerAvkonImp::ConstructFindBoxL( TBool aIsFindPopup )
       
   891     {
       
   892     MPX_FUNC( "CMPXCommonContainerAvkonImp::ConstructFindBoxL" );
       
   893     CAknFilteredTextListBoxModel* lbxModel = 
       
   894         static_cast<CAknFilteredTextListBoxModel*>( iListBox->Model() );
       
   895 
       
   896     iIsFindPopup = aIsFindPopup;
       
   897 
       
   898     CAknSearchField::TSearchFieldStyle flag( 
       
   899         iIsFindPopup ? CAknSearchField::EPopup : CAknSearchField::ESearch );
       
   900 
       
   901     iFindBox = CAknSearchField::NewL( 
       
   902         *this, flag, NULL, KMPXFindboxTextLimit );
       
   903     lbxModel->CreateFilterL( iListBox, iFindBox );
       
   904     iFindBoxFilterItems = lbxModel->Filter();
       
   905 
       
   906     // Limit Japanese input modes
       
   907     if ( FeatureManager::FeatureSupported( KFeatureIdJapanese ) )
       
   908         {
       
   909         CEikEdwin& findEditor = iFindBox->Editor();
       
   910        
       
   911         findEditor.SetAknEditorInputMode( EAknEditorKatakanaInputMode );
       
   912        
       
   913         findEditor.SetAknEditorAllowedInputModes(
       
   914             EAknEditorKatakanaInputMode |
       
   915             EAknEditorHalfWidthTextInputMode |
       
   916             EAknEditorNumericInputMode );
       
   917         }
       
   918 
       
   919     if ( iIsFindPopup )
       
   920         {
       
   921         SetFindBoxVisibilityL( EFalse );
       
   922         }
       
   923 
       
   924     }
       
   925 
       
   926 // -----------------------------------------------------------------------------
       
   927 // Creates icon array, populates iIconArray to be used by listbox
       
   928 // -----------------------------------------------------------------------------
       
   929 //
       
   930 void CMPXCommonContainerAvkonImp::CreateIconArrayL()
       
   931     {
       
   932     if ( iListBoxArray )
       
   933         {
       
   934         iIconArray = iListBoxArray->CreateIconArrayL();
       
   935         }
       
   936     }   
       
   937 
       
   938 //  End of File