1 /*

     2 * Copyright (c) 2002-2009 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:

    15 *

    16 *    Support for setting item lists and their setting

    17 *    items.  THe setting item list owns a listbox and an array of

    18 *    setting items. The latter provides a MDesCArray interface for the

    19 *    listbox model.

    20 *

    21 *    Setting Items are abstractions of data types, that

    22 *    have a capability to launch setting pages.

    23 *

    24 *

    25 */

    26 

    27 

    28 #include <gulicon.h>

    29 #include <coemain.h>

    30 

    31 //For TResourceReader

    32 #include <barsread.h>

    33 

    34 #include <avkon.hrh>

    35 #include <avkon.rsg>

    36 #include <avkon.mbg>

    37 

    38 // For Numbered and unnumbered setting style lists

    39 #include <aknlists.h>

    40 #include <aknnotewrappers.h>

    41 

    42 #include <aknlayoutscalable_avkon.cdl.h>

    43 #include <aknconsts.h>

    44 

    45 // For layout switch events

    46 #include "AknDef.h"

    47 

    48 // For proper icon array management

    49 #include "AknIconArray.h"

    50 

    51 #include "aknsettingitemlist.h"

    52 #include "akntextsettingpage.h"

    53 #include "aknvolumesettingpage.h"

    54 #include "aknslidersettingpage.h"

    55 #include "aknmfnesettingpage.h"

    56 #include "aknpopupsettingpage.h"

    57 #include "aknpasswordsettingpage.h"

    58 #include <AknsConstants.h>

    59 

    60 #include "akntrace.h"

    61 

    62 const TInt KAknSettingItemMaxNumberDigits = 3; // for the setting item numbers

    63 const TInt KAknSettingItemArrayGranularity = 5;

    64 const TInt KAknSettingItemTimeBufferLength = 30;

    65 const TInt KAknSettingItemIpTextBufferLength = 15; //Assumes 4 fields of 3 + 3 dots

    66 

    67 

    68 // Separator for listbox text decoration

    69 _LIT(KListBoxTextSeparator, "\t");

    70 

    71 // Format for a number

    72 _LIT(KAknSettingItemDecimalFormat, "%d" );

    73 

    74 // Space used for listbox and time offset text formatting

    75 _LIT(KAknSettingItemSingleSpace, " " );

    76 

    77 // Plus and minus used for listbox time offset

    78 _LIT(KAknSettingItemPlus, "+" );

    79 _LIT(KAknSettingItemMinus, "-" );

    80 

    81 // Empty IP address

    82 _LIT(KAknSettingItemEmptyIpAddress, "0.0.0.0" );

    83 

    84 enum TAknSettingItemListPanic

    85     {

    86     EAknPanicSettingItemListUnused,

    87     EAknPanicSettingItemListNoEmptyText,

    88     EAknPanicSettingItemListInsufficientResource,

    89     EAknPanicSettingItemListInconsistentControlType,

    90     EAknPanicSettingItemListInvalidPasswordMode,

    91     EAknPanicSettingItemListInvalidDateMode,

    92     EAknPanicSettingItemListInvalidEnumeratedValue,

    93     EAknPanicSettingItemListWrongNumberOfValues,

    94     EAknPanicSettingItemListRequiredValueNotInArray,

    95     EAknPanicSettingItemListInvalidIndex,

    96     EAknPanicSettingItemListConstructionNotComplete,

    97     EAknPanicSettingItemListArrayLengthsMisMatch,

    98     EAknPanicSettingItemListNotBinaryCompatible,

    99     EAknPanicSettingItemListInvalidPointer,

   100     EAknPanicSettingItemListBadIcon

   101     };

   102 

   103 GLDEF_C void Panic(TAknSettingItemListPanic aPanic)

   104     {

   105     _LIT(KPanicCat,"Setting Item List");

   106     User::Panic(KPanicCat, aPanic);

   107     }

   108 

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

   110 // CAknSettingItemExtension

   111 // -------------------------------

   112 //

   113 

   114 NONSHARABLE_CLASS( CAknSettingItemExtension ) : CBase

   115     {

   116     public:

   117 

   118     static CAknSettingItemExtension* NewL();

   119     ~CAknSettingItemExtension();

   120     void CreateLockIconL(CArrayPtr<CGulIcon>* aIconArray);

   121 

   122     protected:

   123     void ConstructL();

   124 

   125     private:

   126     CAknSettingItemExtension();

   127 

   128     //members

   129     public:

   130     TInt iLockIconIndex;

   131     TInt iLockIconHighlightIndex;

   132 

   133     private:

   134 

   135     };

   136 

   137 CAknSettingItemExtension::CAknSettingItemExtension()

   138 : iLockIconIndex(KErrNotFound), iLockIconHighlightIndex(KErrNotFound)

   139     {

   140     }

   141 CAknSettingItemExtension::~CAknSettingItemExtension()

   142     {

   143     }

   144 

   145 void CAknSettingItemExtension::ConstructL()

   146     {

   147     }

   148 

   149 CAknSettingItemExtension* CAknSettingItemExtension::NewL()

   150     {

   151     CAknSettingItemExtension* settingExtension = new (ELeave) CAknSettingItemExtension;

   152     CleanupStack::PushL(settingExtension);

   153     settingExtension->ConstructL();

   154     CleanupStack::Pop(settingExtension);

   155     return settingExtension;

   156     }

   157 

   158 void CAknSettingItemExtension::CreateLockIconL(CArrayPtr<CGulIcon>* aIconArray)

   159     {

   160     // START of lock icon creation

   161 

   162     // Create the lock icon as the last icon in the table

   163     CFbsBitmap* skinnedBitmap = NULL;

   164     CFbsBitmap* skinnedMask = NULL;

   165 

   166     // Make the icon and put it in the array

   167     CGulIcon* icon = CGulIcon::NewL();

   168     CleanupStack::PushL(icon);

   169 

   170     MAknsSkinInstance* skin = AknsUtils::SkinInstance();

   171 

   172     // Create color icon

   173     AknsUtils::CreateColorIconL(skin, KAknsIIDQgnIndiSettProtectedAdd,

   174                                 KAknsIIDQsnIconColors, EAknsCIQsnIconColorsCG13,

   175                                 skinnedBitmap, skinnedMask, KAvkonBitmapFile,

   176                                 EMbmAvkonQgn_indi_sett_protected_add,

   177                                 EMbmAvkonQgn_indi_sett_protected_add_mask, KRgbBlack);

   178 

   179     icon->SetMask(skinnedMask);// ownership transferred

   180     icon->SetBitmap(skinnedBitmap); // ownership transferred

   181 

   182     if(iLockIconIndex == KErrNotFound)

   183         {

   184         aIconArray->AppendL( icon );

   185         iLockIconIndex = aIconArray->Count() - 1;

   186         }

   187     else

   188         {

   189         delete aIconArray->At(iLockIconIndex);

   190         aIconArray->Delete(iLockIconIndex);

   191         aIconArray->InsertL(iLockIconIndex, icon);

   192         }

   193 

   194     CleanupStack::Pop(); // icon

   195 

   196     // Create the lock icon for highlight

   197     skinnedBitmap = NULL;

   198     skinnedMask = NULL;

   199 

   200     // Make the icon and put it in the array

   201     icon = CGulIcon::NewL();

   202     CleanupStack::PushL(icon);

   203 

   204     // Create color icon

   205     AknsUtils::CreateColorIconL(skin, KAknsIIDQgnIndiSettProtectedAdd,

   206                                 KAknsIIDQsnIconColors, EAknsCIQsnIconColorsCG16,

   207                                 skinnedBitmap, skinnedMask, KAvkonBitmapFile,

   208                                 EMbmAvkonQgn_indi_sett_protected_add,

   209                                 EMbmAvkonQgn_indi_sett_protected_add_mask, KRgbBlack);

   210 

   211 

   212     icon->SetMask(skinnedMask);// ownership transferred

   213     icon->SetBitmap(skinnedBitmap); // ownership transferred

   214 

   215     if(iLockIconHighlightIndex == KErrNotFound)

   216         {

   217         aIconArray->AppendL( icon );

   218         iLockIconHighlightIndex = aIconArray->Count() - 1;

   219         }

   220     else

   221         {

   222         delete aIconArray->At(iLockIconHighlightIndex);

   223         aIconArray->Delete(iLockIconHighlightIndex);

   224         aIconArray->InsertL(iLockIconHighlightIndex, icon);

   225         }

   226 

   227     CleanupStack::Pop(); // icon

   228 

   229     // END of lock icon creation

   230     }

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

   232 // CAknSettingItem

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

   234 //

   235 // public:

   236 

   237 /**

   238 * Default constructor.

   239 */

   240 EXPORT_C CAknSettingItem::CAknSettingItem( TInt aIdentifier) : iIdentifier( aIdentifier )

   241     {

   242     }

   243 EXPORT_C CAknSettingItem::~CAknSettingItem()

   244     {

   245     delete iExtension;

   246     delete iSettingName;

   247     delete iListBoxText;

   248     delete iEmptyItemText;

   249     delete iCompulsoryText;

   250     }

   251 

   252 EXPORT_C void CAknSettingItem::ConstructL(

   253     const TBool aIsNumberedStyle,

   254     const TInt aOrdinal,

   255     const TDesC& aSettingName,

   256     CArrayPtr<CGulIcon>* aIconArray,

   257     TInt aSettingPageResourceId,

   258     TInt aEditorControlType,

   259     TInt aSettingEditorResourceId,

   260     TInt aAssociatedResourceId)

   261     {

   262     _AKNTRACE_FUNC_ENTER;

   263     iExtension = CAknSettingItemExtension::NewL();

   264 

   265     if ( aIsNumberedStyle )

   266         iFlags |= EIsNumberedStyle;

   267     else

   268         iFlags &= (~EIsNumberedStyle);

   269 

   270     iOrdinal = aOrdinal;

   271 

   272     HBufC* newText = aSettingName.AllocL();

   273     delete( iSettingName ); // after the AllocL succeeds

   274     iSettingName = newText;

   275 

   276     iIconArray = aIconArray;

   277 

   278     iSettingPageResourceId = aSettingPageResourceId;

   279     iEditorControlType = aEditorControlType;

   280     iSettingEditorResourceId = aSettingEditorResourceId;

   281     iAssociatedResourceId = aAssociatedResourceId;

   282 

   283     // Give the derived classes a chance to use the additional resource id:

   284     CompleteConstructionL();

   285 

   286     // Perform the initial load of the data

   287     LoadL();

   288 

   289     CFbsBitmap* bitmap = CreateBitmapL(); // This is a test to see if the setting item HAS a bitmap to offfer

   290     if ( bitmap )

   291         {

   292         CleanupStack::PushL(bitmap);

   293         // Make the icon and put it in the array

   294         CGulIcon* icon = CGulIcon::NewL();

   295         icon->SetBitmap( bitmap ); // ownership transferred

   296         CleanupStack::Pop(); // bitmap;

   297 

   298         CleanupStack::PushL( icon );

   299         iIconArray->AppendL( icon );

   300         CleanupStack::Pop(); // icon

   301 

   302         iIconIndex = iIconArray->Count() - 1;

   303         iFlags |= EHasIcon;

   304 

   305         // This is repeated to catch any mask information that might be available

   306         bitmap = CreateBitmapL();

   307         if ( bitmap )

   308             icon->SetBitmap( bitmap ); // ownership transferred

   309         }

   310     else

   311         {

   312         iFlags &= (~EHasIcon);

   313         }

   314 

   315     // Finally this sets up the text for the MDcaPoint calls from listbox

   316     UpdateListBoxTextL();

   317 

   318     _AKNTRACE_FUNC_EXIT;

   319     }

   320 /**

   321 * This routine is used to replace the old bitmap with a new one.

   322 *

   323 */

   324 void CAknSettingItem::UpdateBitmapL()

   325     {

   326     if (HasIcon() )

   327         {

   328         CFbsBitmap* bitmap = CreateBitmapL();

   329         if ( bitmap )

   330             {

   331             // This deletes the old one as the bitmaps are owned

   332             iIconArray->At(iIconIndex)->SetBitmap( bitmap );

   333             }

   334         }

   335 

   336     }

   337 

   338 EXPORT_C void CAknSettingItem::StoreL()

   339     {

   340     }

   341 EXPORT_C void CAknSettingItem::LoadL()

   342     {

   343     }

   344 EXPORT_C CFbsBitmap* CAknSettingItem::CreateBitmapL()

   345     {

   346     return 0;

   347     }

   348 EXPORT_C TBool CAknSettingItem::IsNumberedStyle() const

   349     {

   350     return (iFlags & EIsNumberedStyle );

   351     }

   352 EXPORT_C TBool CAknSettingItem::IsHidden() const

   353     {

   354     return (iFlags & EIsHidden );

   355     }

   356 

   357 EXPORT_C void CAknSettingItem::SetHidden(TBool aHidden)

   358     {

   359     if ( aHidden )

   360         iFlags |= EIsHidden;

   361     else

   362         iFlags &= (~EIsHidden);

   363     // Note the the client code needs to do any recalculation and re-presentation of the listbox

   364     }

   365 

   366 

   367 EXPORT_C TPtrC CAknSettingItem::SettingName()

   368     {

   369     return (TPtrC) *iSettingName;

   370     }

   371 

   372 /**

   373 * Returns the ordinal for the setting. Only valid the numberstyle is Numbered;

   374 * if not it returns the "NOt displaeyd" value

   375 */

   376 

   377 EXPORT_C TInt CAknSettingItem::SettingNumber() const

   378     {

   379     if (IsNumberedStyle())

   380         return iOrdinal;

   381     else

   382         return EAknSettingPageNoOrdinalDisplayed;

   383     }

   384 

   385 EXPORT_C HBufC* CAknSettingItem::ListBoxText()

   386     {

   387     return iListBoxText;

   388     }

   389 

   390 EXPORT_C const TDesC& CAknSettingItem::SettingTextL()

   391     {

   392     return EmptyItemText();

   393     }

   394 

   395 EXPORT_C TBool CAknSettingItem::HasIcon() const

   396     {

   397     return (iFlags & EHasIcon );

   398     }

   399 

   400 EXPORT_C void CAknSettingItem::EditItemL( TBool /* aCalledFromMenu */)

   401     {

   402     }

   403 

   404 EXPORT_C void CAknSettingItem::HandleSettingPageEventL(CAknSettingPage* /* aSettingPage */,MAknSettingPageObserver::TAknSettingPageEvent /* aEventType */ )

   405     {

   406     _AKNTRACE_FUNC_ENTER;

   407     UpdateListBoxTextL();

   408     _AKNTRACE_FUNC_EXIT;

   409     }

   410 /**

   411 *

   412 */

   413 EXPORT_C void CAknSettingItem::SetSettingPage( CAknSettingPage* aSettingPage )

   414     {

   415     iSettingPage = aSettingPage;

   416     }

   417 

   418 /**

   419 *

   420 */

   421 EXPORT_C CAknSettingPage* CAknSettingItem::SettingPage() const

   422     {

   423     return iSettingPage;

   424     }

   425 

   426 /**

   427 *

   428 *  Set up the setting page in the standard way

   429 *

   430 *

   431 */

   432 EXPORT_C void CAknSettingItem::SetUpStandardSettingPageL()

   433     {

   434     SettingPage()->SetSettingTextL( SettingName() );

   435 

   436     if ( IsNumberedStyle() )

   437         {

   438         SettingPage()->SetSettingNumberL( SettingNumber() );

   439         SettingPage()->SetNumbered(ETrue);

   440         }

   441     else

   442         SettingPage()->SetNumbered(EFalse); // Suppress the numbering

   443     }

   444 

   445 /**

   446 *

   447 *

   448 *

   449 */

   450 EXPORT_C TInt CAknSettingItem::SettingPageResourceId() const

   451     {

   452     return iSettingPageResourceId;

   453     }

   454 

   455 /**

   456 * Access method for the setting editor resource id

   457 *

   458 *

   459 */

   460 EXPORT_C TInt CAknSettingItem::SettingEditorResourceId() const

   461     {

   462     return iSettingEditorResourceId;

   463     }

   464 

   465 /**

   466 * Access function for the associated resource Id

   467 *

   468 *

   469 */

   470 EXPORT_C TInt CAknSettingItem::AssociatedResourceId() const

   471     {

   472     return iAssociatedResourceId;

   473     }

   474 

   475 EXPORT_C void CAknSettingItem::UpdateListBoxTextL()

   476     {

   477     _AKNTRACE_FUNC_ENTER;

   478 

   479     // Get rid of the old value

   480     delete iListBoxText;

   481     iListBoxText = 0;

   482 

   483     // Update the bitmap

   484     UpdateBitmapL();

   485 

   486     if((iFlags & EViewOnly) || (iFlags & EProtected))

   487         {

   488         iExtension->CreateLockIconL(iIconArray);

   489         }

   490 

   491     // Calculate the right length

   492     TInt lengthRequired = 2 * KAknSettingItemMaxNumberDigits;

   493     lengthRequired += 4 * KListBoxTextSeparator().Length();

   494     lengthRequired += (SettingName().Length() );

   495     lengthRequired += (SettingTextL().Length() );

   496     if (iCompulsoryText)

   497         {

   498         lengthRequired += (iCompulsoryText->Length() );

   499         }

   500 

   501     if ( ProtectionState() == ESettingItemViewOnly ||

   502             ProtectionState() == ESettingItemProtected )

   503         {

   504         lengthRequired += 4 * KAknSettingItemMaxNumberDigits; // 4*3

   505         }

   506 

   507     // Create the buffer

   508     iListBoxText = HBufC::NewL( lengthRequired );

   509 

   510     TPtr listBoxTextPtr = iListBoxText->Des();

   511     if ( iFlags & EIsNumberedStyle )

   512         {

   513         // Locale-specific number conversion of this is done in listbox code, so not

   514         // done here

   515         listBoxTextPtr.Format( KAknSettingItemDecimalFormat, iOrdinal );

   516         }

   517     else

   518         {

   519         listBoxTextPtr.Copy( KAknSettingItemSingleSpace );

   520         }

   521     listBoxTextPtr.Append( KListBoxTextSeparator ); // index 1

   522     listBoxTextPtr.Append( SettingName() );

   523     listBoxTextPtr.Append( KListBoxTextSeparator ); // index 2

   524     if ( HasIcon() )

   525         {

   526         TBuf<KAknSettingItemMaxNumberDigits> iconIndexText;

   527         iconIndexText.Format( _L("%d"), iIconIndex ); // bitmap index encoding; not locale specific!

   528         listBoxTextPtr.Append( iconIndexText );

   529         }

   530 

   531     listBoxTextPtr.Append( KListBoxTextSeparator ); // index 3

   532 

   533     // The text put into the setting item list has had its non-printing chracters replace

   534     // by spaces:

   535     HBufC* settingText = SettingTextL().AllocL();

   536     TPtr settingPtr = settingText->Des();

   537     listBoxTextPtr.Append(ReplaceNonPrintingCharacters( settingPtr ) );

   538     delete settingText;

   539 

   540     if (iCompulsoryText)

   541         {

   542         listBoxTextPtr.Append( KListBoxTextSeparator ); // index 4

   543         listBoxTextPtr.Append( *iCompulsoryText );

   544         }

   545 

   546     if ( ProtectionState() == ESettingItemViewOnly ||

   547             ProtectionState() == ESettingItemProtected )

   548         {

   549         // icon coloring is supported in lists by using upper and lower 16 bits of the icon index number to

   550         // include the both non-highlight and highligh icon index in the same number

   551         TBuf<KAknSettingItemMaxNumberDigits*4> protectedIconIndexText;

   552         TInt iconIndex = iExtension->iLockIconIndex;

   553         iconIndex |= iExtension->iLockIconHighlightIndex << 16; // shift one word, to get the highlight to upper part

   554         protectedIconIndexText.Format( _L("%d"), iconIndex ); // bitmap index encoding; not locale specific!

   555 

   556         if (!iCompulsoryText)

   557             listBoxTextPtr.Append( KListBoxTextSeparator ); // index 4

   558 

   559         listBoxTextPtr.Append( KListBoxTextSeparator ); //index 5

   560         listBoxTextPtr.Append( KListBoxTextSeparator ); // index 6 -> icon 2

   561         listBoxTextPtr.Append( protectedIconIndexText );

   562         }

   563     _AKNTRACE_FUNC_EXIT;

   564     }

   565 

   566 /**

   567 *

   568 * Complete the construction using the additional resource id. This is called from within ConstructXXXL routines.

   569 * Note that Load() will not have been called yet, so the setting is still uninitialized in terms of its data content

   570 * after this has finished. Otherwise, the instance should be ready.

   571 *

   572 */

   573 EXPORT_C void CAknSettingItem::CompleteConstructionL()

   574     {

   575     }

   576 

   577 EXPORT_C void CAknSettingItem::SetEmptyItemTextL( const TDesC& aEmptyItemText )

   578     {

   579     delete iEmptyItemText;

   580     iEmptyItemText = NULL;

   581     iEmptyItemText = aEmptyItemText.AllocL();

   582     }

   583 

   584 EXPORT_C void CAknSettingItem::SetCompulsoryIndTextL( const TDesC& aCompulsoryText )

   585     {

   586     delete iCompulsoryText;

   587     iCompulsoryText = NULL;

   588     iCompulsoryText = aCompulsoryText.AllocL();

   589     }

   590 

   591 EXPORT_C TDesC& CAknSettingItem::EmptyItemText() const

   592     {

   593     __ASSERT_ALWAYS( iEmptyItemText , Panic( EAknPanicSettingItemListNoEmptyText ) );

   594     return *iEmptyItemText;

   595     }

   596 

   597 TInt CAknSettingItem::EditorControlType() const

   598     {

   599     return iEditorControlType;

   600     }

   601 

   602 EXPORT_C TBool CAknSettingItem::SetIconMask( CFbsBitmap* aMask )

   603     {

   604     TBool successfullyTransferred( EFalse );

   605     if (HasIcon() && aMask )

   606         {

   607         __ASSERT_DEBUG( !iIconArray->At(iIconIndex)->BitmapsOwnedExternally() , Panic( EAknPanicSettingItemListBadIcon ) );

   608         // This deletes the old one as the bitmaps are owned internally

   609         iIconArray->At(iIconIndex)->SetMask( aMask );

   610         successfullyTransferred = ETrue;

   611         }

   612     return successfullyTransferred;

   613     }

   614 

   615 CFbsBitmap* CAknSettingItem::SetIconMaskAndReturnBitmap( CGulIcon* aIcon )

   616     {

   617     CFbsBitmap* returnedBitmap = NULL;

   618 

   619     if ( aIcon )

   620         {

   621         aIcon->SetBitmapsOwnedExternally( ETrue );

   622         CFbsBitmap* bitmap = aIcon->Bitmap();

   623         CFbsBitmap* mask = aIcon->Mask();

   624         delete aIcon; // does not own the bitmaps, so let it go

   625 

   626         // Nothing leaves for the rest of the routine. No Pushing

   627 

   628         // always return the bitmap and transfer ownership if there is one.

   629         if ( bitmap )

   630             returnedBitmap = bitmap;

   631 

   632         // Set the mask if there is a bitmap, an icon and a mask

   633         TBool maskOwnershipTransferred(EFalse);

   634         if ( bitmap && mask && HasIcon() )

   635             maskOwnershipTransferred = SetIconMask( mask );

   636         if ( !maskOwnershipTransferred )

   637             delete mask;

   638 

   639         }

   640     return returnedBitmap;

   641     }

   642 

   643 // For managing item hiding

   644 EXPORT_C TInt CAknSettingItem::VisibleIndex()

   645     {

   646     return iVisibleIndex;

   647     }

   648 

   649 void CAknSettingItem::SetVisibleIndex( TInt aVisibleIndex)

   650     {

   651     iVisibleIndex = aVisibleIndex;

   652     }

   653 

   654 void CAknSettingItem::SetOrdinal( TInt aOrdinal )

   655     {

   656     iOrdinal = aOrdinal;

   657     }

   658 

   659 EXPORT_C void CAknSettingItem::SetSettingPageFlags( TInt aFlagPattern)

   660     {

   661     iSettingPageFlags = aFlagPattern;

   662     _AKNTRACE( "[%s][%s] iSettingPageFlags = %d", "CAknSettingItem", __FUNCTION__, iSettingPageFlags );

   663     }

   664 

   665 EXPORT_C TInt CAknSettingItem::SettingPageFlags( ) const

   666     {

   667     return iSettingPageFlags;

   668     }

   669 

   670 void CAknSettingItem::SetParentListBox( const CEikFormattedCellListBox* aListBox )

   671     {

   672     iParentListBox = aListBox;

   673     }

   674 

   675 EXPORT_C TInt CAknSettingItem::Identifier() const

   676     {

   677     return iIdentifier;

   678     }

   679 

   680 TPtrC CAknSettingItem::ReplaceNonPrintingCharacters( TDes& aText )

   681     {

   682     /*

   683     *

   684     *  this methdod is needed for stripping tab's away, so user

   685     *  entered text can not crash the listbox

   686     *

   687     *  0x0001 should not be stripped away, since it is used as

   688     *  separator for different length localization strings

   689     *

   690     *  0x200F and 0x200E are token for RTL and LTR.

   691     *

   692     */

   693     for(TInt i = 0; i < aText.Length(); i++)

   694         {

   695         TChar c (aText[i]);

   696 

   697         if ( !c.IsPrint() && c != 0x0001 && c != 0x200F && c != 0x200E )

   698             {

   699             TLanguage lang = User::Language();

   700             if ( ELangThai == lang && c == 0x200B )

   701             	continue;

   702             aText[i] = ' ';

   703             }

   704         }

   705     return (TPtrC) aText;

   706     }

   707 

   708 EXPORT_C void CAknSettingItem::CAknSettingItem_Reserved()

   709     {

   710     }

   711 

   712 EXPORT_C void CAknSettingItem::SetProtectionState( CAknSettingItem::TSettingItemProtection aProtected )

   713     {

   714     _AKNTRACE( "[%s][%s] aProtected = %d", "CAknSettingItem", __FUNCTION__, aProtected );

   715     if (aProtected == ENoSettingItemProtection)

   716         {

   717         iFlags |= ENoProtection;

   718         iFlags &= (~(EViewOnly | EProtected));

   719         }

   720     else if(aProtected == ESettingItemViewOnly)

   721         {

   722         iFlags |= EViewOnly;

   723         iFlags &= (~(ENoProtection | EProtected));

   724         }

   725     else if(aProtected == ESettingItemProtected)

   726         {

   727         iFlags |= EProtected;

   728         iFlags &= (~(ENoProtection | EViewOnly));

   729         }

   730     }

   731 

   732 EXPORT_C CAknSettingItem::TSettingItemProtection CAknSettingItem::ProtectionState()

   733     {

   734     TSettingItemProtection isProtected = ENoSettingItemProtection;

   735 

   736     if(iFlags & ENoProtection)

   737         isProtected = ENoSettingItemProtection;

   738     else if(iFlags & EViewOnly)

   739         isProtected = ESettingItemViewOnly;

   740     else if(iFlags & EProtected)

   741         isProtected = ESettingItemProtected;

   742 

   743     return isProtected;

   744     }

   745 // ---------------------------------------

   746 // CAknTextSettingItem

   747 //

   748 //----------------------------------------

   749 

   750 EXPORT_C CAknTextSettingItem::CAknTextSettingItem( TInt aIdentifier, TDes& aText ):

   751     CAknSettingItem(aIdentifier), iExternalText( aText ), iInternalTextPtr(0,0)

   752     {

   753     // iInternalTextPtr points to no buffer, so no allocation is done here

   754     }

   755 

   756 EXPORT_C CAknTextSettingItem::~CAknTextSettingItem()

   757     {

   758     delete iInternalText;

   759     }

   760 

   761 EXPORT_C void CAknTextSettingItem::StoreL()

   762     {

   763     // Copy the internal to the external

   764     iExternalText.Copy(iInternalText->Des() );

   765     }

   766 

   767 EXPORT_C void CAknTextSettingItem::LoadL()

   768     {

   769     // iInternalText is always deleted and re-created.

   770     delete iInternalText;

   771     iInternalText = 0;

   772     // New buffer is long enough for the maximum length of the external buffer.

   773     iInternalText = HBufC::NewL(iExternalText.MaxLength());

   774     // Use Set so that the whole TPtr is just overwritten - and gets a new buffer

   775     // Note that the TPtr's buffer is owned by iInternalText, hence the old one is

   776     // already deleted - see above.

   777     iInternalTextPtr.Set(iInternalText->Des() );

   778     iInternalTextPtr.Copy( iExternalText );

   779     }

   780 

   781 EXPORT_C const TDesC& CAknTextSettingItem::SettingTextL()

   782     {

   783     if ( iInternalText->Length() > 0 )

   784         return *iInternalText;

   785     else

   786         return EmptyItemText();

   787     }

   788 

   789 EXPORT_C void CAknTextSettingItem::EditItemL( TBool /* aCalledFromMenu */)

   790     {

   791     _AKNTRACE_FUNC_ENTER;

   792     TPtrC settingName = SettingName();

   793     CAknSettingPage* dlg = new( ELeave )CAknTextSettingPage(

   794         &settingName,

   795         SettingNumber(),

   796         EditorControlType(),

   797         SettingEditorResourceId(),

   798         SettingPageResourceId(),

   799         iInternalTextPtr,

   800         SettingPageFlags() ); // Flags

   801     SetSettingPage( dlg );

   802     SettingPage()->SetSettingPageObserver(this);

   803 

   804     if(ProtectionState() == CAknSettingItem::ESettingItemViewOnly)

   805         SettingPage()->SetEditState(EFalse);

   806 

   807     SettingPage()->ExecuteLD(CAknSettingPage::EUpdateWhenChanged);

   808     SetSettingPage(0); // it is deleted now

   809     _AKNTRACE_FUNC_EXIT;

   810     }

   811 

   812 EXPORT_C TPtr& CAknTextSettingItem::InternalTextPtr()

   813     {

   814     return iInternalTextPtr;

   815     }

   816 

   817 EXPORT_C TPtrC CAknTextSettingItem::ExternalText()

   818     {

   819     return (TPtrC)(iExternalText);

   820     }

   821 

   822 EXPORT_C void CAknTextSettingItem::SetExternalText( TDesC& aNewExternalText )

   823     {

   824     iExternalText.Copy( aNewExternalText );

   825     }

   826 

   827 EXPORT_C void CAknTextSettingItem::CAknSettingItem_Reserved()

   828     {

   829     };

   830 

   831 // ---------------------------------------

   832 // CAknIntegerSettingItem

   833 //

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

   835 

   836 EXPORT_C CAknIntegerSettingItem::CAknIntegerSettingItem( TInt aIdentifier, TInt& aValue ):

   837     CAknSettingItem(aIdentifier), iExternalValue( aValue ), iInternalTextPtr(0,0)

   838     {

   839     }

   840 EXPORT_C CAknIntegerSettingItem::~CAknIntegerSettingItem()

   841     {

   842     delete iInternalText;

   843     }

   844 

   845 EXPORT_C void CAknIntegerSettingItem::CompleteConstructionL()

   846     {

   847     // Prepare the date buffer

   848     iInternalText = HBufC::NewMaxL(EAknMaxIntegerDigits);

   849     }

   850 EXPORT_C void CAknIntegerSettingItem::StoreL()

   851     {

   852     // Copy the internal to the external

   853     iExternalValue = iInternalValue;

   854     }

   855 EXPORT_C void CAknIntegerSettingItem::LoadL()

   856     {

   857     iInternalValue = iExternalValue;

   858     }

   859 

   860 EXPORT_C const TDesC& CAknIntegerSettingItem::SettingTextL()

   861     {

   862     _AKNTRACE( "[%s][%s][%d].", "CAknIntegerSettingItem", __FUNCTION__, __LINE__ );

   863     // set the text ptr again. Its buffers are always owned by some else, so

   864     // removing the reference from the TPtr is OK.

   865     iInternalTextPtr.Set(iInternalText->Des());

   866     iInternalTextPtr.Format(KAknIntegerFormat, iInternalValue );

   867     AknTextUtils::DisplayTextLanguageSpecificNumberConversion(iInternalTextPtr);

   868     return iInternalTextPtr;

   869     }

   870 

   871 

   872 EXPORT_C TInt& CAknIntegerSettingItem::InternalValueRef()

   873     {

   874     return iInternalValue;

   875     }

   876 

   877 EXPORT_C TInt& CAknIntegerSettingItem::ExternalValueRef()

   878     {

   879     return iExternalValue;

   880     }

   881 

   882 EXPORT_C void CAknIntegerSettingItem::SetExternalValue( TInt& aValue )

   883     {

   884     iExternalValue  = aValue;

   885     }

   886 

   887 EXPORT_C void CAknIntegerSettingItem::CAknSettingItem_Reserved()

   888     {

   889     };

   890 

   891 EXPORT_C CAknIntegerEdwinSettingItem::CAknIntegerEdwinSettingItem( TInt aIdentifier, TInt& aValue ):

   892     CAknIntegerSettingItem(aIdentifier, aValue)

   893     {}

   894 

   895 EXPORT_C void CAknIntegerEdwinSettingItem::EditItemL( TBool /* aCalledFromMenu */)

   896     {

   897     _AKNTRACE_FUNC_ENTER;

   898     TPtrC settingName = SettingName();

   899     CAknSettingPage* dlg = new( ELeave )CAknIntegerSettingPage(

   900         &settingName,

   901         SettingNumber(),

   902         EditorControlType(),

   903         SettingEditorResourceId(),

   904         SettingPageResourceId(),

   905         InternalValueRef(),

   906         SettingPageFlags() ); // Flags

   907 

   908     SetSettingPage( dlg );

   909     SettingPage()->SetSettingPageObserver(this);

   910 

   911     if(ProtectionState() == CAknSettingItem::ESettingItemViewOnly)

   912         SettingPage()->SetEditState(EFalse);

   913 

   914     SettingPage()->ExecuteLD(CAknSettingPage::EUpdateWhenChanged);

   915     SetSettingPage( 0 );

   916 

   917     _AKNTRACE_FUNC_EXIT;

   918     }

   919 

   920 EXPORT_C void CAknIntegerEdwinSettingItem::CAknSettingItem_Reserved()

   921     {

   922     };

   923 

   924 

   925 // ---------------------------------------

   926 // CAknPasswordSettingItem

   927 //

   928 //----------------------------------------

   929 

   930 EXPORT_C CAknPasswordSettingItem::CAknPasswordSettingItem( TInt aIdentifier, enum CAknPasswordSettingItem::TAknPasswordSettingItemMode aPasswordMode, TDes& aPassword ):

   931     CAknTextSettingItem(aIdentifier, aPassword ), iPasswordMode( aPasswordMode )

   932     {

   933     }

   934 

   935 EXPORT_C void CAknPasswordSettingItem::CompleteConstructionL( )

   936     {

   937     _AKNTRACE_FUNC_ENTER;

   938     if ( AssociatedResourceId() != 0 )

   939         {

   940 

   941         TResourceReader reader;

   942         CEikonEnv::Static()->CreateResourceReaderLC( reader, AssociatedResourceId() );

   943 

   944         TPtrC text = reader.ReadTPtrC();  // LTEXT name;

   945         iBlankingText.Copy( text );

   946         iBlankingText.Copy( text.Left( Min( KMaxPasswordBlankingTextLength, text.Length() ) ) );

   947 

   948         // Read the Old password confirmation LLINK

   949         iOldPasswordQueryResourceId = reader.ReadInt32();

   950 

   951         CleanupStack::PopAndDestroy(); // reader

   952         }

   953 

   954     // No blanking text, then read the password blanking from AVKON resource

   955     if ( iBlankingText.Length() == 0 )

   956         {

   957         HBufC* blankingText;

   958 

   959         if ( iPasswordMode == ENumeric )

   960             blankingText = CCoeEnv::Static()->AllocReadResourceLC( R_AVKON_NUMERIC_PASSWORD_BLANKING_TEXT );

   961         else

   962             blankingText = CCoeEnv::Static()->AllocReadResourceLC( R_AVKON_ALPHA_PASSWORD_BLANKING_TEXT );

   963 

   964         iBlankingText.Copy( blankingText->Left( Min( KMaxPasswordBlankingTextLength, blankingText->Length() ) ) );

   965         CleanupStack::PopAndDestroy(); // blankingText

   966         }

   967     _AKNTRACE_FUNC_EXIT;

   968     }

   969 

   970 EXPORT_C const TDesC& CAknPasswordSettingItem::SettingTextL()

   971     {

   972     if ( InternalTextPtr().Length() != 0 )

   973         return iBlankingText;

   974     else

   975         return EmptyItemText();

   976     }

   977 

   978 EXPORT_C void CAknPasswordSettingItem::EditItemL( TBool /* aCalledFromMenu */)

   979     {

   980     _AKNTRACE_FUNC_ENTER;

   981     const TPtrC oldPassword = ExternalText();

   982     TPtrC settingName = SettingName();

   983 

   984     // Allocate a new password to the length of the internal buffer

   985     HBufC* newPasswordBuf = HBufC::NewLC( InternalTextPtr().MaxLength() );

   986     TPtr newPassword( newPasswordBuf->Des() );

   987 

   988     CAknSettingPage* dlg = 0;

   989 

   990     switch ( iPasswordMode )

   991         {

   992         case EAlpha:

   993             dlg = new( ELeave )CAknAlphaPasswordSettingPage(

   994                 &settingName,

   995                 SettingNumber(),

   996                 EditorControlType(),

   997                 SettingEditorResourceId(),

   998                 SettingPageResourceId(),

   999                 newPassword,

  1000                 oldPassword );

  1001 

  1002             break;

  1003 

  1004         case ENumeric:

  1005             dlg = new( ELeave )CAknNumericPasswordSettingPage(

  1006                 &settingName,

  1007                 SettingNumber(),

  1008                 EditorControlType(),

  1009                 SettingEditorResourceId(),

  1010                 SettingPageResourceId(),

  1011                 newPassword,

  1012                 oldPassword );

  1013             break;

  1014 

  1015         default:

  1016             __ASSERT_ALWAYS(0, Panic(EAknPanicSettingItemListInvalidPasswordMode ) );

  1017             break;

  1018         }

  1019 

  1020     SetSettingPage( dlg );

  1021     SettingPage()->SetSettingPageObserver(this);

  1022 

  1023     if(ProtectionState() == CAknSettingItem::ESettingItemViewOnly)

  1024         SettingPage()->SetEditState(EFalse);

  1025 

  1026     // Copy the new password text in if return value is ETrue

  1027     if ( SettingPage()->ExecuteLD(CAknSettingPage::EUpdateWhenChanged) )

  1028         InternalTextPtr().Copy( newPassword );

  1029 

  1030     SetSettingPage( 0 );

  1031 

  1032     CleanupStack::PopAndDestroy(); // newPasswordBuf

  1033 

  1034     _AKNTRACE_FUNC_EXIT;

  1035     }

  1036 

  1037 EXPORT_C void CAknPasswordSettingItem::CAknSettingItem_Reserved()

  1038     {

  1039     };

  1040 

  1041 // ---------------------------------------

  1042 // CAknVolumeSettingItem

  1043 //

  1044 //----------------------------------------

  1045 

  1046 EXPORT_C CAknVolumeSettingItem::CAknVolumeSettingItem( TInt aIdentifier, TInt& aVolume ):

  1047     CAknSettingItem(aIdentifier), iExternalVolume( aVolume )

  1048     {

  1049     }

  1050 

  1051 EXPORT_C void CAknVolumeSettingItem::StoreL()

  1052     {

  1053     // Copy the internal to the external

  1054     iExternalVolume = iInternalVolume;

  1055     }

  1056 

  1057 EXPORT_C void CAknVolumeSettingItem::LoadL()

  1058     {

  1059     iInternalVolume = iExternalVolume;

  1060     }

  1061 

  1062 EXPORT_C const TDesC& CAknVolumeSettingItem::SettingTextL()

  1063     {

  1064     return KAknSettingItemSingleSpace;

  1065     }

  1066 

  1067 EXPORT_C void CAknVolumeSettingItem::EditItemL( TBool /* aCalledFromMenu */)

  1068     {

  1069     _AKNTRACE_FUNC_ENTER;

  1070 

  1071     TPtrC settingName = SettingName();

  1072 

  1073     CAknVolumeSettingPage* dlg = new( ELeave )CAknVolumeSettingPage(

  1074         &settingName,

  1075         SettingNumber(),

  1076         EditorControlType(),

  1077         SettingEditorResourceId(),

  1078         SettingPageResourceId(),

  1079         InternalVolumeValue() );

  1080     SetSettingPage( dlg );

  1081     SettingPage()->SetSettingPageObserver(this);

  1082 

  1083     if(ProtectionState() == CAknSettingItem::ESettingItemViewOnly)

  1084         SettingPage()->SetEditState(EFalse);

  1085 

  1086     SettingPage()->ExecuteLD(CAknSettingPage::EUpdateWhenChanged);

  1087     SetSettingPage(0);

  1088     UpdateListBoxTextL(); // update bitmap

  1089 

  1090     _AKNTRACE_FUNC_EXIT;

  1091     }

  1092 

  1093 EXPORT_C TInt& CAknVolumeSettingItem::InternalVolumeValue()

  1094     {

  1095     return iInternalVolume;

  1096     }

  1097 

  1098 /**

  1099 * This method is used to generate an appropriate bitmap for the current internal value

  1100 *

  1101 */

  1102 EXPORT_C CFbsBitmap* CAknVolumeSettingItem::CreateBitmapL()

  1103     {

  1104     _AKNTRACE_FUNC_ENTER;

  1105 

  1106     CGulIcon* icon = NULL;

  1107     TResourceReader reader;

  1108     CCoeEnv::Static()->CreateResourceReaderLC( reader, SettingPageResourceId() );

  1109 

  1110     TInt number= reader.ReadInt16();

  1111     TPtrC settingText = reader.ReadTPtrC();

  1112     TPtrC hintText = reader.ReadTPtrC();

  1113     TInt cba = reader.ReadInt32();

  1114     TInt menuBarId = reader.ReadInt32();

  1115     TInt controlType = reader.ReadInt16();

  1116     TInt editorResourceId = reader.ReadInt32();

  1117     CleanupStack::PopAndDestroy(); // reader

  1118 

  1119     CCoeEnv::Static()->CreateResourceReaderLC( reader, editorResourceId );

  1120 

  1121     TInt style = reader.ReadInt16();

  1122 

  1123     if ( style == EDynRangeSettingsVolumeControl )

  1124         {

  1125         TInt value = reader.ReadInt16();

  1126         TPtrC bmpFile=reader.ReadTPtrC();

  1127         TInt bmpId=reader.ReadInt16();

  1128         TInt bmpMask=reader.ReadInt16();

  1129         TInt min= reader.ReadInt16();

  1130         TInt max = reader.ReadInt16();

  1131 

  1132         icon = CAknVolumeControl::CreateSetDynRangeStyleListBoxIconL( InternalVolumeValue(),min,max );

  1133         }

  1134     else