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:  MuiuDynamicSettingsDialog.cpp

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include <e32base.h>

    22 #include <eiktxlbx.h>               // CEikTextListBox

    23 #include <badesca.h>                // CDesCArray

    24 #include <eiktxlbm.h>               // CTextListBoxModel

    25 #include <AknUtils.h>               // CAknTextUtils

    26 #include <akntitle.h>               // CAknTitlePane

    27 #include <AknQueryDialog.h>         // CAknQueryDialog

    28 #include <aknsettingpage.h>         // CAknSettingPage

    29 #include <aknradiobuttonsettingpage.h> // CAknRadioButtonSettingPage

    30 #include <aknpasswordsettingpage.h> // CAknPasswordSettingPage

    31 #include <akntextsettingpage.h>     // CAknTextSettingPage

    32 #include <eikbtgpc.h>               // CEikButtonGroupContainer

    33 #include <StringLoader.h>           // StringLoader

    34 #include "MuiuDynamicSettingsDialog.h" // CMuiuDynamicSettingsDialog

    35 #include "IMSWCheckBoxPage.h"   // CIMSSettingsWizardCheckBoxPage

    36 

    37 #include <muiu_internal.rsg>

    38 #include <ImumUtils.rsg>                 // R_IMAS_MSK_OPEN, should be temporary

    39 

    40 // EXTERNAL DATA STRUCTURES

    41 // EXTERNAL FUNCTION PROTOTYPES

    42 // CONSTANTS

    43 

    44 // Prevent any looping problems by defining maximum amount of editor openings

    45 const TInt KMuiuMaxEditors = 100;

    46 

    47 // MACROS

    48 // LOCAL CONSTANTS AND MACROS

    49 // MODULE DATA STRUCTURES

    50 // LOCAL FUNCTION PROTOTYPES

    51 // FORWARD DECLARATIONS

    52 

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

    54 

    55 // ----------------------------------------------------------------------------

    56 // CMuiuDynamicSettingsDialog::CMuiuDynamicSettingsDialog()

    57 // ----------------------------------------------------------------------------

    58 //

    59 CMuiuDynamicSettingsDialog::CMuiuDynamicSettingsDialog(

    60     CEikFormattedCellListBox& aListBox,

    61     CAknTitlePane& aTitlePane )

    62     :

    63     CMuiuDynamicSettingsArray(),

    64     iListBox( aListBox ),

    65     iTitlePane( aTitlePane ),

    66     iSettingValue( KErrNotFound )

    67     {

    68     }

    69 

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

    71 // CMuiuDynamicSettingsDialog::~CMuiuDynamicSettingsDialog()

    72 // ----------------------------------------------------------------------------

    73 //

    74 CMuiuDynamicSettingsDialog::~CMuiuDynamicSettingsDialog()

    75     {

    76     // Remove the scrollbar from listbox

    77     iListBox.SetScrollBarFrame( NULL, CEikListBox::EOwnedExternally );

    78 

    79     if ( iSoftkeys )

    80         {

    81         iSoftkeys->SetObserver( EFalse, EFalse, EFalse, *this );

    82         delete iSoftkeys;

    83         }

    84     iSoftkeys = NULL;

    85 

    86     delete iSettingPageResources;

    87     iSettingPageResources = NULL;

    88 

    89     if ( iSettingsLastItemIndex )

    90         {

    91         iSettingsLastItemIndex->Reset();

    92         }

    93 

    94     delete iSettingsLastItemIndex;

    95     iSettingsLastItemIndex = NULL;

    96 

    97     if ( iCheckboxArray )

    98         {

    99         iCheckboxArray->ResetAndDestroy();

   100         }

   101 

   102     if ( iSettingsPageArray )

   103         {

   104         iSettingsPageArray->Reset();

   105         }

   106 

   107     if ( iBackupArray )

   108         {

   109         iBackupArray->ResetAndDestroy();

   110         }

   111 

   112     delete iBackupArray;

   113     iBackupArray = NULL;

   114     delete iSettingsPageArray;

   115     iSettingsPageArray = NULL;

   116     delete iCheckboxArray;

   117     iCheckboxArray = NULL;

   118     delete iOldTitleText;

   119     iOldTitleText = NULL;

   120     delete iQueryDialog;

   121     iQueryDialog = NULL;

   122     delete iSettingPage;

   123     iSettingPage = NULL;

   124     delete iButtonArray;

   125     iButtonArray = NULL;

   126     delete iSettingText;

   127     iSettingText = NULL;

   128     delete iNewPassword;

   129     iNewPassword = NULL;

   130     delete iOldPassword;

   131     iOldPassword = NULL;

   132     iScrollBar = NULL;

   133     }

   134 

   135 // ----------------------------------------------------------------------------

   136 // CMuiuDynamicSettingsDialog::SettingsConstructL()

   137 // ----------------------------------------------------------------------------

   138 //

   139 void CMuiuDynamicSettingsDialog::SettingsConstructL(

   140     CEikButtonGroupContainer& aSoftkeys,

   141     const TInt aResource,

   142     const TBool aUpdateMSK,

   143     const TBool aLockedSettings )

   144     {

   145     BaseConstructL( aResource, aLockedSettings );

   146 

   147     // Set as observer

   148     iListBox.SetListBoxObserver( this );

   149     iListBox.View()->SetListEmptyTextL( KNullDesC );

   150 

   151     // Get scrollbar

   152     iScrollBar = iListBox.CreateScrollBarFrameL( ETrue );

   153     iScrollBar->SetScrollBarVisibilityL(

   154         CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto );

   155 

   156     // Create array

   157     CTextListBoxModel* model = iListBox.Model();

   158     model->SetItemTextArray( this );

   159     model->SetOwnershipType( ELbmDoesNotOwnItemArray );

   160 

   161     // Set this dialog for button listening

   162     iSoftkeys = CIMSSoftkeyControl::NewL( aSoftkeys );

   163     iSoftkeys->SetObserver( ETrue, ETrue, ETrue, *this );

   164     iSoftkeys->SetMSKLabelling( aUpdateMSK );

   165     UpdateMskL();

   166 

   167     // Prepare setting page arrays

   168     iSettingPageResources = CIMSPageResourceControl::NewL();

   169     iSettingsLastItemIndex =

   170         new ( ELeave ) CMuiuDynSetIntArray( KMuiuDynArrayGranularity );

   171 

   172     // Add array to store the backup items

   173     iBackupArray = new ( ELeave ) CMuiuDynSetItemArray( KMuiuDynArrayGranularity );

   174 

   175     // Define setting pages in enumeration order

   176     iSettingPageResources->CreateStackL( R_MUIU_SETTINGS_DIALOG_LISTBOX );

   177     iSettingPageResources->CreateStackL( R_MUIU_SETTINGS_DIALOG_CHECKLISTBOX );

   178     iSettingPageResources->CreateStackL( R_MUIU_SETTINGS_DIALOG_TEXT );

   179     iSettingPageResources->CreateStackL( R_MUIU_SETTINGS_DIALOG_NUMBER );

   180     iSettingPageResources->CreateStackL( R_MUIU_SETTINGS_DIALOG_SC_NUMBER );

   181     iSettingPageResources->CreateStackL( R_MUIU_SETTINGS_DIALOG_PASSWORD );

   182     iSettingPageResources->CreateStackL( NULL );

   183     }

   184 

   185 // ----------------------------------------------------------------------------

   186 // CMuiuDynamicSettingsDialog::HandleListBoxEventL()

   187 // ----------------------------------------------------------------------------

   188 //

   189 void CMuiuDynamicSettingsDialog::HandleListBoxEventL(

   190     CEikListBox* /* aListBox */,

   191     TListBoxEvent aEventType )

   192     {

   193     switch ( aEventType )

   194         {

   195         // Note for TouchUi. When focused item is tapped, both

   196         // EEventItemClicked and EEventItemDoubleClicked events

   197         // are received. When unfocused item is tapped, EEventItemClicked

   198         // event is received. Double tap to focused item produces

   199         // the same events as a single tap.

   200         case EEventEnterKeyPressed:

   201         case EEventItemDoubleClicked:

   202         case EEventItemActioned:

   203             OpenSettingPageL();

   204             break;

   205 

   206         case EEventItemClicked:

   207         case EEventItemDraggingActioned:

   208             UpdateMskL();

   209             break;

   210         default:

   211             break;

   212         }

   213     }

   214 

   215 // ----------------------------------------------------------------------------

   216 // CMuiuDynamicSettingsDialog::OfferKeyEventL

   217 // ----------------------------------------------------------------------------

   218 //

   219 TKeyResponse CMuiuDynamicSettingsDialog::OfferKeyEventL(

   220     const TKeyEvent& /* aKeyEvent */,

   221     TEventCode aType )

   222     {

   223     if ( aType == EEventKeyUp )

   224         {

   225         UpdateMskL();

   226         }

   227 

   228     return EKeyWasNotConsumed;

   229     }

   230 

   231 // ----------------------------------------------------------------------------

   232 // CMuiuDynamicSettingsDialog::SetTitlePaneTextL()

   233 // ----------------------------------------------------------------------------

   234 //

   235 void CMuiuDynamicSettingsDialog::SetTitlePaneTextL(

   236     const TDesC& aText,

   237     const TBool aSaveCurrent )

   238     {

   239     HBufC* text = aText.Alloc();

   240     CleanupStack::PushL( text );

   241 

   242     if ( aSaveCurrent )

   243         {

   244         delete iOldTitleText;

   245         iOldTitleText = NULL;

   246         iOldTitleText = iTitlePane.Text()->Alloc();

   247         }

   248 

   249     iTitlePane.SetTextL( *text );

   250     CleanupStack::PopAndDestroy( text );

   251     text = NULL;

   252     }

   253 

   254 // ----------------------------------------------------------------------------

   255 // CMuiuDynamicSettingsDialog::SetPreviousTitlePaneText()

   256 // ----------------------------------------------------------------------------

   257 //

   258 void CMuiuDynamicSettingsDialog::SetPreviousTitlePaneText(

   259     const TBool aSaveCurrent )

   260     {

   261     TRAP_IGNORE( SetTitlePaneTextL( *iOldTitleText, aSaveCurrent ) );

   262     }

   263 

   264 /******************************************************************************

   265 

   266     Settingpage opening

   267 

   268     - Find out the item to be edited

   269     - Send start editing event with the item

   270     - Check the item type

   271     - Check the resources

   272     - If no resources available, ask them

   273     - Start editing

   274     - Send end editing event

   275 

   276 ******************************************************************************/

   277 

   278 // ----------------------------------------------------------------------------

   279 // CMuiuDynamicSettingsDialog::OpenSettingPageL()

   280 // ----------------------------------------------------------------------------

   281 //

   282 TMuiuPageResult CMuiuDynamicSettingsDialog::OpenSettingPageL(

   283     const TInt aIndex )

   284     {

   285     // To open setting page, check if the Setting Page index is provided,

   286     // if not get the current item index in array

   287     TInt index = ( aIndex == KErrNotFound ) ?

   288         iListBox.CurrentItemIndex() : aIndex;

   289 

   290     // Search for the item and open it

   291     return SettingPageOpenL( *GetItem( index ) );

   292     }

   293 

   294 // ----------------------------------------------------------------------------

   295 // CMuiuDynamicSettingsDialog::OpenSettingPageL()

   296 // ----------------------------------------------------------------------------

   297 //

   298 TMuiuPageResult CMuiuDynamicSettingsDialog::OpenSettingPageL(

   299     CMuiuSettingBase& aBaseItem )

   300     {

   301     return SettingPageOpenL( aBaseItem );

   302     }

   303 

   304 // ----------------------------------------------------------------------------

   305 // CMuiuDynamicSettingsDialog::SettingPageOpenL()

   306 //

   307 // This function contains the main logic for the setting editor handling

   308 // in the settings dialog. The setting editors are kept opening as long

   309 // as the all the settings are gone through or the editor is dismissed.

   310 // ----------------------------------------------------------------------------

   311 //

   312 TMuiuPageResult CMuiuDynamicSettingsDialog::SettingPageOpenL(

   313     CMuiuSettingBase& aBaseItem )

   314     {

   315     // Don't open the editor for read-only items

   316     if ( aBaseItem.iItemFlags.Flag( EMuiuDynItemReadOnly ) )

   317         {

   318         return EMuiuPageResultReadOnly;

   319         }

   320     else if( aBaseItem.iItemFlags.Flag( EMuiuDynItemLockableSetting ) &&

   321         iArrayFlags.Flag( EMuiuEMailLockedSettings ) )

   322         {

   323         return EMuiuPageResultPageLocked;

   324         }

   325 

   326     // Store current focused item for last item index array

   327     iCurrentItemIndex = iListBox.CurrentItemIndex();

   328 

   329     // Starting editing of the item, do not allow updating during editing

   330     iListBox.MakeVisible( EFalse );

   331     iArrayFlags.ClearFlag( EMuiuDynArrayAllowRefresh );

   332 

   333     // When starting to edit page, send event so that item can be prepared

   334     // for the editing. In case of error, editing won't start

   335     TMuiuPageEventResult eventResult = EventItemEditStartsL( aBaseItem );

   336     TMuiuPageResult result;

   337 

   338     if ( eventResult == EMuiuPageEventResultApproved )

   339         {

   340         // Create the array if it doesn't exist yet

   341         if ( !iSettingsPageArray )

   342             {

   343             iSettingsPageArray = new ( ELeave ) CMuiuDynSetItemArray(

   344                 KMuiuDynArrayGranularity );

   345             }

   346 

   347         // Clear the array and add the editable item to array

   348         CleanBackupArray();

   349         iSettingsPageArray->Reset();

   350         SetCurrentSettingsPage( aBaseItem );

   351         result = SettingsPageOpenCheckL();

   352 

   353         do

   354             {

   355             if ( result == EMuiuPageResultEditing )

   356                 {

   357                 // Open the setting page

   358                 result = SettingPageOpenEditorL();

   359 

   360                 // Do open check. Note that the result can be modified!

   361                 SettingsCheckNextEditorOpen( result );

   362                 }

   363 

   364             // Finish the editing of the item

   365             SettingPageOpenFinishL();

   366             }

   367         while ( result == EMuiuPageResultEditing );

   368         }

   369     else if ( eventResult == EMuiuPageEventResultDisapproved )

   370         {

   371         result = EMuiuPageResultOk;

   372         }

   373     else

   374         {

   375         result = EMuiuPageResultEventCancel;

   376         }

   377 

   378     // Send item edit ends

   379     EventItemEditEndsL( aBaseItem );

   380     aBaseItem.iItemFlags.ClearFlag( EMuiuDynItemOneTimeForceViewOpen );

   381 

   382     iArrayFlags.SetFlag( EMuiuDynArrayAllowRefresh );

   383     iListBox.MakeVisible( ETrue );

   384 

   385     // Update the listbox

   386     Refresh();

   387 

   388     return result;

   389     }

   390 

   391 // ----------------------------------------------------------------------------

   392 // CMuiuDynamicSettingsDialog::EventPrepareSubArrayL()

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

   394 //

   395 TInt CMuiuDynamicSettingsDialog::EventPrepareSubArrayL(

   396     CMuiuSettingBase& aBaseItem,

   397     const TBool aForward )

   398     {

   399     // Check direction in array

   400     if ( aForward )

   401         {

   402         // Store the index and set to beginning

   403         SetSettingsLastItemIndexL( iCurrentItemIndex );

   404         iListBox.SetCurrentItemIndex( 0 );

   405         }

   406     // When going backwards

   407     else

   408         {

   409         // Restore previous index

   410         iListBox.SetCurrentItemIndex( SettingsLastItemIndex() );

   411         }

   412 

   413     return EventSubArrayChangeL( aBaseItem );

   414     }

   415 

   416 /******************************************************************************

   417 

   418     Settingpage creation

   419 

   420 ******************************************************************************/

   421 

   422 // ----------------------------------------------------------------------------

   423 // CMuiuDynamicSettingsDialog::SettingsPageOpenCheckL()

   424 // ----------------------------------------------------------------------------

   425 //

   426 TMuiuPageResult CMuiuDynamicSettingsDialog::SettingsPageOpenCheckL()

   427     {

   428     CMuiuSettingBase* base = CurrentSettingsPage();

   429 

   430     // Before starting to open the page, check that item type is not

   431     // menuarray. In case of menuarray, just open the next level

   432     if ( HandleStackForwardL( *base ) == EMuiuStackResultSubMenuOpen )

   433         {

   434         UpdateMskL();

   435         return EMuiuPageResultSubMenuOpen;

   436         }

   437 

   438     // Don't open read only items

   439     if ( base->iItemFlags.Flag( EMuiuDynItemReadOnly ) )

   440         {

   441         return EMuiuPageResultReadOnly;

   442         }

   443 

   444     // The page is ok is for edit

   445     return EMuiuPageResultEditing;

   446     }

   447 

   448 // ----------------------------------------------------------------------------

   449 // CMuiuDynamicSettingsDialog::SettingsCheckNextEditorOpen()

   450 // ----------------------------------------------------------------------------

   451 //

   452 void CMuiuDynamicSettingsDialog::SettingsCheckNextEditorOpen(

   453     TMuiuPageResult& aResult )

   454     {

   455     // The settings user have selected, must be available to user.

   456     // For this reason, items shall restored to main array only, when

   457     // returning from editors

   458 

   459     switch ( aResult )

   460         {

   461         // Handle approved

   462         case EMuiuPageResultOk:

   463             aResult = HandleEditorOk();

   464             break;

   465 

   466         // Handle the cancelled editor page

   467         case EMuiuPageResultCancelled:

   468             aResult = HandleEditorCancel();

   469             break;

   470 

   471         // Continue editing

   472         case EMuiuPageResultEditing:

   473             aResult = HandleEditorDisapproved();

   474             break;

   475 

   476         default:

   477             __ASSERT_DEBUG( EFalse, User::Panic(

   478                 KMuiuDynSetDialogPanic, KErrUnknown ) );

   479             break;

   480         }

   481     }

   482 

   483 // ----------------------------------------------------------------------------

   484 // CMuiuDynamicSettingsDialog::HandleEditorCancel()

   485 // ----------------------------------------------------------------------------

   486 //

   487 TMuiuPageResult CMuiuDynamicSettingsDialog::HandleEditorCancel()

   488     {

   489     // The editor was cancelled, so the first check needed to make

   490     // is deterimine, if the editor was first in the line.

   491     TMuiuPageResult result = EMuiuPageResultInvalidResult;

   492 

   493     TInt editorCount = iSettingsPageArray->Count();

   494     if ( editorCount == 1 )

   495         {

   496         // Restore all of the items

   497         RestoreFromBackup();

   498         result = EMuiuPageResultCancelled;

   499         }

   500     // More than one page in the array, just jump back to the previous

   501     // and remove the previous value

   502     else if ( editorCount > 0 )

   503         {

   504         RemoveLastBackupItem();

   505         iSettingsPageArray->Delete( editorCount-1 );

   506         result = EMuiuPageResultEditing;

   507         }

   508     // Array is empty, unexpected situation

   509     else

   510         {

   511         __ASSERT_DEBUG( EFalse, User::Panic(

   512             KMuiuDynSetDialogPanic, KErrNotFound ) );

   513         }

   514 

   515     return result;

   516     }

   517 

   518 // ----------------------------------------------------------------------------

   519 // CMuiuDynamicSettingsDialog::HandleEditorOk()

   520 // ----------------------------------------------------------------------------

   521 //

   522 TMuiuPageResult CMuiuDynamicSettingsDialog::HandleEditorOk()

   523     {

   524     CMuiuSettingBase* nextItem = NULL;

   525 

   526     // Check if current selection contains subeditors

   527     if ( iSettingValue >= 0 )

   528         {

   529         nextItem = SettingFindEditor(

   530             *CurrentSettingsPage(), iSettingValue );

   531         }

   532 

   533     TMuiuPageResult result = EMuiuPageResultInvalidResult;

   534 

   535     // In case subeditor is found, set the item to list and continue

   536     // editing

   537     if ( nextItem )

   538         {

   539         SetCurrentSettingsPage( *nextItem );

   540         result = EMuiuPageResultEditing;

   541         }

   542     // Cleanup the array and stop editing

   543     else

   544         {

   545         CleanBackupArray();

   546         result = EMuiuPageResultOk;

   547         }

   548 

   549     return result;

   550     }

   551 

   552 // ----------------------------------------------------------------------------

   553 // CMuiuDynamicSettingsDialog::HandleEditorDisapproved()

   554 // ----------------------------------------------------------------------------

   555 //

   556 TMuiuPageResult CMuiuDynamicSettingsDialog::HandleEditorDisapproved()

   557     {

   558     // Get current setting page

   559     CurrentSettingsPage()->SetText( iSettingText );

   560 

   561     return EMuiuPageResultEditing;

   562     }

   563 

   564 // ----------------------------------------------------------------------------

   565 // CMuiuDynamicSettingsDialog::SettingPageOpenEditorL()

   566 // ----------------------------------------------------------------------------

   567 //

   568 TMuiuPageResult CMuiuDynamicSettingsDialog::SettingPageOpenEditorL()

   569     {

   570     CMuiuSettingBase* currentEditor = CurrentSettingsPage();

   571 

   572     // Prepare setting page. The setting page shall be acquired

   573     // from the owner class, if required, or the setting page is

   574     // created with default values

   575     TMuiuDynSetUpdateMode updateMode;

   576     TMuiuFlags editorFlags = currentEditor->iItemFlags;

   577 

   578     // If enter pressed is set, the setting page won't be opened,

   579     // which means creation of page is not needed either

   580     if ( !editorFlags.Flag( EMuiuDynItemEnterPressed ) ||

   581          editorFlags.Flag( EMuiuDynItemOneTimeForceViewOpen ) )

   582         {

   583         if ( editorFlags.Flag( EMuiuDynItemAcquireCustomPage ) )

   584             {

   585             SettingPrepareAcquireL( updateMode, *currentEditor );

   586             __ASSERT_DEBUG( iSettingPage != NULL,

   587                 User::Panic( KMuiuDynSetDialogPanic, KErrUnknown ) );

   588             }

   589         else

   590             {

   591             SettingCreateEditorL( *currentEditor, updateMode );

   592             }

   593         }

   594 

   595     // Finally launch the editor

   596     return SettingLaunchPageLD( *currentEditor, updateMode );

   597     }

   598 

   599 // ----------------------------------------------------------------------------

   600 // CMuiuDynamicSettingsDialog::SettingPageOpenFinishL()

   601 // ----------------------------------------------------------------------------

   602 //

   603 void CMuiuDynamicSettingsDialog::SettingPageOpenFinishL()

   604     {

   605     // Clean up

   606     iDynSettingsFlags.ClearFlag( EMuiuDynSetRunningCustomPage );

   607     delete iButtonArray;

   608     iButtonArray = NULL;

   609     if ( iCheckboxArray )

   610         {

   611         iCheckboxArray->ResetAndDestroy();

   612         }

   613     delete iCheckboxArray;

   614     iCheckboxArray = NULL;

   615     iSettingPage = NULL;

   616     iSettingValue = KErrNotFound;

   617     delete iSettingText;

   618     iSettingText = NULL;

   619     delete iNewPassword;

   620     iNewPassword = NULL;

   621     delete iOldPassword;

   622     iOldPassword = NULL;

   623     }

   624 

   625 /******************************************************************************

   626 

   627     Settingpage Open

   628 

   629 ******************************************************************************/

   630 

   631 // ----------------------------------------------------------------------------

   632 // CIMSSettingsDialog::SettingFindEditor()

   633 // ----------------------------------------------------------------------------

   634 //

   635 CMuiuSettingBase* CMuiuDynamicSettingsDialog::SettingFindEditor(

   636     const CMuiuSettingBase& aBaseItem,

   637     const TInt aIndex,

   638     const TBool aExcludeHidden )

   639     {

   640     // The settings structure is constructed in a way, that the radiobutton

   641     // or the checkbox editor has the array of buttons. To retrieve the editor

   642     // first the radiobutton has to be retrieved, then inside the radiobutton,

   643     // the editor can be taken.

   644     CMuiuSettingBase* volunteerBase =

   645         GetSubItem( aBaseItem, aIndex, aExcludeHidden );

   646 

   647     // Make sure the item is found and check that it is

   648     if ( volunteerBase )

   649         {

   650         volunteerBase = GetSubItem( *volunteerBase, 0, EFalse );

   651         }

   652     else

   653         {

   654         volunteerBase = NULL;

   655         }

   656 

   657     // return the item

   658     return volunteerBase;

   659     }

   660 

   661 // ----------------------------------------------------------------------------

   662 // CIMSSettingsDialog::SettingFindEditor()

   663 // ----------------------------------------------------------------------------

   664 //

   665 CMuiuSettingBase* CMuiuDynamicSettingsDialog::SettingFindEditor(

   666     const CMuiuSettingBase& aBaseItem,

   667     const TUid& aId,

   668     const TBool aExcludeHidden )

   669     {

   670     // The settings structure is constructed in a way, that the radiobutton

   671     // or the checkbox editor has the array of buttons. To retrieve the editor

   672     // first the radiobutton has to be retrieved, then inside the radiobutton,

   673     // the editor can be taken.

   674     CMuiuSettingBase* volunteerBase =

   675         GetSubItem( aBaseItem, aId, aExcludeHidden );

   676 

   677     // Make sure the item is found and check that it is

   678     if ( volunteerBase )

   679         {

   680         volunteerBase = GetSubItem( *volunteerBase, 0, EFalse );

   681         }

   682     else

   683         {

   684         volunteerBase = NULL;

   685         }

   686 

   687     // return the item

   688     return volunteerBase;

   689     }

   690 

   691 // ----------------------------------------------------------------------------

   692 // CMuiuDynamicSettingsDialog::SettingPrepareAcquireRadioButtonPageL()

   693 // ----------------------------------------------------------------------------

   694 //

   695 void CMuiuDynamicSettingsDialog::SettingPrepareAcquireRadioButtonPageL(

   696     CMuiuSettingBase& aBaseItem )

   697     {

   698     // Convert the base item to link item and define button array

   699     CMuiuSettingsLink* radio = static_cast<CMuiuSettingsLink*>( &aBaseItem );

   700 

   701     // Make sure the link exist

   702     if ( !radio->iItemLinkArray )

   703         {

   704         radio->iItemLinkArray =

   705             new ( ELeave ) CMuiuDynSetItemArray( KMuiuDynArrayGranularity );

   706         }

   707 

   708     SettingCreateButtonArrayL( *radio->iItemLinkArray );

   709 

   710     iSettingValue = radio->Value();

   711     radio = NULL;

   712     }

   713 

   714 // ----------------------------------------------------------------------------

   715 // CMuiuDynamicSettingsDialog::SettingPrepareAcquireCheckboxPageL()

   716 // ----------------------------------------------------------------------------

   717 //

   718 void CMuiuDynamicSettingsDialog::SettingPrepareAcquireCheckboxPageL(

   719     CMuiuSettingBase& aBaseItem )

   720     {

   721     // Convert the base item to link item and define button array

   722     CMuiuSettingsLink* link = static_cast<CMuiuSettingsLink*>( &aBaseItem );

   723 

   724     // Make sure the link array exist

   725     if ( link->iItemLinkArray )

   726         {

   727         SettingCreateButtonArrayL( *link->iItemLinkArray );

   728         }

   729 

   730     link = NULL;

   731     }

   732 

   733 // ----------------------------------------------------------------------------

   734 // CMuiuDynamicSettingsDialog::SettingPrepareAcquireTextEditorPageL()

   735 // ----------------------------------------------------------------------------

   736 //

   737 void CMuiuDynamicSettingsDialog::SettingPrepareAcquireTextEditorPageL(

   738     CMuiuSettingBase& aBaseItem )

   739     {

   740     // Create either password or plain texts

   741     if ( aBaseItem.iItemFlags.Flag( EMuiuDynItemPassword ) )

   742         {

   743         iNewPassword = new ( ELeave ) TMuiuPasswordText( *aBaseItem.Text() );

   744         iOldPassword = new ( ELeave ) TMuiuPasswordText( *aBaseItem.Text() );

   745         }

   746     else

   747         {

   748         iSettingText = new ( ELeave ) TMuiuSettingsText( *aBaseItem.Text() );

   749         }

   750     }

   751 

   752 // ----------------------------------------------------------------------------

   753 // CMuiuDynamicSettingsDialog::SettingPrepareAcquireValueEditorPageL()

   754 // ----------------------------------------------------------------------------

   755 //

   756 void CMuiuDynamicSettingsDialog::SettingPrepareAcquireValueEditorPageL(

   757     CMuiuSettingBase& aBaseItem )

   758     {

   759     iSettingValue = aBaseItem.Value();

   760     }

   761 

   762 // ----------------------------------------------------------------------------

   763 // CMuiuDynamicSettingsDialog::SettingPrepareAcquireL()

   764 // ----------------------------------------------------------------------------

   765 //

   766 void CMuiuDynamicSettingsDialog::SettingPrepareAcquireL(

   767     TMuiuDynSetUpdateMode& aUpdateMode,

   768     CMuiuSettingBase& aBaseItem )

   769     {

   770     // Handle the item, based on the type

   771     switch ( aBaseItem.Type() )

   772         {

   773         // Radio button page

   774         case EMuiuDynSetRadioButtonArray:

   775             SettingPrepareAcquireRadioButtonPageL( aBaseItem );

   776             break;

   777 

   778         // Checkbox page

   779         case EMuiuDynSetCheckBoxArray:

   780             SettingPrepareAcquireCheckboxPageL( aBaseItem );

   781             break;

   782 

   783         // Text editor

   784         case EMuiuDynSetItemEditText:

   785             SettingPrepareAcquireTextEditorPageL( aBaseItem );

   786             break;

   787 

   788         // Number editor

   789         case EMuiuDynSetItemEditValue:

   790             SettingPrepareAcquireValueEditorPageL( aBaseItem );

   791             break;

   792 

   793         // Type is not recognized

   794         default:

   795             __ASSERT_DEBUG( EFalse,

   796                 User::Panic( KMuiuDynSetDialogPanic, KErrUnknown ) );

   797             User::Leave( KErrUnknown );

   798         }

   799 

   800     // Acquire the custom setting page

   801     AcquireCustomSettingPageL(

   802         iSettingPage, aUpdateMode, iSettingValue,

   803         *iSettingText, *iButtonArray, aBaseItem );

   804     }

   805 

   806 // ----------------------------------------------------------------------------

   807 // CMuiuDynamicSettingsDialog::AcquireCustomSettingPageL()

   808 // ----------------------------------------------------------------------------

   809 //

   810 void CMuiuDynamicSettingsDialog::AcquireCustomSettingPageL(

   811     CAknSettingPage*& /* aReturnPage */,

   812     TMuiuDynSetUpdateMode& /* aReturnUpdateMode */,

   813     TInt& /* aReturnSettingValue */,

   814     TMuiuSettingsText& /* aReturnSettingText */,

   815     CDesCArrayFlat& /* aParamRadioButtonArray */,

   816     CMuiuSettingBase& /* aParamBaseItem */ )

   817     {

   818     }

   819 

   820 // ----------------------------------------------------------------------------

   821 // CMuiuDynamicSettingsDialog::SettingCreateEditorL()

   822 // ----------------------------------------------------------------------------

   823 //

   824 void CMuiuDynamicSettingsDialog::SettingCreateEditorL(

   825     CMuiuSettingBase& aBaseItem,

   826     TMuiuDynSetUpdateMode& aUpdateMode )

   827     {

   828     // Create different editors for password settings

   829     if ( aBaseItem.iItemFlags.Flag( EMuiuDynItemPassword ) )

   830         {

   831         switch ( aBaseItem.iItemType )

   832             {

   833             case EMuiuDynSetItemEditText:

   834                 SettingCreatePasswordTextEditorPageL(

   835                     aBaseItem, aUpdateMode );

   836                 break;

   837 

   838             }

   839         }

   840     // Normal editors

   841     else

   842         {

   843         switch ( aBaseItem.iItemType )

   844             {

   845             case EMuiuDynSetRadioButtonArray:

   846                 SettingCreateRadioButtonPageL( aBaseItem, aUpdateMode );

   847                 break;

   848 

   849             case EMuiuDynSetCheckBoxArray:

   850                 SettingCreateCheckboxPageL( aBaseItem, aUpdateMode );

   851                 break;

   852 

   853             case EMuiuDynSetItemEditText:

   854                 SettingCreatePlainTextEditorPageL(

   855                     aBaseItem, aUpdateMode );

   856                 break;

   857 

   858             case EMuiuDynSetItemEditValue:

   859                 SettingCreatePlainNumberEditorPageL(

   860                     aBaseItem, aUpdateMode );

   861                 break;

   862 

   863             case EMuiuDynSetItemEditScValue:

   864                 SettingCreateScNumberEditorPageL(

   865                     aBaseItem, aUpdateMode );

   866                 break;

   867 

   868             default:

   869                 break;

   870             }

   871         }

   872     }

   873 

   874 // ----------------------------------------------------------------------------

   875 // CMuiuDynamicSettingsDialog::DefineDefaultSettingPageL()

   876 // ----------------------------------------------------------------------------

   877 //

   878 TMuiuDynSetUpdateMode CMuiuDynamicSettingsDialog::DefineDefaultSettingPageL(

   879     const CMuiuSettingBase& aBase )

   880     {

   881     // Create the aSetting page

   882     iSettingPage->SetSettingTextL( *aBase.iItemLabel );

   883 

   884     // Determine the update mode

   885     return aBase.iItemFlags.Flag( EMuiuDynItemUpdateOnChange ) ?

   886             CAknSettingPage::EUpdateWhenChanged :

   887             CAknSettingPage::EUpdateWhenAccepted;

   888     }

   889 

   890 // ----------------------------------------------------------------------------

   891 // CMuiuDynamicSettingsDialog::SettingCreateButtonArrayL()

   892 // ----------------------------------------------------------------------------

   893 //

   894 void CMuiuDynamicSettingsDialog::SettingCreateButtonArrayL(

   895     CMuiuDynSetItemArray& aButtonArray )

   896     {

   897     // Get the item count in array

   898     const TInt count = aButtonArray.Count();

   899     iButtonArray = new ( ELeave ) CDesCArrayFlat( KMuiuDynArrayGranularity );

   900 

   901     // Do number conversion to all items and add them to temporary array

   902     for ( TInt item = 0; item < count; item++ )

   903         {

   904         CMuiuSettingBase* base = aButtonArray[item];

   905 

   906         // Append only visible items on the list

   907         if ( !IsHidden( *base ) )

   908             {

   909             HBufC* label = base->iItemLabel->AllocLC();

   910             TPtr labelPtr = label->Des();

   911 

   912             // Do number conversion when needed

   913             if ( base->iItemFlags.Flag( EMuiuDynItemLangSpecificNumConv ) )

   914                 {

   915                 AknTextUtils::DisplayTextLanguageSpecificNumberConversion(

   916                     labelPtr );

   917                 }

   918 

   919             // Insert to array and delete old item

   920             iButtonArray->AppendL( *label );

   921             CleanupStack::PopAndDestroy( label );

   922             label = NULL;

   923             }

   924         }

   925     }

   926 

   927 // ----------------------------------------------------------------------------

   928 // CMuiuDynamicSettingsDialog::SettingCreateCheckboxArrayL()

   929 // ----------------------------------------------------------------------------

   930 //

   931 void CMuiuDynamicSettingsDialog::SettingCreateCheckboxArrayL(

   932     CMuiuDynSetItemArray& aButtonArray )

   933     {

   934     // Get the item count in array

   935     const TInt count = aButtonArray.Count();

   936     iCheckboxArray =

   937         new ( ELeave ) CSelectionItemList( KMuiuDynArrayGranularity );

   938 

   939     // Do number conversion to all items and add them to temporary array

   940     for ( TInt item = 0; item < count; item++ )

   941         {

   942         CMuiuSettingBase* base = aButtonArray[item];

   943 

   944         // Append only visible items on the list

   945         if ( !IsHidden( *base ) )

   946             {

   947             HBufC* label = base->iItemLabel->AllocLC();

   948             TPtr labelPtr = label->Des();

   949 

   950             // Do number conversion when needed

   951             if ( base->iItemFlags.Flag( EMuiuDynItemLangSpecificNumConv ) )

   952                 {

   953                 AknTextUtils::DisplayTextLanguageSpecificNumberConversion(

   954                     labelPtr );

   955                 }

   956 

   957             // Create item and check it

   958             CSelectableItem* checkbox =

   959                 new ( ELeave ) CSelectableItem(

   960                     *label, base->iItemFlags.Flag( EMuiuDynItemChecked ) );

   961             CleanupStack::PushL( checkbox );

   962             checkbox->ConstructL();

   963 

   964             // Insert to array and delete old item

   965             iCheckboxArray->AppendL( checkbox );

   966             CleanupStack::Pop( checkbox );

   967             CleanupStack::PopAndDestroy( label );

   968             label = NULL;

   969             }

   970         }

   971     }

   972 

   973 // ----------------------------------------------------------------------------

   974 // CMuiuDynamicSettingsDialog::SettingCreateRadioButtonPageL()

   975 // ----------------------------------------------------------------------------

   976 //

   977 void CMuiuDynamicSettingsDialog::SettingCreateRadioButtonPageL(

   978     CMuiuSettingBase& aBaseItem,

   979     TMuiuDynSetUpdateMode& aUpdateMode )

   980     {

   981     // Convert the base item to radiobutton item

   982     CMuiuSettingsLinkExtended* radioArray =

   983         static_cast<CMuiuSettingsLinkExtended*>( &aBaseItem );

   984 

   985     // Create button array for the page and set the selection for page

   986     SettingCreateButtonArrayL( *radioArray->iItemLinkArray );

   987     iSettingValue = radioArray->Value();

   988 

   989     // Create the setting page to member

   990     iSettingPage = ( new ( ELeave ) CAknRadioButtonSettingPage(

   991         ( *iSettingPageResources )[EIPRRadioButton],

   992         iSettingValue, iButtonArray ) );

   993 

   994     // Apply defaults

   995     aUpdateMode = DefineDefaultSettingPageL( aBaseItem );

   996     }

   997 

   998 // ----------------------------------------------------------------------------

   999 // CMuiuDynamicSettingsDialog::SettingCreateCheckboxPageL()

  1000 // ----------------------------------------------------------------------------

  1001 //

  1002 void CMuiuDynamicSettingsDialog::SettingCreateCheckboxPageL(

  1003     CMuiuSettingBase& aBaseItem,

  1004     TMuiuDynSetUpdateMode& aUpdateMode )

  1005     {

  1006     // Convert the base item to radiobutton item

  1007     CMuiuSettingsLink* radioArray =

  1008         static_cast<CMuiuSettingsLink*>( &aBaseItem );

  1009 

  1010     // Create button array for the page

  1011     SettingCreateCheckboxArrayL( *radioArray->iItemLinkArray );

  1012 

  1013     // Create the setting page to member

  1014     iSettingPage = new ( ELeave ) CIMSSettingsWizardCheckBoxPage(

  1015         ( *iSettingPageResources )[EIPRCheckbox], iCheckboxArray,

  1016         aBaseItem.iItemFlags.Flag( EMuiuDynItemForceMustFill ) );

  1017 

  1018     // Apply defaults

  1019     aUpdateMode = DefineDefaultSettingPageL( aBaseItem );

  1020     }

  1021 

  1022 // ----------------------------------------------------------------------------

  1023 // CMuiuDynamicSettingsDialog::SettingCreatePlainTextEditorPageL()

  1024 // ----------------------------------------------------------------------------

  1025 //

  1026 void CMuiuDynamicSettingsDialog::SettingCreatePlainTextEditorPageL(

  1027     CMuiuSettingBase& aBaseItem,

  1028     TMuiuDynSetUpdateMode& aUpdateMode )

  1029     {

  1030     // Get the text to be edited

  1031     CMuiuSettingsEditText* textEditor =

  1032         static_cast<CMuiuSettingsEditText*>( &aBaseItem );

  1033     iSettingText = new ( ELeave ) TMuiuSettingsText( *textEditor->Text() );

  1034     iSettingText->Copy( *textEditor->Text() );

  1035 

  1036     // Define flags according to item

  1037     TInt flags = GetTextEditorFlags( aBaseItem );

  1038 

  1039     // Create the setting page using the flags

  1040     TInt pageResource = ( *iSettingPageResources )[EIPRText];

  1041     CAknTextSettingPage* settingPage =

  1042         new ( ELeave ) CAknTextSettingPage(

  1043             pageResource, *iSettingText, flags );

  1044     CleanupStack::PushL( settingPage );

  1045     settingPage->ConstructL();

  1046     CEikEdwin& txtCtrl = *settingPage->TextControl();

  1047     txtCtrl.SetTextLimit( textEditor->iItemMaxLength );

  1048 

  1049     if ( textEditor->iItemFlags.Flag( EMuiuDynItemLatinOnly ) )

  1050         {

  1051         txtCtrl.SetAknEditorFlags(

  1052             EAknEditorFlagLatinInputModesOnly | EAknEditorFlagNoT9 );

  1053         }

  1054 

  1055     iSettingPage = settingPage;

  1056     CleanupStack::Pop( settingPage );

  1057 

  1058     // Apply defaults

  1059     aUpdateMode = DefineDefaultSettingPageL( aBaseItem );

  1060     }

  1061 

  1062 // ----------------------------------------------------------------------------

  1063 // CMuiuDynamicSettingsDialog::SettingCreatePasswordTextEditorPageL()

  1064 // ----------------------------------------------------------------------------

  1065 //

  1066 void CMuiuDynamicSettingsDialog::SettingCreatePasswordTextEditorPageL(

  1067     CMuiuSettingBase& aBaseItem,

  1068     TMuiuDynSetUpdateMode& aUpdateMode )

  1069     {

  1070     // Prepare password and save the old

  1071     CMuiuSettingsEditText* textEditor =

  1072         static_cast<CMuiuSettingsEditText*>( &aBaseItem );

  1073 

  1074     iNewPassword = new ( ELeave ) TMuiuPasswordText(

  1075         textEditor->Text()->Left( KMuiuDynMaxPasswordLength ) );

  1076     iOldPassword = new ( ELeave ) TMuiuPasswordText(

  1077         textEditor->Text()->Left( KMuiuDynMaxPasswordLength ) );

  1078 

  1079     // Create the settings page

  1080     iSettingPage = ( new ( ELeave ) CAknAlphaPasswordSettingPage(

  1081         ( *iSettingPageResources )[EIPRSecret],

  1082         *iNewPassword, *iOldPassword ) );

  1083     iSettingPage->ConstructL();

  1084     CAknAlphaPasswordSettingPage* pwPage =

  1085         static_cast<CAknAlphaPasswordSettingPage*>( iSettingPage );

  1086     pwPage->SetMaxPasswordLength( textEditor->iItemMaxLength );

  1087     if ( pwPage->AlphaPasswordEditor() )

  1088         {

  1089         pwPage->AlphaPasswordEditor()->SetMaxLength(

  1090             textEditor->iItemMaxLength );

  1091         }

  1092 

  1093     // Apply defaults

  1094     aUpdateMode = DefineDefaultSettingPageL( aBaseItem );

  1095     }

  1096 

  1097 // ----------------------------------------------------------------------------

  1098 // CMuiuDynamicSettingsDialog::SettingCreatePlainNumberEditorPageL()

  1099 // ----------------------------------------------------------------------------

  1100 //

  1101 void CMuiuDynamicSettingsDialog::SettingCreatePlainNumberEditorPageL(

  1102     CMuiuSettingBase& aBaseItem,

  1103     TMuiuDynSetUpdateMode& aUpdateMode )

  1104     {

  1105     // Conver item and set the value

  1106     CMuiuSettingsEditValue* numberEditor =

  1107         static_cast<CMuiuSettingsEditValue*>( &aBaseItem );

  1108     iSettingValue = numberEditor->Value();

  1109 

  1110     // Define flags according to item

  1111     TInt flags = GetValueEditorFlags( aBaseItem );

  1112 

  1113     // Create aSetting page

  1114     iSettingPage = ( new ( ELeave ) CAknIntegerSettingPage(

  1115         ( *iSettingPageResources )[EIPRNumber],

  1116             *&iSettingValue , flags ) );

  1117     iSettingPage->ConstructL();

  1118 

  1119     CEikEdwin* textControl = static_cast<CAknIntegerSettingPage*>(

  1120                                         iSettingPage )->TextControl();

  1121 

  1122 

  1123     textControl->SetTextLimit( numberEditor->iItemMaxLength );

  1124     textControl->SetAknEditorNumericKeymap( EAknEditorPlainNumberModeKeymap );

  1125 

  1126 

  1127     // Apply defaults, for number editors, the update mode has to be onchange

  1128     aBaseItem.iItemFlags.SetFlag( EMuiuDynItemUpdateOnChange );

  1129     aUpdateMode = DefineDefaultSettingPageL( aBaseItem );

  1130     }

  1131 

  1132 // ----------------------------------------------------------------------------

  1133 // CMuiuDynamicSettingsDialog::SettingCreateScNumberEditorPageL()

  1134 // ----------------------------------------------------------------------------