--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/email/imum/Utils/Src/MuiuDynamicSettingsDialog.cpp Wed Sep 01 12:31:54 2010 +0100
@@ -0,0 +1,2605 @@
+/*
+* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: MuiuDynamicSettingsDialog.cpp
+*
+*/
+
+
+
+// INCLUDE FILES
+#include <e32base.h>
+#include <eiktxlbx.h> // CEikTextListBox
+#include <badesca.h> // CDesCArray
+#include <eiktxlbm.h> // CTextListBoxModel
+#include <AknUtils.h> // CAknTextUtils
+#include <akntitle.h> // CAknTitlePane
+#include <AknQueryDialog.h> // CAknQueryDialog
+#include <aknsettingpage.h> // CAknSettingPage
+#include <aknradiobuttonsettingpage.h> // CAknRadioButtonSettingPage
+#include <aknpasswordsettingpage.h> // CAknPasswordSettingPage
+#include <akntextsettingpage.h> // CAknTextSettingPage
+#include <eikbtgpc.h> // CEikButtonGroupContainer
+#include <StringLoader.h> // StringLoader
+#include "MuiuDynamicSettingsDialog.h" // CMuiuDynamicSettingsDialog
+#include "IMSWCheckBoxPage.h" // CIMSSettingsWizardCheckBoxPage
+
+#include <muiu_internal.rsg>
+#include <ImumUtils.rsg> // R_IMAS_MSK_OPEN, should be temporary
+
+// EXTERNAL DATA STRUCTURES
+// EXTERNAL FUNCTION PROTOTYPES
+// CONSTANTS
+
+// Prevent any looping problems by defining maximum amount of editor openings
+const TInt KMuiuMaxEditors = 100;
+
+// MACROS
+// LOCAL CONSTANTS AND MACROS
+// MODULE DATA STRUCTURES
+// LOCAL FUNCTION PROTOTYPES
+// FORWARD DECLARATIONS
+
+// ============================ MEMBER FUNCTIONS ==============================
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::CMuiuDynamicSettingsDialog()
+// ----------------------------------------------------------------------------
+//
+CMuiuDynamicSettingsDialog::CMuiuDynamicSettingsDialog(
+ CEikFormattedCellListBox& aListBox,
+ CAknTitlePane& aTitlePane )
+ :
+ CMuiuDynamicSettingsArray(),
+ iListBox( aListBox ),
+ iTitlePane( aTitlePane ),
+ iSettingValue( KErrNotFound )
+ {
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::~CMuiuDynamicSettingsDialog()
+// ----------------------------------------------------------------------------
+//
+CMuiuDynamicSettingsDialog::~CMuiuDynamicSettingsDialog()
+ {
+ // Remove the scrollbar from listbox
+ iListBox.SetScrollBarFrame( NULL, CEikListBox::EOwnedExternally );
+
+ if ( iSoftkeys )
+ {
+ iSoftkeys->SetObserver( EFalse, EFalse, EFalse, *this );
+ delete iSoftkeys;
+ }
+ iSoftkeys = NULL;
+
+ delete iSettingPageResources;
+ iSettingPageResources = NULL;
+
+ if ( iSettingsLastItemIndex )
+ {
+ iSettingsLastItemIndex->Reset();
+ }
+
+ delete iSettingsLastItemIndex;
+ iSettingsLastItemIndex = NULL;
+
+ if ( iCheckboxArray )
+ {
+ iCheckboxArray->ResetAndDestroy();
+ }
+
+ if ( iSettingsPageArray )
+ {
+ iSettingsPageArray->Reset();
+ }
+
+ if ( iBackupArray )
+ {
+ iBackupArray->ResetAndDestroy();
+ }
+
+ delete iBackupArray;
+ iBackupArray = NULL;
+ delete iSettingsPageArray;
+ iSettingsPageArray = NULL;
+ delete iCheckboxArray;
+ iCheckboxArray = NULL;
+ delete iOldTitleText;
+ iOldTitleText = NULL;
+ delete iQueryDialog;
+ iQueryDialog = NULL;
+ delete iSettingPage;
+ iSettingPage = NULL;
+ delete iButtonArray;
+ iButtonArray = NULL;
+ delete iSettingText;
+ iSettingText = NULL;
+ delete iNewPassword;
+ iNewPassword = NULL;
+ delete iOldPassword;
+ iOldPassword = NULL;
+ iScrollBar = NULL;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingsConstructL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SettingsConstructL(
+ CEikButtonGroupContainer& aSoftkeys,
+ const TInt aResource,
+ const TBool aUpdateMSK,
+ const TBool aLockedSettings )
+ {
+ BaseConstructL( aResource, aLockedSettings );
+
+ // Set as observer
+ iListBox.SetListBoxObserver( this );
+ iListBox.View()->SetListEmptyTextL( KNullDesC );
+
+ // Get scrollbar
+ iScrollBar = iListBox.CreateScrollBarFrameL( ETrue );
+ iScrollBar->SetScrollBarVisibilityL(
+ CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto );
+
+ // Create array
+ CTextListBoxModel* model = iListBox.Model();
+ model->SetItemTextArray( this );
+ model->SetOwnershipType( ELbmDoesNotOwnItemArray );
+
+ // Set this dialog for button listening
+ iSoftkeys = CIMSSoftkeyControl::NewL( aSoftkeys );
+ iSoftkeys->SetObserver( ETrue, ETrue, ETrue, *this );
+ iSoftkeys->SetMSKLabelling( aUpdateMSK );
+ UpdateMskL();
+
+ // Prepare setting page arrays
+ iSettingPageResources = CIMSPageResourceControl::NewL();
+ iSettingsLastItemIndex =
+ new ( ELeave ) CMuiuDynSetIntArray( KMuiuDynArrayGranularity );
+
+ // Add array to store the backup items
+ iBackupArray = new ( ELeave ) CMuiuDynSetItemArray( KMuiuDynArrayGranularity );
+
+ // Define setting pages in enumeration order
+ iSettingPageResources->CreateStackL( R_MUIU_SETTINGS_DIALOG_LISTBOX );
+ iSettingPageResources->CreateStackL( R_MUIU_SETTINGS_DIALOG_CHECKLISTBOX );
+ iSettingPageResources->CreateStackL( R_MUIU_SETTINGS_DIALOG_TEXT );
+ iSettingPageResources->CreateStackL( R_MUIU_SETTINGS_DIALOG_NUMBER );
+ iSettingPageResources->CreateStackL( R_MUIU_SETTINGS_DIALOG_SC_NUMBER );
+ iSettingPageResources->CreateStackL( R_MUIU_SETTINGS_DIALOG_PASSWORD );
+ iSettingPageResources->CreateStackL( NULL );
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::HandleListBoxEventL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::HandleListBoxEventL(
+ CEikListBox* /* aListBox */,
+ TListBoxEvent aEventType )
+ {
+ switch ( aEventType )
+ {
+ // Note for TouchUi. When focused item is tapped, both
+ // EEventItemClicked and EEventItemDoubleClicked events
+ // are received. When unfocused item is tapped, EEventItemClicked
+ // event is received. Double tap to focused item produces
+ // the same events as a single tap.
+ case EEventEnterKeyPressed:
+ case EEventItemDoubleClicked:
+ case EEventItemActioned:
+ OpenSettingPageL();
+ break;
+
+ case EEventItemClicked:
+ case EEventItemDraggingActioned:
+ UpdateMskL();
+ break;
+ default:
+ break;
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::OfferKeyEventL
+// ----------------------------------------------------------------------------
+//
+TKeyResponse CMuiuDynamicSettingsDialog::OfferKeyEventL(
+ const TKeyEvent& /* aKeyEvent */,
+ TEventCode aType )
+ {
+ if ( aType == EEventKeyUp )
+ {
+ UpdateMskL();
+ }
+
+ return EKeyWasNotConsumed;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SetTitlePaneTextL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SetTitlePaneTextL(
+ const TDesC& aText,
+ const TBool aSaveCurrent )
+ {
+ HBufC* text = aText.Alloc();
+ CleanupStack::PushL( text );
+
+ if ( aSaveCurrent )
+ {
+ delete iOldTitleText;
+ iOldTitleText = NULL;
+ iOldTitleText = iTitlePane.Text()->Alloc();
+ }
+
+ iTitlePane.SetTextL( *text );
+ CleanupStack::PopAndDestroy( text );
+ text = NULL;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SetPreviousTitlePaneText()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SetPreviousTitlePaneText(
+ const TBool aSaveCurrent )
+ {
+ TRAP_IGNORE( SetTitlePaneTextL( *iOldTitleText, aSaveCurrent ) );
+ }
+
+/******************************************************************************
+
+ Settingpage opening
+
+ - Find out the item to be edited
+ - Send start editing event with the item
+ - Check the item type
+ - Check the resources
+ - If no resources available, ask them
+ - Start editing
+ - Send end editing event
+
+******************************************************************************/
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::OpenSettingPageL()
+// ----------------------------------------------------------------------------
+//
+TMuiuPageResult CMuiuDynamicSettingsDialog::OpenSettingPageL(
+ const TInt aIndex )
+ {
+ // To open setting page, check if the Setting Page index is provided,
+ // if not get the current item index in array
+ TInt index = ( aIndex == KErrNotFound ) ?
+ iListBox.CurrentItemIndex() : aIndex;
+
+ // Search for the item and open it
+ return SettingPageOpenL( *GetItem( index ) );
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::OpenSettingPageL()
+// ----------------------------------------------------------------------------
+//
+TMuiuPageResult CMuiuDynamicSettingsDialog::OpenSettingPageL(
+ CMuiuSettingBase& aBaseItem )
+ {
+ return SettingPageOpenL( aBaseItem );
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingPageOpenL()
+//
+// This function contains the main logic for the setting editor handling
+// in the settings dialog. The setting editors are kept opening as long
+// as the all the settings are gone through or the editor is dismissed.
+// ----------------------------------------------------------------------------
+//
+TMuiuPageResult CMuiuDynamicSettingsDialog::SettingPageOpenL(
+ CMuiuSettingBase& aBaseItem )
+ {
+ // Don't open the editor for read-only items
+ if ( aBaseItem.iItemFlags.Flag( EMuiuDynItemReadOnly ) )
+ {
+ return EMuiuPageResultReadOnly;
+ }
+ else if( aBaseItem.iItemFlags.Flag( EMuiuDynItemLockableSetting ) &&
+ iArrayFlags.Flag( EMuiuEMailLockedSettings ) )
+ {
+ return EMuiuPageResultPageLocked;
+ }
+
+ // Store current focused item for last item index array
+ iCurrentItemIndex = iListBox.CurrentItemIndex();
+
+ // Starting editing of the item, do not allow updating during editing
+ iListBox.MakeVisible( EFalse );
+ iArrayFlags.ClearFlag( EMuiuDynArrayAllowRefresh );
+
+ // When starting to edit page, send event so that item can be prepared
+ // for the editing. In case of error, editing won't start
+ TMuiuPageEventResult eventResult = EventItemEditStartsL( aBaseItem );
+ TMuiuPageResult result;
+
+ if ( eventResult == EMuiuPageEventResultApproved )
+ {
+ // Create the array if it doesn't exist yet
+ if ( !iSettingsPageArray )
+ {
+ iSettingsPageArray = new ( ELeave ) CMuiuDynSetItemArray(
+ KMuiuDynArrayGranularity );
+ }
+
+ // Clear the array and add the editable item to array
+ CleanBackupArray();
+ iSettingsPageArray->Reset();
+ SetCurrentSettingsPage( aBaseItem );
+ result = SettingsPageOpenCheckL();
+
+ do
+ {
+ if ( result == EMuiuPageResultEditing )
+ {
+ // Open the setting page
+ result = SettingPageOpenEditorL();
+
+ // Do open check. Note that the result can be modified!
+ SettingsCheckNextEditorOpen( result );
+ }
+
+ // Finish the editing of the item
+ SettingPageOpenFinishL();
+ }
+ while ( result == EMuiuPageResultEditing );
+ }
+ else if ( eventResult == EMuiuPageEventResultDisapproved )
+ {
+ result = EMuiuPageResultOk;
+ }
+ else
+ {
+ result = EMuiuPageResultEventCancel;
+ }
+
+ // Send item edit ends
+ EventItemEditEndsL( aBaseItem );
+ aBaseItem.iItemFlags.ClearFlag( EMuiuDynItemOneTimeForceViewOpen );
+
+ iArrayFlags.SetFlag( EMuiuDynArrayAllowRefresh );
+ iListBox.MakeVisible( ETrue );
+
+ // Update the listbox
+ Refresh();
+
+ return result;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::EventPrepareSubArrayL()
+// ----------------------------------------------------------------------------
+//
+TInt CMuiuDynamicSettingsDialog::EventPrepareSubArrayL(
+ CMuiuSettingBase& aBaseItem,
+ const TBool aForward )
+ {
+ // Check direction in array
+ if ( aForward )
+ {
+ // Store the index and set to beginning
+ SetSettingsLastItemIndexL( iCurrentItemIndex );
+ iListBox.SetCurrentItemIndex( 0 );
+ }
+ // When going backwards
+ else
+ {
+ // Restore previous index
+ iListBox.SetCurrentItemIndex( SettingsLastItemIndex() );
+ }
+
+ return EventSubArrayChangeL( aBaseItem );
+ }
+
+/******************************************************************************
+
+ Settingpage creation
+
+******************************************************************************/
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingsPageOpenCheckL()
+// ----------------------------------------------------------------------------
+//
+TMuiuPageResult CMuiuDynamicSettingsDialog::SettingsPageOpenCheckL()
+ {
+ CMuiuSettingBase* base = CurrentSettingsPage();
+
+ // Before starting to open the page, check that item type is not
+ // menuarray. In case of menuarray, just open the next level
+ if ( HandleStackForwardL( *base ) == EMuiuStackResultSubMenuOpen )
+ {
+ UpdateMskL();
+ return EMuiuPageResultSubMenuOpen;
+ }
+
+ // Don't open read only items
+ if ( base->iItemFlags.Flag( EMuiuDynItemReadOnly ) )
+ {
+ return EMuiuPageResultReadOnly;
+ }
+
+ // The page is ok is for edit
+ return EMuiuPageResultEditing;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingsCheckNextEditorOpen()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SettingsCheckNextEditorOpen(
+ TMuiuPageResult& aResult )
+ {
+ // The settings user have selected, must be available to user.
+ // For this reason, items shall restored to main array only, when
+ // returning from editors
+
+ switch ( aResult )
+ {
+ // Handle approved
+ case EMuiuPageResultOk:
+ aResult = HandleEditorOk();
+ break;
+
+ // Handle the cancelled editor page
+ case EMuiuPageResultCancelled:
+ aResult = HandleEditorCancel();
+ break;
+
+ // Continue editing
+ case EMuiuPageResultEditing:
+ aResult = HandleEditorDisapproved();
+ break;
+
+ default:
+ __ASSERT_DEBUG( EFalse, User::Panic(
+ KMuiuDynSetDialogPanic, KErrUnknown ) );
+ break;
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::HandleEditorCancel()
+// ----------------------------------------------------------------------------
+//
+TMuiuPageResult CMuiuDynamicSettingsDialog::HandleEditorCancel()
+ {
+ // The editor was cancelled, so the first check needed to make
+ // is deterimine, if the editor was first in the line.
+ TMuiuPageResult result = EMuiuPageResultInvalidResult;
+
+ TInt editorCount = iSettingsPageArray->Count();
+ if ( editorCount == 1 )
+ {
+ // Restore all of the items
+ RestoreFromBackup();
+ result = EMuiuPageResultCancelled;
+ }
+ // More than one page in the array, just jump back to the previous
+ // and remove the previous value
+ else if ( editorCount > 0 )
+ {
+ RemoveLastBackupItem();
+ iSettingsPageArray->Delete( editorCount-1 );
+ result = EMuiuPageResultEditing;
+ }
+ // Array is empty, unexpected situation
+ else
+ {
+ __ASSERT_DEBUG( EFalse, User::Panic(
+ KMuiuDynSetDialogPanic, KErrNotFound ) );
+ }
+
+ return result;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::HandleEditorOk()
+// ----------------------------------------------------------------------------
+//
+TMuiuPageResult CMuiuDynamicSettingsDialog::HandleEditorOk()
+ {
+ CMuiuSettingBase* nextItem = NULL;
+
+ // Check if current selection contains subeditors
+ if ( iSettingValue >= 0 )
+ {
+ nextItem = SettingFindEditor(
+ *CurrentSettingsPage(), iSettingValue );
+ }
+
+ TMuiuPageResult result = EMuiuPageResultInvalidResult;
+
+ // In case subeditor is found, set the item to list and continue
+ // editing
+ if ( nextItem )
+ {
+ SetCurrentSettingsPage( *nextItem );
+ result = EMuiuPageResultEditing;
+ }
+ // Cleanup the array and stop editing
+ else
+ {
+ CleanBackupArray();
+ result = EMuiuPageResultOk;
+ }
+
+ return result;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::HandleEditorDisapproved()
+// ----------------------------------------------------------------------------
+//
+TMuiuPageResult CMuiuDynamicSettingsDialog::HandleEditorDisapproved()
+ {
+ // Get current setting page
+ CurrentSettingsPage()->SetText( iSettingText );
+
+ return EMuiuPageResultEditing;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingPageOpenEditorL()
+// ----------------------------------------------------------------------------
+//
+TMuiuPageResult CMuiuDynamicSettingsDialog::SettingPageOpenEditorL()
+ {
+ CMuiuSettingBase* currentEditor = CurrentSettingsPage();
+
+ // Prepare setting page. The setting page shall be acquired
+ // from the owner class, if required, or the setting page is
+ // created with default values
+ TMuiuDynSetUpdateMode updateMode;
+ TMuiuFlags editorFlags = currentEditor->iItemFlags;
+
+ // If enter pressed is set, the setting page won't be opened,
+ // which means creation of page is not needed either
+ if ( !editorFlags.Flag( EMuiuDynItemEnterPressed ) ||
+ editorFlags.Flag( EMuiuDynItemOneTimeForceViewOpen ) )
+ {
+ if ( editorFlags.Flag( EMuiuDynItemAcquireCustomPage ) )
+ {
+ SettingPrepareAcquireL( updateMode, *currentEditor );
+ __ASSERT_DEBUG( iSettingPage != NULL,
+ User::Panic( KMuiuDynSetDialogPanic, KErrUnknown ) );
+ }
+ else
+ {
+ SettingCreateEditorL( *currentEditor, updateMode );
+ }
+ }
+
+ // Finally launch the editor
+ return SettingLaunchPageLD( *currentEditor, updateMode );
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingPageOpenFinishL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SettingPageOpenFinishL()
+ {
+ // Clean up
+ iDynSettingsFlags.ClearFlag( EMuiuDynSetRunningCustomPage );
+ delete iButtonArray;
+ iButtonArray = NULL;
+ if ( iCheckboxArray )
+ {
+ iCheckboxArray->ResetAndDestroy();
+ }
+ delete iCheckboxArray;
+ iCheckboxArray = NULL;
+ iSettingPage = NULL;
+ iSettingValue = KErrNotFound;
+ delete iSettingText;
+ iSettingText = NULL;
+ delete iNewPassword;
+ iNewPassword = NULL;
+ delete iOldPassword;
+ iOldPassword = NULL;
+ }
+
+/******************************************************************************
+
+ Settingpage Open
+
+******************************************************************************/
+
+// ----------------------------------------------------------------------------
+// CIMSSettingsDialog::SettingFindEditor()
+// ----------------------------------------------------------------------------
+//
+CMuiuSettingBase* CMuiuDynamicSettingsDialog::SettingFindEditor(
+ const CMuiuSettingBase& aBaseItem,
+ const TInt aIndex,
+ const TBool aExcludeHidden )
+ {
+ // The settings structure is constructed in a way, that the radiobutton
+ // or the checkbox editor has the array of buttons. To retrieve the editor
+ // first the radiobutton has to be retrieved, then inside the radiobutton,
+ // the editor can be taken.
+ CMuiuSettingBase* volunteerBase =
+ GetSubItem( aBaseItem, aIndex, aExcludeHidden );
+
+ // Make sure the item is found and check that it is
+ if ( volunteerBase )
+ {
+ volunteerBase = GetSubItem( *volunteerBase, 0, EFalse );
+ }
+ else
+ {
+ volunteerBase = NULL;
+ }
+
+ // return the item
+ return volunteerBase;
+ }
+
+// ----------------------------------------------------------------------------
+// CIMSSettingsDialog::SettingFindEditor()
+// ----------------------------------------------------------------------------
+//
+CMuiuSettingBase* CMuiuDynamicSettingsDialog::SettingFindEditor(
+ const CMuiuSettingBase& aBaseItem,
+ const TUid& aId,
+ const TBool aExcludeHidden )
+ {
+ // The settings structure is constructed in a way, that the radiobutton
+ // or the checkbox editor has the array of buttons. To retrieve the editor
+ // first the radiobutton has to be retrieved, then inside the radiobutton,
+ // the editor can be taken.
+ CMuiuSettingBase* volunteerBase =
+ GetSubItem( aBaseItem, aId, aExcludeHidden );
+
+ // Make sure the item is found and check that it is
+ if ( volunteerBase )
+ {
+ volunteerBase = GetSubItem( *volunteerBase, 0, EFalse );
+ }
+ else
+ {
+ volunteerBase = NULL;
+ }
+
+ // return the item
+ return volunteerBase;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingPrepareAcquireRadioButtonPageL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SettingPrepareAcquireRadioButtonPageL(
+ CMuiuSettingBase& aBaseItem )
+ {
+ // Convert the base item to link item and define button array
+ CMuiuSettingsLink* radio = static_cast<CMuiuSettingsLink*>( &aBaseItem );
+
+ // Make sure the link exist
+ if ( !radio->iItemLinkArray )
+ {
+ radio->iItemLinkArray =
+ new ( ELeave ) CMuiuDynSetItemArray( KMuiuDynArrayGranularity );
+ }
+
+ SettingCreateButtonArrayL( *radio->iItemLinkArray );
+
+ iSettingValue = radio->Value();
+ radio = NULL;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingPrepareAcquireCheckboxPageL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SettingPrepareAcquireCheckboxPageL(
+ CMuiuSettingBase& aBaseItem )
+ {
+ // Convert the base item to link item and define button array
+ CMuiuSettingsLink* link = static_cast<CMuiuSettingsLink*>( &aBaseItem );
+
+ // Make sure the link array exist
+ if ( link->iItemLinkArray )
+ {
+ SettingCreateButtonArrayL( *link->iItemLinkArray );
+ }
+
+ link = NULL;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingPrepareAcquireTextEditorPageL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SettingPrepareAcquireTextEditorPageL(
+ CMuiuSettingBase& aBaseItem )
+ {
+ // Create either password or plain texts
+ if ( aBaseItem.iItemFlags.Flag( EMuiuDynItemPassword ) )
+ {
+ iNewPassword = new ( ELeave ) TMuiuPasswordText( *aBaseItem.Text() );
+ iOldPassword = new ( ELeave ) TMuiuPasswordText( *aBaseItem.Text() );
+ }
+ else
+ {
+ iSettingText = new ( ELeave ) TMuiuSettingsText( *aBaseItem.Text() );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingPrepareAcquireValueEditorPageL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SettingPrepareAcquireValueEditorPageL(
+ CMuiuSettingBase& aBaseItem )
+ {
+ iSettingValue = aBaseItem.Value();
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingPrepareAcquireL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SettingPrepareAcquireL(
+ TMuiuDynSetUpdateMode& aUpdateMode,
+ CMuiuSettingBase& aBaseItem )
+ {
+ // Handle the item, based on the type
+ switch ( aBaseItem.Type() )
+ {
+ // Radio button page
+ case EMuiuDynSetRadioButtonArray:
+ SettingPrepareAcquireRadioButtonPageL( aBaseItem );
+ break;
+
+ // Checkbox page
+ case EMuiuDynSetCheckBoxArray:
+ SettingPrepareAcquireCheckboxPageL( aBaseItem );
+ break;
+
+ // Text editor
+ case EMuiuDynSetItemEditText:
+ SettingPrepareAcquireTextEditorPageL( aBaseItem );
+ break;
+
+ // Number editor
+ case EMuiuDynSetItemEditValue:
+ SettingPrepareAcquireValueEditorPageL( aBaseItem );
+ break;
+
+ // Type is not recognized
+ default:
+ __ASSERT_DEBUG( EFalse,
+ User::Panic( KMuiuDynSetDialogPanic, KErrUnknown ) );
+ User::Leave( KErrUnknown );
+ }
+
+ // Acquire the custom setting page
+ AcquireCustomSettingPageL(
+ iSettingPage, aUpdateMode, iSettingValue,
+ *iSettingText, *iButtonArray, aBaseItem );
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::AcquireCustomSettingPageL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::AcquireCustomSettingPageL(
+ CAknSettingPage*& /* aReturnPage */,
+ TMuiuDynSetUpdateMode& /* aReturnUpdateMode */,
+ TInt& /* aReturnSettingValue */,
+ TMuiuSettingsText& /* aReturnSettingText */,
+ CDesCArrayFlat& /* aParamRadioButtonArray */,
+ CMuiuSettingBase& /* aParamBaseItem */ )
+ {
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingCreateEditorL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SettingCreateEditorL(
+ CMuiuSettingBase& aBaseItem,
+ TMuiuDynSetUpdateMode& aUpdateMode )
+ {
+ // Create different editors for password settings
+ if ( aBaseItem.iItemFlags.Flag( EMuiuDynItemPassword ) )
+ {
+ switch ( aBaseItem.iItemType )
+ {
+ case EMuiuDynSetItemEditText:
+ SettingCreatePasswordTextEditorPageL(
+ aBaseItem, aUpdateMode );
+ break;
+
+ }
+ }
+ // Normal editors
+ else
+ {
+ switch ( aBaseItem.iItemType )
+ {
+ case EMuiuDynSetRadioButtonArray:
+ SettingCreateRadioButtonPageL( aBaseItem, aUpdateMode );
+ break;
+
+ case EMuiuDynSetCheckBoxArray:
+ SettingCreateCheckboxPageL( aBaseItem, aUpdateMode );
+ break;
+
+ case EMuiuDynSetItemEditText:
+ SettingCreatePlainTextEditorPageL(
+ aBaseItem, aUpdateMode );
+ break;
+
+ case EMuiuDynSetItemEditValue:
+ SettingCreatePlainNumberEditorPageL(
+ aBaseItem, aUpdateMode );
+ break;
+
+ case EMuiuDynSetItemEditScValue:
+ SettingCreateScNumberEditorPageL(
+ aBaseItem, aUpdateMode );
+ break;
+
+ default:
+ break;
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::DefineDefaultSettingPageL()
+// ----------------------------------------------------------------------------
+//
+TMuiuDynSetUpdateMode CMuiuDynamicSettingsDialog::DefineDefaultSettingPageL(
+ const CMuiuSettingBase& aBase )
+ {
+ // Create the aSetting page
+ iSettingPage->SetSettingTextL( *aBase.iItemLabel );
+
+ // Determine the update mode
+ return aBase.iItemFlags.Flag( EMuiuDynItemUpdateOnChange ) ?
+ CAknSettingPage::EUpdateWhenChanged :
+ CAknSettingPage::EUpdateWhenAccepted;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingCreateButtonArrayL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SettingCreateButtonArrayL(
+ CMuiuDynSetItemArray& aButtonArray )
+ {
+ // Get the item count in array
+ const TInt count = aButtonArray.Count();
+ iButtonArray = new ( ELeave ) CDesCArrayFlat( KMuiuDynArrayGranularity );
+
+ // Do number conversion to all items and add them to temporary array
+ for ( TInt item = 0; item < count; item++ )
+ {
+ CMuiuSettingBase* base = aButtonArray[item];
+
+ // Append only visible items on the list
+ if ( !IsHidden( *base ) )
+ {
+ HBufC* label = base->iItemLabel->AllocLC();
+ TPtr labelPtr = label->Des();
+
+ // Do number conversion when needed
+ if ( base->iItemFlags.Flag( EMuiuDynItemLangSpecificNumConv ) )
+ {
+ AknTextUtils::DisplayTextLanguageSpecificNumberConversion(
+ labelPtr );
+ }
+
+ // Insert to array and delete old item
+ iButtonArray->AppendL( *label );
+ CleanupStack::PopAndDestroy( label );
+ label = NULL;
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingCreateCheckboxArrayL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SettingCreateCheckboxArrayL(
+ CMuiuDynSetItemArray& aButtonArray )
+ {
+ // Get the item count in array
+ const TInt count = aButtonArray.Count();
+ iCheckboxArray =
+ new ( ELeave ) CSelectionItemList( KMuiuDynArrayGranularity );
+
+ // Do number conversion to all items and add them to temporary array
+ for ( TInt item = 0; item < count; item++ )
+ {
+ CMuiuSettingBase* base = aButtonArray[item];
+
+ // Append only visible items on the list
+ if ( !IsHidden( *base ) )
+ {
+ HBufC* label = base->iItemLabel->AllocLC();
+ TPtr labelPtr = label->Des();
+
+ // Do number conversion when needed
+ if ( base->iItemFlags.Flag( EMuiuDynItemLangSpecificNumConv ) )
+ {
+ AknTextUtils::DisplayTextLanguageSpecificNumberConversion(
+ labelPtr );
+ }
+
+ // Create item and check it
+ CSelectableItem* checkbox =
+ new ( ELeave ) CSelectableItem(
+ *label, base->iItemFlags.Flag( EMuiuDynItemChecked ) );
+ CleanupStack::PushL( checkbox );
+ checkbox->ConstructL();
+
+ // Insert to array and delete old item
+ iCheckboxArray->AppendL( checkbox );
+ CleanupStack::Pop( checkbox );
+ CleanupStack::PopAndDestroy( label );
+ label = NULL;
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingCreateRadioButtonPageL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SettingCreateRadioButtonPageL(
+ CMuiuSettingBase& aBaseItem,
+ TMuiuDynSetUpdateMode& aUpdateMode )
+ {
+ // Convert the base item to radiobutton item
+ CMuiuSettingsLinkExtended* radioArray =
+ static_cast<CMuiuSettingsLinkExtended*>( &aBaseItem );
+
+ // Create button array for the page and set the selection for page
+ SettingCreateButtonArrayL( *radioArray->iItemLinkArray );
+ iSettingValue = radioArray->Value();
+
+ // Create the setting page to member
+ iSettingPage = ( new ( ELeave ) CAknRadioButtonSettingPage(
+ ( *iSettingPageResources )[EIPRRadioButton],
+ iSettingValue, iButtonArray ) );
+
+ // Apply defaults
+ aUpdateMode = DefineDefaultSettingPageL( aBaseItem );
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingCreateCheckboxPageL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SettingCreateCheckboxPageL(
+ CMuiuSettingBase& aBaseItem,
+ TMuiuDynSetUpdateMode& aUpdateMode )
+ {
+ // Convert the base item to radiobutton item
+ CMuiuSettingsLink* radioArray =
+ static_cast<CMuiuSettingsLink*>( &aBaseItem );
+
+ // Create button array for the page
+ SettingCreateCheckboxArrayL( *radioArray->iItemLinkArray );
+
+ // Create the setting page to member
+ iSettingPage = new ( ELeave ) CIMSSettingsWizardCheckBoxPage(
+ ( *iSettingPageResources )[EIPRCheckbox], iCheckboxArray,
+ aBaseItem.iItemFlags.Flag( EMuiuDynItemForceMustFill ) );
+
+ // Apply defaults
+ aUpdateMode = DefineDefaultSettingPageL( aBaseItem );
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingCreatePlainTextEditorPageL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SettingCreatePlainTextEditorPageL(
+ CMuiuSettingBase& aBaseItem,
+ TMuiuDynSetUpdateMode& aUpdateMode )
+ {
+ // Get the text to be edited
+ CMuiuSettingsEditText* textEditor =
+ static_cast<CMuiuSettingsEditText*>( &aBaseItem );
+ iSettingText = new ( ELeave ) TMuiuSettingsText( *textEditor->Text() );
+ iSettingText->Copy( *textEditor->Text() );
+
+ // Define flags according to item
+ TInt flags = GetTextEditorFlags( aBaseItem );
+
+ // Create the setting page using the flags
+ TInt pageResource = ( *iSettingPageResources )[EIPRText];
+ CAknTextSettingPage* settingPage =
+ new ( ELeave ) CAknTextSettingPage(
+ pageResource, *iSettingText, flags );
+ CleanupStack::PushL( settingPage );
+ settingPage->ConstructL();
+ CEikEdwin& txtCtrl = *settingPage->TextControl();
+ txtCtrl.SetTextLimit( textEditor->iItemMaxLength );
+
+ if ( textEditor->iItemFlags.Flag( EMuiuDynItemLatinOnly ) )
+ {
+ txtCtrl.SetAknEditorFlags(
+ EAknEditorFlagLatinInputModesOnly | EAknEditorFlagNoT9 );
+ }
+
+ iSettingPage = settingPage;
+ CleanupStack::Pop( settingPage );
+
+ // Apply defaults
+ aUpdateMode = DefineDefaultSettingPageL( aBaseItem );
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingCreatePasswordTextEditorPageL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SettingCreatePasswordTextEditorPageL(
+ CMuiuSettingBase& aBaseItem,
+ TMuiuDynSetUpdateMode& aUpdateMode )
+ {
+ // Prepare password and save the old
+ CMuiuSettingsEditText* textEditor =
+ static_cast<CMuiuSettingsEditText*>( &aBaseItem );
+
+ iNewPassword = new ( ELeave ) TMuiuPasswordText(
+ textEditor->Text()->Left( KMuiuDynMaxPasswordLength ) );
+ iOldPassword = new ( ELeave ) TMuiuPasswordText(
+ textEditor->Text()->Left( KMuiuDynMaxPasswordLength ) );
+
+ // Create the settings page
+ iSettingPage = ( new ( ELeave ) CAknAlphaPasswordSettingPage(
+ ( *iSettingPageResources )[EIPRSecret],
+ *iNewPassword, *iOldPassword ) );
+ iSettingPage->ConstructL();
+ CAknAlphaPasswordSettingPage* pwPage =
+ static_cast<CAknAlphaPasswordSettingPage*>( iSettingPage );
+ pwPage->SetMaxPasswordLength( textEditor->iItemMaxLength );
+ if ( pwPage->AlphaPasswordEditor() )
+ {
+ pwPage->AlphaPasswordEditor()->SetMaxLength(
+ textEditor->iItemMaxLength );
+ }
+
+ // Apply defaults
+ aUpdateMode = DefineDefaultSettingPageL( aBaseItem );
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingCreatePlainNumberEditorPageL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SettingCreatePlainNumberEditorPageL(
+ CMuiuSettingBase& aBaseItem,
+ TMuiuDynSetUpdateMode& aUpdateMode )
+ {
+ // Conver item and set the value
+ CMuiuSettingsEditValue* numberEditor =
+ static_cast<CMuiuSettingsEditValue*>( &aBaseItem );
+ iSettingValue = numberEditor->Value();
+
+ // Define flags according to item
+ TInt flags = GetValueEditorFlags( aBaseItem );
+
+ // Create aSetting page
+ iSettingPage = ( new ( ELeave ) CAknIntegerSettingPage(
+ ( *iSettingPageResources )[EIPRNumber],
+ *&iSettingValue , flags ) );
+ iSettingPage->ConstructL();
+
+ CEikEdwin* textControl = static_cast<CAknIntegerSettingPage*>(
+ iSettingPage )->TextControl();
+
+
+ textControl->SetTextLimit( numberEditor->iItemMaxLength );
+ textControl->SetAknEditorNumericKeymap( EAknEditorPlainNumberModeKeymap );
+
+
+ // Apply defaults, for number editors, the update mode has to be onchange
+ aBaseItem.iItemFlags.SetFlag( EMuiuDynItemUpdateOnChange );
+ aUpdateMode = DefineDefaultSettingPageL( aBaseItem );
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingCreateScNumberEditorPageL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SettingCreateScNumberEditorPageL(
+ CMuiuSettingBase& aBaseItem,
+ TMuiuDynSetUpdateMode& aUpdateMode )
+ {
+ // Conver item and set the value
+ CMuiuSettingsEditText* textEditor =
+ static_cast<CMuiuSettingsEditText*>( &aBaseItem );
+ iSettingText = new ( ELeave ) TMuiuSettingsText( *textEditor->Text() );
+ iSettingText->Copy( *textEditor->Text() );
+
+ if ( aBaseItem.iItemFlags.Flag( EMuiuDynItemLangSpecificNumConv ) )
+ {
+ AknTextUtils::DisplayTextLanguageSpecificNumberConversion(
+ *iSettingText );
+ }
+
+ // Define flags according to item
+ TInt flags = CAknIntegerSettingPage::EInvalidValueNotOffered;
+ flags |= !aBaseItem.iItemFlags.Flag( EMuiuDynItemForceMustFill ) &
+ CAknIntegerSettingPage::EEmptyValueAllowed;
+ flags |= aBaseItem.iItemFlags.Flag( EMuiuDynItemNoInitialSelection ) &
+ CAknIntegerSettingPage::ENoInitialSelection;
+ flags |= aBaseItem.iItemFlags.Flag( EMuiuDynItemEditorCursorAtBeginning ) &
+ CAknIntegerSettingPage::EPutCursorAtBeginning;
+
+ // Create aSetting page
+ iSettingPage = ( new ( ELeave ) CAknTextSettingPage(
+ ( *iSettingPageResources )[EIPRScNumber],
+ *iSettingText, flags ) );
+ iSettingPage->ConstructL();
+ static_cast<CAknTextSettingPage*>( iSettingPage
+ )->TextControl()->SetTextLimit( textEditor->iItemMaxLength );
+ iSettingPage->SetSettingTextL( *textEditor->iItemLabel );
+
+ // Apply defaults
+ aUpdateMode = DefineDefaultSettingPageL( aBaseItem );
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingLaunchPageLD()
+// ----------------------------------------------------------------------------
+//
+TMuiuPageResult CMuiuDynamicSettingsDialog::SettingLaunchPageLD(
+ CMuiuSettingBase& aBaseItem,
+ TMuiuDynSetUpdateMode& aUpdateMode )
+ {
+ switch ( aBaseItem.Type() )
+ {
+ case EMuiuDynSetRadioButtonArray:
+ return SettingLaunchRadioButtonPageLD(
+ aBaseItem, aUpdateMode );
+
+ case EMuiuDynSetCheckBoxArray:
+ return SettingLaunchCheckboxPageLD( aBaseItem, aUpdateMode );
+
+ case EMuiuDynSetItemEditText:
+ case EMuiuDynSetItemEditScValue:
+ return SettingLaunchTextEditorPageLD( aBaseItem, aUpdateMode );
+
+ case EMuiuDynSetItemEditValue:
+ return SettingLaunchNumberEditorPageLD( aBaseItem, aUpdateMode );
+
+ // Multiline dialogs are launched from client only
+ case EMuiuDynSetItemMultiLine:
+ return SettingLaunchMultilinePageL( aBaseItem, aUpdateMode );
+
+ default:
+ __ASSERT_DEBUG( EFalse, User::Panic(
+ KMuiuDynSetDialogPanic, KErrUnknown ) );
+ return EMuiuPageResultCancelled;
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingLaunchRadioButtonPageLD()
+// ----------------------------------------------------------------------------
+//
+TMuiuPageResult CMuiuDynamicSettingsDialog::SettingLaunchRadioButtonPageLD(
+ CMuiuSettingBase& aBaseItem,
+ TMuiuDynSetUpdateMode& aUpdateMode )
+ {
+ // Convert the base item to radio item
+ CMuiuSettingsLink* linkArray = static_cast<CMuiuSettingsLink*>( &aBaseItem );
+ TMuiuPageResult result = EMuiuPageResultOk;
+
+ if ( linkArray->iItemFlags.Flag( EMuiuDynItemEnterPressed ) &&
+ !linkArray->iItemFlags.Flag( EMuiuDynItemOneTimeForceViewOpen ) )
+ {
+ TInt value = !linkArray->Value();
+ TMuiuPageEventResult evaluation =
+ EventItemEvaluateRadioButton( *linkArray, value );
+
+ // Handle approved item
+ if ( evaluation == EMuiuPageEventResultApproved )
+ {
+ // Change the value and the text
+ linkArray->SetValue( value );
+ linkArray->iItemSettingText->Copy(
+ *( *linkArray->iItemLinkArray
+ )[value]->iItemLabel );
+ }
+
+ result = EMuiuPageResultOk;
+ }
+ else
+ {
+ // Opening the editor, clear flag immediately
+ linkArray->iItemFlags.ClearFlag( EMuiuDynItemOneTimeForceViewOpen );
+
+ // Launch the settings dialog and update the item, if item is valid
+ if ( iSettingPage->ExecuteLD( aUpdateMode ) > 0 )
+ {
+ iSettingPage = NULL;
+ TMuiuPageEventResult evaluation =
+ EventItemEvaluateRadioButton( *linkArray, iSettingValue );
+
+ // Handle approved item
+ if ( evaluation == EMuiuPageEventResultApproved )
+ {
+ // First store the index value from the visible radiobutton array
+ linkArray->SetValue( iSettingValue );
+ CMuiuSettingBase* subItem =
+ GetSubItem( *linkArray, iSettingValue );
+
+ // Mark the item as checked and copy the text
+ if ( subItem )
+ {
+ CheckRadioButton( *linkArray, subItem->iItemId );
+ linkArray->iItemSettingText->Copy( *subItem->iItemLabel );
+ }
+
+ result = EMuiuPageResultOk;
+ }
+ // Handle disapproved item
+ else if ( evaluation == EMuiuPageEventResultDisapproved )
+ {
+ result = EMuiuPageResultEditing;
+ }
+ // Handle cancelled item
+ else
+ {
+ result = EMuiuPageResultCancelled;
+ }
+ }
+ else
+ {
+ // Editor cancelled
+ iSettingPage = NULL;
+ result = EMuiuPageResultCancelled;
+ }
+ }
+
+ linkArray = NULL;
+
+ // Return the result
+ return result;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingLaunchCheckboxPageLD()
+// ----------------------------------------------------------------------------
+//
+TMuiuPageResult CMuiuDynamicSettingsDialog::SettingLaunchCheckboxPageLD(
+ CMuiuSettingBase& aBaseItem,
+ TMuiuDynSetUpdateMode& aUpdateMode )
+ {
+ // Convert the base item to link item
+ CMuiuSettingsLinkExtended* checkboxArray =
+ static_cast<CMuiuSettingsLinkExtended*>( &aBaseItem );
+ TMuiuPageResult result = EMuiuPageResultOk;
+
+ // Launch the settings dialog and update the item, if item is valid
+ if ( iSettingPage->ExecuteLD( aUpdateMode ) )
+ {
+ iSettingPage = NULL;
+ TMuiuPageEventResult evaluation =
+ EventItemEvaluateValue( aBaseItem, iSettingValue );
+
+ if ( evaluation == EMuiuPageEventResultApproved )
+ {
+ // Clean the value
+ TInt checkbox = 0;
+
+ // Check all items in the array, and set the flags to item
+ for ( TInt item = iCheckboxArray->Count(); --item >= 0; )
+ {
+ TBool checked = iCheckboxArray->At( item )->SelectionStatus();
+ checkboxArray->iItemLinkArray->At( item )->iItemFlags.ChangeFlag(
+ EMuiuDynItemChecked, checked );
+
+ checkbox |= ( checked << item );
+ }
+
+ checkboxArray->SetValue( checkbox );
+
+ result = EMuiuPageResultOk;
+ }
+ // Handle disapproved item
+ else if ( evaluation == EMuiuPageEventResultDisapproved )
+ {
+ result = EMuiuPageResultEditing;
+ }
+ // Handle cancelled item
+ else
+ {
+ result = EMuiuPageResultCancelled;
+ }
+ }
+ else
+ {
+ // Editor cancelled
+ iSettingPage = NULL;
+ result = EMuiuPageResultCancelled;
+ }
+
+ return result;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingLaunchTextEditorPageLD()
+// ----------------------------------------------------------------------------
+//
+TMuiuPageResult CMuiuDynamicSettingsDialog::SettingLaunchTextEditorPageLD(
+ CMuiuSettingBase& aBaseItem,
+ TMuiuDynSetUpdateMode& aUpdateMode )
+ {
+ TMuiuPageResult result = EMuiuPageResultOk;
+
+ if ( iSettingPage->ExecuteLD( aUpdateMode ) > 0 )
+ {
+ iSettingPage = NULL;
+ TMuiuSettingsText* settingText = new(ELeave) TMuiuSettingsText;
+
+ // Depending on the text editor, choose the correct text
+ if ( aBaseItem.iItemFlags.Flag( EMuiuDynItemPassword ) )
+ {
+ settingText->Copy( *iNewPassword );
+ }
+ else
+ {
+ settingText->Copy( *iSettingText );
+ }
+
+ TMuiuPageEventResult evaluation =
+ EventItemEvaluateText( aBaseItem, *settingText );
+
+ if ( evaluation == EMuiuPageEventResultApproved )
+ {
+ // Text is ok, store the text and close editor
+ aBaseItem.SetText( settingText );
+ }
+ // Handle disapproved item
+ else if ( evaluation == EMuiuPageEventResultDisapproved )
+ {
+ result = EMuiuPageResultEditing;
+ }
+ // Handle cancelled item
+ else
+ {
+ result = EMuiuPageResultCancelled;
+ }
+ }
+ else
+ {
+ iSettingPage = NULL;
+ result = EMuiuPageResultCancelled;
+ }
+
+ return result;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingLaunchNumberEditorPageLD()
+// ----------------------------------------------------------------------------
+//
+TMuiuPageResult CMuiuDynamicSettingsDialog::SettingLaunchNumberEditorPageLD(
+ CMuiuSettingBase& aBaseItem,
+ TMuiuDynSetUpdateMode& aUpdateMode )
+ {
+ TMuiuPageResult result = EMuiuPageResultOk;
+
+ // Convert baseitem to number editor
+ CMuiuSettingsEditValue* numberEdit =
+ static_cast<CMuiuSettingsEditValue*>( &aBaseItem );
+
+ // Launch the editor and fill the settings if approved
+ if ( iSettingPage->ExecuteLD( aUpdateMode ) )
+ {
+ iSettingPage = NULL;
+ TMuiuPageEventResult evaluation =
+ EventItemEvaluateValue( aBaseItem, iSettingValue );
+
+ // Evaluate item
+ if ( evaluation == EMuiuPageEventResultApproved )
+ {
+ // Item ok
+ numberEdit->SetValue( iSettingValue );
+ numberEdit->iItemSettingText->Num( iSettingValue );
+ result = EMuiuPageResultOk;
+ }
+ // Handle disapproved item
+ else if ( evaluation == EMuiuPageEventResultDisapproved )
+ {
+ result = EMuiuPageResultEditing;
+ }
+ // Handle cancelled item
+ else
+ {
+ result = EMuiuPageResultCancelled;
+ }
+ }
+ else
+ {
+ // Editor cancelled
+ iSettingPage = NULL;
+ result = EMuiuPageResultCancelled;
+ }
+
+ return result;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingLaunchScNumberEditorPageLD()
+// ----------------------------------------------------------------------------
+//
+TMuiuPageResult CMuiuDynamicSettingsDialog::SettingLaunchScNumberEditorPageLD(
+ CMuiuSettingBase& aBaseItem,
+ TMuiuDynSetUpdateMode& aUpdateMode )
+ {
+ // Convert baseitem to number editor
+ CMuiuSettingsEditText* textEditor =
+ static_cast<CMuiuSettingsEditText*>( &aBaseItem );
+ TMuiuPageResult result = EMuiuPageResultOk;
+
+ // Launch the editor and fill the settings if approved
+ if ( iSettingPage->ExecuteLD( aUpdateMode ) )
+ {
+ iSettingPage = NULL;
+ TMuiuPageEventResult evaluation =
+ EventItemEvaluateText( aBaseItem, *iSettingText );
+
+ if ( evaluation == EMuiuPageEventResultApproved )
+ {
+ // Item ok
+ AknTextUtils::ConvertDigitsTo( *iSettingText, EDigitTypeWestern );
+ textEditor->SetText( iSettingText );
+ result = EMuiuPageResultOk;
+ }
+ // Handle disapproved item
+ else if ( evaluation == EMuiuPageEventResultDisapproved )
+ {
+ result = EMuiuPageResultEditing;
+ }
+ // Handle cancelled item
+ else
+ {
+ result = EMuiuPageResultCancelled;
+ }
+ }
+ else
+ {
+ // Editor cancelled
+ iSettingPage = NULL;
+ result = EMuiuPageResultCancelled;
+ }
+
+ return result;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingLaunchMultilinePageL()
+// ----------------------------------------------------------------------------
+//
+TMuiuPageResult CMuiuDynamicSettingsDialog::SettingLaunchMultilinePageL(
+ CMuiuSettingBase& aBaseItem,
+ TMuiuDynSetUpdateMode& aUpdateMode )
+ {
+ TMuiuPageEventResult result =
+ SettingLaunchMultilineEditorL( aBaseItem, aUpdateMode );
+
+ switch ( result )
+ {
+ case EMuiuPageEventResultApproved:
+ return EMuiuPageResultOk;
+
+ case EMuiuPageEventResultDisapproved:
+ return EMuiuPageResultEditing;
+
+ default:
+ case EMuiuPageEventResultCancel:
+ break;
+ }
+
+ return EMuiuPageResultCancelled;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingLaunchMultilineEditorL()
+// ----------------------------------------------------------------------------
+//
+TMuiuPageEventResult CMuiuDynamicSettingsDialog::SettingLaunchMultilineEditorL(
+ CMuiuSettingBase& /* aBaseItem */,
+ TMuiuDynSetUpdateMode& /* aUpdateMode */ )
+ {
+ // This should be called from the client side
+ __ASSERT_DEBUG( EFalse,
+ User::Panic( KMuiuDynSetDialogPanic, KErrUnknown ) );
+
+ return EMuiuPageEventResultCancel;
+ }
+
+/******************************************************************************
+
+ Event handling
+
+******************************************************************************/
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::EventArrayChangedL()
+// ----------------------------------------------------------------------------
+//
+TInt CMuiuDynamicSettingsDialog::EventArrayChangedL(
+ const TMuiuArrayEvents aEvent )
+ {
+ switch ( aEvent )
+ {
+ case EMuiuDynArrayAdded:
+ iListBox.HandleItemAdditionL();
+ break;
+
+ case EMuiuDynArrayRemoved:
+ iListBox.HandleItemRemovalL();
+ break;
+
+ // When array has changed, send event before updating listbox
+ case EMuiuDynArrayStackForward:
+ case EMuiuDynArrayStackBackward:
+ EventPrepareSubArrayL(
+ *GetItem( 0 ),
+ aEvent == EMuiuDynArrayStackForward ? ETrue : EFalse );
+
+ //lint -fallthrough
+ case EMuiuDynArrayChanged:
+ iListBox.HandleItemRemovalL();
+ iListBox.HandleItemAdditionL();
+ break;
+ }
+
+ return KErrNone;
+ }
+
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::EventSubArrayChangeL()
+// ----------------------------------------------------------------------------
+//
+TInt CMuiuDynamicSettingsDialog::EventSubArrayChangeL(
+ CMuiuSettingBase& /* aBaseItem */ )
+ {
+ return KErrNone;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::EventItemEditStartsL()
+// ----------------------------------------------------------------------------
+//
+TMuiuPageEventResult CMuiuDynamicSettingsDialog::EventItemEditStartsL(
+ CMuiuSettingBase& /* aBaseItem */ )
+ {
+ return EMuiuPageEventResultApproved;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::EventItemEditEndsL()
+// ----------------------------------------------------------------------------
+//
+TInt CMuiuDynamicSettingsDialog::EventItemEditEndsL(
+ CMuiuSettingBase& /* aBaseItem */ )
+ {
+ return KErrNone;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::EventItemEvaluateRadioButton()
+// ----------------------------------------------------------------------------
+//
+TMuiuPageEventResult CMuiuDynamicSettingsDialog::EventItemEvaluateRadioButton(
+ const CMuiuSettingBase& /* aBaseItem */,
+ TInt& /* aNewValue */ )
+ {
+ // This check fails always
+ return EMuiuPageEventResultApproved;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::EventItemEvaluateValue()
+// ----------------------------------------------------------------------------
+//
+TMuiuPageEventResult CMuiuDynamicSettingsDialog::EventItemEvaluateValue(
+ const CMuiuSettingBase& /* aBaseItem */,
+ TInt& /* aNewValue */ )
+ {
+ // This check always true
+ return EMuiuPageEventResultApproved;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::EventItemEvaluateText()
+// ----------------------------------------------------------------------------
+//
+TMuiuPageEventResult CMuiuDynamicSettingsDialog::EventItemEvaluateText(
+ const CMuiuSettingBase& /* aBaseItem */,
+ TDes& /* aNewText */ )
+ {
+ // This check fails always
+ return EMuiuPageEventResultApproved;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::EventCustomMdcaPoint()
+// ----------------------------------------------------------------------------
+//
+TBool CMuiuDynamicSettingsDialog::EventCustomMdcaPoint(
+ const TUid& /* aId */,
+ TPtr& /* aString */ ) const
+ {
+ return EFalse;
+ }
+
+/******************************************************************************
+
+ Utilities
+
+******************************************************************************/
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingsStartedL()
+// ----------------------------------------------------------------------------
+//
+TInt CMuiuDynamicSettingsDialog::SettingsStartedL()
+ {
+ return KErrNone;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingPageResource()
+// ----------------------------------------------------------------------------
+//
+TInt CMuiuDynamicSettingsDialog::SettingPageResource(
+ const TIMSPageResource aSettingPage ) const
+ {
+ return ( *iSettingPageResources )[aSettingPage];
+ }
+
+
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SetSettingPageResource()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SetSettingPageResource(
+ const TIMSPageResource aSettingPage,
+ const TInt aResourceId )
+ {
+ TRAP_IGNORE( iSettingPageResources->PushResourceL( aSettingPage, aResourceId ) );
+ }
+
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::ShowCustomQueryL()
+// ----------------------------------------------------------------------------
+//
+TInt CMuiuDynamicSettingsDialog::ShowCustomQueryL(
+ const TInt aResourceStringId )
+ {
+ iQueryDialog = CAknQueryDialog::NewL();
+ TInt result = iQueryDialog->ExecuteLD( aResourceStringId );
+ iQueryDialog = NULL;
+ return result;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::CurrentItemIndex()
+// ----------------------------------------------------------------------------
+//
+TInt CMuiuDynamicSettingsDialog::CurrentItemIndex() const
+ {
+ return iListBox.CurrentItemIndex();
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::CurrentItem()
+// ----------------------------------------------------------------------------
+//
+CMuiuSettingBase* CMuiuDynamicSettingsDialog::CurrentItem() const
+ {
+ return GetItem( iListBox.CurrentItemIndex() );
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::GetValueEditorFlags()
+// ----------------------------------------------------------------------------
+//
+TInt CMuiuDynamicSettingsDialog::GetValueEditorFlags(
+ const CMuiuSettingBase& aBaseItem )
+ {
+ // Get the flags for editor
+ TInt flags =
+ CAknIntegerSettingPage::EInvalidValueNotOffered;
+ flags |= !aBaseItem.iItemFlags.Flag( EMuiuDynItemForceMustFill ) ?
+ CAknIntegerSettingPage::EEmptyValueAllowed : 0;
+ flags |= aBaseItem.iItemFlags.Flag( EMuiuDynItemNoInitialSelection ) ?
+ CAknIntegerSettingPage::ENoInitialSelection : 0;
+ flags |= aBaseItem.iItemFlags.Flag( EMuiuDynItemEditorCursorAtBeginning ) ?
+ CAknIntegerSettingPage::EPutCursorAtBeginning : 0;
+
+ return flags;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::GetTextEditorFlags()
+// ----------------------------------------------------------------------------
+//
+TInt CMuiuDynamicSettingsDialog::GetTextEditorFlags(
+ const CMuiuSettingBase& aBaseItem )
+ {
+ TInt flags =
+ CAknTextSettingPage::EZeroLengthNotOffered;
+ flags |= !aBaseItem.iItemFlags.Flag( EMuiuDynItemForceMustFill ) ?
+ CAknTextSettingPage::EZeroLengthAllowed : 0;
+ flags |= aBaseItem.iItemFlags.Flag( EMuiuDynItemNoInitialSelection ) ?
+ CAknTextSettingPage::ENoInitialSelection : 0;
+ flags |= aBaseItem.iItemFlags.Flag( EMuiuDynItemEditorCursorAtBeginning ) ?
+ CAknTextSettingPage::EPutCursorAtBeginning : 0;
+
+ return flags;
+ }
+
+/******************************************************************************
+
+ Item initialization
+
+******************************************************************************/
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::InitAnyItem()
+// ----------------------------------------------------------------------------
+//
+TInt CMuiuDynamicSettingsDialog::InitAnyItem(
+ CMuiuSettingBase& aBaseItem,
+ const TInt aValue,
+ const TMuiuSettingsText* aText )
+ {
+ TInt error = KErrNone;
+
+ // Initialize any item
+ switch ( aBaseItem.Type() )
+ {
+ case EMuiuDynSetMenuArray:
+ error = InitArrayLink( aBaseItem, aText );
+ break;
+
+ case EMuiuDynSetRadioButtonArray:
+ error = InitArrayRadioButton( aBaseItem, aValue, aText );
+ break;
+
+ case EMuiuDynSetCheckBoxArray:
+ error = InitArrayCheckBox( aBaseItem, aValue, aText );
+ break;
+
+ case EMuiuDynSetItemEditText:
+ error = InitItemTextEdit( aBaseItem, aText );
+ break;
+
+ case EMuiuDynSetItemEditValue:
+ error = InitItemNumberEdit( aBaseItem, aValue, aText );
+ break;
+
+ // Radiobutton and checkbox initialization is done during
+ // the array initialization
+ default:
+ error = KErrNotFound;
+ break;
+ }
+
+ // Set the initialized flag on for the item
+ aBaseItem.iItemFlags.ChangeFlag(
+ EMuiuDynItemIsInitialized, error == KErrNone );
+ return error;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::InitAnyMultiItem()
+// ----------------------------------------------------------------------------
+//
+TInt CMuiuDynamicSettingsDialog::InitAnyMultiItem(
+ const CMuiuDynInitItemIdArray* aStartTree,
+ const CMuiuDynInitItemIdArray& aIdArray,
+ const CMuiuDynInitItemValueArray* aValueArray,
+ const CMuiuDynInitItemTextArray* aDescArray,
+ const CMuiuDynInitInfoArray* aInitInfoArray )
+ {
+ // Make sure there are items in array
+ if ( !aIdArray.Count() )
+ {
+ return KErrNotFound;
+ }
+
+ // Count the items in the tree if provided.
+ TInt count = aStartTree ? aStartTree->Count() : KErrNotFound;
+ CMuiuSettingBase* base = NULL;
+
+ // if the starting point has been provided and there is items,
+ // try to find the starting point.
+ if ( count > 0 )
+ {
+ // Get the starting point
+ base = GetItem( aStartTree->At( 0 ) );
+
+ // Go as deep as there are items provided
+ for ( TInt item = 0; ++item < count; )
+ {
+ base = GetSubItem( *base, aStartTree->At( item ) );
+ }
+ }
+
+ // Seek the starting point. If the item has not been found during
+ // the tree search, try to find the given item by normal means.
+ if ( base )
+ {
+ base = GetSubItem( *base, aIdArray.At( 0 ) );
+ }
+ else
+ {
+ base = GetItem( aIdArray.At( 0 ) );
+ }
+
+ // The item has been found initialize item
+ if ( base )
+ {
+ // Prepare
+ TInt valueIndex = 0;
+ TInt textIndex = 0;
+ TInt item = 0;
+ count = aIdArray.Count();
+
+ do
+ {
+ // Intialize the item
+ PrepareInit(
+ *base, aValueArray, aDescArray,
+ aInitInfoArray, valueIndex, textIndex, item );
+
+ // Check if the next item is defined and find it
+ base = ++item < count ?
+ SettingFindEditor( *base, aIdArray.At( item ) ) : NULL;
+ }
+ while ( base );
+ }
+
+ return base ? KErrNone : KErrNotFound;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::PrepareInit()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::PrepareInit(
+ CMuiuSettingBase& aBaseItem,
+ const CMuiuDynInitItemValueArray* aValueArray,
+ const CMuiuDynInitItemTextArray* aDescArray,
+ const CMuiuDynInitInfoArray* aInitInfoArray,
+ TInt& aValueIndex,
+ TInt& aTextIndex,
+ TInt aIndex )
+ {
+ // Prepare temporary array
+ CMuiuDynInitItemValueArray* valueArray =
+ const_cast<CMuiuDynInitItemValueArray*>( aValueArray );
+ CMuiuDynInitItemTextArray* descArray =
+ const_cast<CMuiuDynInitItemTextArray*>( aDescArray );
+
+ // If info array is defined, check, which one should be used
+ if ( aInitInfoArray && aIndex >= 0 && aIndex < aInitInfoArray->Count() )
+ {
+ TMuiuDynInitInfo info = aInitInfoArray->At( aIndex );
+
+ valueArray = ( info == EMuiuDynInitInfoValue ) ?
+ valueArray : NULL;
+ descArray = ( info == EMuiuDynInitInfoText ) ?
+ descArray : NULL;
+ }
+
+ // Initialize item as value
+ if ( valueArray && valueArray->Count() )
+ {
+ InitAnyItem( aBaseItem, valueArray->At( aValueIndex++ ), NULL );
+ }
+ // Initialize item as text
+ else if ( descArray && descArray->Count() )
+ {
+ InitAnyItem( aBaseItem, NULL, descArray->At( aTextIndex++ ) );
+ }
+ else
+ {
+ // Unidentified combination
+ __ASSERT_DEBUG( EFalse,
+ User::Panic( KMuiuDynSetDialogPanic, KErrUnknown ) );
+ }
+
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::InitArrayLink()
+// ----------------------------------------------------------------------------
+//
+TInt CMuiuDynamicSettingsDialog::InitArrayLink(
+ CMuiuSettingBase& aBaseItem,
+ const TMuiuSettingsText* aText )
+ {
+ // Convert item
+ CMuiuSettingsLink* link = static_cast<CMuiuSettingsLink*>( &aBaseItem );
+
+ // Get the item count in array
+ TInt items = KErrNotFound;
+ if ( link->iItemLinkArray )
+ {
+ items = link->iItemLinkArray->Count();
+ }
+
+ // Clear checked flag from all items
+ while ( --items >= 0 )
+ {
+ link->iItemFlags.ClearFlag( EMuiuDynItemChecked );
+
+ // Uncheck the buttons in the array
+ CMuiuSettingBase* base = GetSubItem( aBaseItem, items );
+ if ( base )
+ {
+ base->iItemFlags.ClearFlag( EMuiuDynItemChecked );
+ base = NULL;
+ }
+ }
+
+ // Set the text if provided
+ if ( aText && link->iItemSettingText )
+ {
+ link->iItemSettingText->Copy( *aText );
+ }
+
+ return KErrNone;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::InitArrayRadioButton()
+// ----------------------------------------------------------------------------
+//
+TInt CMuiuDynamicSettingsDialog::InitArrayRadioButton(
+ CMuiuSettingBase& aBaseItem,
+ const TInt aValue,
+ const TMuiuSettingsText* aText )
+ {
+ // Convert item
+ CMuiuSettingsLinkExtended* radioArray =
+ static_cast<CMuiuSettingsLinkExtended*>( &aBaseItem );
+ CMuiuSettingBase* base = NULL;
+
+ // Do normal link array initialization
+ InitArrayLink( aBaseItem, NULL );
+
+ TInt result = KErrNotFound;
+
+ // If the item has no value, check if any of the radiobuttons is
+ // checked, and get the index from there
+ if ( aValue == KErrNotFound && radioArray->iItemLinkArray )
+ {
+ TUid id = TUid::Uid( 0 );
+ TInt index;
+ FindCheckedRadiobutton( *radioArray, id, index );
+ base = GetSubItem( *radioArray, id );
+
+ radioArray->SetValue( index );
+ }
+ // For listbox item, simply check one of the buttons
+ else if ( aValue >= 0 && radioArray->iItemLinkArray &&
+ aValue < radioArray->iItemLinkArray->Count() )
+ {
+ // In initialization phase, the received index value is from
+ // the main resource. Get the visible array's item index
+ // and setting the item checked and getting the checked item
+ TInt value = GetSubItemIndex( *radioArray, aValue, EFalse );
+ CheckRadioButton( *radioArray, value );
+ base = GetSubItem( *radioArray, value );
+
+ // Set number of radiobox item to indicate the checked item
+ radioArray->SetValue( value );
+ result = KErrNone;
+ }
+ else
+ {
+ result = KErrNotFound;
+ }
+
+ // Make sure the setting text exist and copy text if provided
+ if ( result == KErrNone && radioArray->iItemSettingText &&
+ ( aText || ( base && base->iItemLabel ) ) )
+ {
+ radioArray->iItemSettingText->Copy(
+ aText != NULL ? *aText : *base->iItemLabel );
+ }
+
+ base = NULL;
+ radioArray = NULL;
+
+ return result;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::InitArrayCheckBox()
+// ----------------------------------------------------------------------------
+//
+TInt CMuiuDynamicSettingsDialog::InitArrayCheckBox(
+ CMuiuSettingBase& aBaseItem,
+ const TInt aValue,
+ const TMuiuSettingsText* aText )
+ {
+ // Convert item
+ CMuiuSettingsLinkExtended* link =
+ static_cast<CMuiuSettingsLinkExtended*>( &aBaseItem );
+ CMuiuSettingBase* base;
+
+ // Do normal link array initialization
+ InitArrayLink( aBaseItem, NULL );
+ link->SetValue( aValue );
+
+ // aValue can contain value KErrNotFound, which means 32 flags set.
+ // This function trusts the user provides correct value in the field
+ if ( link->iItemLinkArray )
+ {
+ // Get the item count in array
+ TInt buttons = link->iItemLinkArray->Count();
+
+ // Check the checkbox buttons
+ while ( --buttons >= 0 )
+ {
+ base = link->iItemLinkArray->At( buttons );
+
+ base->iItemFlags.ChangeFlag(
+ EMuiuDynItemChecked, ( aValue >> buttons ) & 0x01 );
+ }
+ }
+
+ // Make sure the setting text exist and copy text if provided
+ if ( aText && link->iItemSettingText )
+ {
+ link->iItemSettingText->Copy( *aText );
+ }
+
+ link = NULL;
+ base = NULL;
+
+ return KErrNone;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::InitItemTextEdit()
+// ----------------------------------------------------------------------------
+//
+TInt CMuiuDynamicSettingsDialog::InitItemTextEdit(
+ CMuiuSettingBase& aBaseItem,
+ const TMuiuSettingsText* aText )
+ {
+ // Make sure the text fields exists and fill the item if possible
+ if ( aText && aBaseItem.Text() )
+ {
+ CMuiuSettingsEditText* textEditor =
+ static_cast<CMuiuSettingsEditText*>( &aBaseItem );
+ TMuiuSettingsText tempText;
+ tempText.Copy( aText->Left( textEditor->iItemMaxLength ) );
+ aBaseItem.SetText( &tempText );
+ }
+
+ return KErrNone;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::InitItemNumberEdit()
+// ----------------------------------------------------------------------------
+//
+TInt CMuiuDynamicSettingsDialog::InitItemNumberEdit(
+ CMuiuSettingBase& aBaseItem,
+ const TInt aValue,
+ const TMuiuSettingsText* aText )
+ {
+ // Convert item
+ CMuiuSettingsEditValue* numberEditor =
+ static_cast<CMuiuSettingsEditValue*>( &aBaseItem );
+
+ // Fill the existing fields
+ numberEditor->SetValue( aValue );
+
+ // Make sure all of the fields exists
+ if ( numberEditor->iItemSettingText )
+ {
+ if ( !aText )
+ {
+ numberEditor->iItemSettingText->Num( aValue );
+ }
+ else
+ {
+ numberEditor->iItemSettingText->Copy( *aText );
+ }
+ }
+
+ return KErrNone;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::InitItemUnidentified()
+// ----------------------------------------------------------------------------
+//
+TInt CMuiuDynamicSettingsDialog::InitItemUnidentified(
+ CMuiuSettingBase& /* aBaseItem */,
+ const TInt /* aValue */,
+ const TMuiuSettingsText* /* aText */ )
+ {
+ return KErrNotFound;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SettingsLastItemIndex()
+// ----------------------------------------------------------------------------
+//
+TInt CMuiuDynamicSettingsDialog::SettingsLastItemIndex(
+ const TBool aRemove ) const
+ {
+ // Store the last index to speed up fetching and removing
+ TInt lastIndex = iSettingsLastItemIndex->Count() - 1;
+
+ // Fetch the last item in the list and remove it
+ TInt lastItem = iSettingsLastItemIndex->At( lastIndex );
+
+ if ( aRemove )
+ {
+ iSettingsLastItemIndex->Delete( lastIndex );
+ }
+
+ // in case the array has been changed, set the new index in the boundaries
+ // of the new array
+ SetBetweenValues( lastItem, 0, MdcaCount() );
+
+ return lastItem;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SetSettingsLastItemIndexL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SetSettingsLastItemIndexL(
+ const TInt aLastItemIndex )
+ {
+ iSettingsLastItemIndex->AppendL( aLastItemIndex );
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SetListboxEmptyTextL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SetListboxEmptyTextL(
+ const TDesC& aText )
+ {
+ iListBox.View()->SetListEmptyTextL( aText );
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::CurrentSettingsPage()
+// ----------------------------------------------------------------------------
+//
+CMuiuSettingBase* CMuiuDynamicSettingsDialog::CurrentSettingsPage(
+ const TBool aRemove )
+ {
+ // Get the last item in the array
+ TInt lastIndex = iSettingsPageArray->Count() - 1;
+
+ // Get item
+ CMuiuSettingBase* currentItem = NULL;
+
+ if ( lastIndex >= 0 )
+ {
+ currentItem = iSettingsPageArray->At( lastIndex );
+ }
+
+ // Remove the item when required
+ if ( aRemove )
+ {
+ iSettingsPageArray->Delete( lastIndex );
+ }
+
+ return currentItem;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SetCurrentSettingsPage()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SetCurrentSettingsPage(
+ CMuiuSettingBase& aBaseItem )
+ {
+ if ( iSettingsPageArray->Count() < KMuiuMaxEditors )
+ {
+ // Set the new item as a last item
+ TRAP_IGNORE( iSettingsPageArray->AppendL( &aBaseItem ) );
+
+ // Insert the backup item to array
+ TRAP_IGNORE( AddBackupItemL( aBaseItem ) );
+ }
+ else
+ {
+ // Too many editors, something is wrong
+ __ASSERT_DEBUG( EFalse, User::Panic(
+ KMuiuDynSetDialogPanic, KErrOverflow ) );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::CheckRadioButton()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::CheckRadioButton(
+ CMuiuSettingsLink& aRadioButtonArray,
+ const TInt aRadioButtonIndex )
+ {
+ // Make sure the array exists
+ if ( aRadioButtonArray.iItemLinkArray )
+ {
+ CMuiuDynSetItemArray& array = *aRadioButtonArray.iItemLinkArray;
+
+ // The loop must return the index of the item from the visible list
+ // All items must be searched through
+ // Each item has to be checked from their hidden properties
+ const TInt buttons = array.Count();
+ TInt index = buttons;
+
+ // First, the item flags needs to be cleared
+ while ( --index >= 0 )
+ {
+ array[index]->iItemFlags.ClearFlag( EMuiuDynItemChecked );
+ }
+
+ // Get the item from the actual list
+ CMuiuSettingBase* subItem =
+ GetSubItem( aRadioButtonArray, aRadioButtonIndex );
+
+ if ( subItem )
+ {
+ subItem->iItemFlags.SetFlag( EMuiuDynItemChecked );
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::CheckRadioButton()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::CheckRadioButton(
+ CMuiuSettingsLink& aRadioButtonArray,
+ const TUid& aId )
+ {
+ // Make sure the array exists
+ if ( aRadioButtonArray.iItemLinkArray )
+ {
+ CMuiuSettingBase* radioButton = NULL;
+
+ TInt buttons = aRadioButtonArray.iItemLinkArray->Count();
+
+ // Check the selected radiobutton
+ while ( --buttons >= 0 )
+ {
+ radioButton = ( *aRadioButtonArray.iItemLinkArray )[buttons];
+ radioButton->iItemFlags.ChangeFlag(
+ EMuiuDynItemChecked, radioButton->iItemId == aId );
+ }
+ }
+
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::FindCheckedRadiobutton()
+// ----------------------------------------------------------------------------
+//
+TInt CMuiuDynamicSettingsDialog::FindCheckedRadiobutton(
+ const CMuiuSettingsLinkExtended& aArray,
+ TUid& aId,
+ TInt& aIndex )
+ {
+ CMuiuSettingBase* radioButton = NULL;
+ aId.iUid = KErrNotFound;
+ aIndex = KErrNotFound;
+
+ if ( aArray.iItemLinkArray )
+ {
+ // Find the checked radio button, as there can be only one!
+ for ( TInt count = aArray.iItemLinkArray->Count(); --count >= 0; )
+ {
+ radioButton = ( *aArray.iItemLinkArray )[count];
+
+ // Search for the radiobuttons but ignore hidden ones,
+ // even if it is checked
+ if ( radioButton && !IsHidden( *radioButton ) )
+ {
+ ++aIndex;
+
+ // If checked, return the value
+ if ( radioButton->iItemFlags.Flag( EMuiuDynItemChecked ) )
+ {
+ aId = radioButton->iItemId;
+ return KErrNone;
+ }
+ }
+ }
+ }
+
+ return KErrNotFound;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::AddBackupItemL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::AddBackupItemL(
+ const CMuiuSettingBase& aBaseItem )
+ {
+ switch ( aBaseItem.iItemType )
+ {
+ case EMuiuDynSetItemMultiLine:
+ case EMuiuDynSetRadioButtonArray:
+ case EMuiuDynSetCheckBoxArray:
+ BackupItemCreateRadioL( aBaseItem );
+ break;
+
+ case EMuiuDynSetItemEditScValue:
+ case EMuiuDynSetItemEditText:
+ BackupItemCreateTextL( aBaseItem );
+ break;
+
+ case EMuiuDynSetItemEditValue:
+ BackupItemCreateValueL( aBaseItem );
+ break;
+
+ case EMuiuDynSetUndefined:
+ BackupItemCreateUndefinedL( aBaseItem );
+ break;
+
+ default:
+ // No need to backup, or unsupported
+ break;
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::RemoveLastBackupItem()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::RemoveLastBackupItem()
+ {
+ CMuiuSettingBase* base = GetLastBackupItem();
+ iBackupArray->Delete( iBackupArray->Count() - 1 );
+
+ if ( base )
+ {
+ // With link items do not delete array, since the pointer points
+ // directly to original array. So set the pointer to null before
+ // deleting the item.
+ if ( base->HasLinkArray() )
+ {
+ static_cast<CMuiuSettingsLink*>( &*base )->iItemLinkArray = NULL;
+ }
+
+ delete base;
+ base = NULL;
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::GetLastBackupItem()
+// ----------------------------------------------------------------------------
+//
+CMuiuSettingBase* CMuiuDynamicSettingsDialog::GetLastBackupItem()
+ {
+ return iBackupArray->At( iBackupArray->Count() - 1 );
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::RestoreFromBackup()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::RestoreFromBackup()
+ {
+ // Restore
+ for ( TInt count = iSettingsPageArray->Count(); --count >= 0; )
+ {
+ TInt lastPageNum = iSettingsPageArray->Count() - 1;
+ TInt lastBackupNum = iBackupArray->Count() - 1;
+ CMuiuSettingBase* currentPage = iSettingsPageArray->At( lastPageNum );
+ CMuiuSettingBase* backupPage = iBackupArray->At( lastBackupNum );
+
+ // Restore values
+ const TMuiuSettingsText* text = ItemText( *backupPage );
+ if ( text )
+ {
+ SetItemText( *currentPage, *text );
+ }
+
+ currentPage->SetValue( backupPage->Value() );
+ currentPage->SetText( backupPage->Text() );
+
+ if ( currentPage->iItemType == EMuiuDynSetRadioButtonArray )
+ {
+ // Convert item and check radiobutton from backup array
+ CMuiuSettingsLinkExtended* radioArray =
+ static_cast<CMuiuSettingsLinkExtended*>( currentPage );
+ CheckRadioButton( *radioArray, backupPage->Value() );
+ }
+
+ iSettingsPageArray->Delete( lastPageNum );
+ RemoveLastBackupItem();
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::CleanBackupArray()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::CleanBackupArray()
+ {
+ for ( TInt count = iBackupArray->Count(); --count >= 0; )
+ {
+ RemoveLastBackupItem();
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::BackupItemCreateLinkL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::BackupItemCreateLinkL(
+ const CMuiuSettingBase& aBaseItem )
+ {
+ CMuiuSettingsLink* linkBackup = CMuiuSettingsLink::NewL();
+ const CMuiuSettingsLink* link =
+ static_cast<const CMuiuSettingsLink*>( &aBaseItem );
+ *linkBackup = *link;
+
+ iBackupArray->AppendL( linkBackup );
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::BackupItemCreateRadioL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::BackupItemCreateRadioL(
+ const CMuiuSettingBase& aBaseItem )
+ {
+ CMuiuSettingsLinkExtended* radioBackup = CMuiuSettingsLinkExtended::NewL();
+ const CMuiuSettingsLinkExtended* radio =
+ static_cast<const CMuiuSettingsLinkExtended*>( &aBaseItem );
+ *radioBackup = *radio;
+
+ iBackupArray->AppendL( radioBackup );
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::BackupItemCreateValueL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::BackupItemCreateValueL(
+ const CMuiuSettingBase& aBaseItem )
+ {
+ CMuiuSettingsEditValue* valueBackup = CMuiuSettingsEditValue::NewL();
+ const CMuiuSettingsEditValue* value =
+ static_cast<const CMuiuSettingsEditValue*>( &aBaseItem );
+ *valueBackup = *value;
+
+ iBackupArray->AppendL( valueBackup );
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::BackupItemCreateTextL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::BackupItemCreateTextL(
+ const CMuiuSettingBase& aBaseItem )
+ {
+ CMuiuSettingsEditText* textBackup = CMuiuSettingsEditText::NewL();
+ const CMuiuSettingsEditText* text =
+ static_cast<const CMuiuSettingsEditText*>( &aBaseItem );
+ *textBackup = *text;
+
+ iBackupArray->AppendL( textBackup );
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::BackupItemCreateUndefinedL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::BackupItemCreateUndefinedL(
+ const CMuiuSettingBase& aBaseItem )
+ {
+ CMuiuSettingBase* base = CreateItemForBackupL( aBaseItem );
+
+ iBackupArray->AppendL( base );
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::CreateItemForBackupL()
+// ----------------------------------------------------------------------------
+//
+CMuiuSettingBase* CMuiuDynamicSettingsDialog::CreateItemForBackupL(
+ const CMuiuSettingBase& aBaseItem )
+ {
+ CMuiuSettingsLinkExtended* radioBackup = CMuiuSettingsLinkExtended::NewL();
+ const CMuiuSettingsLinkExtended* radio =
+ static_cast<const CMuiuSettingsLinkExtended*>( &aBaseItem );
+ *radioBackup = *radio;
+
+ return radioBackup;
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::UpdateMskL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::UpdateMskL()
+ {
+ if ( iSoftkeys->MSKLabelling() )
+ {
+ SetMskL();
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::SetMskL()
+// ----------------------------------------------------------------------------
+//
+void CMuiuDynamicSettingsDialog::SetMskL()
+ {
+ CMuiuSettingBase* item = CurrentItem();
+ __ASSERT_DEBUG( item != NULL, User::Panic(
+ KMuiuDynSetDialogPanic, KErrNotFound ) );
+
+ TInt resource = R_IMAS_MSK_OPEN;
+ if ( item && !ItemSubArrayCheck( *item ) )
+ {
+ resource = R_IMAS_MSK_CHANGE;
+ }
+ iSoftkeys->UpdateMiddleSoftkeyLabelL( resource, MskCommand(), this );
+ }
+
+// ----------------------------------------------------------------------------
+// CMuiuDynamicSettingsDialog::MskCommand()
+// ----------------------------------------------------------------------------
+//
+TInt CMuiuDynamicSettingsDialog::MskCommand()
+ {
+ // This function is intended for derived classes to get current msk
+ // command value. Though it's a constant now. It could vary in the future.
+ return EAknSoftkeyOk;
+ }
+
+// End of File