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 CIpsSetUiBaseArray.

    15 *

    16 */

    17 

    18 

    19 #include "emailtrace.h"

    20 #include <e32base.h>            // Base symbian include

    21 #include <gulutil.h>            // KColumnListSeparator

    22 #include <eikenv.h>             // CEikonEnv

    23 #include <eikrutil.h>           // EikResourceUtils

    24 #include <AknUtils.h>           // AknTextUtils

    25 

    26 #include <data_caging_path_literals.hrh>

    27 #include <ipssossettings.rsg>

    28 

    29 #include "ipssetutilsexception.h"

    30 #include "ipssetutilsconsts.h"

    31 #include "ipssetuifinder.h"

    32 #include "ipssetuiitembase.h"   

    33 #include "ipssetuiitemvalue.h"  

    34 #include "ipssetuiitemtext.h"   

    35 #include "ipssetuiitemlink.h"   

    36 #include "ipssetuiitemextlink.h"

    37 #include "ipssetuifinder.h"

    38 #include "ipssetutilspageids.hrh"

    39 #include "ipssetuibasearray.h"

    40 

    41 // This is added at the end of the compulsory setting item string

    42 _LIT( KIpsSetUiStrCompulsory, "\t*" );

    43 // The number of characters that can be shown in the screen

    44 const TInt KIpsSetUiVisibleTextLength = 30;

    45 //

    46 const TInt KIpsSetUiPasswordSecLength = 4;

    47 

    48 _LIT( KCharsToReplace, "\r\n\t\x2028\x2029" );

    49 

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

    51 

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

    53 // CIpsSetUiBaseArray::CIpsSetUiBaseArray()

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

    55 //

    56 CIpsSetUiBaseArray::CIpsSetUiBaseArray()

    57     :

    58     iFinder( NULL ),

    59     iItemArray( NULL ),

    60     iPasswordFill( 0x00 ),

    61     iActiveCount( 0 ),

    62     iError( KErrNone ),

    63     iEnv( CEikonEnv::Static() ) // faulty CS warning

    64     {

    65     FUNC_LOG;

    66     }

    67 

    68 // ----------------------------------------------------------------------------

    69 // CIpsSetUiBaseArray::~CIpsSetUiBaseArray()

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

    71 //

    72 CIpsSetUiBaseArray::~CIpsSetUiBaseArray()

    73     {

    74     FUNC_LOG;

    75     CleanArrayItems();

    76 

    77     if ( iResourceStack )

    78         {

    79         iResourceStack->Reset();

    80         delete iResourceStack;

    81         iResourceStack = NULL;

    82         }

    83     delete iItemArray;

    84     delete iTempText;

    85     delete iFinder;

    86     }

    87 

    88 // ----------------------------------------------------------------------------

    89 // CIpsSetUiBaseArray::BaseConstructL()

    90 // ----------------------------------------------------------------------------

    91 //

    92 void CIpsSetUiBaseArray::BaseConstructL()

    93     {

    94     FUNC_LOG;

    95     // Prepare the arrays

    96     iItemArray = new ( ELeave ) CIpsSetUiBaseItemArray( KIpsSetUiArrayGranularity );

    97     iResourceStack = new ( ELeave ) RResourceStack( KIpsSetUiArrayGranularity );

    98     iFinder = CIpsSetUiFinder::NewL( *this );

    99     iArrayFlags.SetFlag( EIpsSetUiArrayAllowRefresh );

   100         

   101     // Prepare strings

   102     iTempText = HBufC::NewL( KIpsSetUiMaxSettingsTextLength );

   103     iPasswordFill = EikResourceUtils::ReadTInt16L( 

   104         R_IPS_SET_DIALOG_PASSWORD_FILL, iEnv );

   105     }

   106 

   107 // ----------------------------------------------------------------------------

   108 // CIpsSetUiBaseArray::BaseConstructL()

   109 // ----------------------------------------------------------------------------

   110 //

   111 void CIpsSetUiBaseArray::BaseConstructL(

   112     const TInt aResourceId )

   113     {

   114     FUNC_LOG;

   115     // Initialize the members

   116     BaseConstructL();

   117 

   118     // If resource provided add it into the setting array

   119     LoadSettingArrayFromResourceL( aResourceId );

   120 

   121     UpdateActiveItemsCount();

   122     }

   123 

   124 TInt CIpsSetUiBaseArray::GetLastResourceId( )

   125     {

   126     FUNC_LOG;

   127     TInt ret = KErrNotFound;

   128     if ( iResourceStack && iResourceStack->Count() > 0 )

   129         {

   130         ret = (*iResourceStack)[ iResourceStack->Count() -1 ];

   131         }

   132     return ret;

   133     }

   134 

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

   136 // CIpsSetUiBaseArray::CleanArrayItems()

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

   138 //

   139 void CIpsSetUiBaseArray::CleanArrayItems()

   140     {

   141     FUNC_LOG;

   142     if ( iItemArray )

   143         {

   144         // Search through all items in the array

   145         for ( TInt index = iItemArray->Count() - 1 ; index >= 0; index-- )

   146             {

   147             // Only certain type of items can contain subarrays

   148             CIpsSetUiItem* base = ( *iItemArray )[index];

   149             delete base;

   150             base = NULL;

   151             }

   152         }

   153     }

   154 

   155 // ----------------------------------------------------------------------------

   156 // CIpsSetUiBaseArray::CreateCustomItemToArrayLC()

   157 // ----------------------------------------------------------------------------

   158 //

   159 CIpsSetUiItem* CIpsSetUiBaseArray::CreateCustomItemToArrayLC(

   160     const TUid& /* aId */ )

   161     {

   162     FUNC_LOG;

   163     return NULL;

   164     }

   165 

   166 // ----------------------------------------------------------------------------

   167 // CIpsSetUiBaseArray::ListboxItemFillMultiLineLabel()

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

   169 //

   170 void CIpsSetUiBaseArray::ListboxItemFillMultiLineLabel(

   171     const CIpsSetUiItem& aBaseItem,

   172     TIpsSetUtilsTextPlain& aText ) const

   173     {

   174     FUNC_LOG;

   175     aText = static_cast<const CIpsSetUiItemLink*>( 

   176         &aBaseItem )->iItemSettingText->Left( KIpsSetUiVisibleTextLength );

   177     }

   178 

   179 // ----------------------------------------------------------------------------

   180 // CIpsSetUiBaseArray::ListboxItemFillEditTextLabel()

   181 // ----------------------------------------------------------------------------

   182 //

   183 void CIpsSetUiBaseArray::ListboxItemFillEditTextLabel(

   184     const CIpsSetUiItem& aBaseItem,

   185     TIpsSetUtilsTextPlain& aText ) const

   186     {

   187     FUNC_LOG;

   188     aText.Copy( aBaseItem.Text().Left( KIpsSetUiVisibleTextLength ) );

   189     }

   190 

   191 // ----------------------------------------------------------------------------

   192 // CIpsSetUiBaseArray::ListboxItemFillEditValueLabel()

   193 // ----------------------------------------------------------------------------

   194 //

   195 void CIpsSetUiBaseArray::ListboxItemFillEditValueLabel(

   196     const CIpsSetUiItem& aBaseItem,

   197     TIpsSetUtilsTextPlain& aText ) const

   198     {

   199     FUNC_LOG;

   200     aText.Append( aBaseItem.Value() );

   201     aText.SetLength( KIpsSetUiVisibleTextLength );

   202     }

   203 

   204 // ----------------------------------------------------------------------------

   205 // CIpsSetUiBaseArray::ListboxItemFillEditTimeLabel()

   206 // ----------------------------------------------------------------------------

   207 //

   208 void CIpsSetUiBaseArray::ListboxItemFillEditTimeLabel(

   209     const CIpsSetUiItem& aBaseItem,

   210     TIpsSetUtilsTextPlain& aText ) const

   211     {

   212     FUNC_LOG;

   213     aText.Append( aBaseItem.Value() );

   214     aText.SetLength( KIpsSetUiVisibleTextLength );

   215     }

   216 

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

   218 // CIpsSetUiBaseArray::ListboxUndefinedFillLabel()

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

   220 //

   221 void CIpsSetUiBaseArray::ListboxUndefinedFillLabel(

   222     const CIpsSetUiItem& aBaseItem,

   223     TIpsSetUtilsTextPlain& aText ) const

   224     {

   225     FUNC_LOG;

   226     aText = static_cast<const CIpsSetUiItemLinkExt*>( 

   227         &aBaseItem )->iItemSettingText->Left( KIpsSetUiVisibleTextLength );

   228     }

   229 

   230 // ----------------------------------------------------------------------------

   231 // CIpsSetUiBaseArray::ListboxRadioButtonFillArrayLabel()

   232 // ----------------------------------------------------------------------------

   233 //

   234 void CIpsSetUiBaseArray::ListboxRadioButtonFillArrayLabel(

   235     const CIpsSetUiItem& aBaseItem,

   236     TIpsSetUtilsTextPlain& aText ) const

   237     {

   238     FUNC_LOG;

   239     aText = static_cast<const CIpsSetUiItemLinkExt*>( 

   240         &aBaseItem )->iItemSettingText->Left( KIpsSetUiVisibleTextLength );

   241     }

   242 

   243 // ----------------------------------------------------------------------------

   244 // CIpsSetUiBaseArray::ListboxCheckboxFillArrayLabel()

   245 // ----------------------------------------------------------------------------

   246 //

   247 void CIpsSetUiBaseArray::ListboxCheckboxFillArrayLabel(

   248     const CIpsSetUiItem& aBaseItem,

   249     TIpsSetUtilsTextPlain& aText ) const

   250     {

   251     FUNC_LOG;

   252     aText = static_cast<const CIpsSetUiItemLinkExt*>( 

   253         &aBaseItem )->iItemSettingText->Left( KIpsSetUiVisibleTextLength );

   254     }

   255 

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

   257 // CIpsSetUiBaseArray::ListboxItemLabelFillL()

   258 // ----------------------------------------------------------------------------

   259 //

   260 TPtrC16 CIpsSetUiBaseArray::ListboxItemLabelFillL(

   261     CIpsSetUiItem& aBaseItem ) const

   262     {

   263     FUNC_LOG;

   264     // Get the type of the setting item

   265     TIpsSetUiSettingsType type = aBaseItem.iItemType;

   266     TIpsSetUtilsTextPlain tempSettingText;

   267     tempSettingText.Zero();

   268 

   269     switch ( type )

   270         {

   271         case EIpsSetUiItemMultiLine:

   272             ListboxItemFillMultiLineLabel( aBaseItem, tempSettingText );

   273             break;

   274 

   275         case EIpsSetUiUndefined:

   276             ListboxUndefinedFillLabel( aBaseItem, tempSettingText );

   277             break;

   278 

   279         case EIpsSetUiRadioButtonArray:

   280             ListboxRadioButtonFillArrayLabel( aBaseItem, tempSettingText );

   281             break;

   282 

   283         case EIpsSetUiCheckBoxArray:

   284             ListboxCheckboxFillArrayLabel( aBaseItem, tempSettingText );

   285             break;

   286 

   287         case EIpsSetUiItemText:

   288             ListboxItemFillEditTextLabel( aBaseItem, tempSettingText );

   289             break;

   290 

   291         case EIpsSetUiItemValue:

   292             ListboxItemFillEditValueLabel( aBaseItem, tempSettingText );

   293             break;

   294 

   295         case EIpsSetUiItemTime:

   296             ListboxItemFillEditTimeLabel( aBaseItem, tempSettingText );

   297             break;

   298 

   299         default:

   300             // Nothing to show, send empty text

   301             break;

   302         }

   303 

   304     // remove line feed from signature line's visible part

   305     if( aBaseItem.iItemId == TUid::Uid(EIpsSetUiMailboxSignature) || 

   306         aBaseItem.iItemId == TUid::Uid(EIpsSetUiMailboxMailboxName) )

   307         {

   308         AknTextUtils::ReplaceCharacters( tempSettingText, KCharsToReplace, ' ' );

   309         }

   310 

   311     // If the setting is marked as password, fill special character

   312     // instead of readable text

   313     TInt length = tempSettingText.Length();

   314     if ( length > 0 && aBaseItem.iItemFlags.Flag32( KIpsSetUiFlagPassword ) )

   315         {

   316         // Add special chars to all type characters in setting field

   317         TChar passFill = TChar( iPasswordFill );

   318         tempSettingText.Zero();

   319         tempSettingText.AppendFill( passFill, KIpsSetUiPasswordSecLength );

   320         }

   321 

   322     return tempSettingText;

   323     }

   324 

   325 /******************************************************************************

   326 

   327     Item property editors

   328 

   329 ******************************************************************************/

   330 

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

   332 // CIpsSetUiBaseArray::SetItemText()

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

   334 //

   335 void CIpsSetUiBaseArray::SetItemText(

   336     CIpsSetUiItem& aBaseItem,

   337     const TDesC& aText,

   338     const TBool aUpdate )

   339     {

   340     FUNC_LOG;

   341     switch ( aBaseItem.iItemType )

   342         {

   343         case EIpsSetUiItemValue:

   344             static_cast<CIpsSetUiItemValue*>( 

   345                 &aBaseItem )->iItemSettingText->Copy( aText );

   346             break;

   347 

   348         case EIpsSetUiRadioButtonArray:

   349         case EIpsSetUiCheckBoxArray:

   350             static_cast<CIpsSetUiItemLinkExt*>( 

   351                 &aBaseItem )->iItemSettingText->Copy( aText );

   352             break;

   353 

   354         default:

   355             aBaseItem.SetText( aText );

   356             break;

   357         }

   358 

   359     // Issue update when needed

   360     if ( aUpdate )

   361         {

   362         Refresh();

   363         }

   364     }

   365 

   366 // ----------------------------------------------------------------------------

   367 // CIpsSetUiBaseArray::ItemText()

   368 // ----------------------------------------------------------------------------

   369 //

   370 const TDesC& CIpsSetUiBaseArray::ItemText(

   371     CIpsSetUiItem& aBaseItem )

   372     {

   373     FUNC_LOG;

   374     switch ( aBaseItem.iItemType )

   375         {

   376         case EIpsSetUiItemValue:

   377             return *static_cast<CIpsSetUiItemValue*>( 

   378                 &aBaseItem )->iItemSettingText;

   379 

   380         case EIpsSetUiRadioButtonArray:

   381         case EIpsSetUiCheckBoxArray:

   382             return *static_cast<CIpsSetUiItemLinkExt*>( 

   383                 &aBaseItem )->iItemSettingText;

   384         }

   385 

   386     return aBaseItem.Text();

   387     }

   388 

   389 /******************************************************************************

   390 

   391     Base class function definitions

   392 

   393 ******************************************************************************/

   394 

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

   396 // CIpsSetUiBaseArray::SearchDoError()

   397 // ----------------------------------------------------------------------------

   398 //

   399 TBool CIpsSetUiBaseArray::SearchDoError()

   400     {

   401     FUNC_LOG;

   402     return ETrue;

   403     }

   404 

   405 // ----------------------------------------------------------------------------

   406 // CIpsSetUiBaseArray::SearchDoContinuationCheck()

   407 // ----------------------------------------------------------------------------

   408 //

   409 TBool CIpsSetUiBaseArray::SearchDoContinuationCheck(

   410     const CIpsSetUiItem& /* aItem */,

   411     const TInt /* aIndex */ )

   412     {

   413     FUNC_LOG;

   414     return ETrue;

   415     }

   416 

   417 // ----------------------------------------------------------------------------

   418 // CIpsSetUiBaseArray::SearchDoItemCheck()

   419 // ----------------------------------------------------------------------------

   420 //

   421 TBool CIpsSetUiBaseArray::SearchDoItemCheck(

   422     CIpsSetUiItem& /* aItem */ )

   423     {

   424     FUNC_LOG;

   425     return ETrue;

   426     }

   427 

   428 // ----------------------------------------------------------------------------

   429 // CIpsSetUiBaseArray::MdcaCount()

   430 // ----------------------------------------------------------------------------

   431 //

   432 TInt CIpsSetUiBaseArray::MdcaCount() const

   433     {

   434     FUNC_LOG;

   435     return iActiveCount;

   436     }

   437 

   438 // ----------------------------------------------------------------------------

   439 // CIpsSetUiBaseArray::MdcaPoint()

   440 // ----------------------------------------------------------------------------

   441 //

   442 TPtrC16 CIpsSetUiBaseArray::MdcaPoint( TInt aIndex ) const

   443     {

   444     FUNC_LOG;

   445     // First search the currently active resource to array and check

   446     // the given index is in the current array

   447     IPS_ASSERT_DEBUG( aIndex < StackCountItems(), KErrOverflow, EBaseArray );

   448 

   449     // Temp text ptr

   450     TPtr tempText = iTempText->Des();

   451     

   452     // Do a sanity check for index and return null text if out of range

   453     if ( !iFinder || aIndex < 0 || aIndex >= StackCountItems())

   454         {       

   455         tempText.Zero();

   456         tempText.Append(KNullDesC);        

   457         return tempText;

   458         }

   459 

   460     // Search for item from the active array

   461     CIpsSetUiItem* setting = iFinder->FinderArray()->At( aIndex ).iItem;  // faulty CS warning

   462     IPS_ASSERT_DEBUG( setting , KErrNotFound, EBaseArray );

   463 

   464     // Prepare strings

   465     // Send custom event and if not used, prepare default

   466     if ( !EventCustomMdcaPoint( setting->iItemId, tempText ) )

   467         {

   468         // Initialize string

   469         tempText.Zero();

   470         tempText.Append( KIpsSetUiStrSpace );

   471         tempText.Append( KColumnListSeparator );

   472         tempText.Append( *setting->iItemLabel );

   473 

   474         // Submenus doesn't contain other information

   475         if ( !ItemSubArrayCheck( *setting ) )

   476             {

   477             tempText.Append( KColumnListSeparator );

   478             tempText.Append( KColumnListSeparator );

   479 

   480             TIpsSetUtilsTextPlain tempSettingText;

   481             // Try to add the text

   482             TRAP_IGNORE( tempSettingText =

   483                 ListboxItemLabelFillL( *setting ) );

   484 

   485             // Fill the setting text with string

   486             if ( tempSettingText.Length() )

   487                 {

   488                 tempText.Append( tempSettingText );

   489                 }

   490             else

   491                 {

   492                 tempText.Append( KIpsSetUiStrSpace );

   493                 }

   494 

   495             // Add the special string after compulsory fields

   496             if ( setting->iItemFlags.Flag32( KIpsSetUiFlagCompulsory ) )

   497                 {

   498                 tempText.Append( KIpsSetUiStrCompulsory );

   499                 }

   500 

   501             // Do the number conversion, if allowed

   502             if ( setting->iItemFlags.Flag32( KIpsSetUiFlagLangSpecificNumConv ) )

   503                 {

   504                 AknTextUtils::DisplayTextLanguageSpecificNumberConversion(

   505                     tempText );

   506                 }

   507             }

   508         }

   509 

   510     setting = NULL;

   511     return tempText;

   512     }

   513 

   514 /******************************************************************************

   515 

   516     Resource loading functions

   517 

   518 ******************************************************************************/

   519 

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

   521 // CIpsSetUiBaseArray::LoadDynamicSettingItemL()

   522 // ----------------------------------------------------------------------------

   523 //

   524 void CIpsSetUiBaseArray::LoadDynamicSettingItemL(

   525     TResourceReader& aReader,

   526     CIpsSetUiItem& aBaseItem )

   527     {

   528     FUNC_LOG;

   529     // Read rest of the settings first

   530     // STRUCT IPS_SET_ITEM : LTEXT itemlabel

   531     HBufC* txt = aReader.ReadHBufCL();   // message text

   532 

   533     if ( txt )

   534         {

   535         aBaseItem.iItemLabel->Copy( *txt );

   536         }

   537 

   538     delete txt;

   539     txt = NULL;

   540 

   541     // STRUCT IPS_SET_ITEM : LLINK itemmaxlength

   542     TInt maxLength = aReader.ReadInt32();

   543 

   544     // STRUCT IPS_SET_ITEM : LONG itemflags

   545     aBaseItem.iItemFlags = MAKE_TUINT64( aReader.ReadInt32(), 0 );

   546 

   547     // STRUCT IPS_SET_ITEM : LLINK itemarray

   548     TInt linkResourceId = aReader.ReadInt32();

   549 

   550     // STRUCT IPS_SET_ITEM : WORD itemappereance

   551     TIpsSetUiSettingsType subtype =

   552         static_cast<TIpsSetUiSettingsType>( aReader.ReadInt16() );

   553 

   554     // Finally add the item to list

   555     HandleDynamicSettingsItemL(

   556         aBaseItem, maxLength, subtype, linkResourceId );

   557 

   558     // The basic data has been set, now init the userdata section

   559     InitUserData( aBaseItem );        

   560     }

   561 

   562 // ----------------------------------------------------------------------------

   563 // CIpsSetUiBaseArray::UpdateItemEditTextL()

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

   565 //

   566 void CIpsSetUiBaseArray::UpdateItemEditTextL(

   567     CIpsSetUiItem& aBaseItem,

   568     const TInt aMaxLength )

   569     {

   570     FUNC_LOG;

   571     CIpsSetUiItemsEditText* text = 

   572         static_cast<CIpsSetUiItemsEditText*>( &aBaseItem );

   573     text->iItemMaxLength = aMaxLength;

   574     text = NULL;

   575     }

   576 

   577 // ----------------------------------------------------------------------------

   578 // CIpsSetUiBaseArray::UpdateItemEditValueL()

   579 // ----------------------------------------------------------------------------

   580 //

   581 void CIpsSetUiBaseArray::UpdateItemEditValueL(

   582     CIpsSetUiItem& aBaseItem,

   583     const TInt aMaxLength )

   584     {

   585     FUNC_LOG;

   586     CIpsSetUiItemValue* value = 

   587         static_cast<CIpsSetUiItemValue*>( &aBaseItem );

   588     value->iItemMaxLength = aMaxLength;

   589     value = NULL;

   590     }

   591 

   592 // ----------------------------------------------------------------------------

   593 // CIpsSetUiBaseArray::HandleDynamicSettingsItemL()

   594 // ----------------------------------------------------------------------------

   595 //

   596 void CIpsSetUiBaseArray::HandleDynamicSettingsItemL(

   597     CIpsSetUiItem& aBaseItem,

   598     const TInt aMaxLength,

   599     const TIpsSetUiSettingsType aSubType,

   600     const TInt aLinkResourceId )

   601     {

   602     FUNC_LOG;

   603     switch ( aBaseItem.Type() )

   604         {

   605         // Load dynamically linked items or submenus

   606         case EIpsSetUiMenuArray:

   607         case EIpsSetUiRadioButtonArray:

   608         case EIpsSetUiCheckBoxArray:

   609         case EIpsSetUiItemMultiLine:

   610             LoadDynamicSettingsItemLinkItemL(

   611                 aBaseItem, aSubType, aLinkResourceId );

   612             break;

   613 

   614         // Finish text item

   615         case EIpsSetUiItemText:

   616             UpdateItemEditTextL( aBaseItem, aMaxLength );

   617             break;

   618 

   619         // Finish number item

   620         case EIpsSetUiItemValue:

   621         case EIpsSetUiItemTime:

   622             UpdateItemEditValueL( aBaseItem, aMaxLength );

   623             break;

   624 

   625         // Other items are already finished

   626         case EIpsSetUiItemRadioButton:

   627         case EIpsSetUiItemCheckBox:

   628         default:

   629             break;

   630         }

   631     }

   632 

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

   634 // CIpsSetUiBaseArray::CreateItemToArrayL()

   635 // ----------------------------------------------------------------------------

   636 //

   637 CIpsSetUiItem* CIpsSetUiBaseArray::CreateItemToArrayL(

   638     const TIpsSetUiSettingsType aType,

   639     const TUid& aId,

   640     CIpsSetUiBaseItemArray& aItemArray )

   641     {

   642     FUNC_LOG;

   643     CIpsSetUiItem* base = NULL;

   644 

   645     switch ( aType )

   646         {

   647         // Create array item

   648         case EIpsSetUiMenuArray:

   649             base = CIpsSetUiItemLink::NewLC();

   650             break;

   651 

   652         // Force manual item creation

   653         case EIpsSetUiUndefined:

   654             base = CreateCustomItemToArrayLC( aId );

   655             IPS_ASSERT_DEBUG( base , EUnidentifiedItem, EBaseArray );

   656             break;

   657 

   658         // Create radiobutton array item

   659         case EIpsSetUiRadioButtonArray:

   660         case EIpsSetUiCheckBoxArray:

   661         case EIpsSetUiItemMultiLine:

   662             base = CIpsSetUiItemLinkExt::NewLC();

   663             break;

   664 

   665         // Create edit text item

   666         case EIpsSetUiItemText:

   667             base = CIpsSetUiItemsEditText::NewLC();

   668             break;

   669 

   670         // Create edit number item

   671         case EIpsSetUiItemValue:

   672         case EIpsSetUiItemTime:

   673             base = CIpsSetUiItemValue::NewLC();

   674             break;

   675 

   676         // Create normal base item

   677         case EIpsSetUiItemRadioButton:

   678         case EIpsSetUiItemCheckBox:

   679         default:

   680             base = CIpsSetUiItem::NewLC();

   681             break;

   682         }

   683 

   684     // Add to array

   685     aItemArray.AppendL( base );

   686     CleanupStack::Pop( base );

   687 

   688     return base;

   689     }

   690 

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

   692 // CIpsSetUiBaseArray::LoadDynamicSettingsItemLinkItemL()

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

   694 //

   695 void CIpsSetUiBaseArray::LoadDynamicSettingsItemLinkItemL(

   696     CIpsSetUiItem& aBaseItem,

   697     const TIpsSetUiSettingsType aSubType,

   698     const TInt aLinkResourceId )

   699     {

   700     FUNC_LOG;

   701     // Prepare the item

   702     CIpsSetUiItemLink* linkItem = static_cast<CIpsSetUiItemLink*>( &aBaseItem );

   703     linkItem->iItemAppereance = aSubType;

   704     linkItem->iItemFlags.SetFlag32( KIpsSetUiFlagUpdateOnChange );

   705 

   706     // Start reading only if resource is provided

   707     if ( aLinkResourceId )

   708         {

   709         linkItem->iItemLinkArray =

   710             new ( ELeave ) CIpsSetUiBaseItemArray(

   711                 KIpsSetUiArrayGranularity );

   712 

   713         // Start loading the settings

   714         LoadSettingItemsToArrayL( aLinkResourceId, *linkItem->iItemLinkArray );

   715         }

   716 

   717     linkItem = NULL;

   718     }

   719 

   720 // ----------------------------------------------------------------------------

   721 // CIpsSetUiBaseArray::LoadSettingArrayFromResource()

   722 // ----------------------------------------------------------------------------

   723 //

   724 void CIpsSetUiBaseArray::LoadSettingArrayFromResourceL(

   725     const TInt aResourceId )

   726     {

   727     FUNC_LOG;

   728     // Start reading only if resource is provided

   729     if ( aResourceId )

   730         {

   731         iResourceStack->AppendL( aResourceId );

   732         const TInt items = iItemArray->Count();

   733 

   734         // Begin to read the items from the resource

   735         TInt count = LoadSettingItemsToArrayL( aResourceId, *iItemArray );

   736 

   737         // Update the item count

   738         UpdateActiveItemsCount( count );

   739         }

   740     }

   741 

   742 // ----------------------------------------------------------------------------

   743 // CIpsSetUiBaseArray::LoadSettingItemsToArrayL()

   744 // ----------------------------------------------------------------------------

   745 //

   746 TInt CIpsSetUiBaseArray::LoadSettingItemsToArrayL(

   747     const TInt aResourceId,

   748     CIpsSetUiBaseItemArray& aItemArray )

   749     {

   750     FUNC_LOG;

   751     // Define new read based on last item

   752     TResourceReader reader;

   753     iEnv->CreateResourceReaderLC(

   754         reader, aResourceId );

   755 

   756     // Get the count of items in resource

   757     TInt count = reader.ReadInt16();

   758     for ( TInt loop = 0; loop < count; loop++ )

   759         {

   760         // Read the settings from the resource

   761 

   762         // STRUCT IPS_SET_ITEM : WORD itemtype

   763         TIpsSetUiSettingsType type =

   764             static_cast<TIpsSetUiSettingsType>( reader.ReadInt16() );

   765 

   766         // STRUCT IPS_SET_ITEM : WORD itemid

   767         TUid id = TUid::Uid( reader.ReadInt16() );

   768 

   769         // Create the setting item

   770         CIpsSetUiItem* base =

   771             CreateItemToArrayL( type, id, aItemArray );

   772         base->iItemId = id;

   773         base->iItemType = type;

   774         base->iItemResourceId = aResourceId;

   775 

   776         // Start loading the item, based on item type

   777         LoadDynamicSettingItemL( reader, *base );

   778         base = NULL;

   779         }

   780 

   781     CleanupStack::PopAndDestroy(); // reader

   782 

   783     return count;

   784     }

   785 

   786 /******************************************************************************

   787 

   788     Item hide functions

   789 

   790 ******************************************************************************/

   791 

   792 // ----------------------------------------------------------------------------

   793 // CIpsSetUiBaseArray::IsHidden()

   794 // ----------------------------------------------------------------------------

   795 //

   796 TInt CIpsSetUiBaseArray::IsHidden( const TUid& aId ) const

   797     {

   798     FUNC_LOG;

   799     return IsHidden( *GetItem( aId ) );

   800     }

   801 

   802 // ----------------------------------------------------------------------------

   803 // CIpsSetUiBaseArray::IsHidden()

   804 // ----------------------------------------------------------------------------

   805 //

   806 TInt CIpsSetUiBaseArray::IsHidden(

   807     const CIpsSetUiItem& aItem ) const

   808     {

   809     FUNC_LOG;

   810     if ( aItem.iItemFlags.Flag32( KIpsSetUiFlagPermanentlyHidden ) )

   811         {

   812         return KErrNotSupported;

   813         }

   814     else if ( aItem.iItemFlags.Flag32( KIpsSetUiFlagHidden ) )

   815         {

   816         return KErrNotFound;

   817         }

   818     else

   819         {

   820         return KErrNone;

   821         }

   822     }

   823 

   824 // ----------------------------------------------------------------------------

   825 // CIpsSetUiBaseArray::IsHidden()

   826 // ----------------------------------------------------------------------------

   827 //

   828 TInt CIpsSetUiBaseArray::IsHidden( const TInt aIndex ) const

   829     {

   830     FUNC_LOG;

   831     return IsHidden( *GetItem( aIndex ) );

   832     }

   833 

   834 // ----------------------------------------------------------------------------

   835 // CIpsSetUiBaseArray::DoHideItems()

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

   837 //

   838 void CIpsSetUiBaseArray::DoHideItems( const TBool aHide )

   839     {

   840     FUNC_LOG;

   841     // All items collected, set their flags hidden flags

   842     CIpsSetUiFinderArray& array = *iFinder->FinderArray();

   843     TInt item = array.Count();

   844     while ( --item >= 0 )

   845         {

   846         CIpsSetUiItem* base = array[item].iItem;

   847         if ( aHide )

   848             {

   849             base->iItemFlags.SetFlag32( KIpsSetUiFlagHidden );

   850             }

   851         else

   852             {

   853             base->iItemFlags.ClearFlag32( KIpsSetUiFlagHidden );

   854             }        

   855         }

   856     }

   857 

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

   859 // CIpsSetUiBaseArray::SetHideItem()

   860 // ----------------------------------------------------------------------------

   861 //

   862 void CIpsSetUiBaseArray::SetHideItem(

   863     const TBool aHide,

   864     const TUid& aId,

   865     const TBool aUpdate )

   866     {

   867     FUNC_LOG;

   868     if ( aHide )

   869         {

   870         GetItem( aId )->iItemFlags.SetFlag32( KIpsSetUiFlagHidden );

   871         }

   872     else

   873         {

   874         GetItem( aId )->iItemFlags.ClearFlag32( KIpsSetUiFlagHidden );

   875         }    

   876 

   877     // Handle the array change

   878     if ( aUpdate )

   879         {

   880         Refresh();

   881         }

   882     }

   883     

   884 // ----------------------------------------------------------------------------

   885 // CIpsSetUiBaseArray::SetHideItem()

   886 // ----------------------------------------------------------------------------

   887 //

   888 void CIpsSetUiBaseArray::SetHideItem(

   889     const TBool aHide,

   890     CIpsSetUiItem& aItem,

   891     const TBool aUpdate )

   892     {

   893     FUNC_LOG;

   894     if ( aHide )

   895         {

   896         aItem.iItemFlags.SetFlag32( KIpsSetUiFlagHidden );

   897         }

   898     else

   899         {

   900         aItem.iItemFlags.ClearFlag32( KIpsSetUiFlagHidden );

   901         }    

   902 

   903     // Handle the array change

   904     if ( aUpdate )

   905         {

   906         Refresh();

   907         }

   908     }

   909     

   910 /******************************************************************************

   911 

   912     Item search functions

   913 

   914 ******************************************************************************/

   915 

   916 // ----------------------------------------------------------------------------

   917 // CIpsSetUiBaseArray::InitDefaultSearch()

   918 // ----------------------------------------------------------------------------

   919 //

   920 void CIpsSetUiBaseArray::InitDefaultSearch(

   921     const TBool aExcludeHidden ) const

   922     {

   923     FUNC_LOG;

   924     // In default search, subfolders are included and hidden items are not

   925     // included into the search

   926     TUint64 search = 0x00;

   927     search |= CIpsSetUiFinder::EFinderSearchSubFolders;

   928     if ( aExcludeHidden )

   929         {

   930         search |= CIpsSetUiFinder::EFinderDoHideCheck;

   931         }

   932     else

   933         {

   934         search &= CIpsSetUiFinder::EFinderDoHideCheck;

   935         }    

   936     iFinder->SetSearchFlags( search );

   937     }

   938 

   939 // ----------------------------------------------------------------------------

   940 // CIpsSetUiBaseArray::ItemIndex()

   941 // ----------------------------------------------------------------------------

   942 //

   943 TInt CIpsSetUiBaseArray::ItemIndex(

   944     const TUid& aId,

   945     const TBool aExcludeHidden ) const

   946     {

   947     FUNC_LOG;

   948     InitDefaultSearch( aExcludeHidden );

   949 

   950     // Try to make the search, but if the search fails, allow caller

   951     // to handle the result

   952     TRAP_IGNORE( iFinder->StartSearchL( *iItemArray, aId ) );

   953 

   954     TInt ret( KErrNotFound );

   955     if ( iFinder->FinderArray()->Count() )

   956         {

   957     // Return the found item

   958         ret = iFinder->FinderArray()->At( 0 ).iIndex;

   959         }

   960     return ret;

   961     }

   962 

   963 // ----------------------------------------------------------------------------

   964 // CIpsSetUiBaseArray::GetItem()

   965 // ----------------------------------------------------------------------------

   966 //

   967 CIpsSetUiItem* CIpsSetUiBaseArray::GetItem(

   968     const TInt aIndex,

   969     const TBool aExcludeHidden ) const

   970     {

   971     FUNC_LOG;

   972     // First search the currently active resource to array and check

   973     // the given index is in the current array

   974     TBool ok = aIndex < StackCountItems( aExcludeHidden );

   975     IPS_ASSERT_DEBUG( ok, KErrOverflow, EBaseArray );

   976     IPS_ASSERT_DEBUG( aIndex >= 0, KErrUnderflow, EBaseArray );

   977 

   978     // Return the found item

   979     return ok ? iFinder->FinderArray()->At( aIndex ).iItem : NULL; // CS warning

   980     }

   981 

   982 // ----------------------------------------------------------------------------

   983 // CIpsSetUiBaseArray::GetItem()

   984 // ----------------------------------------------------------------------------

   985 //

   986 CIpsSetUiItem* CIpsSetUiBaseArray::GetItem(

   987     const TUid& aId,

   988     const TBool aExcludeHidden ) const

   989     {

   990     FUNC_LOG;

   991     InitDefaultSearch( aExcludeHidden );

   992 

   993     // Try to make the search, but if the search fails, allow caller

   994     // to handle the result

   995     TRAP_IGNORE( iFinder->StartSearchL( *iItemArray, aId ) );

   996 

   997     // Return the found item

   998     return iFinder->FinderArray()->At( 0 ).iItem;

   999     }

  1000 

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

  1002 // CIpsSetUiBaseArray::GetSubItem()

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

  1004 //

  1005 CIpsSetUiItem* CIpsSetUiBaseArray::GetSubItem(

  1006     const CIpsSetUiItem& aBaseItem,

  1007     const TUid& aId,

  1008     const TBool aExcludeHidden ) const

  1009     {

  1010     FUNC_LOG;

  1011     // Make sure the item has subitems

  1012     if ( ItemSubItemCheck( aBaseItem ) )

  1013         {

  1014         // Convert the item to link item

  1015         const CIpsSetUiItemLink* link = 

  1016             static_cast<const CIpsSetUiItemLink*>( &aBaseItem );

  1017 

  1018         // Get item count

  1019         TInt count = link->iItemLinkArray ?

  1020             link->iItemLinkArray->Count() : KErrNotFound;

  1021 

  1022         // Find the item from the array

  1023         while ( --count >= 0)

  1024             {

  1025             CIpsSetUiItem* base = ( *link->iItemLinkArray )[count];

  1026 

  1027             if ( IsVisibleCheck( aBaseItem, aExcludeHidden ) &&

  1028                  base->iItemId == aId )

  1029                 {

  1030                 return base;

  1031                 }

  1032             }

  1033         }

  1034 

  1035     return NULL;

  1036     }

  1037 

  1038 // ----------------------------------------------------------------------------

  1039 // CIpsSetUiBaseArray::GetSubItem()

  1040 // ----------------------------------------------------------------------------

  1041 //

  1042 CIpsSetUiItem* CIpsSetUiBaseArray::GetSubItem(

  1043     const CIpsSetUiItem& aBaseItem,

  1044     const TInt aIndex,

  1045     const TBool aExcludeHidden ) const

  1046     {

  1047     FUNC_LOG;

  1048     CIpsSetUiItem* base = NULL;

  1049 

  1050     // Make sure the item has subitems

  1051     if ( ItemSubItemCheck( aBaseItem ) )

  1052         {

  1053         // Convert the item to link item

  1054         const CIpsSetUiItemLink* link = 

  1055             static_cast<const CIpsSetUiItemLink*>( &aBaseItem );

  1056 

  1057         // Get the item count and make sure the required index is

  1058         // below the number of items

  1059         TInt count = link->iItemLinkArray ?

  1060             link->iItemLinkArray->Count() : KErrNotFound;

  1061         count = ( aIndex >= 0 && aIndex < count ) ? count : KErrNotFound;

  1062         TInt index = KErrNotFound;

  1063         TInt item = 0;

  1064 

  1065         for ( ; index != aIndex && item < count; item++ )

  1066             {

  1067             base = ( *link->iItemLinkArray )[item];

  1068 

  1069             if ( IsVisibleCheck( *base, aExcludeHidden ) )

  1070                 {

  1071                 index++;

  1072                 }

  1073             }

  1074 

  1075         // At the end of the items and still not found

  1076         if ( item == count && index != aIndex )

  1077             {

  1078             base = NULL;

  1079             }

  1080         }

  1081 

  1082     return base;

  1083     }

  1084 

  1085 

  1086 // ----------------------------------------------------------------------------

  1087 // CIpsSetUiBaseArray::GetSubItemByType()

  1088 // ----------------------------------------------------------------------------

  1089 //

  1090 CIpsSetUiItem* CIpsSetUiBaseArray::GetSubItemByType(

  1091     const CIpsSetUiItem& aBaseItem,

  1092     const TInt aType ) const

  1093     {

  1094     FUNC_LOG;

  1095     CIpsSetUiItem* base = NULL;

  1096 

  1097     // Make sure the item has subitems

  1098     if ( ItemSubItemCheck( aBaseItem ) )

  1099         {

  1100         // Convert the item to link item

  1101         const CIpsSetUiItemLink* link = 

  1102             static_cast<const CIpsSetUiItemLink*>( &aBaseItem );

  1103 

  1104         // Get the item count and make sure the required index is

  1105         // below the number of items

  1106         TInt count = link->iItemLinkArray ?

  1107             link->iItemLinkArray->Count() : KErrNotFound;

  1108 

  1109         for ( TInt item = 0 ; !base && item < count; item++ )

  1110             {

  1111             base = ( *link->iItemLinkArray )[item];

  1112             base = ( base && base->Type() == aType ) ? base : NULL;                

  1113             }

  1114         }

  1115 

  1116     return base;

  1117     }

  1118     

  1119 // ----------------------------------------------------------------------------

  1120 // CIpsSetUiBaseArray::GetSubItemIndex()

  1121 // ----------------------------------------------------------------------------

  1122 //

  1123 TInt CIpsSetUiBaseArray::GetSubItemIndex(

  1124     const CIpsSetUiItemLink& aLinkItem,

  1125     const TUid& aId,

  1126     const TBool aExcludeHidden ) const

  1127     {

  1128     FUNC_LOG;

  1129     TBool found = EFalse;

  1130     TInt index = KErrNotFound;

  1131 

  1132     if ( aLinkItem.iItemLinkArray )

  1133         {

  1134         CIpsSetUiItem* subItem = NULL;