1 /*

     2 * Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: This file implements class CIpsSetUiBaseDialog.

    15 *

    16 */

    17 

    18 

    19 

    20 #include "emailtrace.h"

    21 #include <akntitle.h>               // CAknTitlePane

    22 #include <AknQueryDialog.h>         // CAknQueryDialog

    23 #include <aknradiobuttonsettingpage.h> // CAknRadioButtonSettingPage

    24 #include <aknpasswordsettingpage.h> // CAknPasswordSettingPage

    25 #include <akntextsettingpage.h>     // CAknTextSettingPage

    26 #include <akncheckboxsettingpage.h> // CAknCheckBoxSettingPage

    27 #include <ipssossettings.rsg>

    28 #include <StringLoader.h>

    29 //<cmail> checking if MSK is enabled in layout (Layout_Meta_Data::IsMSKEnabled)

    30 #include <layoutmetadata.cdl.h>

    31 //</cmail>

    32 

    33 #include "ipssetutilsexception.h"

    34 #include "ipssetuiapprover.h"

    35 #include "ipssetuiitembase.h"      // CIpsSetUiItem

    36 #include "ipssetuiitemvalue.h" // CIpsSetUiItemValue

    37 #include "ipssetuiitemtext.h"  // CIpsSetUiItemEditText

    38 #include "ipssetuiitemlink.h"      // CIpsSetUiItemLink

    39 #include "ipssetuiitemextlink.h"   // CIpsSetUiItemExtLink

    40 #include "ipssetuictrlsoftkey.h"

    41 #include "ipssetdata.h" // CIpsSetData::EAllDay, KIpsSetDataTimeDefault

    42 #include "ipssetuibasedialog.h"     // CIpsSetUiBaseDialog

    43 #include "ipssetutilspageids.hrh"

    44 

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

    46 const TInt KIpsSetUiMaxEditors = 100;

    47 

    48 

    49 

    50 // ============================ MEMBER FUNCTIONS ==============================

    51 

    52 // ----------------------------------------------------------------------------

    53 // CIpsSetUiBaseDialog::CIpsSetUiBaseDialog()

    54 // ----------------------------------------------------------------------------

    55 //

    56 CIpsSetUiBaseDialog::CIpsSetUiBaseDialog(

    57     CEikFormattedCellListBox& aListBox,

    58     CAknTitlePane& aTitlePane )

    59     :

    60     CIpsSetUiBaseArray(),

    61     iListBox( aListBox ),

    62     iTitlePane( aTitlePane ),

    63     iSoftkeys( NULL ),

    64     iSettingPage( NULL ),

    65     iSettingPageResources( NULL ),

    66     iSettingsPageArray( NULL ),

    67     iScrollBar( NULL ),

    68     iOldTitleText( NULL ),

    69     iQueryDialog( NULL ),

    70     iSettingsLastItemIndex( NULL ),

    71     iSettingValue( KErrNotFound ),

    72     iSettingText( NULL ),

    73     iNewPassword( NULL ),

    74     iOldPassword( NULL ),

    75     iButtonArray( NULL ),

    76     iCheckboxArray( NULL )

    77     {

    78     FUNC_LOG;

    79     }

    80 

    81 // ----------------------------------------------------------------------------

    82 // CIpsSetUiBaseDialog::~CIpsSetUiBaseDialog()

    83 // ----------------------------------------------------------------------------

    84 //

    85 CIpsSetUiBaseDialog::~CIpsSetUiBaseDialog()

    86     {

    87     FUNC_LOG;

    88     // Remove the scrollbar from listbox

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

    90 

    91     if ( iSoftkeys )

    92         {

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

    94         }

    95     delete iSoftkeys;

    96     iSoftkeys = NULL;

    97 

    98     delete iSettingPageResources;

    99     iSettingPageResources = NULL;

   100 

   101     if ( iSettingsLastItemIndex )

   102         {

   103         iSettingsLastItemIndex->Reset();

   104         }

   105 

   106     delete iSettingsLastItemIndex;

   107     iSettingsLastItemIndex = NULL;

   108 

   109     if ( iCheckboxArray )

   110         {

   111         iCheckboxArray->ResetAndDestroy();

   112         }

   113 

   114     if ( iSettingsPageArray )

   115         {

   116         iSettingsPageArray->Reset();

   117         }

   118 

   119     if ( iBackupArray )

   120         {

   121         iBackupArray->ResetAndDestroy();

   122         }

   123 

   124     delete iBackupArray;

   125     iBackupArray = NULL;

   126     delete iSettingsPageArray;

   127     iSettingsPageArray = NULL;

   128     delete iCheckboxArray;

   129     iCheckboxArray = NULL;

   130     delete iOldTitleText;

   131     iOldTitleText = NULL;

   132     delete iQueryDialog;

   133     iQueryDialog = NULL;

   134     delete iSettingPage;

   135     iSettingPage = NULL;

   136     delete iButtonArray;

   137     iButtonArray = NULL;

   138     iSettingText.Close();

   139     delete iNewPassword;

   140     iNewPassword = NULL;

   141     delete iOldPassword;

   142     iOldPassword = NULL;

   143     iScrollBar = NULL;

   144     delete iItemApprover;

   145     iItemApprover = NULL;

   146     delete iMainMBoxMenuTitleText;

   147     iMainMBoxMenuTitleText = NULL;

   148     }

   149 

   150 // ----------------------------------------------------------------------------

   151 // CIpsSetUiBaseDialog::ConstructL()

   152 // ----------------------------------------------------------------------------

   153 //

   154 void CIpsSetUiBaseDialog::ConstructL(

   155     CEikButtonGroupContainer& aSoftkeys,

   156     const TInt aResource,

   157     const TBool aUpdateMSK )

   158     {

   159     FUNC_LOG;

   160     BaseConstructL( aResource );

   161 

   162     // Set as observer

   163     iListBox.SetListBoxObserver( this );

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

   165 

   166     // Get scrollbar

   167     iScrollBar = iListBox.CreateScrollBarFrameL( ETrue );

   168     iScrollBar->SetScrollBarVisibilityL(

   169         CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto );

   170 

   171     // Create array

   172     CTextListBoxModel* model = iListBox.Model();

   173     model->SetItemTextArray( this );

   174     model->SetOwnershipType( ELbmDoesNotOwnItemArray );

   175 

   176     // Set this dialog for button listening

   177     iSoftkeys = CIpsSetUiCtrlSoftkey::NewL( aSoftkeys );

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

   179     iSoftkeys->SetMSKLabelling( aUpdateMSK );

   180     iSoftkeys->UpdateMiddleSoftkeyLabelL(

   181         GetResourceForMiddlekey(), EAknSoftkeyOpen, this );

   182 

   183     // Prepare setting page arrays

   184     iSettingPageResources = CIpsSetUiCtrlPageResource::NewL();

   185     iSettingsLastItemIndex =

   186         new ( ELeave ) CIpsSetUiIntArray( KIpsSetUiArrayGranularity );

   187 

   188     // Add array to store the backup items

   189     iBackupArray = new ( ELeave ) CIpsSetUiBaseItemArray( KIpsSetUiArrayGranularity );

   190 

   191     // Define setting pages in enumeration order

   192     iSettingPageResources->CreateStackL( R_IPS_SET_DIALOG_LISTBOX );

   193     iSettingPageResources->CreateStackL( R_IPS_SET_DIALOG_CHECKLISTBOX );

   194     iSettingPageResources->CreateStackL( R_IPS_SET_DIALOG_TEXT );

   195     iSettingPageResources->CreateStackL( R_IPS_SET_DIALOG_NUMBER );

   196     iSettingPageResources->CreateStackL( R_IPS_SET_DIALOG_SC_NUMBER );

   197     iSettingPageResources->CreateStackL( R_IPS_SET_DIALOG_PASSWORD );

   198     iSettingPageResources->CreateStackL( NULL );

   199 

   200     iItemApprover = CIpsSetUiApprover::NewL();

   201     }

   202 

   203 // ----------------------------------------------------------------------------

   204 // CIpsSetUiBaseDialog::HandleListBoxEventL()

   205 // ----------------------------------------------------------------------------

   206 //

   207 void CIpsSetUiBaseDialog::HandleListBoxEventL(

   208     CEikListBox* /* aListBox */,

   209     TListBoxEvent aEventType )

   210     {

   211     FUNC_LOG;

   212     if( aEventType == EEventItemSingleClicked )

   213     	{

   214     	CIpsSetUiItem* base = CurrentItem();

   215     	OpenSettingPageL( *base );

   216         }

   217     }

   218 

   219 // ----------------------------------------------------------------------------

   220 // CIpsSetUiBaseDialog::OfferKeyEventL

   221 // ----------------------------------------------------------------------------

   222 //

   223 TKeyResponse CIpsSetUiBaseDialog::OfferKeyEventL(

   224     const TKeyEvent& /* aKeyEvent */,

   225     TEventCode aType )

   226     {

   227     FUNC_LOG;

   228     if ( aType == EEventKeyUp && iSoftkeys->MSKLabelling() )

   229         {

   230         iSoftkeys->UpdateMiddleSoftkeyLabelL(

   231             GetResourceForMiddlekey(), EAknSoftkeyOpen, this );

   232         }

   233 

   234     return EKeyWasNotConsumed;

   235     }

   236 

   237 // ----------------------------------------------------------------------------

   238 // CIpsSetUiBaseDialog::GetResourceForMiddlekey()

   239 // ----------------------------------------------------------------------------

   240 //

   241 TInt CIpsSetUiBaseDialog::GetResourceForMiddlekey()

   242     {

   243     FUNC_LOG;

   244 //<cmail> run-time MSK variation check (enabled in platform + in current layout)

   245     TInt resource = 0;

   246     if ( AknLayoutUtils::MSKEnabled() && Layout_Meta_Data::IsMSKEnabled() )

   247         {

   248         CIpsSetUiItem* item = CurrentItem();

   249         IPS_ASSERT_DEBUG( item , KErrNotFound, EBaseDialog );

   250         if ( item )

   251             {

   252             resource = ItemSubArrayCheck( *item ) ?

   253                 R_QTN_MSK_OPEN : R_QTN_MSK_CHANGE; // <cmail>

   254             }

   255         }

   256     return resource;

   257 //</cmail>

   258     }

   259 

   260 // ----------------------------------------------------------------------------

   261 // CIpsSetUiBaseDialog::SetTitlePaneTextL()

   262 // ----------------------------------------------------------------------------

   263 //

   264 void CIpsSetUiBaseDialog::SetMainMBoxMenuTitlePaneTextL(

   265     const TDesC& aText,

   266     const TBool aSaveCurrent )

   267     {

   268     FUNC_LOG;

   269     // aText contains mailbox name

   270     HBufC* titleText = StringLoader::LoadLC(

   271             R_FSE_SETTINGS_LIST_MAILBOX_TITLE, aText );

   272 

   273     if ( aSaveCurrent )

   274         {

   275         delete iOldTitleText;

   276         iOldTitleText = NULL;

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

   278         delete iMainMBoxMenuTitleText;

   279         iMainMBoxMenuTitleText = NULL;

   280         iMainMBoxMenuTitleText = aText.AllocL();

   281         }

   282 

   283     iTitlePane.SetTextL( *titleText );

   284     CleanupStack::PopAndDestroy( titleText );

   285     titleText = NULL;

   286     }

   287 

   288 // ----------------------------------------------------------------------------

   289 // CIpsSetUiBaseDialog::SetPreviousTitlePaneText()

   290 // ----------------------------------------------------------------------------

   291 //

   292 void CIpsSetUiBaseDialog::SetSettingsMenuTitlePaneText(

   293     const TBool aSaveCurrent )

   294     {

   295     FUNC_LOG;

   296     TRAP_IGNORE( SetMainMBoxMenuTitlePaneTextL(

   297             *iOldTitleText, aSaveCurrent ) );

   298     }

   299 

   300 /******************************************************************************

   301 

   302     Settingpage opening

   303 

   304     - Find out the item to be edited

   305     - Send start editing event with the item

   306     - Check the item type

   307     - Check the resources

   308     - If no resources available, ask them

   309     - Start editing

   310     - Send end editing event

   311 

   312 ******************************************************************************/

   313 

   314 // ----------------------------------------------------------------------------

   315 // CIpsSetUiBaseDialog::OpenSettingPageL()

   316 // ----------------------------------------------------------------------------

   317 //

   318 TIpsSetUiPageResult CIpsSetUiBaseDialog::OpenSettingPageL(

   319     const TInt aIndex )

   320     {

   321     FUNC_LOG;

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

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

   324     TInt index = ( aIndex == KErrNotFound ) ?

   325         iListBox.CurrentItemIndex() : aIndex;

   326 

   327     // Search for the item and open it

   328     return SettingPageOpenL( *GetItem( index ) );

   329     }

   330 

   331 // ----------------------------------------------------------------------------

   332 // CIpsSetUiBaseDialog::OpenSettingPageL()

   333 // ----------------------------------------------------------------------------

   334 //

   335 TIpsSetUiPageResult CIpsSetUiBaseDialog::OpenSettingPageL(

   336     CIpsSetUiItem& aBaseItem )

   337     {

   338     FUNC_LOG;

   339     return SettingPageOpenL( aBaseItem );

   340     }

   341 

   342 // ----------------------------------------------------------------------------

   343 // CIpsSetUiBaseDialog::SettingPageOpenL()

   344 //

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

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

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

   348 // ----------------------------------------------------------------------------

   349 //

   350 TIpsSetUiPageResult CIpsSetUiBaseDialog::SettingPageOpenL(

   351     CIpsSetUiItem& aBaseItem )

   352     {

   353     FUNC_LOG;

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

   355     if ( aBaseItem.iItemFlags.Flag32( KIpsSetUiFlagReadOnly ) )

   356         {

   357         return EIpsSetUiPageResultReadOnly;

   358         }

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

   360     iCurrentItemIndex = iListBox.CurrentItemIndex();

   361 

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

   363     iArrayFlags.ClearFlag( EIpsSetUiArrayAllowRefresh );

   364 

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

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

   367     TIpsSetUiEventResult eventResult = EventItemEditStartsL( aBaseItem );

   368     TIpsSetUiPageResult result;

   369 

   370     if ( eventResult == EIpsSetUiPageEventResultApproved )

   371         {

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

   373         if ( !iSettingsPageArray )

   374             {

   375             iSettingsPageArray = new ( ELeave ) CIpsSetUiBaseItemArray(

   376                 KIpsSetUiArrayGranularity );

   377             }

   378 

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

   380         CleanBackupArray();

   381         iSettingsPageArray->Reset();

   382         SetCurrentSettingsPageL( aBaseItem );

   383         result = SettingsPageOpenCheckL();

   384 

   385         do

   386             {

   387             if ( result == EIpsSetUiPageResultEditing )

   388                 {

   389                 // Open the setting page

   390                 result = SettingPageOpenEditorL();

   391 

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

   393                 SettingsCheckNextEditorOpenL( result );

   394                 }

   395 

   396             // Finish the editing of the item

   397             SettingPageOpenFinishL();

   398             }

   399         while ( result == EIpsSetUiPageResultEditing );

   400         }

   401     else if ( eventResult == EIpsSetUiPageEventResultDisapproved )

   402         {

   403         result = EIpsSetUiPageResultOk;

   404         }

   405     else

   406         {

   407         result = EIpsSetUiPageResultEventCancel;

   408         }

   409 

   410     // Send item edit ends

   411     EventItemEditEndsL( aBaseItem );

   412     aBaseItem.iItemFlags.ClearFlag32( KIpsSetUiFlagOneTimeForceViewOpen );

   413     iArrayFlags.SetFlag( EIpsSetUiArrayAllowRefresh );

   414     

   415     // Update the listbox

   416     Refresh();

   417 

   418     return result;

   419     }

   420 

   421 // ----------------------------------------------------------------------------

   422 // CIpsSetUiBaseDialog::EventPrepareSubArrayL()

   423 // ----------------------------------------------------------------------------

   424 //

   425 TInt CIpsSetUiBaseDialog::EventPrepareSubArrayL(

   426     CIpsSetUiItem& aBaseItem,

   427     const TBool aForward )

   428     {

   429     FUNC_LOG;

   430     // Check direction in array

   431     UpdateTitlePaneTextL( GetLastResourceId( ) );

   432     if ( aForward )

   433         {

   434         // Store the index and set to beginning

   435         SetSettingsLastItemIndexL( iCurrentItemIndex );

   436         iListBox.SetCurrentItemIndex( 0 );

   437         }

   438     // When going backwards

   439     else

   440         {

   441         // Restore previous index

   442         iListBox.SetCurrentItemIndex( SettingsLastItemIndex() );

   443         }

   444 

   445     return EventSubArrayChangeL( aBaseItem );

   446     }

   447 

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

   449 // CIpsSetUiBaseDialog::UpdateTitlePaneTextL()

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

   451 //

   452 void CIpsSetUiBaseDialog::UpdateTitlePaneTextL( TInt aId )

   453     {

   454     FUNC_LOG;

   455     HBufC* titleText = NULL;

   456     switch ( aId )

   457         {

   458         case R_IPS_SET_MENU_MAILBOX_SETTINGS:

   459             titleText = StringLoader::LoadLC( R_FSE_SETTINGS_TITLE_MAILBOX );

   460             iTitlePane.SetTextL( *titleText );

   461             break;

   462         case R_IPS_SET_MENU_ADVANCED_MAILBOX_SETTINGS:

   463             titleText = StringLoader::LoadLC(

   464                     R_FSE_SETTINGS_ADVANCED_MAILBOX_SETTINGS );

   465             iTitlePane.SetTextL( *titleText );

   466             break;

   467 		// <cmail> ipssossettings to use correct loc strings in titles

   468         case R_IPS_SET_MENU_INCOMING_SETTINGS:

   469             titleText = StringLoader::LoadLC(

   470             	R_FSE_SETTINGS_INCOMING_TITLE );

   471             iTitlePane.SetTextL( *titleText );

   472             break;

   473         case R_IPS_SET_MENU_OUTGOING_SETTINGS:

   474             titleText = StringLoader::LoadLC(

   475             	R_FSE_SETTINGS_OUTGOING_TITLE );

   476             iTitlePane.SetTextL( *titleText );

   477             break;

   478         case R_IPS_SET_MENU_WHAT_TO_SYNC:

   479         case R_IPS_SET_WHAT_TO_SYNC_ARRAY_EMAIL_RETRIEVE_POP3:

   480         case R_IPS_SET_WHAT_TO_SYNC_ARRAY_EMAIL_RETRIEVE_IMAP4:

   481             titleText = StringLoader::LoadLC( 

   482                     R_FSE_SETTINGS_SERVICE_WHAT_TO_SYNC_TITLE );

   483             iTitlePane.SetTextL( *titleText );

   484             break;

   485         case R_IPS_SET_MENU_WHEN_TO_SYNC:

   486             titleText = StringLoader::LoadLC( 

   487                     R_FSE_SETTINGS_SERVICE_WHEN_TO_SYNC_TITLE );

   488             iTitlePane.SetTextL( *titleText );

   489             break;

   490         // </cmail>

   491         default:

   492             {

   493             delete iMainMBoxMenuTitleText;

   494             iMainMBoxMenuTitleText = NULL;

   495             iMainMBoxMenuTitleText = GetItem( TUid::Uid( EIpsSetUiMailboxMailboxName ) )->Text().AllocL();

   496             Refresh();

   497             

   498             if ( iMainMBoxMenuTitleText )

   499                 {

   500                 titleText = StringLoader::LoadLC(

   501                         R_FSE_SETTINGS_LIST_MAILBOX_TITLE, *iMainMBoxMenuTitleText );

   502                 iTitlePane.SetTextL( *titleText );

   503                 }

   504             break;

   505             }

   506         }

   507     if ( titleText )

   508         {

   509         CleanupStack::PopAndDestroy( titleText );

   510         }

   511     }

   512 

   513 /******************************************************************************

   514 

   515     Settingpage creation

   516 

   517 ******************************************************************************/

   518 

   519 // ----------------------------------------------------------------------------

   520 // CIpsSetUiBaseDialog::SettingsPageOpenCheckL()

   521 // ----------------------------------------------------------------------------

   522 //

   523 TIpsSetUiPageResult CIpsSetUiBaseDialog::SettingsPageOpenCheckL()

   524     {

   525     FUNC_LOG;

   526     CIpsSetUiItem* base = CurrentSettingsPage();

   527 

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

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

   530     if ( HandleStackForwardL( *base ) == EIpsSetUiStackResultSubMenuOpen )

   531         {

   532         iSoftkeys->UpdateMiddleSoftkeyLabelL(

   533             GetResourceForMiddlekey(), EAknSoftkeyOpen, this );

   534         return EIpsSetUiPageResultSubMenuOpen;

   535         }

   536 

   537     // Don't open read only items

   538     if ( base->iItemFlags.Flag32( KIpsSetUiFlagReadOnly ) )

   539         {

   540         return EIpsSetUiPageResultReadOnly;

   541         }

   542 

   543     // The page is ok is for edit

   544     return EIpsSetUiPageResultEditing;

   545     }

   546 

   547 // ----------------------------------------------------------------------------

   548 // CIpsSetUiBaseDialog::SettingsCheckNextEditorOpenL()

   549 // ----------------------------------------------------------------------------

   550 //

   551 void CIpsSetUiBaseDialog::SettingsCheckNextEditorOpenL(

   552     TIpsSetUiPageResult& aResult )

   553     {

   554     FUNC_LOG;

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

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

   557     // returning from editors

   558 

   559     switch ( aResult )

   560         {

   561         // Handle approved

   562         case EIpsSetUiPageResultOk:

   563             aResult = HandleEditorOk();

   564             break;

   565 

   566         // Handle the cancelled editor page

   567         case EIpsSetUiPageResultCancelled:

   568             aResult = HandleEditorCancelL();

   569             break;

   570 

   571         // Continue editing

   572         case EIpsSetUiPageResultEditing:

   573             aResult = HandleEditorDisapproved();

   574             break;

   575 

   576         default:

   577             IPS_ASSERT_DEBUG( EFalse, KErrUnknown, EBaseDialog );

   578             User::Leave( KErrUnknown );

   579             break;

   580         }

   581     }

   582 

   583 // ----------------------------------------------------------------------------

   584 // CIpsSetUiBaseDialog::HandleEditorCancelL()

   585 // ----------------------------------------------------------------------------

   586 //

   587 TIpsSetUiPageResult CIpsSetUiBaseDialog::HandleEditorCancelL()

   588     {

   589     FUNC_LOG;

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

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

   592     TIpsSetUiPageResult result = EIpsSetUiPageResultInvalidResult;

   593 

   594     TInt editorCount = iSettingsPageArray->Count();

   595     if ( editorCount == 1 )

   596         {

   597         // Restore all of the items

   598         RestoreFromBackup();

   599         result = EIpsSetUiPageResultCancelled;

   600         }

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

   602     // and remove the previous value

   603     else if ( editorCount > 0 )

   604         {

   605         RemoveLastBackupItem();

   606         iSettingsPageArray->Delete( editorCount-1 );

   607         result = EIpsSetUiPageResultEditing;

   608         }

   609     // Array is empty, unexpected situation

   610     else

   611         {

   612         IPS_ASSERT_DEBUG( EFalse, KErrNotFound, EBaseDialog );

   613         User::Leave( KErrNotFound );

   614         }

   615 

   616     return result;

   617     }

   618 

   619 // ----------------------------------------------------------------------------

   620 // CIpsSetUiBaseDialog::HandleEditorOk()

   621 // ----------------------------------------------------------------------------

   622 //

   623 TIpsSetUiPageResult CIpsSetUiBaseDialog::HandleEditorOk()

   624     {

   625     FUNC_LOG;

   626     CIpsSetUiItem* nextItem = NULL;

   627 

   628     // Check if current selection contains subeditors

   629     if ( iSettingValue >= 0 )

   630         {

   631         nextItem = SettingFindEditor(

   632            *CurrentSettingsPage(), iSettingValue );

   633         }

   634 

   635     TIpsSetUiPageResult result = EIpsSetUiPageResultInvalidResult;

   636 

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

   638     // editing

   639     if ( nextItem )

   640         {

   641         TRAP_IGNORE( SetCurrentSettingsPageL( *nextItem ) );

   642         result = EIpsSetUiPageResultEditing;

   643         }

   644     // Cleanup the array and stop editing

   645     else

   646         {

   647         CleanBackupArray();

   648         result = EIpsSetUiPageResultOk;

   649         }

   650 

   651     return result;

   652     }

   653 

   654 // ----------------------------------------------------------------------------

   655 // CIpsSetUiBaseDialog::HandleEditorDisapproved()

   656 // ----------------------------------------------------------------------------

   657 //

   658 TIpsSetUiPageResult CIpsSetUiBaseDialog::HandleEditorDisapproved()

   659     {

   660     FUNC_LOG;

   661     // Get current setting page

   662     CurrentSettingsPage()->SetText( iSettingText );

   663 

   664     return EIpsSetUiPageResultEditing;

   665     }

   666 

   667 // ----------------------------------------------------------------------------

   668 // CIpsSetUiBaseDialog::SettingPageOpenEditorL()

   669 // ----------------------------------------------------------------------------

   670 //

   671 TIpsSetUiPageResult CIpsSetUiBaseDialog::SettingPageOpenEditorL()

   672     {

   673     FUNC_LOG;

   674     CIpsSetUiItem* currentEditor = CurrentSettingsPage();

   675 

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

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

   678     // created with default values

   679     TIpsSetUiUpdateMode updateMode;

   680     TIpsSetUtilsFlags& editorFlags = currentEditor->iItemFlags;

   681 

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

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

   684     if ( !( editorFlags.Flag32( KIpsSetUiFlagEnterPressed ) ) ||

   685          editorFlags.Flag32( KIpsSetUiFlagOneTimeForceViewOpen ) )

   686         {

   687         if ( editorFlags.Flag32( KIpsSetUiFlagAcquireCustomPage ) )

   688             {

   689             SettingPrepareAcquireL( updateMode, *currentEditor );

   690             IPS_ASSERT_DEBUG( iSettingPage , KErrUnknown, EBaseDialog );

   691             }

   692         else

   693             {

   694             SettingCreateEditorL( *currentEditor, updateMode );

   695             }

   696         }

   697 

   698     // Finally launch the editor

   699     return SettingLaunchPageLD( *currentEditor, updateMode );

   700     }

   701 

   702 // ----------------------------------------------------------------------------

   703 // CIpsSetUiBaseDialog::SettingPageOpenFinishL()

   704 // ----------------------------------------------------------------------------

   705 //

   706 void CIpsSetUiBaseDialog::SettingPageOpenFinishL()

   707     {

   708     FUNC_LOG;

   709     // Clean up

   710     iBaseDialogFlags &= ~EIpsSetUiRunningCustomPage;

   711     delete iButtonArray;

   712     iButtonArray = NULL;

   713     if ( iCheckboxArray )

   714         {

   715         iCheckboxArray->ResetAndDestroy();

   716         }

   717     delete iCheckboxArray;

   718     iCheckboxArray = NULL;

   719     iSettingPage = NULL;

   720     iSettingValue = KErrNotFound;

   721     iSettingText.Close();

   722     delete iNewPassword;

   723     iNewPassword = NULL;

   724     delete iOldPassword;

   725     iOldPassword = NULL;

   726     }

   727 

   728 /******************************************************************************

   729 

   730     Settingpage Open

   731 

   732 ******************************************************************************/

   733 

   734 // ----------------------------------------------------------------------------

   735 // CIpsSetUiDialogCtrl::SettingFindEditor()

   736 // ----------------------------------------------------------------------------

   737 //

   738 CIpsSetUiItem* CIpsSetUiBaseDialog::SettingFindEditor(

   739     const CIpsSetUiItem& aBaseItem,

   740     const TInt aIndex,

   741     const TBool aExcludeHidden )

   742     {

   743     FUNC_LOG;

   744     CIpsSetUiItem* volunteerBase = NULL;

   745 

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

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

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

   749     // the editor can be taken.

   750     volunteerBase =

   751         GetSubItem( aBaseItem, aIndex, aExcludeHidden );

   752 

   753     if ( volunteerBase &&

   754         volunteerBase->iItemFlags.Flag32( KIpsSetUiFlagFindEditor ) )

   755         {

   756         // Find the editor from the link array

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

   758 

   759         if ( !volunteerBase )

   760             {

   761             // Not found, yet. It may be seperate editor in the button arrays

   762             volunteerBase = GetSubItemByType( aBaseItem, EIpsSetUiItemValue );

   763             }

   764 

   765         if ( !volunteerBase )

   766             {

   767             // Still not found... time editor perhaps??

   768             volunteerBase =

   769                 GetSubItemByType( aBaseItem, EIpsSetUiItemMultiLine );

   770             }

   771         }

   772     else

   773         {

   774         volunteerBase = NULL;

   775         }

   776 

   777     // return the item

   778     return volunteerBase;

   779     }

   780 

   781 // ----------------------------------------------------------------------------

   782 // CIpsSetUiDialogCtrl::SettingFindEditor()

   783 // ----------------------------------------------------------------------------

   784 //

   785 CIpsSetUiItem* CIpsSetUiBaseDialog::SettingFindEditor(

   786     const CIpsSetUiItem& aBaseItem,

   787     const TUid& aId,

   788     const TBool aExcludeHidden )

   789     {

   790     FUNC_LOG;

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

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

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

   794     // the editor can be taken.

   795     CIpsSetUiItem* volunteerBase =

   796         GetSubItem( aBaseItem, aId, aExcludeHidden );

   797 

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

   799     if ( volunteerBase )

   800         {

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

   802         }

   803     else

   804         {

   805         volunteerBase = NULL;

   806         }

   807 

   808     // return the item

   809     return volunteerBase;

   810     }

   811 

   812 // ----------------------------------------------------------------------------

   813 // CIpsSetUiBaseDialog::SettingPrepareAcquireRadioButtonPageL()

   814 // ----------------------------------------------------------------------------

   815 //

   816 void CIpsSetUiBaseDialog::SettingPrepareAcquireRadioButtonPageL(

   817     CIpsSetUiItem& aBaseItem )

   818     {

   819     FUNC_LOG;

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

   821     CIpsSetUiItemLink* radio = static_cast<CIpsSetUiItemLink*>( &aBaseItem );

   822 

   823     // Make sure the link exist

   824     if ( !radio->iItemLinkArray )

   825         {

   826         radio->iItemLinkArray =

   827             new ( ELeave ) CIpsSetUiBaseItemArray( KIpsSetUiArrayGranularity );

   828         }

   829 

   830     SettingCreateButtonArrayL( *radio->iItemLinkArray );

   831 

   832     iSettingValue = radio->Value();

   833     radio = NULL;

   834     }

   835 

   836 // ----------------------------------------------------------------------------

   837 // CIpsSetUiBaseDialog::SettingPrepareAcquireCheckboxPageL()

   838 // ----------------------------------------------------------------------------

   839 //

   840 void CIpsSetUiBaseDialog::SettingPrepareAcquireCheckboxPageL(

   841     CIpsSetUiItem& aBaseItem )

   842     {

   843     FUNC_LOG;

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

   845     CIpsSetUiItemLink* link = static_cast<CIpsSetUiItemLink*>( &aBaseItem );

   846 

   847     // Make sure the link array exist

   848     if ( link->iItemLinkArray )

   849         {

   850         SettingCreateButtonArrayL( *link->iItemLinkArray );

   851         }

   852 

   853     link = NULL;

   854     }

   855 

   856 // ----------------------------------------------------------------------------

   857 // CIpsSetUiBaseDialog::SettingPrepareAcquireTextEditorPageL()

   858 // ----------------------------------------------------------------------------

   859 //

   860 void CIpsSetUiBaseDialog::SettingPrepareAcquireTextEditorPageL(

   861     CIpsSetUiItem& aBaseItem )

   862     {

   863     FUNC_LOG;

   864     // Create either password or plain texts

   865     if ( aBaseItem.iItemFlags.Flag32( KIpsSetUiFlagPassword ) )

   866         {

   867         iNewPassword = new ( ELeave ) TIpsSetUiPasswordText( aBaseItem.Text() );

   868         iOldPassword = new ( ELeave ) TIpsSetUiPasswordText( aBaseItem.Text() );

   869         }

   870     else

   871         {

   872         iSettingText.CreateL( aBaseItem.Text() );

   873         }

   874     }

   875 

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

   877 // CIpsSetUiBaseDialog::SettingPrepareAcquireValueEditorPageL()

   878 // ----------------------------------------------------------------------------

   879 //

   880 void CIpsSetUiBaseDialog::SettingPrepareAcquireValueEditorPageL(

   881     CIpsSetUiItem& aBaseItem )

   882     {

   883     FUNC_LOG;

   884     iSettingValue = aBaseItem.Value();

   885     }

   886 

   887 // ----------------------------------------------------------------------------

   888 // CIpsSetUiBaseDialog::SettingPrepareAcquireL()

   889 // ----------------------------------------------------------------------------

   890 //

   891 void CIpsSetUiBaseDialog::SettingPrepareAcquireL(

   892     TIpsSetUiUpdateMode& aUpdateMode,

   893     CIpsSetUiItem& aBaseItem )

   894     {

   895     FUNC_LOG;

   896     // Handle the item, based on the type

   897     switch ( aBaseItem.Type() )

   898         {

   899         // Radio button page

   900         case EIpsSetUiRadioButtonArray:

   901             SettingPrepareAcquireRadioButtonPageL( aBaseItem );

   902             break;

   903 

   904         // Checkbox page

   905         case EIpsSetUiCheckBoxArray:

   906             SettingPrepareAcquireCheckboxPageL( aBaseItem );

   907             break;

   908 

   909         // Text editor

   910         case EIpsSetUiItemText:

   911             SettingPrepareAcquireTextEditorPageL( aBaseItem );

   912             break;

   913 

   914         // Number editor

   915         case EIpsSetUiItemValue:

   916             SettingPrepareAcquireValueEditorPageL( aBaseItem );

   917             break;

   918 

   919         // Type is not recognized

   920         default:

   921             IPS_ASSERT_DEBUG( EFalse, KErrUnknown, EBaseDialog );

   922             User::Leave( KErrUnknown );

   923         }

   924 

   925     // Acquire the custom setting page

   926     AcquireCustomSettingPageL(

   927         iSettingPage, aUpdateMode, iSettingValue,

   928         iSettingText, *iButtonArray, aBaseItem );

   929     }

   930 

   931 // ----------------------------------------------------------------------------

   932 // CIpsSetUiBaseDialog::AcquireCustomSettingPageL()

   933 // ----------------------------------------------------------------------------

   934 //

   935 void CIpsSetUiBaseDialog::AcquireCustomSettingPageL(

   936     CAknSettingPage*& /* aReturnPage */,

   937     TIpsSetUiUpdateMode& /* aReturnUpdateMode */,

   938     TInt& /* aReturnSettingValue */,

   939     TDes& /* aReturnSettingText */,

   940     CDesCArrayFlat& /* aParamRadioButtonArray */,

   941     CIpsSetUiItem& /* aParamBaseItem */ )

   942     {

   943     FUNC_LOG;

   944     }

   945 

   946 // ----------------------------------------------------------------------------

   947 // CIpsSetUiBaseDialog::SettingCreateEditorL()

   948 // ----------------------------------------------------------------------------

   949 //

   950 void CIpsSetUiBaseDialog::SettingCreateEditorL(

   951     CIpsSetUiItem& aBaseItem,

   952     TIpsSetUiUpdateMode& aUpdateMode )

   953     {

   954     FUNC_LOG;

   955     // Create different editors for password settings

   956     if ( aBaseItem.iItemFlags.Flag32( KIpsSetUiFlagPassword ) )

   957         {

   958         switch ( aBaseItem.iItemType )

   959             {

   960             case EIpsSetUiItemText:

   961                 SettingCreatePasswordTextEditorPageL(

   962                     aBaseItem, aUpdateMode );

   963                 break;

   964 

   965             }

   966         }

   967     // Normal editors

   968     else

   969         {

   970         switch ( aBaseItem.iItemType )

   971             {

   972             case EIpsSetUiRadioButtonArray:

   973                 SettingCreateRadioButtonPageL( aBaseItem, aUpdateMode );

   974                 break;

   975 

   976             case EIpsSetUiCheckBoxArray:

   977                 SettingCreateCheckboxPageL( aBaseItem, aUpdateMode );

   978                 break;

   979 

   980             case EIpsSetUiItemText:

   981                 SettingCreatePlainTextEditorPageL(

   982                     aBaseItem, aUpdateMode );

   983                 break;

   984 

   985             case EIpsSetUiItemValue:

   986                 SettingCreatePlainNumberEditorPageL(

   987                     aBaseItem, aUpdateMode );

   988                 break;

   989 

   990             case EIpsSetUiItemScValue:

   991                 SettingCreateScNumberEditorPageL(

   992                     aBaseItem, aUpdateMode );

   993                 break;

   994 

   995             default:

   996                 break;

   997             }

   998         }

   999     }

  1000 

  1001 // ----------------------------------------------------------------------------

  1002 // CIpsSetUiBaseDialog::DefineDefaultSettingPageL()

  1003 // ----------------------------------------------------------------------------

  1004 //

  1005 TIpsSetUiUpdateMode CIpsSetUiBaseDialog::DefineDefaultSettingPageL(

  1006     const CIpsSetUiItem& aBase )

  1007     {

  1008     FUNC_LOG;

  1009     // Create the aSetting page

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

  1011 

  1012     // Determine the update mode

  1013     return static_cast<TIpsSetUiUpdateMode>( aBase.iItemFlags.ValueForFlag(

  1014         KIpsSetUiFlagUpdateOnChange,

  1015         CAknSettingPage::EUpdateWhenChanged,

  1016         CAknSettingPage::EUpdateWhenAccepted ) );

  1017     }

  1018 

  1019 // ----------------------------------------------------------------------------

  1020 // CIpsSetUiBaseDialog::SettingCreateButtonArrayL()

  1021 // ----------------------------------------------------------------------------

  1022 //

  1023 void CIpsSetUiBaseDialog::SettingCreateButtonArrayL(

  1024     CIpsSetUiBaseItemArray& aButtonArray )

  1025     {

  1026     FUNC_LOG;

  1027     // Get the item count in array

  1028     const TInt count = aButtonArray.Count();

  1029     iButtonArray = new ( ELeave ) CDesCArrayFlat( KIpsSetUiArrayGranularity );

  1030 

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

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

  1033         {

  1034         CIpsSetUiItem* base = aButtonArray[item];

  1035 

  1036         // Append only visible items on the list

  1037         if ( !IsHidden( *base ) )

  1038             {

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

  1040             TPtr labelPtr = label->Des();

  1041 

  1042             // Do number conversion when needed

  1043             if ( base->iItemFlags.Flag32( KIpsSetUiFlagLangSpecificNumConv ) )

  1044                 {

  1045                 AknTextUtils::DisplayTextLanguageSpecificNumberConversion(

  1046                     labelPtr );

  1047                 }

  1048 

  1049             // Insert to array and delete old item

  1050             iButtonArray->AppendL( *label );

  1051             CleanupStack::PopAndDestroy( label );

  1052             label = NULL;

  1053             }

  1054         }

  1055     }

  1056 

  1057 // ----------------------------------------------------------------------------

  1058 // CIpsSetUiBaseDialog::SettingCreateCheckboxArrayL()

  1059 // ----------------------------------------------------------------------------

  1060 //

  1061 void CIpsSetUiBaseDialog::SettingCreateCheckboxArrayL(

  1062     CIpsSetUiBaseItemArray& aButtonArray )

  1063     {

  1064     FUNC_LOG;

  1065     // Get the item count in array

  1066     const TInt count = aButtonArray.Count();

  1067     iCheckboxArray =

  1068         new ( ELeave ) CSelectionItemList( KIpsSetUiArrayGranularity );

  1069 

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

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

  1072         {

  1073         CIpsSetUiItem* base = aButtonArray[item];

  1074 

  1075         // Append only visible items on the list

  1076         if ( !IsHidden( *base ) )

  1077             {

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

  1079             TPtr labelPtr = label->Des();

  1080 

  1081             // Do number conversion when needed

  1082             if ( base->iItemFlags.Flag32( KIpsSetUiFlagLangSpecificNumConv ) )

  1083                 {

  1084                 AknTextUtils::DisplayTextLanguageSpecificNumberConversion(

  1085                     labelPtr );

  1086                 }

  1087 

  1088             // Create item and check it

  1089             CSelectableItem* checkbox =

  1090                 new ( ELeave ) CSelectableItem(

  1091                    *label, base->iItemFlags.Flag32( KIpsSetUiFlagChecked ) );

  1092             CleanupStack::PushL( checkbox );

  1093             checkbox->ConstructL();

  1094 

  1095             // Insert to array and delete old item

  1096             iCheckboxArray->AppendL( checkbox );

  1097             CleanupStack::Pop( checkbox );

  1098             CleanupStack::PopAndDestroy( label );

  1099             label = NULL;

  1100             }

  1101         }

  1102     }

  1103 

  1104 // ----------------------------------------------------------------------------

  1105 // CIpsSetUiBaseDialog::SettingCreateRadioButtonPageL()

  1106 // ----------------------------------------------------------------------------

  1107 //

  1108 void CIpsSetUiBaseDialog::SettingCreateRadioButtonPageL(

  1109     CIpsSetUiItem& aBaseItem,

  1110     TIpsSetUiUpdateMode& aUpdateMode )

  1111     {

  1112     FUNC_LOG;

  1113     // Convert the base item to radiobutton item

  1114     CIpsSetUiItemLinkExt* radioArray =

  1115         static_cast<CIpsSetUiItemLinkExt*>( &aBaseItem );

  1116 

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

  1118     SettingCreateButtonArrayL( *radioArray->iItemLinkArray );

  1119     iSettingValue = radioArray->Value();

  1120 

  1121     // Create the setting page to member

  1122     iSettingPage = ( new ( ELeave ) CAknRadioButtonSettingPage(

  1123         ( *iSettingPageResources )[EIpsSetUiRadioButton],

  1124         iSettingValue, iButtonArray ) );

  1125 

  1126     // Apply defaults

  1127     aUpdateMode = DefineDefaultSettingPageL( aBaseItem );

  1128     }

  1129 

  1130 // ----------------------------------------------------------------------------

  1131 // CIpsSetUiBaseDialog::SettingCreateCheckboxPageL()

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

  1133 //

  1134 void CIpsSetUiBaseDialog::SettingCreateCheckboxPageL(