--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uifw/AvKon/src/AknSettingItemList.cpp Tue Feb 02 01:00:49 2010 +0200
@@ -0,0 +1,2838 @@
+/*
+* Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+* Support for setting item lists and their setting
+* items. THe setting item list owns a listbox and an array of
+* setting items. The latter provides a MDesCArray interface for the
+* listbox model.
+*
+* Setting Items are abstractions of data types, that
+* have a capability to launch setting pages.
+*
+*
+*/
+
+
+#include <gulicon.h>
+#include <coemain.h>
+
+//For TResourceReader
+#include <barsread.h>
+
+#include <avkon.hrh>
+#include <avkon.rsg>
+#include <avkon.mbg>
+
+// For Numbered and unnumbered setting style lists
+#include <aknlists.h>
+#include <aknnotewrappers.h>
+
+#include <aknlayoutscalable_avkon.cdl.h>
+#include <aknconsts.h>
+
+// For layout switch events
+#include "AknDef.h"
+
+// For proper icon array management
+#include "AknIconArray.h"
+
+#include "aknsettingitemlist.h"
+#include "akntextsettingpage.h"
+#include "aknvolumesettingpage.h"
+#include "aknslidersettingpage.h"
+#include "aknmfnesettingpage.h"
+#include "aknpopupsettingpage.h"
+#include "aknpasswordsettingpage.h"
+#include <AknsConstants.h>
+
+#include "akntrace.h"
+
+const TInt KAknSettingItemMaxNumberDigits = 3; // for the setting item numbers
+const TInt KAknSettingItemArrayGranularity = 5;
+const TInt KAknSettingItemTimeBufferLength = 30;
+const TInt KAknSettingItemIpTextBufferLength = 15; //Assumes 4 fields of 3 + 3 dots
+
+
+// Separator for listbox text decoration
+_LIT(KListBoxTextSeparator, "\t");
+
+// Format for a number
+_LIT(KAknSettingItemDecimalFormat, "%d" );
+
+// Space used for listbox and time offset text formatting
+_LIT(KAknSettingItemSingleSpace, " " );
+
+// Plus and minus used for listbox time offset
+_LIT(KAknSettingItemPlus, "+" );
+_LIT(KAknSettingItemMinus, "-" );
+
+// Empty IP address
+_LIT(KAknSettingItemEmptyIpAddress, "0.0.0.0" );
+
+enum TAknSettingItemListPanic
+ {
+ EAknPanicSettingItemListUnused,
+ EAknPanicSettingItemListNoEmptyText,
+ EAknPanicSettingItemListInsufficientResource,
+ EAknPanicSettingItemListInconsistentControlType,
+ EAknPanicSettingItemListInvalidPasswordMode,
+ EAknPanicSettingItemListInvalidDateMode,
+ EAknPanicSettingItemListInvalidEnumeratedValue,
+ EAknPanicSettingItemListWrongNumberOfValues,
+ EAknPanicSettingItemListRequiredValueNotInArray,
+ EAknPanicSettingItemListInvalidIndex,
+ EAknPanicSettingItemListConstructionNotComplete,
+ EAknPanicSettingItemListArrayLengthsMisMatch,
+ EAknPanicSettingItemListNotBinaryCompatible,
+ EAknPanicSettingItemListInvalidPointer,
+ EAknPanicSettingItemListBadIcon
+ };
+
+GLDEF_C void Panic(TAknSettingItemListPanic aPanic)
+ {
+ _LIT(KPanicCat,"Setting Item List");
+ User::Panic(KPanicCat, aPanic);
+ }
+
+// -------------------------------
+// CAknSettingItemExtension
+// -------------------------------
+//
+
+NONSHARABLE_CLASS( CAknSettingItemExtension ) : CBase
+ {
+ public:
+
+ static CAknSettingItemExtension* NewL();
+ ~CAknSettingItemExtension();
+ void CreateLockIconL(CArrayPtr<CGulIcon>* aIconArray);
+
+ protected:
+ void ConstructL();
+
+ private:
+ CAknSettingItemExtension();
+
+ //members
+ public:
+ TInt iLockIconIndex;
+ TInt iLockIconHighlightIndex;
+
+ private:
+
+ };
+
+CAknSettingItemExtension::CAknSettingItemExtension()
+: iLockIconIndex(KErrNotFound), iLockIconHighlightIndex(KErrNotFound)
+ {
+ }
+CAknSettingItemExtension::~CAknSettingItemExtension()
+ {
+ }
+
+void CAknSettingItemExtension::ConstructL()
+ {
+ }
+
+CAknSettingItemExtension* CAknSettingItemExtension::NewL()
+ {
+ CAknSettingItemExtension* settingExtension = new (ELeave) CAknSettingItemExtension;
+ CleanupStack::PushL(settingExtension);
+ settingExtension->ConstructL();
+ CleanupStack::Pop(settingExtension);
+ return settingExtension;
+ }
+
+void CAknSettingItemExtension::CreateLockIconL(CArrayPtr<CGulIcon>* aIconArray)
+ {
+ // START of lock icon creation
+
+ // Create the lock icon as the last icon in the table
+ CFbsBitmap* skinnedBitmap = NULL;
+ CFbsBitmap* skinnedMask = NULL;
+
+ // Make the icon and put it in the array
+ CGulIcon* icon = CGulIcon::NewL();
+ CleanupStack::PushL(icon);
+
+ MAknsSkinInstance* skin = AknsUtils::SkinInstance();
+
+ // Create color icon
+ AknsUtils::CreateColorIconL(skin, KAknsIIDQgnIndiSettProtectedAdd,
+ KAknsIIDQsnIconColors, EAknsCIQsnIconColorsCG13,
+ skinnedBitmap, skinnedMask, KAvkonBitmapFile,
+ EMbmAvkonQgn_indi_sett_protected_add,
+ EMbmAvkonQgn_indi_sett_protected_add_mask, KRgbBlack);
+
+ icon->SetMask(skinnedMask);// ownership transferred
+ icon->SetBitmap(skinnedBitmap); // ownership transferred
+
+ if(iLockIconIndex == KErrNotFound)
+ {
+ aIconArray->AppendL( icon );
+ iLockIconIndex = aIconArray->Count() - 1;
+ }
+ else
+ {
+ delete aIconArray->At(iLockIconIndex);
+ aIconArray->Delete(iLockIconIndex);
+ aIconArray->InsertL(iLockIconIndex, icon);
+ }
+
+ CleanupStack::Pop(); // icon
+
+ // Create the lock icon for highlight
+ skinnedBitmap = NULL;
+ skinnedMask = NULL;
+
+ // Make the icon and put it in the array
+ icon = CGulIcon::NewL();
+ CleanupStack::PushL(icon);
+
+ // Create color icon
+ AknsUtils::CreateColorIconL(skin, KAknsIIDQgnIndiSettProtectedAdd,
+ KAknsIIDQsnIconColors, EAknsCIQsnIconColorsCG16,
+ skinnedBitmap, skinnedMask, KAvkonBitmapFile,
+ EMbmAvkonQgn_indi_sett_protected_add,
+ EMbmAvkonQgn_indi_sett_protected_add_mask, KRgbBlack);
+
+
+ icon->SetMask(skinnedMask);// ownership transferred
+ icon->SetBitmap(skinnedBitmap); // ownership transferred
+
+ if(iLockIconHighlightIndex == KErrNotFound)
+ {
+ aIconArray->AppendL( icon );
+ iLockIconHighlightIndex = aIconArray->Count() - 1;
+ }
+ else
+ {
+ delete aIconArray->At(iLockIconHighlightIndex);
+ aIconArray->Delete(iLockIconHighlightIndex);
+ aIconArray->InsertL(iLockIconHighlightIndex, icon);
+ }
+
+ CleanupStack::Pop(); // icon
+
+ // END of lock icon creation
+ }
+// -------------------------------
+// CAknSettingItem
+// -------------------------------
+//
+// public:
+
+/**
+* Default constructor.
+*/
+EXPORT_C CAknSettingItem::CAknSettingItem( TInt aIdentifier) : iIdentifier( aIdentifier )
+ {
+ }
+EXPORT_C CAknSettingItem::~CAknSettingItem()
+ {
+ delete iExtension;
+ delete iSettingName;
+ delete iListBoxText;
+ delete iEmptyItemText;
+ delete iCompulsoryText;
+ }
+
+EXPORT_C void CAknSettingItem::ConstructL(
+ const TBool aIsNumberedStyle,
+ const TInt aOrdinal,
+ const TDesC& aSettingName,
+ CArrayPtr<CGulIcon>* aIconArray,
+ TInt aSettingPageResourceId,
+ TInt aEditorControlType,
+ TInt aSettingEditorResourceId,
+ TInt aAssociatedResourceId)
+ {
+ _AKNTRACE_FUNC_ENTER;
+ iExtension = CAknSettingItemExtension::NewL();
+
+ if ( aIsNumberedStyle )
+ iFlags |= EIsNumberedStyle;
+ else
+ iFlags &= (~EIsNumberedStyle);
+
+ iOrdinal = aOrdinal;
+
+ HBufC* newText = aSettingName.AllocL();
+ delete( iSettingName ); // after the AllocL succeeds
+ iSettingName = newText;
+
+ iIconArray = aIconArray;
+
+ iSettingPageResourceId = aSettingPageResourceId;
+ iEditorControlType = aEditorControlType;
+ iSettingEditorResourceId = aSettingEditorResourceId;
+ iAssociatedResourceId = aAssociatedResourceId;
+
+ // Give the derived classes a chance to use the additional resource id:
+ CompleteConstructionL();
+
+ // Perform the initial load of the data
+ LoadL();
+
+ CFbsBitmap* bitmap = CreateBitmapL(); // This is a test to see if the setting item HAS a bitmap to offfer
+ if ( bitmap )
+ {
+ CleanupStack::PushL(bitmap);
+ // Make the icon and put it in the array
+ CGulIcon* icon = CGulIcon::NewL();
+ icon->SetBitmap( bitmap ); // ownership transferred
+ CleanupStack::Pop(); // bitmap;
+
+ CleanupStack::PushL( icon );
+ iIconArray->AppendL( icon );
+ CleanupStack::Pop(); // icon
+
+ iIconIndex = iIconArray->Count() - 1;
+ iFlags |= EHasIcon;
+
+ // This is repeated to catch any mask information that might be available
+ bitmap = CreateBitmapL();
+ if ( bitmap )
+ icon->SetBitmap( bitmap ); // ownership transferred
+ }
+ else
+ {
+ iFlags &= (~EHasIcon);
+ }
+
+ // Finally this sets up the text for the MDcaPoint calls from listbox
+ UpdateListBoxTextL();
+
+ _AKNTRACE_FUNC_EXIT;
+ }
+/**
+* This routine is used to replace the old bitmap with a new one.
+*
+*/
+void CAknSettingItem::UpdateBitmapL()
+ {
+ if (HasIcon() )
+ {
+ CFbsBitmap* bitmap = CreateBitmapL();
+ if ( bitmap )
+ {
+ // This deletes the old one as the bitmaps are owned
+ iIconArray->At(iIconIndex)->SetBitmap( bitmap );
+ }
+ }
+
+ }
+
+EXPORT_C void CAknSettingItem::StoreL()
+ {
+ }
+EXPORT_C void CAknSettingItem::LoadL()
+ {
+ }
+EXPORT_C CFbsBitmap* CAknSettingItem::CreateBitmapL()
+ {
+ return 0;
+ }
+EXPORT_C TBool CAknSettingItem::IsNumberedStyle() const
+ {
+ return (iFlags & EIsNumberedStyle );
+ }
+EXPORT_C TBool CAknSettingItem::IsHidden() const
+ {
+ return (iFlags & EIsHidden );
+ }
+
+EXPORT_C void CAknSettingItem::SetHidden(TBool aHidden)
+ {
+ if ( aHidden )
+ iFlags |= EIsHidden;
+ else
+ iFlags &= (~EIsHidden);
+ // Note the the client code needs to do any recalculation and re-presentation of the listbox
+ }
+
+
+EXPORT_C TPtrC CAknSettingItem::SettingName()
+ {
+ return (TPtrC) *iSettingName;
+ }
+
+/**
+* Returns the ordinal for the setting. Only valid the numberstyle is Numbered;
+* if not it returns the "NOt displaeyd" value
+*/
+
+EXPORT_C TInt CAknSettingItem::SettingNumber() const
+ {
+ if (IsNumberedStyle())
+ return iOrdinal;
+ else
+ return EAknSettingPageNoOrdinalDisplayed;
+ }
+
+EXPORT_C HBufC* CAknSettingItem::ListBoxText()
+ {
+ return iListBoxText;
+ }
+
+EXPORT_C const TDesC& CAknSettingItem::SettingTextL()
+ {
+ return EmptyItemText();
+ }
+
+EXPORT_C TBool CAknSettingItem::HasIcon() const
+ {
+ return (iFlags & EHasIcon );
+ }
+
+EXPORT_C void CAknSettingItem::EditItemL( TBool /* aCalledFromMenu */)
+ {
+ }
+
+EXPORT_C void CAknSettingItem::HandleSettingPageEventL(CAknSettingPage* /* aSettingPage */,MAknSettingPageObserver::TAknSettingPageEvent /* aEventType */ )
+ {
+ _AKNTRACE_FUNC_ENTER;
+ UpdateListBoxTextL();
+ _AKNTRACE_FUNC_EXIT;
+ }
+/**
+*
+*/
+EXPORT_C void CAknSettingItem::SetSettingPage( CAknSettingPage* aSettingPage )
+ {
+ iSettingPage = aSettingPage;
+ }
+
+/**
+*
+*/
+EXPORT_C CAknSettingPage* CAknSettingItem::SettingPage() const
+ {
+ return iSettingPage;
+ }
+
+/**
+*
+* Set up the setting page in the standard way
+*
+*
+*/
+EXPORT_C void CAknSettingItem::SetUpStandardSettingPageL()
+ {
+ SettingPage()->SetSettingTextL( SettingName() );
+
+ if ( IsNumberedStyle() )
+ {
+ SettingPage()->SetSettingNumberL( SettingNumber() );
+ SettingPage()->SetNumbered(ETrue);
+ }
+ else
+ SettingPage()->SetNumbered(EFalse); // Suppress the numbering
+ }
+
+/**
+*
+*
+*
+*/
+EXPORT_C TInt CAknSettingItem::SettingPageResourceId() const
+ {
+ return iSettingPageResourceId;
+ }
+
+/**
+* Access method for the setting editor resource id
+*
+*
+*/
+EXPORT_C TInt CAknSettingItem::SettingEditorResourceId() const
+ {
+ return iSettingEditorResourceId;
+ }
+
+/**
+* Access function for the associated resource Id
+*
+*
+*/
+EXPORT_C TInt CAknSettingItem::AssociatedResourceId() const
+ {
+ return iAssociatedResourceId;
+ }
+
+EXPORT_C void CAknSettingItem::UpdateListBoxTextL()
+ {
+ _AKNTRACE_FUNC_ENTER;
+
+ // Get rid of the old value
+ delete iListBoxText;
+ iListBoxText = 0;
+
+ // Update the bitmap
+ UpdateBitmapL();
+
+ if((iFlags & EViewOnly) || (iFlags & EProtected))
+ {
+ iExtension->CreateLockIconL(iIconArray);
+ }
+
+ // Calculate the right length
+ TInt lengthRequired = 2 * KAknSettingItemMaxNumberDigits;
+ lengthRequired += 4 * KListBoxTextSeparator().Length();
+ lengthRequired += (SettingName().Length() );
+ lengthRequired += (SettingTextL().Length() );
+ if (iCompulsoryText)
+ {
+ lengthRequired += (iCompulsoryText->Length() );
+ }
+
+ if ( ProtectionState() == ESettingItemViewOnly ||
+ ProtectionState() == ESettingItemProtected )
+ {
+ lengthRequired += 4 * KAknSettingItemMaxNumberDigits; // 4*3
+ }
+
+ // Create the buffer
+ iListBoxText = HBufC::NewL( lengthRequired );
+
+ TPtr listBoxTextPtr = iListBoxText->Des();
+ if ( iFlags & EIsNumberedStyle )
+ {
+ // Locale-specific number conversion of this is done in listbox code, so not
+ // done here
+ listBoxTextPtr.Format( KAknSettingItemDecimalFormat, iOrdinal );
+ }
+ else
+ {
+ listBoxTextPtr.Copy( KAknSettingItemSingleSpace );
+ }
+ listBoxTextPtr.Append( KListBoxTextSeparator ); // index 1
+ listBoxTextPtr.Append( SettingName() );
+ listBoxTextPtr.Append( KListBoxTextSeparator ); // index 2
+ if ( HasIcon() )
+ {
+ TBuf<KAknSettingItemMaxNumberDigits> iconIndexText;
+ iconIndexText.Format( _L("%d"), iIconIndex ); // bitmap index encoding; not locale specific!
+ listBoxTextPtr.Append( iconIndexText );
+ }
+
+ listBoxTextPtr.Append( KListBoxTextSeparator ); // index 3
+
+ // The text put into the setting item list has had its non-printing chracters replace
+ // by spaces:
+ HBufC* settingText = SettingTextL().AllocL();
+ TPtr settingPtr = settingText->Des();
+ listBoxTextPtr.Append(ReplaceNonPrintingCharacters( settingPtr ) );
+ delete settingText;
+
+ if (iCompulsoryText)
+ {
+ listBoxTextPtr.Append( KListBoxTextSeparator ); // index 4
+ listBoxTextPtr.Append( *iCompulsoryText );
+ }
+
+ if ( ProtectionState() == ESettingItemViewOnly ||
+ ProtectionState() == ESettingItemProtected )
+ {
+ // icon coloring is supported in lists by using upper and lower 16 bits of the icon index number to
+ // include the both non-highlight and highligh icon index in the same number
+ TBuf<KAknSettingItemMaxNumberDigits*4> protectedIconIndexText;
+ TInt iconIndex = iExtension->iLockIconIndex;
+ iconIndex |= iExtension->iLockIconHighlightIndex << 16; // shift one word, to get the highlight to upper part
+ protectedIconIndexText.Format( _L("%d"), iconIndex ); // bitmap index encoding; not locale specific!
+
+ if (!iCompulsoryText)
+ listBoxTextPtr.Append( KListBoxTextSeparator ); // index 4
+
+ listBoxTextPtr.Append( KListBoxTextSeparator ); //index 5
+ listBoxTextPtr.Append( KListBoxTextSeparator ); // index 6 -> icon 2
+ listBoxTextPtr.Append( protectedIconIndexText );
+ }
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+/**
+*
+* Complete the construction using the additional resource id. This is called from within ConstructXXXL routines.
+* Note that Load() will not have been called yet, so the setting is still uninitialized in terms of its data content
+* after this has finished. Otherwise, the instance should be ready.
+*
+*/
+EXPORT_C void CAknSettingItem::CompleteConstructionL()
+ {
+ }
+
+EXPORT_C void CAknSettingItem::SetEmptyItemTextL( const TDesC& aEmptyItemText )
+ {
+ delete iEmptyItemText;
+ iEmptyItemText = NULL;
+ iEmptyItemText = aEmptyItemText.AllocL();
+ }
+
+EXPORT_C void CAknSettingItem::SetCompulsoryIndTextL( const TDesC& aCompulsoryText )
+ {
+ delete iCompulsoryText;
+ iCompulsoryText = NULL;
+ iCompulsoryText = aCompulsoryText.AllocL();
+ }
+
+EXPORT_C TDesC& CAknSettingItem::EmptyItemText() const
+ {
+ __ASSERT_ALWAYS( iEmptyItemText , Panic( EAknPanicSettingItemListNoEmptyText ) );
+ return *iEmptyItemText;
+ }
+
+TInt CAknSettingItem::EditorControlType() const
+ {
+ return iEditorControlType;
+ }
+
+EXPORT_C TBool CAknSettingItem::SetIconMask( CFbsBitmap* aMask )
+ {
+ TBool successfullyTransferred( EFalse );
+ if (HasIcon() && aMask )
+ {
+ __ASSERT_DEBUG( !iIconArray->At(iIconIndex)->BitmapsOwnedExternally() , Panic( EAknPanicSettingItemListBadIcon ) );
+ // This deletes the old one as the bitmaps are owned internally
+ iIconArray->At(iIconIndex)->SetMask( aMask );
+ successfullyTransferred = ETrue;
+ }
+ return successfullyTransferred;
+ }
+
+CFbsBitmap* CAknSettingItem::SetIconMaskAndReturnBitmap( CGulIcon* aIcon )
+ {
+ CFbsBitmap* returnedBitmap = NULL;
+
+ if ( aIcon )
+ {
+ aIcon->SetBitmapsOwnedExternally( ETrue );
+ CFbsBitmap* bitmap = aIcon->Bitmap();
+ CFbsBitmap* mask = aIcon->Mask();
+ delete aIcon; // does not own the bitmaps, so let it go
+
+ // Nothing leaves for the rest of the routine. No Pushing
+
+ // always return the bitmap and transfer ownership if there is one.
+ if ( bitmap )
+ returnedBitmap = bitmap;
+
+ // Set the mask if there is a bitmap, an icon and a mask
+ TBool maskOwnershipTransferred(EFalse);
+ if ( bitmap && mask && HasIcon() )
+ maskOwnershipTransferred = SetIconMask( mask );
+ if ( !maskOwnershipTransferred )
+ delete mask;
+
+ }
+ return returnedBitmap;
+ }
+
+// For managing item hiding
+EXPORT_C TInt CAknSettingItem::VisibleIndex()
+ {
+ return iVisibleIndex;
+ }
+
+void CAknSettingItem::SetVisibleIndex( TInt aVisibleIndex)
+ {
+ iVisibleIndex = aVisibleIndex;
+ }
+
+void CAknSettingItem::SetOrdinal( TInt aOrdinal )
+ {
+ iOrdinal = aOrdinal;
+ }
+
+EXPORT_C void CAknSettingItem::SetSettingPageFlags( TInt aFlagPattern)
+ {
+ iSettingPageFlags = aFlagPattern;
+ _AKNTRACE( "[%s][%s] iSettingPageFlags = %d", "CAknSettingItem", __FUNCTION__, iSettingPageFlags );
+ }
+
+EXPORT_C TInt CAknSettingItem::SettingPageFlags( ) const
+ {
+ return iSettingPageFlags;
+ }
+
+void CAknSettingItem::SetParentListBox( const CEikFormattedCellListBox* aListBox )
+ {
+ iParentListBox = aListBox;
+ }
+
+EXPORT_C TInt CAknSettingItem::Identifier() const
+ {
+ return iIdentifier;
+ }
+
+TPtrC CAknSettingItem::ReplaceNonPrintingCharacters( TDes& aText )
+ {
+ /*
+ *
+ * this methdod is needed for stripping tab's away, so user
+ * entered text can not crash the listbox
+ *
+ * 0x0001 should not be stripped away, since it is used as
+ * separator for different length localization strings
+ *
+ * 0x200F and 0x200E are token for RTL and LTR.
+ *
+ */
+ for(TInt i = 0; i < aText.Length(); i++)
+ {
+ TChar c (aText[i]);
+
+ if ( !c.IsPrint() && c != 0x0001 && c != 0x200F && c != 0x200E )
+ {
+ TLanguage lang = User::Language();
+ if ( ELangThai == lang && c == 0x200B )
+ continue;
+ aText[i] = ' ';
+ }
+ }
+ return (TPtrC) aText;
+ }
+
+EXPORT_C void CAknSettingItem::CAknSettingItem_Reserved()
+ {
+ }
+
+EXPORT_C void CAknSettingItem::SetProtectionState( CAknSettingItem::TSettingItemProtection aProtected )
+ {
+ _AKNTRACE( "[%s][%s] aProtected = %d", "CAknSettingItem", __FUNCTION__, aProtected );
+ if (aProtected == ENoSettingItemProtection)
+ {
+ iFlags |= ENoProtection;
+ iFlags &= (~(EViewOnly | EProtected));
+ }
+ else if(aProtected == ESettingItemViewOnly)
+ {
+ iFlags |= EViewOnly;
+ iFlags &= (~(ENoProtection | EProtected));
+ }
+ else if(aProtected == ESettingItemProtected)
+ {
+ iFlags |= EProtected;
+ iFlags &= (~(ENoProtection | EViewOnly));
+ }
+ }
+
+EXPORT_C CAknSettingItem::TSettingItemProtection CAknSettingItem::ProtectionState()
+ {
+ TSettingItemProtection isProtected = ENoSettingItemProtection;
+
+ if(iFlags & ENoProtection)
+ isProtected = ENoSettingItemProtection;
+ else if(iFlags & EViewOnly)
+ isProtected = ESettingItemViewOnly;
+ else if(iFlags & EProtected)
+ isProtected = ESettingItemProtected;
+
+ return isProtected;
+ }
+// ---------------------------------------
+// CAknTextSettingItem
+//
+//----------------------------------------
+
+EXPORT_C CAknTextSettingItem::CAknTextSettingItem( TInt aIdentifier, TDes& aText ):
+ CAknSettingItem(aIdentifier), iExternalText( aText ), iInternalTextPtr(0,0)
+ {
+ // iInternalTextPtr points to no buffer, so no allocation is done here
+ }
+
+EXPORT_C CAknTextSettingItem::~CAknTextSettingItem()
+ {
+ delete iInternalText;
+ }
+
+EXPORT_C void CAknTextSettingItem::StoreL()
+ {
+ // Copy the internal to the external
+ iExternalText.Copy(iInternalText->Des() );
+ }
+
+EXPORT_C void CAknTextSettingItem::LoadL()
+ {
+ // iInternalText is always deleted and re-created.
+ delete iInternalText;
+ iInternalText = 0;
+ // New buffer is long enough for the maximum length of the external buffer.
+ iInternalText = HBufC::NewL(iExternalText.MaxLength());
+ // Use Set so that the whole TPtr is just overwritten - and gets a new buffer
+ // Note that the TPtr's buffer is owned by iInternalText, hence the old one is
+ // already deleted - see above.
+ iInternalTextPtr.Set(iInternalText->Des() );
+ iInternalTextPtr.Copy( iExternalText );
+ }
+
+EXPORT_C const TDesC& CAknTextSettingItem::SettingTextL()
+ {
+ if ( iInternalText->Length() > 0 )
+ return *iInternalText;
+ else
+ return EmptyItemText();
+ }
+
+EXPORT_C void CAknTextSettingItem::EditItemL( TBool /* aCalledFromMenu */)
+ {
+ _AKNTRACE_FUNC_ENTER;
+ TPtrC settingName = SettingName();
+ CAknSettingPage* dlg = new( ELeave )CAknTextSettingPage(
+ &settingName,
+ SettingNumber(),
+ EditorControlType(),
+ SettingEditorResourceId(),
+ SettingPageResourceId(),
+ iInternalTextPtr,
+ SettingPageFlags() ); // Flags
+ SetSettingPage( dlg );
+ SettingPage()->SetSettingPageObserver(this);
+
+ if(ProtectionState() == CAknSettingItem::ESettingItemViewOnly)
+ SettingPage()->SetEditState(EFalse);
+
+ SettingPage()->ExecuteLD(CAknSettingPage::EUpdateWhenChanged);
+ SetSettingPage(0); // it is deleted now
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+EXPORT_C TPtr& CAknTextSettingItem::InternalTextPtr()
+ {
+ return iInternalTextPtr;
+ }
+
+EXPORT_C TPtrC CAknTextSettingItem::ExternalText()
+ {
+ return (TPtrC)(iExternalText);
+ }
+
+EXPORT_C void CAknTextSettingItem::SetExternalText( TDesC& aNewExternalText )
+ {
+ iExternalText.Copy( aNewExternalText );
+ }
+
+EXPORT_C void CAknTextSettingItem::CAknSettingItem_Reserved()
+ {
+ };
+
+// ---------------------------------------
+// CAknIntegerSettingItem
+//
+//----------------------------------------
+
+EXPORT_C CAknIntegerSettingItem::CAknIntegerSettingItem( TInt aIdentifier, TInt& aValue ):
+ CAknSettingItem(aIdentifier), iExternalValue( aValue ), iInternalTextPtr(0,0)
+ {
+ }
+EXPORT_C CAknIntegerSettingItem::~CAknIntegerSettingItem()
+ {
+ delete iInternalText;
+ }
+
+EXPORT_C void CAknIntegerSettingItem::CompleteConstructionL()
+ {
+ // Prepare the date buffer
+ iInternalText = HBufC::NewMaxL(EAknMaxIntegerDigits);
+ }
+EXPORT_C void CAknIntegerSettingItem::StoreL()
+ {
+ // Copy the internal to the external
+ iExternalValue = iInternalValue;
+ }
+EXPORT_C void CAknIntegerSettingItem::LoadL()
+ {
+ iInternalValue = iExternalValue;
+ }
+
+EXPORT_C const TDesC& CAknIntegerSettingItem::SettingTextL()
+ {
+ _AKNTRACE( "[%s][%s][%d].", "CAknIntegerSettingItem", __FUNCTION__, __LINE__ );
+ // set the text ptr again. Its buffers are always owned by some else, so
+ // removing the reference from the TPtr is OK.
+ iInternalTextPtr.Set(iInternalText->Des());
+ iInternalTextPtr.Format(KAknIntegerFormat, iInternalValue );
+ AknTextUtils::DisplayTextLanguageSpecificNumberConversion(iInternalTextPtr);
+ return iInternalTextPtr;
+ }
+
+
+EXPORT_C TInt& CAknIntegerSettingItem::InternalValueRef()
+ {
+ return iInternalValue;
+ }
+
+EXPORT_C TInt& CAknIntegerSettingItem::ExternalValueRef()
+ {
+ return iExternalValue;
+ }
+
+EXPORT_C void CAknIntegerSettingItem::SetExternalValue( TInt& aValue )
+ {
+ iExternalValue = aValue;
+ }
+
+EXPORT_C void CAknIntegerSettingItem::CAknSettingItem_Reserved()
+ {
+ };
+
+EXPORT_C CAknIntegerEdwinSettingItem::CAknIntegerEdwinSettingItem( TInt aIdentifier, TInt& aValue ):
+ CAknIntegerSettingItem(aIdentifier, aValue)
+ {}
+
+EXPORT_C void CAknIntegerEdwinSettingItem::EditItemL( TBool /* aCalledFromMenu */)
+ {
+ _AKNTRACE_FUNC_ENTER;
+ TPtrC settingName = SettingName();
+ CAknSettingPage* dlg = new( ELeave )CAknIntegerSettingPage(
+ &settingName,
+ SettingNumber(),
+ EditorControlType(),
+ SettingEditorResourceId(),
+ SettingPageResourceId(),
+ InternalValueRef(),
+ SettingPageFlags() ); // Flags
+
+ SetSettingPage( dlg );
+ SettingPage()->SetSettingPageObserver(this);
+
+ if(ProtectionState() == CAknSettingItem::ESettingItemViewOnly)
+ SettingPage()->SetEditState(EFalse);
+
+ SettingPage()->ExecuteLD(CAknSettingPage::EUpdateWhenChanged);
+ SetSettingPage( 0 );
+
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void CAknIntegerEdwinSettingItem::CAknSettingItem_Reserved()
+ {
+ };
+
+
+// ---------------------------------------
+// CAknPasswordSettingItem
+//
+//----------------------------------------
+
+EXPORT_C CAknPasswordSettingItem::CAknPasswordSettingItem( TInt aIdentifier, enum CAknPasswordSettingItem::TAknPasswordSettingItemMode aPasswordMode, TDes& aPassword ):
+ CAknTextSettingItem(aIdentifier, aPassword ), iPasswordMode( aPasswordMode )
+ {
+ }
+
+EXPORT_C void CAknPasswordSettingItem::CompleteConstructionL( )
+ {
+ _AKNTRACE_FUNC_ENTER;
+ if ( AssociatedResourceId() != 0 )
+ {
+
+ TResourceReader reader;
+ CEikonEnv::Static()->CreateResourceReaderLC( reader, AssociatedResourceId() );
+
+ TPtrC text = reader.ReadTPtrC(); // LTEXT name;
+ iBlankingText.Copy( text );
+ iBlankingText.Copy( text.Left( Min( KMaxPasswordBlankingTextLength, text.Length() ) ) );
+
+ // Read the Old password confirmation LLINK
+ iOldPasswordQueryResourceId = reader.ReadInt32();
+
+ CleanupStack::PopAndDestroy(); // reader
+ }
+
+ // No blanking text, then read the password blanking from AVKON resource
+ if ( iBlankingText.Length() == 0 )
+ {
+ HBufC* blankingText;
+
+ if ( iPasswordMode == ENumeric )
+ blankingText = CCoeEnv::Static()->AllocReadResourceLC( R_AVKON_NUMERIC_PASSWORD_BLANKING_TEXT );
+ else
+ blankingText = CCoeEnv::Static()->AllocReadResourceLC( R_AVKON_ALPHA_PASSWORD_BLANKING_TEXT );
+
+ iBlankingText.Copy( blankingText->Left( Min( KMaxPasswordBlankingTextLength, blankingText->Length() ) ) );
+ CleanupStack::PopAndDestroy(); // blankingText
+ }
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+EXPORT_C const TDesC& CAknPasswordSettingItem::SettingTextL()
+ {
+ if ( InternalTextPtr().Length() != 0 )
+ return iBlankingText;
+ else
+ return EmptyItemText();
+ }
+
+EXPORT_C void CAknPasswordSettingItem::EditItemL( TBool /* aCalledFromMenu */)
+ {
+ _AKNTRACE_FUNC_ENTER;
+ const TPtrC oldPassword = ExternalText();
+ TPtrC settingName = SettingName();
+
+ // Allocate a new password to the length of the internal buffer
+ HBufC* newPasswordBuf = HBufC::NewLC( InternalTextPtr().MaxLength() );
+ TPtr newPassword( newPasswordBuf->Des() );
+
+ CAknSettingPage* dlg = 0;
+
+ switch ( iPasswordMode )
+ {
+ case EAlpha:
+ dlg = new( ELeave )CAknAlphaPasswordSettingPage(
+ &settingName,
+ SettingNumber(),
+ EditorControlType(),
+ SettingEditorResourceId(),
+ SettingPageResourceId(),
+ newPassword,
+ oldPassword );
+
+ break;
+
+ case ENumeric:
+ dlg = new( ELeave )CAknNumericPasswordSettingPage(
+ &settingName,
+ SettingNumber(),
+ EditorControlType(),
+ SettingEditorResourceId(),
+ SettingPageResourceId(),
+ newPassword,
+ oldPassword );
+ break;
+
+ default:
+ __ASSERT_ALWAYS(0, Panic(EAknPanicSettingItemListInvalidPasswordMode ) );
+ break;
+ }
+
+ SetSettingPage( dlg );
+ SettingPage()->SetSettingPageObserver(this);
+
+ if(ProtectionState() == CAknSettingItem::ESettingItemViewOnly)
+ SettingPage()->SetEditState(EFalse);
+
+ // Copy the new password text in if return value is ETrue
+ if ( SettingPage()->ExecuteLD(CAknSettingPage::EUpdateWhenChanged) )
+ InternalTextPtr().Copy( newPassword );
+
+ SetSettingPage( 0 );
+
+ CleanupStack::PopAndDestroy(); // newPasswordBuf
+
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void CAknPasswordSettingItem::CAknSettingItem_Reserved()
+ {
+ };
+
+// ---------------------------------------
+// CAknVolumeSettingItem
+//
+//----------------------------------------
+
+EXPORT_C CAknVolumeSettingItem::CAknVolumeSettingItem( TInt aIdentifier, TInt& aVolume ):
+ CAknSettingItem(aIdentifier), iExternalVolume( aVolume )
+ {
+ }
+
+EXPORT_C void CAknVolumeSettingItem::StoreL()
+ {
+ // Copy the internal to the external
+ iExternalVolume = iInternalVolume;
+ }
+
+EXPORT_C void CAknVolumeSettingItem::LoadL()
+ {
+ iInternalVolume = iExternalVolume;
+ }
+
+EXPORT_C const TDesC& CAknVolumeSettingItem::SettingTextL()
+ {
+ return KAknSettingItemSingleSpace;
+ }
+
+EXPORT_C void CAknVolumeSettingItem::EditItemL( TBool /* aCalledFromMenu */)
+ {
+ _AKNTRACE_FUNC_ENTER;
+
+ TPtrC settingName = SettingName();
+
+ CAknVolumeSettingPage* dlg = new( ELeave )CAknVolumeSettingPage(
+ &settingName,
+ SettingNumber(),
+ EditorControlType(),
+ SettingEditorResourceId(),
+ SettingPageResourceId(),
+ InternalVolumeValue() );
+ SetSettingPage( dlg );
+ SettingPage()->SetSettingPageObserver(this);
+
+ if(ProtectionState() == CAknSettingItem::ESettingItemViewOnly)
+ SettingPage()->SetEditState(EFalse);
+
+ SettingPage()->ExecuteLD(CAknSettingPage::EUpdateWhenChanged);
+ SetSettingPage(0);
+ UpdateListBoxTextL(); // update bitmap
+
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+EXPORT_C TInt& CAknVolumeSettingItem::InternalVolumeValue()
+ {
+ return iInternalVolume;
+ }
+
+/**
+* This method is used to generate an appropriate bitmap for the current internal value
+*
+*/
+EXPORT_C CFbsBitmap* CAknVolumeSettingItem::CreateBitmapL()
+ {
+ _AKNTRACE_FUNC_ENTER;
+
+ CGulIcon* icon = NULL;
+ TResourceReader reader;
+ CCoeEnv::Static()->CreateResourceReaderLC( reader, SettingPageResourceId() );
+
+ TInt number= reader.ReadInt16();
+ TPtrC settingText = reader.ReadTPtrC();
+ TPtrC hintText = reader.ReadTPtrC();
+ TInt cba = reader.ReadInt32();
+ TInt menuBarId = reader.ReadInt32();
+ TInt controlType = reader.ReadInt16();
+ TInt editorResourceId = reader.ReadInt32();
+ CleanupStack::PopAndDestroy(); // reader
+
+ CCoeEnv::Static()->CreateResourceReaderLC( reader, editorResourceId );
+
+ TInt style = reader.ReadInt16();
+
+ if ( style == EDynRangeSettingsVolumeControl )
+ {
+ TInt value = reader.ReadInt16();
+ TPtrC bmpFile=reader.ReadTPtrC();
+ TInt bmpId=reader.ReadInt16();
+ TInt bmpMask=reader.ReadInt16();
+ TInt min= reader.ReadInt16();
+ TInt max = reader.ReadInt16();
+
+ icon = CAknVolumeControl::CreateSetDynRangeStyleListBoxIconL( InternalVolumeValue(),min,max );
+ }
+ else
+ {
+ icon = CAknVolumeControl::CreateSetStyleListBoxIconL( InternalVolumeValue() );
+ }
+ CleanupStack::PopAndDestroy(); // reader
+
+
+ CFbsBitmap* returnedBitmap = SetIconMaskAndReturnBitmap( icon ); // ownership of icon transfered,
+
+ _AKNTRACE_FUNC_EXIT;
+ return returnedBitmap; // and this transfers ownership to caller
+ }
+
+EXPORT_C void CAknVolumeSettingItem::CAknSettingItem_Reserved()
+ {
+ };
+
+// ---------------------------------------
+// CAknSliderSettingItem
+//
+//----------------------------------------
+
+EXPORT_C CAknSliderSettingItem::CAknSliderSettingItem( TInt aIdentifier, TInt& aSliderValue ):
+ CAknSettingItem(aIdentifier), iExternalSliderValue( aSliderValue )
+ {
+ }
+
+EXPORT_C void CAknSliderSettingItem::StoreL()
+ {
+ // Copy the internal to the external
+ iExternalSliderValue = iInternalSliderValue;
+ }
+
+EXPORT_C void CAknSliderSettingItem::LoadL()
+ {
+ iInternalSliderValue = iExternalSliderValue;
+ }
+
+EXPORT_C const TDesC& CAknSliderSettingItem::SettingTextL()
+ {
+ return KAknSettingItemSingleSpace;
+ }
+
+
+EXPORT_C TInt& CAknSliderSettingItem::InternalSliderValue()
+ {
+ return iInternalSliderValue;
+ }
+
+EXPORT_C void CAknSliderSettingItem::EditItemL( TBool /* aCalledFromMenu */)
+ {
+ CreateAndExecuteSettingPageL();
+ }
+
+EXPORT_C void CAknSliderSettingItem::CreateAndExecuteSettingPageL()
+ {
+ _AKNTRACE_FUNC_ENTER;
+
+ CAknSettingPage* dlg = CreateSettingPageL();
+
+ SetSettingPage( dlg );
+ SettingPage()->SetSettingPageObserver(this);
+
+ if(ProtectionState() == CAknSettingItem::ESettingItemViewOnly)
+ SettingPage()->SetEditState(EFalse);
+
+ SettingPage()->ExecuteLD(CAknSettingPage::EUpdateWhenChanged);
+ SetSettingPage(0);
+ UpdateListBoxTextL();
+
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+EXPORT_C CAknSettingPage* CAknSliderSettingItem::CreateSettingPageL()
+ {
+ TPtrC text = SettingName();
+ return new( ELeave )CAknSliderSettingPage(&text,SettingNumber(),EAknCtSlider,
+ SettingEditorResourceId(), SettingPageResourceId(), iInternalSliderValue);
+ }
+
+
+/**
+* This method is used to generate an appropriate bitmap for the current internal value
+*
+*/
+EXPORT_C CFbsBitmap* CAknSliderSettingItem::CreateBitmapL()
+ {
+ _AKNTRACE_FUNC_ENTER;
+ TInt editorResource = SettingEditorResourceId();
+ if ( ( editorResource == 0 ) && ( SettingPageResourceId() != 0 ) )
+ {
+ TInt editorType;
+ CAknSettingPage::GetEditorResourceInfoL( SettingPageResourceId(), editorType, editorResource );
+ __ASSERT_ALWAYS( editorType == EAknCtSlider, Panic( EAknPanicSettingItemListInconsistentControlType ) );
+ }
+ __ASSERT_ALWAYS( editorResource , Panic( EAknPanicSettingItemListInsufficientResource ) );
+
+
+ CGulIcon* icon = CAknSlider::CreateSetStyleListBoxIconL( InternalSliderValue(), editorResource );
+ CFbsBitmap* returnedBitmap = SetIconMaskAndReturnBitmap( icon ); // ownership of icon transfered,
+
+ _AKNTRACE_FUNC_EXIT;
+ return returnedBitmap; // and this transfers ownership to caller
+ }
+
+EXPORT_C void CAknSliderSettingItem::CAknSettingItem_Reserved()
+ {
+ };
+
+// ---------------------------------------
+// CAknTimeOrDateSettingItem
+//
+//----------------------------------------
+
+EXPORT_C CAknTimeOrDateSettingItem::CAknTimeOrDateSettingItem( TInt aIdentifier, enum CAknTimeOrDateSettingItem::TAknTimeOrDateSettingItemMode aTimeOrDateMode, TTime& aTime ):
+ CAknSettingItem(aIdentifier), iExternalTime( aTime ), iInternalTextPtr(0,0), iTimeFormatPtr(0,0), iTimeOrDateMode (aTimeOrDateMode )
+ {
+ }
+
+
+EXPORT_C CAknTimeOrDateSettingItem::~CAknTimeOrDateSettingItem()
+ {
+ delete iTimeFormat;
+ delete iInternalText;
+ }
+
+
+/**
+*
+* Complete the construction
+*
+*/
+
+EXPORT_C void CAknTimeOrDateSettingItem::CompleteConstructionL()
+ {
+ _AKNTRACE_FUNC_ENTER;
+ // Prepare the date buffer
+ iInternalText = HBufC::NewL(KAknSettingItemTimeBufferLength);
+ // and the format buffer
+ // Set up according to default
+
+ delete iTimeFormat;
+ iTimeFormat = NULL;
+ switch ( iTimeOrDateMode )
+ {
+ case ETime:
+ iTimeFormat = CCoeEnv::Static()->AllocReadResourceL( R_QTN_TIME_USUAL_WITH_ZERO );
+ break;
+
+ case EDate:
+ iTimeFormat = CCoeEnv::Static()->AllocReadResourceL( R_QTN_DATE_USUAL_WITH_ZERO );
+ break;
+
+ default:
+ __ASSERT_ALWAYS(0, Panic(EAknPanicSettingItemListInvalidDateMode) );
+ break;
+
+ }
+
+ iTimeFormatPtr.Set(iTimeFormat->Des());
+
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+
+EXPORT_C void CAknTimeOrDateSettingItem::StoreL()
+ {
+ // Copy the internal to the external
+ iExternalTime = iInternalTime;
+ }
+
+EXPORT_C void CAknTimeOrDateSettingItem::LoadL()
+ {
+ iInternalTime = iExternalTime;
+ }
+
+EXPORT_C const TDesC& CAknTimeOrDateSettingItem::SettingTextL()
+ {
+
+ // set the text ptr again
+ iInternalTextPtr.Set(iInternalText->Des());
+ iInternalTime.FormatL(iInternalTextPtr, TimeFormatString());
+ AknTextUtils::DisplayTextLanguageSpecificNumberConversion(iInternalTextPtr);
+ return iInternalTextPtr;
+ }
+
+EXPORT_C void CAknTimeOrDateSettingItem::SetTimeFormatStringL( const TDesC& aTimeFormat )
+ {
+ delete iTimeFormat;
+ iTimeFormat = 0;
+ iTimeFormat = aTimeFormat.AllocL();
+ // Use Set so that the whole TPtr is just overwritten - and gets a new buffer
+ iTimeFormatPtr.Set(iTimeFormat->Des() );
+ }
+
+EXPORT_C const TPtrC CAknTimeOrDateSettingItem::TimeFormatString()
+ {
+ return TPtrC(iTimeFormatPtr);
+ }
+
+
+EXPORT_C void CAknTimeOrDateSettingItem::EditItemL( TBool /* aCalledFromMenu */)
+ {
+ _AKNTRACE_FUNC_ENTER;
+ TPtrC text = SettingName();
+ CAknSettingPage* dlg = 0;
+
+ switch ( iTimeOrDateMode )
+ {
+ case ETime:
+ dlg = new( ELeave )CAknTimeSettingPage(
+ &text,
+ SettingNumber(),
+ EditorControlType(),
+ SettingEditorResourceId(),
+ SettingPageResourceId(),
+ iInternalTime);
+
+ break;
+
+ case EDate:
+ dlg = new( ELeave )CAknDateSettingPage(
+ &text,
+ SettingNumber(),
+ EditorControlType(),
+ SettingEditorResourceId(),
+ SettingPageResourceId(),
+ iInternalTime);
+ break;
+
+ default:
+ __ASSERT_ALWAYS(0, Panic(EAknPanicSettingItemListInvalidDateMode) );
+ break;
+ }
+
+ SetSettingPage( dlg );
+ SettingPage()->SetSettingPageObserver(this);
+
+ if(ProtectionState() == CAknSettingItem::ESettingItemViewOnly)
+ SettingPage()->SetEditState(EFalse);
+
+ SettingPage()->ExecuteLD(CAknSettingPage::EUpdateWhenChanged);
+ SetSettingPage(0);
+
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void CAknTimeOrDateSettingItem::CAknSettingItem_Reserved()
+ {
+ };
+
+
+// ---------------------------------------
+// CAknTimeOffsetSettingItem
+//
+//----------------------------------------
+
+EXPORT_C CAknTimeOffsetSettingItem::CAknTimeOffsetSettingItem( TInt aIdentifier, TTimeIntervalSeconds& aTime ):
+ CAknSettingItem(aIdentifier), iExternalTime( aTime ), iInternalTextPtr(0,0), iTimeFormatPtr(0,0)
+ {
+ }
+
+
+EXPORT_C CAknTimeOffsetSettingItem::~CAknTimeOffsetSettingItem()
+ {
+ delete iTimeFormat;
+ delete iInternalText;
+ }
+
+
+/**
+*
+* Complete the construction
+*
+*/
+
+EXPORT_C void CAknTimeOffsetSettingItem::CompleteConstructionL()
+ {
+ _AKNTRACE_FUNC_ENTER;
+ // Prepare the date buffer
+ iInternalText = HBufC::NewL(KAknSettingItemTimeBufferLength);
+ // and the format buffer
+ // Set up according to default
+
+ delete iTimeFormat;
+ iTimeFormat = NULL;
+
+ iTimeFormat = CCoeEnv::Static()->AllocReadResourceL( R_QTN_TIME_DURAT_SHORT );
+
+ iTimeFormatPtr.Set(iTimeFormat->Des());
+
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+
+EXPORT_C void CAknTimeOffsetSettingItem::StoreL()
+ {
+ // Copy the internal to the external
+ iExternalTime = iInternalTime;
+ }
+
+EXPORT_C void CAknTimeOffsetSettingItem::LoadL()
+ {
+ iInternalTime = iExternalTime;
+ }
+
+EXPORT_C const TDesC& CAknTimeOffsetSettingItem::SettingTextL()
+ {
+ _AKNTRACE_FUNC_ENTER;
+ // set the text ptr again
+ TBool minus = EFalse;
+
+ TInt timeInSeconds = iInternalTime.Int();
+ if (timeInSeconds<0)
+ {
+ minus = ETrue;
+ timeInSeconds = -timeInSeconds;
+ }
+
+ TTimeIntervalHours hours = (timeInSeconds - timeInSeconds%3600)/3600;
+ TTimeIntervalMinutes minutes = (timeInSeconds%3600 - timeInSeconds%60)/60;
+ TTimeIntervalSeconds seconds = timeInSeconds%60;
+
+ TTime time(0);
+ time += hours;
+ time += minutes;
+ time += seconds;
+
+ HBufC* buf;
+ buf = HBufC::NewL(KAknSettingItemTimeBufferLength);
+ CleanupStack::PushL(buf);
+
+ TPtr bufPtr(0,0);
+
+ bufPtr.Set(buf->Des());
+
+ time.FormatL(bufPtr, TimeFormatString());
+ AknTextUtils::DisplayTextLanguageSpecificNumberConversion(bufPtr);
+
+ iInternalTextPtr.Set(iInternalText->Des());
+
+ if (minus)
+ {
+ iInternalTextPtr = KAknSettingItemMinus;
+ }
+ else
+ {
+ iInternalTextPtr = KAknSettingItemPlus;
+ }
+ iInternalTextPtr += KAknSettingItemSingleSpace;
+ iInternalTextPtr += bufPtr;
+ CleanupStack::Pop(); //buf
+
+ delete buf;
+
+ _AKNTRACE_FUNC_EXIT;
+ return iInternalTextPtr;
+ }
+
+EXPORT_C void CAknTimeOffsetSettingItem::SetTimeFormatStringL( const TDesC& aTimeFormat )
+ {
+ _AKNTRACE( "[%s][%s][%d]", "CAknTimeOffsetSettingItem", __FUNCTION__, __LINE__ );
+ delete iTimeFormat;
+ iTimeFormat = 0;
+ iTimeFormat = aTimeFormat.AllocL();
+ // Use Set so that the whole TPtr is just overwritten - and gets a new buffer
+ iTimeFormatPtr.Set(iTimeFormat->Des() );
+ }
+
+EXPORT_C const TPtrC CAknTimeOffsetSettingItem::TimeFormatString()
+ {
+ return TPtrC(iTimeFormatPtr);
+ }
+
+
+EXPORT_C void CAknTimeOffsetSettingItem::EditItemL( TBool /* aCalledFromMenu */)
+ {
+ _AKNTRACE_FUNC_ENTER;
+ TPtrC text = SettingName();
+ CAknSettingPage* dlg = 0;
+
+ dlg = new( ELeave )CAknTimeOffsetSettingPage(
+ &text,
+ SettingNumber(),
+ EditorControlType(),
+ SettingEditorResourceId(),
+ SettingPageResourceId(),
+ iInternalTime);
+ //interval);
+
+ SetSettingPage( dlg );
+ SettingPage()->SetSettingPageObserver(this);
+
+ if(ProtectionState() == CAknSettingItem::ESettingItemViewOnly)
+ SettingPage()->SetEditState(EFalse);
+
+ SettingPage()->ExecuteLD(CAknSettingPage::EUpdateWhenChanged);
+ SetSettingPage(0);
+
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void CAknTimeOffsetSettingItem::CAknSettingItem_Reserved()
+ {
+ };
+
+
+// ---------------------------------------
+// CAknIpFieldSettingItem
+//
+//----------------------------------------
+
+EXPORT_C CAknIpFieldSettingItem::CAknIpFieldSettingItem( TInt aIdentifier, TInetAddr& aIpAddress ):
+ CAknSettingItem(aIdentifier), iExternalIpAddress( aIpAddress ), iInternalTextPtr(0,0)
+ {
+ }
+
+
+EXPORT_C CAknIpFieldSettingItem::~CAknIpFieldSettingItem()
+ {
+ delete iInternalText;
+ }
+
+
+/**
+*
+* Complete the construction
+*
+*/
+
+EXPORT_C void CAknIpFieldSettingItem::CompleteConstructionL()
+ {
+ // Allocate the ip text buffer
+ iInternalText = HBufC::NewL(KAknSettingItemIpTextBufferLength);
+ }
+
+
+EXPORT_C void CAknIpFieldSettingItem::StoreL()
+ {
+ // Copy the internal to the external
+ iExternalIpAddress = iInternalIpAddress;
+ }
+
+EXPORT_C void CAknIpFieldSettingItem::LoadL()
+ {
+ iInternalIpAddress = iExternalIpAddress;
+ }
+
+EXPORT_C const TDesC& CAknIpFieldSettingItem::SettingTextL()
+ {
+ // set the text ptr again
+ iInternalTextPtr.Set(iInternalText->Des());
+
+ if ( iInternalIpAddress.IsUnspecified() )
+ {
+ iInternalTextPtr.Copy(KAknSettingItemEmptyIpAddress);
+ }
+ else
+ {
+ iInternalIpAddress.Output(iInternalTextPtr);
+ }
+ return iInternalTextPtr;
+ }
+
+
+EXPORT_C void CAknIpFieldSettingItem::EditItemL( TBool /* aCalledFromMenu */)
+ {
+ _AKNTRACE_FUNC_ENTER;
+ TPtrC text = SettingName();
+ CAknSettingPage* dlg = 0;
+
+ dlg = new( ELeave )CAknIpFieldSettingPage(
+ &text,
+ SettingNumber(),
+ EditorControlType(),
+ SettingEditorResourceId(),
+ SettingPageResourceId(),
+ iInternalIpAddress);
+
+ SetSettingPage( dlg );
+ SettingPage()->SetSettingPageObserver(this);
+
+ if(ProtectionState() == CAknSettingItem::ESettingItemViewOnly)
+ SettingPage()->SetEditState(EFalse);
+
+ SettingPage()->ExecuteLD(CAknSettingPage::EUpdateWhenChanged);
+ SetSettingPage(0);
+
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void CAknIpFieldSettingItem::CAknSettingItem_Reserved()
+ {
+ };
+
+
+
+//
+//
+EXPORT_C CAknEnumeratedItemBase::CAknEnumeratedItemBase( TInt aEnumerationValue, TAny* aValue ):
+ iEnumerationValue( aEnumerationValue ), iValue ( aValue )
+ {
+ }
+
+EXPORT_C CAknEnumeratedItemBase::~CAknEnumeratedItemBase()
+ {
+ }
+
+EXPORT_C TInt CAknEnumeratedItemBase::EnumerationValue() const
+ {
+ return iEnumerationValue;
+ }
+
+EXPORT_C void CAknEnumeratedItemBase::SetEnumerationValue( TInt aNewEnumerationValue )
+ {
+ _AKNTRACE( "[%s][%s] aNewEnumerationValue = %d", "CAknEnumeratedItemBase",
+ __FUNCTION__, aNewEnumerationValue );
+ iEnumerationValue = aNewEnumerationValue;
+ }
+
+EXPORT_C TAny* CAknEnumeratedItemBase::Value() const
+ {
+ return iValue;
+ }
+
+EXPORT_C void CAknEnumeratedItemBase::SetValue( TAny* aNewValue )
+ {
+ iValue = aNewValue;
+ }
+
+
+//
+// Implementation of CAknEnumeratedTextSettingItem
+//
+//
+
+#define EMPTY_LIST (NumberOfItems() == 0)
+
+EXPORT_C CAknEnumeratedTextSettingItem::CAknEnumeratedTextSettingItem(
+ TInt aIdentifier ): CAknSettingItem(aIdentifier)
+ {
+ }
+
+EXPORT_C CAknEnumeratedTextSettingItem::~CAknEnumeratedTextSettingItem()
+ {
+ DeleteAndZeroPrimaryArrays();
+ delete iSettingPageText;
+ }
+
+/**
+*
+* Complete the construction using the additional resource id.
+* This reads in the two sets of texts : texts for for the setting item list display
+* and texts for any setting page that may be raised.
+*
+* This also sets the empty listbox text
+*/
+EXPORT_C void CAknEnumeratedTextSettingItem::CompleteConstructionL( )
+ {
+ _AKNTRACE_FUNC_ENTER;
+
+ if ( AssociatedResourceId() )
+ {
+ TResourceReader reader;
+ CEikonEnv::Static()->CreateResourceReaderLC( reader, AssociatedResourceId() );
+
+ iTextPopupFlags = reader.ReadInt16(); // Flags
+
+ iEnumeratedTextArrayResourceId = reader.ReadInt32(); // LLINK to values
+ iPoppedUpTextArrayResourceId = reader.ReadInt32(); // optional LLINK to values
+
+ /* Throw away */ reader.ReadInt32(); // For future needs
+
+ CleanupStack::PopAndDestroy(); // reader
+
+ // Read in the texts to be used in the setting item list
+ CEikonEnv::Static()->CreateResourceReaderLC( reader, iEnumeratedTextArrayResourceId );
+
+ TInt numberOfItems = reader.ReadInt16(); // item count
+
+ // Construct the array
+ iEnumeratedTextArray = new (ELeave) CArrayPtrFlat<CAknEnumeratedText>( KAknSettingItemArrayGranularity );
+ iPoppedUpTextArray = new (ELeave) CArrayPtrFlat<HBufC>(KAknSettingItemArrayGranularity);
+
+ TInt index = 0;
+ //Loop through all the texts
+ for ( index=0; index < numberOfItems ; ++index )
+ {
+ TInt value = reader.ReadInt16();
+ TPtrC text = reader.ReadTPtrC(); // LTEXT name;
+ HBufC* thisText = text.AllocLC(); // pushed thisText
+ TPtr thisTextDes = thisText->Des();
+ AknTextUtils::DisplayTextLanguageSpecificNumberConversion(thisTextDes);
+ CAknEnumeratedText* enumeratedText = new (ELeave) CAknEnumeratedText( value, thisText);
+ CleanupStack::Pop(); // thisText
+ CleanupStack::PushL( enumeratedText );
+ iEnumeratedTextArray->AppendL( enumeratedText );
+ CleanupStack::Pop(); // enumeratedText
+ }
+
+ CleanupStack::PopAndDestroy(); // reader
+
+ // If the "Popped Up" resource is non-zero, then read it in too
+ if ( iPoppedUpTextArrayResourceId )
+ {
+ // Read in the texts to be used in the setting item list
+ CEikonEnv::Static()->CreateResourceReaderLC( reader, iPoppedUpTextArrayResourceId );
+
+ // Read the item count
+ TInt numberOfItems = reader.ReadInt16(); // item count
+
+ //Loop through all the texts
+ for ( index=0; index < numberOfItems ; ++index )
+ {
+ TPtrC text = reader.ReadTPtrC();// LTEXT name;
+ if ( text.Length() > 0 )
+ {
+ HBufC* thisText = text.AllocLC();
+ TPtr thisTextDes = thisText->Des();
+ AknTextUtils::DisplayTextLanguageSpecificNumberConversion(thisTextDes);
+
+ iPoppedUpTextArray->AppendL(thisText);
+ CleanupStack::Pop(); // thisText
+ }
+ else
+ iPoppedUpTextArray->AppendL(0); // zero pointers for the zero length texts
+ }
+
+ CleanupStack::PopAndDestroy(); // reader
+
+ }
+ }
+
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+EXPORT_C CArrayPtr<CAknEnumeratedText>* CAknEnumeratedTextSettingItem::EnumeratedTextArray() const
+ {
+ return iEnumeratedTextArray;
+ }
+
+EXPORT_C CArrayPtr<HBufC>* CAknEnumeratedTextSettingItem::PoppedUpTextArray() const
+ {
+ return iPoppedUpTextArray;
+ }
+
+/**
+* Set the enumerated arrays.
+* Ownership of these arrays and their contents is wholly given over to the setting item
+* object.
+*
+*/
+EXPORT_C void CAknEnumeratedTextSettingItem::SetEnumeratedTextArrays( CArrayPtr<CAknEnumeratedText>* aEnumeratedTextArray,
+ CArrayPtr<HBufC>* aPoppedUpTextArray )
+ {
+ __ASSERT_ALWAYS( aEnumeratedTextArray, Panic( EAknPanicSettingItemListInvalidPointer ) );
+ __ASSERT_ALWAYS( aPoppedUpTextArray, Panic( EAknPanicSettingItemListInvalidPointer ) );
+ DeleteAndZeroPrimaryArrays();
+ iEnumeratedTextArray = aEnumeratedTextArray;
+ iPoppedUpTextArray = aPoppedUpTextArray;
+ }
+
+/**
+* The virtual method LoadL() is called as the base class's best guess as to what needs to be
+* done at this point.
+*/
+EXPORT_C void CAknEnumeratedTextSettingItem::HandleTextArrayUpdateL()
+ {
+ LoadL();
+ }
+
+// Construct the Text Popup with the Setting Page texts.
+//This may be different from the values
+// on the setting item list
+EXPORT_C void CAknEnumeratedTextSettingItem::SetSettingPageTextL()
+ {
+ _AKNTRACE_FUNC_ENTER;
+
+ delete iSettingPageText;
+ iSettingPageText = 0;
+ iSettingPageText = new(ELeave) CDesCArrayFlat(KAknSettingItemArrayGranularity);
+
+ TBool textIsSet;
+ TInt numberOfItems = NumberOfItems();
+ for ( TInt index = 0; index < numberOfItems ; index++ )
+ {
+ textIsSet = EFalse;
+ HBufC* poppedUpText;
+ if ( index < iPoppedUpTextArray->Count() ) // Note popped up text array may be shorter than numberOfItems
+ {
+ if ( (poppedUpText = iPoppedUpTextArray->At( index ) ) != 0 )
+ {
+ iSettingPageText->AppendL( poppedUpText->Des() );
+ textIsSet = ETrue;
+ }
+ }
+
+ if (!textIsSet)
+ iSettingPageText->AppendL( iEnumeratedTextArray->At( index )->Value()->Des() );
+ }
+
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+EXPORT_C CDesCArray* CAknEnumeratedTextSettingItem::SettingPageTextArray() const
+ {
+ return iSettingPageText;
+ }
+
+
+EXPORT_C TInt CAknEnumeratedTextSettingItem::NumberOfItems() const
+ {
+ if ( iEnumeratedTextArray )
+ return iEnumeratedTextArray->Count();
+ else
+ return 0;
+ }
+
+
+/**
+* Find the index of the enumeration that matches the input value
+* -1 is returned if the value is not in the enumerated text array
+*
+*/
+EXPORT_C TInt CAknEnumeratedTextSettingItem::IndexFromValue( TInt aInputValue ) const
+ {
+ // Find this value in the enumerated items
+ TInt indexToFind = -1;
+ TInt numItems = EnumeratedTextArray()->Count();
+ for ( TInt index = 0; index < numItems ; index++ )
+ {
+ if ( aInputValue == EnumeratedTextArray()->At( index )->EnumerationValue() )
+ {
+ indexToFind = index;
+ break;
+ }
+ }
+ _AKNTRACE( "[%s][%s] return value = %d", "CAknEnumeratedTextSettingItem",
+ __FUNCTION__, indexToFind );
+ return indexToFind;
+ }
+
+void CAknEnumeratedTextSettingItem::DeleteAndZeroPrimaryArrays()
+ {
+ if ( iEnumeratedTextArray )
+ {
+ iEnumeratedTextArray->ResetAndDestroy();
+ delete iEnumeratedTextArray;
+ iEnumeratedTextArray = 0;
+ }
+ if ( iPoppedUpTextArray )
+ {
+ iPoppedUpTextArray->ResetAndDestroy();
+ delete iPoppedUpTextArray;
+ iPoppedUpTextArray = 0;
+ }
+ }
+
+EXPORT_C void CAknEnumeratedTextSettingItem::CAknSettingItem_Reserved()
+ {
+ };
+
+
+//
+// Implementation of CAknEnumeratedTextPopupSettingItem
+//
+
+
+EXPORT_C CAknEnumeratedTextPopupSettingItem::CAknEnumeratedTextPopupSettingItem(
+ TInt aIdentifier,
+ TInt& aValue ):
+ CAknEnumeratedTextSettingItem(aIdentifier), iExternalValue( aValue )
+ {
+#ifdef __DEBUG__
+ __ASSERT_DEBUG( sizeof( CAknEnumeratedTextPopupSettingItem ) == 0x0000008c , Panic( EAknPanicSettingItemListNotBinaryCompatible ) );
+#endif
+ }
+
+EXPORT_C CAknEnumeratedTextPopupSettingItem::~CAknEnumeratedTextPopupSettingItem()
+ {
+ delete iQueryValue;
+ delete iQueryTextArray; // This does not own the objects it points to
+ }
+
+/**
+*
+* Complete the construction using the additional resource id.
+* This reads in the two binary texts.
+* Note that Load() will not have been called yet, so the setting is still uninitialized in terms of its data content
+* after this has finished. Otherwise, the instance should be ready.
+*
+*/
+
+EXPORT_C void CAknEnumeratedTextPopupSettingItem::CompleteConstructionL( )
+ {
+ _AKNTRACE_FUNC_ENTER;
+ CAknEnumeratedTextSettingItem::CompleteConstructionL();
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+
+EXPORT_C void CAknEnumeratedTextPopupSettingItem::StoreL()
+ {
+ // Copy the internal to the external
+ iExternalValue = iInternalValue;
+ }
+
+EXPORT_C void CAknEnumeratedTextPopupSettingItem::LoadL()
+ {
+ iInternalValue = iExternalValue;
+
+ // Find this value in the enumerated items
+ iSelectedIndex = IndexFromValue( iInternalValue );
+
+ if (iSelectedIndex == -1 && !EMPTY_LIST)
+ {
+ // There may be some sort of error here
+ // Depends on if there is a requirement to support "nothing selected"
+ __ASSERT_ALWAYS(0, Panic(EAknPanicSettingItemListInvalidEnumeratedValue) );
+ }
+ }
+
+
+EXPORT_C const TDesC& CAknEnumeratedTextPopupSettingItem::SettingTextL()
+ {
+ if (EMPTY_LIST) return EmptyItemText();
+ return *(EnumeratedTextArray()->At( iSelectedIndex )->Value());
+ }
+
+EXPORT_C MAknQueryValue* CAknEnumeratedTextPopupSettingItem::QueryValue() const
+ {
+ return iQueryValue;
+ }
+
+/**
+* Launch the setting page for this setting.
+*
+*
+*/
+EXPORT_C void CAknEnumeratedTextPopupSettingItem::EditItemL( TBool /* aCalledFromMenu */)
+ {
+ _AKNTRACE_FUNC_ENTER;
+
+ SetSettingPageTextL();
+ CreateTextArrayL();
+
+ CreateQueryValueL();
+ CreateAndExecuteSettingPageL();
+
+ UpdateInternalValuesL();
+ UpdateListBoxTextL();
+
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+// Construct the Text Popup with the Setting Page texts.
+//This may be different from the values
+// on the setting item list
+void CAknEnumeratedTextPopupSettingItem::SetSettingPageTextL()
+ {
+ CAknEnumeratedTextSettingItem::SetSettingPageTextL();
+ }
+
+void CAknEnumeratedTextPopupSettingItem::CreateTextArrayL()
+ {
+ delete iQueryTextArray;
+ iQueryTextArray = 0;
+ iQueryTextArray = CAknQueryValueTextArray::NewL();
+ iQueryTextArray->SetArray( *(SettingPageTextArray()) );
+ }
+
+//Set the same datearray into all the values, and set initial index values
+void CAknEnumeratedTextPopupSettingItem::CreateQueryValueL()
+ {
+ delete iQueryValue;
+ iQueryValue = 0;
+ iQueryValue = CAknQueryValueText::NewL();
+ iQueryValue->SetArrayL(iQueryTextArray);
+ if (!EMPTY_LIST)
+ iQueryValue->SetCurrentValueIndex(iSelectedIndex);
+ }
+
+EXPORT_C void CAknEnumeratedTextPopupSettingItem::CreateAndExecuteSettingPageL()
+ {
+ _AKNTRACE_FUNC_ENTER;
+
+ CAknSettingPage* dlg = CreateSettingPageL();
+ CleanupStack::PushL(dlg);
+ SetSettingPage( dlg );
+
+ SettingPage()->SetSettingPageObserver(this);
+ SetUpStandardSettingPageL();
+
+ CleanupStack::Pop(dlg);
+
+ if(ProtectionState() == CAknSettingItem::ESettingItemViewOnly)
+ SettingPage()->SetEditState(EFalse);
+
+
+ SettingPage()->ExecuteLD(CAknSettingPage::EUpdateWhenChanged);
+ SetSettingPage(0);
+
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+EXPORT_C CAknSettingPage* CAknEnumeratedTextPopupSettingItem::CreateSettingPageL()
+ {
+ TPtrC settingName = SettingName();
+ return new( ELeave )CAknPopupSettingPage( &settingName, SettingNumber(),
+ EditorControlType(), SettingEditorResourceId(), SettingPageResourceId(),*iQueryValue);
+ }
+
+void CAknEnumeratedTextPopupSettingItem::UpdateInternalValuesL()
+ {
+ _AKNTRACE_FUNC_ENTER;
+
+ if (!EMPTY_LIST)
+ {
+ iSelectedIndex = iQueryValue->CurrentValueIndex();
+// Check if new value has been added
+ if ( iSelectedIndex >= EnumeratedTextArray()->Count() )
+ {
+ // calculate the next enumeration value.
+ TInt nextFreeEnum = FindNextEnumerationValue();
+ // Create the new enumeration (number, text) object
+ HBufC* newText = iQueryValue->CurrentValueTextLC();
+ CAknEnumeratedText* newEnumeratedText = new (ELeave) CAknEnumeratedText( nextFreeEnum, newText );
+ // Ownership of newText has been given to newEnumeratedText.
+ CleanupStack::Pop(); // newText
+ CleanupStack::PushL( newEnumeratedText );
+ EnumeratedTextArray()->AppendL( newEnumeratedText );
+ CleanupStack::Pop(); // newEnumeratedText
+ iNumberOfItems++; // Now we have one more item
+ }
+ // Assert the tie between iNumberOfItems and iEnumeratedItemArray-Count()
+ __ASSERT_DEBUG( (NumberOfItems() == EnumeratedTextArray()->Count()), Panic( EAknPanicSettingItemListArrayLengthsMisMatch ) );
+ // Asserts on the in-range-ness of iSelectedIndex are done inside the array access:
+ iInternalValue = EnumeratedTextArray()->At( iSelectedIndex )->EnumerationValue();
+ }
+
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void CAknEnumeratedTextPopupSettingItem::SetExternalValue( TInt aNewValue )
+ {
+ iExternalValue = aNewValue;
+ }
+
+EXPORT_C void CAknEnumeratedTextPopupSettingItem::SetInternalValue( TInt aNewValue )
+ {
+ iInternalValue = aNewValue;
+ }
+
+EXPORT_C TInt CAknEnumeratedTextPopupSettingItem::ExternalValue() const
+ {
+ return iExternalValue;
+ }
+
+EXPORT_C TInt CAknEnumeratedTextPopupSettingItem::InternalValue() const
+ {
+ return iInternalValue;
+ }
+
+EXPORT_C void CAknEnumeratedTextPopupSettingItem::SetSelectedIndex( TInt aNewIndex )
+ {
+ iSelectedIndex = aNewIndex;
+ }
+
+/**
+* Find the index of the enumeration that matches the input value
+* -1 is returned if the value is not in the enumerated text array
+*
+*/
+EXPORT_C TInt CAknEnumeratedTextPopupSettingItem::IndexFromValue( TInt aInputValue ) const
+ {
+ _AKNTRACE( "[%s][%s] aInputValue = %d", "CAknEnumeratedTextPopupSettingItem", __FUNCTION__, aInputValue );
+ return CAknEnumeratedTextSettingItem::IndexFromValue( aInputValue );
+ }
+
+EXPORT_C CArrayPtr<CAknEnumeratedText>* CAknEnumeratedTextPopupSettingItem::EnumeratedTextArray() const
+ {
+ return CAknEnumeratedTextSettingItem::EnumeratedTextArray();
+ }
+
+EXPORT_C CArrayPtr<HBufC>* CAknEnumeratedTextPopupSettingItem::PoppedUpTextArray() const
+ {
+ return CAknEnumeratedTextSettingItem::PoppedUpTextArray();
+ }
+
+TInt CAknEnumeratedTextPopupSettingItem::FindNextEnumerationValue() const
+ {
+ _AKNTRACE_FUNC_ENTER;
+ // loop through the enumerated texts and record the highest enumeration value
+ TInt highestEnumValue = -1; // value chosen so as to return 0 if empty array
+ TInt enumInArray;
+ TInt count = EnumeratedTextArray()->Count();
+ for ( TInt index = 0; index < count; ++index )
+ {
+ enumInArray = EnumeratedTextArray()->At(index)->EnumerationValue();
+ if (highestEnumValue < enumInArray )
+ highestEnumValue = enumInArray;
+ }
+
+ _AKNTRACE_FUNC_EXIT;
+ return (++highestEnumValue);
+ }
+
+EXPORT_C void CAknEnumeratedTextPopupSettingItem::CAknSettingItem_Reserved()
+ {
+ };
+
+// ==============================================================================
+// CAknBinaryPopupSettingItem
+// ==============================================================================
+
+
+EXPORT_C CAknBinaryPopupSettingItem::CAknBinaryPopupSettingItem(
+ TInt aIdentifier,
+ TBool& aBinaryValue ):
+ CAknEnumeratedTextPopupSettingItem(aIdentifier, (TInt&)aBinaryValue )
+ {
+ }
+
+/**
+*
+* Complete the construction using the additional resource id.
+* This reads in the two binary texts This is called from within ConstructXXXL routines.
+* Note that Load() will not have been called yet, so the setting is still uninitialized in terms of its data content
+* after this has finished. Otherwise, the instance should be ready.
+*
+*/
+
+EXPORT_C void CAknBinaryPopupSettingItem::CompleteConstructionL( )
+ {
+ _AKNTRACE_FUNC_ENTER;
+
+ CAknEnumeratedTextPopupSettingItem::CompleteConstructionL();
+
+ __ASSERT_DEBUG( EnumeratedTextArray() , Panic(EAknPanicSettingItemListConstructionNotComplete) );
+ // that there are 2 values
+ __ASSERT_DEBUG( EnumeratedTextArray()->Count() == 2 , Panic(EAknPanicSettingItemListWrongNumberOfValues) );
+ // that the values are 0 and 1
+ __ASSERT_DEBUG( IndexFromValue( 0 ) != -1 , Panic(EAknPanicSettingItemListRequiredValueNotInArray) );
+ __ASSERT_DEBUG( IndexFromValue( 1 ) != -1 , Panic(EAknPanicSettingItemListRequiredValueNotInArray) );
+
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+
+EXPORT_C void CAknBinaryPopupSettingItem::StoreL()
+ {
+ SetExternalValue( InternalValue() );
+ }
+
+
+EXPORT_C void CAknBinaryPopupSettingItem::LoadL()
+ {
+ // Regularize the external value to 0 or 1
+ TInt tempExternalValue = 0;
+ if ( ExternalValue() )
+ tempExternalValue = 1;
+
+ SetExternalValue( tempExternalValue );
+
+ // This then sets the internal value
+ CAknEnumeratedTextPopupSettingItem::LoadL();
+ }
+
+/**
+* Launch the setting page for this setting.
+*
+*
+*/
+EXPORT_C void CAknBinaryPopupSettingItem::EditItemL( TBool aCalledFromMenu )
+ {
+ _AKNTRACE_FUNC_ENTER;
+
+ // Use base class for the main functionality
+ if ( aCalledFromMenu )
+ {
+ CAknEnumeratedTextPopupSettingItem::EditItemL( aCalledFromMenu );
+ // Check if another value has been added. We should not have to handle this in
+ // Binary setting page
+ // Note, however, that because of index discipline below, the 3rd item that might have
+ // been added will not ever be selected. Only when the list is popped up again, will the user's
+ // (ignored) choice be present
+ __ASSERT_DEBUG( EnumeratedTextArray()->Count() == 2 , Panic(EAknPanicSettingItemListWrongNumberOfValues) );
+ __ASSERT_DEBUG( InternalValue() < 2 , Panic(EAknPanicSettingItemListInvalidIndex) );
+ }
+ else if(ProtectionState() == ESettingItemViewOnly)
+ {
+ // Do not toggle!
+ }
+ else
+ {
+
+ // Toggle the value and update the listbox text
+ if ( InternalValue() )
+ SetInternalValue(0);
+ else
+ SetInternalValue(1);
+
+ TInt index = IndexFromValue( InternalValue() );
+ if (index >= 0 )
+ SetSelectedIndex( index );
+ else // put the seletion on the first in the list
+ SetSelectedIndex( 0 );
+
+ UpdateListBoxTextL();
+
+ }
+
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void CAknBinaryPopupSettingItem::CAknSettingItem_Reserved()
+ {
+ };
+
+
+/**
+* This constructor merely initializes the empty string descriptor required for formatting the
+* listbox text
+*
+*/
+EXPORT_C CAknBigSettingItemBase::CAknBigSettingItemBase( TInt aIdentifier ): CAknSettingItem( aIdentifier ), iEmptyString( KNullDesC )
+ {
+ }
+
+/**
+* Just returns the pre-set empty string
+*
+*/
+EXPORT_C const TDesC& CAknBigSettingItemBase::SettingTextL()
+ {
+ return iEmptyString;
+ }
+
+EXPORT_C void CAknBigSettingItemBase::CAknSettingItem_Reserved()
+ {
+ };
+
+//========================================
+
+
+EXPORT_C CAknSettingItemArray::CAknSettingItemArray(TInt aGranularity, TBool aIsNumbered, TInt aInitialOrdinal ) :
+ CArrayPtrFlat<CAknSettingItem>( aGranularity ), iIsNumbered( aIsNumbered ), iInitialOrdinal( aInitialOrdinal )
+ {
+ }
+
+EXPORT_C CAknSettingItemArray::~CAknSettingItemArray()
+ {
+ }
+
+EXPORT_C TInt CAknSettingItemArray::MdcaCount() const
+ {
+ return VisibleCount();
+ }
+
+EXPORT_C TPtrC16 CAknSettingItemArray::MdcaPoint(TInt aVisibleIndex ) const
+ {
+ TInt indexToUse = ItemIndexFromVisibleIndex( aVisibleIndex );
+ return ( (TPtrC)( *(At( indexToUse )->ListBoxText() ) ) );
+ }
+
+
+EXPORT_C void CAknSettingItemArray::SetVisibleCount( TInt aVisibleCount )
+ {
+ iVisibleCount = aVisibleCount;
+ }
+
+EXPORT_C void CAknSettingItemArray::RecalculateVisibleIndicesL()
+ {
+ _AKNTRACE_FUNC_ENTER;
+
+ TInt count = Count();
+ TInt visibleIndex = -1;
+ for ( TInt index = 0; index < count; ++index )
+ {
+ CAknSettingItem* item = At( index );
+ if ( !( item->IsHidden() ) )
+ {
+ visibleIndex++;
+ item->SetVisibleIndex( visibleIndex );
+ if ( !(iFlags & EAknSettingItemIncludeHiddenInOrdinal ) )
+ item->SetOrdinal( iInitialOrdinal + visibleIndex );
+ else
+ item->SetOrdinal( iInitialOrdinal + index );
+
+ item->UpdateListBoxTextL();
+ }
+ else
+ {
+ item->SetVisibleIndex( -1 );
+ item->SetOrdinal( -1 );
+ }
+ }
+ // The last index used gives the count (but add one first).
+ SetVisibleCount( visibleIndex+1 );
+
+ _AKNTRACE_FUNC_EXIT;
+
+ }
+EXPORT_C TInt CAknSettingItemArray::VisibleCount() const
+ {
+ return iVisibleCount;
+ }
+
+EXPORT_C TInt CAknSettingItemArray::ItemIndexFromVisibleIndex( TInt aVisibleIndex ) const
+ {
+ // go through item array until the one that returns the passed parameter is found
+ TInt count = Count();
+ for ( TInt index = 0; index < count; ++index )
+ {
+ if ( At( index )->VisibleIndex() == aVisibleIndex )
+ return index;
+ }
+ return -1;
+ }
+
+EXPORT_C void CAknSettingItemArray::SetInitialOrdinal( TInt aInitialOrdinal )
+ {
+ iInitialOrdinal = aInitialOrdinal;
+ }
+
+EXPORT_C void CAknSettingItemArray::SetFlags( TInt aFlags )
+ {
+ iFlags = aFlags;
+ }
+
+
+// -------------------------------
+// CAknSettingItemList
+// -------------------------------
+
+EXPORT_C CAknSettingItemList::CAknSettingItemList()
+ {
+ }
+
+EXPORT_C CAknSettingItemList::~CAknSettingItemList()
+ {
+ delete iSettingItemListBox;
+
+ if (iSettingItemArray)
+ {
+ iSettingItemArray->ResetAndDestroy();
+ delete iSettingItemArray;
+ }
+
+ delete iSettingItemListTitle;
+ }
+
+
+EXPORT_C CCoeControl* CAknSettingItemList::ComponentControl(TInt /*aIndex*/) const
+ {
+ return iSettingItemListBox;
+ }
+
+
+EXPORT_C TInt CAknSettingItemList::CountComponentControls() const
+ {
+ return 1;
+ }
+
+/**
+* Construct from resource using a new resource reader
+*
+*/
+EXPORT_C void CAknSettingItemList::ConstructFromResourceL( TInt aResourceId )
+ {
+ _AKNTRACE_FUNC_ENTER;
+
+ TResourceReader reader;
+ iCoeEnv->CreateResourceReaderLC( reader, aResourceId );
+ ConstructFromResourceL( reader );
+ CleanupStack::PopAndDestroy(); // reader
+
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+/**
+* This is the principal resource-reading Construct routine
+*
+*
+*/
+EXPORT_C void CAknSettingItemList::ConstructFromResourceL( TResourceReader& aReader )
+ {
+ _AKNTRACE_FUNC_ENTER;
+
+ if ( &(Window()) == 0 )
+ CreateWindowL();
+
+
+ // Flags read first
+ iFlags = aReader.ReadInt16(); // WORD flags
+
+ TPtrC settingListTitle = aReader.ReadTPtrC(); // LTEXT title
+ HBufC* newText = settingListTitle.AllocL();
+ if (iSettingItemListTitle)
+ delete( iSettingItemListTitle ); // after the AllocL succeeds
+ iSettingItemListTitle = newText;
+
+ iInitialOrdinal = aReader.ReadInt16(); // WORD initial_number
+
+ // Create the listbox in the right style
+ if ( IsNumberedStyle() )
+ iSettingItemListBox = new(ELeave) CAknSettingNumberStyleListBox();
+ else
+ iSettingItemListBox = new(ELeave) CAknSettingStyleListBox();
+
+ iSettingItemListBox->ConstructL( this, CEikListBox::ELeftDownInViewRect);
+
+ TPoint pos = iEikonEnv->EikAppUi()->ClientRect().iTl;
+ TSize size = iSettingItemListBox->MinimumSize();
+ SetExtent( pos,size );
+
+
+ // Set up the CBA
+ iSettingItemListBox->CreateScrollBarFrameL(ETrue);
+ iSettingItemListBox->ScrollBarFrame()->SetScrollBarVisibilityL(CEikScrollBarFrame::EOn, CEikScrollBarFrame::EAuto);
+
+ // The setting array
+ iSettingItemArray= new(ELeave)CAknSettingItemArray(KAknSettingItemArrayGranularity, IsNumberedStyle(), iInitialOrdinal );
+
+ // Transfer the flags to the item array
+ iSettingItemArray->SetFlags( iFlags );
+ // Make the icon array
+ CArrayPtrFlat<CGulIcon>* iconArray = new(ELeave) CAknIconArray(KAknSettingItemArrayGranularity);
+ CleanupStack::PushL( iconArray );
+
+ // In case there is no empty text in resource, this can be set from resource. In order
+ // to get this only once, we can read the default empty text into an HBufC now
+
+ HBufC* defaultEmptyText = iCoeEnv->AllocReadResourceLC(R_AVKON_SELEC_SETT_VAL_FIELD_NONE); // Pushed defaultEmptyText
+
+ // Read the number of items and then loop
+ const TInt numberOfItems = aReader.ReadInt16(); // item count
+ TInt id;
+ for (TInt ii=0; ii < numberOfItems ; ++ii )
+ {
+ id = aReader.ReadInt16(); // WORD identifier
+ TPtrC settingName = aReader.ReadTPtrC(); // LTEXT name;
+
+ TInt settingPageResourceId = aReader.ReadInt32(); // LLINK setting_page_resource
+ TInt editorControlType = aReader.ReadInt16(); // WORD control type
+ TInt settingEditorResourceId = aReader.ReadInt32(); // LLINK setting_editor_resource
+ TInt associatedResourceId = aReader.ReadInt32(); // LLINK associated_resource
+ TPtrC emptyText = aReader.ReadTPtrC(); // LTEXT empty_text
+ TPtrC compulsoryText = aReader.ReadTPtrC();
+ // Extension for future development
+ /* reserved */ aReader.ReadInt32();
+
+ // Call the factory for setting item
+ CAknSettingItem* settingItem = CreateSettingItemL( id );
+ if ( settingItem )
+ {
+ CleanupStack::PushL( settingItem );
+ // If no empty text was read from resource, then supply it from the default
+ if ( emptyText.Length() != 0 )
+ settingItem->SetEmptyItemTextL( emptyText );
+ else
+ settingItem->SetEmptyItemTextL( *defaultEmptyText );
+
+ settingItem->SetCompulsoryIndTextL( compulsoryText );
+ settingItem->ConstructL(
+ IsNumberedStyle(),
+// This is just an initial provision for the ordinal value
+// It may later one be adjusted for hidden items
+ iInitialOrdinal + ii,
+ settingName,
+ iconArray,
+ settingPageResourceId,
+ editorControlType,
+ settingEditorResourceId,
+ associatedResourceId );
+
+ settingItem->SetParentListBox( iSettingItemListBox );
+
+ iSettingItemArray->AppendL( settingItem ); // Ownership is transferred
+ CleanupStack::Pop(); // settingItem
+ }
+ }
+
+ CleanupStack::PopAndDestroy(); // defaultEmptyText
+
+ // Initial ordinal needed for dynamic numbering
+ iSettingItemArray->SetInitialOrdinal( iInitialOrdinal );
+
+ // Set up the visible indices in the listbox and update things
+ HandleChangeInItemArrayOrVisibilityL();
+
+ // Looks like we have no choice but to give ownership of this to the listbox
+ // There is no flag as there is for the item data
+ ListBox()->ItemDrawer()->FormattedCellData()->SetIconArrayL(iconArray);
+
+ CleanupStack::Pop(); // iconArray now has ownership transferred
+
+ CTextListBoxModel* model=ListBox()->Model();
+ model->SetItemTextArray(iSettingItemArray);
+ model->SetOwnershipType(ELbmDoesNotOwnItemArray); // Ownership retained by SettingItemList
+
+ TRect mainpaneRect;
+ AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, mainpaneRect );
+ iSettingItemListBox->SetRect(TRect(mainpaneRect.Size()));
+
+ ListBox()->SetCurrentItemIndex(0);
+ ListBox()->SetListBoxObserver(this);
+ ListBox()->UpdateScrollBarsL();
+
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+/**
+* This is an example implementation of this routine. It shows the typical structure. Nothing else besides the
+* C++ constuction of objects conforming to CAknSettingItem should be done.
+*
+* It may be useful to retain the default constuction of an object with run time type of CAknSettingItem. This will
+* allow visibility of the data in the resource file at least.
+*
+*/
+EXPORT_C CAknSettingItem* CAknSettingItemList::CreateSettingItemL( TInt identifier )
+ {
+ _AKNTRACE( "[%s][%s][%d].", "CAknSettingItemList", __FUNCTION__, __LINE__ );
+
+ CAknSettingItem* settingItem;
+
+ switch (identifier)
+ {
+ case 1:
+ settingItem = new (ELeave) CAknSettingItem(identifier);
+ return settingItem;
+
+
+ default:
+ settingItem = new (ELeave) CAknSettingItem(identifier);
+ return settingItem;
+
+ }
+ }
+
+EXPORT_C TKeyResponse CAknSettingItemList::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)
+ {
+ _AKNTRACE( "[%s][%s][%d].", "CAknSettingItemList", __FUNCTION__, __LINE__ );
+ // All events are sent to the listbox,
+ if (iSettingItemListBox)
+ return iSettingItemListBox->OfferKeyEventL( aKeyEvent, aType );
+ else
+ return EKeyWasNotConsumed;
+ }
+
+EXPORT_C void CAknSettingItemList::LoadSettingsL()// call Load() on each item in the MAknSettingItemArray.
+ {
+ TUint number = SettingItemArray()->Count();
+ TUint index;
+ for ( index = 0; index < number; index++ )
+ {
+ SettingItemArray()->At( index )->LoadL();
+ }
+ UpdateAllListBoxTextsL();
+ }
+EXPORT_C void CAknSettingItemList::StoreSettingsL() // call StoreL() on each item in the MAknSettingItemArray
+ {
+
+ TUint number = SettingItemArray()->Count();
+ for (TUint index = 0; index < number; index++ )
+ {
+ SettingItemArray()->At( index )->StoreL();
+ }
+
+ }
+// Has an initial number (so that numbers can increment over several dialog pages, for instance )
+EXPORT_C void CAknSettingItemList::SetIncludeHiddenInOrdinal( TBool aInclude )
+ {
+ _AKNTRACE( "[%s][%s] aInclude = %d", "CAknSettingItemList", __FUNCTION__, aInclude );
+ if ( aInclude )
+ iFlags |= EAknSettingItemIncludeHiddenInOrdinal;
+ else
+ iFlags &= (~EAknSettingItemIncludeHiddenInOrdinal);
+ // Update the copy of the flags in the array
+ if ( SettingItemArray() )
+ SettingItemArray()->SetFlags( iFlags );
+ }
+
+/**
+* Framework method for launching the setting page.
+*
+*/
+EXPORT_C void CAknSettingItemList::EditItemL(TInt aIndex, TBool aCalledFromMenu )
+ {
+ _AKNTRACE_FUNC_ENTER;
+
+ // Check if the setting page is locked
+ if(SettingItemArray()->At(aIndex)->ProtectionState() ==
+ CAknSettingItem::ESettingItemProtected)
+ //show dialog
+ {
+ // R_QTN_SELEC_PROTECTED_SETTING
+ HBufC* warningText =
+ CCoeEnv::Static()->AllocReadResourceLC( R_QTN_SELEC_PROTECTED_SETTING );
+
+ CAknWarningNote* warningNote = new (ELeave) CAknWarningNote;
+ warningNote->ExecuteLD(warningText->Des());
+
+ CleanupStack::PopAndDestroy(); // warningText
+ }
+ else
+ {
+ // launch the setting page index
+ SettingItemArray()->At(aIndex)->EditItemL( aCalledFromMenu );
+ iSettingItemListBox->View()->DrawItem( iSettingItemListBox->CurrentItemIndex() );
+ }
+
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+EXPORT_C TBool CAknSettingItemList::IsNumberedStyle()
+ {
+ return ( iFlags & EAknSettingItemNumberedStyle );
+ }
+
+EXPORT_C CAknSettingItemArray* CAknSettingItemList::SettingItemArray() const
+ {
+ return ( iSettingItemArray );
+ }
+
+EXPORT_C CEikFormattedCellListBox* CAknSettingItemList::ListBox()
+ {
+ return ( iSettingItemListBox );
+ }
+
+EXPORT_C void CAknSettingItemList::HandleListBoxEventL(CEikListBox* aListBox, TListBoxEvent aEventType)
+ {
+ _AKNTRACE( "[%s][%s] aListBox = 0x%x, aEventType = %d", "CAknSettingItemList", __FUNCTION__, aListBox, aEventType );
+
+ switch(aEventType)
+ {
+ case EEventEnterKeyPressed: // Can be enter key (In Series 60, OK key)
+ case EEventItemDoubleClicked: // Or double click event
+ case EEventItemSingleClicked:
+ {
+ TInt itemIndex = SettingItemArray()->ItemIndexFromVisibleIndex( aListBox->CurrentItemIndex() );
+ if ( itemIndex >= 0 )
+ {
+ EditItemL( itemIndex, EFalse );
+ aListBox->View()->DrawItem( aListBox->CurrentItemIndex() );
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+
+
+//It is the responsibility of the client to call this whenever it hides or deletes
+//SettingItems
+EXPORT_C void CAknSettingItemList::HandleChangeInItemArrayOrVisibilityL()
+ {
+ _AKNTRACE_FUNC_ENTER;
+
+ // Save the original highlight position. This will be -1 if there isn't one.
+
+ TInt originalHighlight = ListBox()->CurrentItemIndex();
+ //Listbox is only aware of the visible list (corresponding to "VisibleIndex");
+
+
+
+ //the actual list of ALL items (visible and invisible) corresponds to
+ //the "SettingItemIndex"
+ TInt originalSettingItemIndex = -1;
+
+ // Possibly, there is no highlight yet, but if there is...
+ if ( originalHighlight >= 0 )
+ {
+ // get the setting item index that corresponds to it
+ originalSettingItemIndex = SettingItemArray()->
+ ItemIndexFromVisibleIndex( originalHighlight );
+ }
+
+ //Save the distance of the highlight from the top of the view window
+ //in order to try to preserve it after allowing for item deletions.
+ //this will be <0 if there is no highlight
+ TInt originalDistanceOfHighlightFromTopOfView = originalHighlight
+ - ListBox()->TopItemIndex();
+
+
+ // Now recalculate the indices
+ SettingItemArray()->RecalculateVisibleIndicesL();
+
+ ListBox()->View()->CalcDataWidth();
+ ListBox()->View()->CalcBottomItemIndex();
+ ListBox()->UpdateScrollBarsL();
+
+ //ListBox assumes it's down to the client to ensure each time an item
+ //is added or deleted, the currentSettingItemIndex is recalculated.
+ //Thus if someone asynchronously deletes/hides an item without recalcing the SettingItemIndex
+ //then we're stuck.
+ TInt currentSettingItemIndex = originalSettingItemIndex;
+
+ //We don't know if we will be able to position our highlight at the same place on
+ //the screen, various items may have been made invisible,
+ //So we now sort out which item will be at the top of the viewable window
+ // Scan backwards starting from currentSettingItem until we find a visible item.
+ TInt currentHighlight = -1;
+
+ for ( ; currentSettingItemIndex >= 0; --currentSettingItemIndex )
+ {
+ if ( !( SettingItemArray()->At(currentSettingItemIndex)->IsHidden() ) )
+ // i.e.,if visible
+ {
+ currentHighlight = SettingItemArray()->
+ At(currentSettingItemIndex)->VisibleIndex();
+ break;
+ }
+ }
+
+
+ // If none found, then go to first visible item (which will be AFTER
+ // the original position)
+ if ( currentSettingItemIndex < 0 )
+ {
+ if ( ListBox()->Model()->NumberOfItems() > 0 )
+ currentHighlight = 0;
+ }
+
+
+ // if there is a highlight, set current item
+ if ( currentHighlight >= 0 )
+ {
+ //if there are enough visible items above the highlight to return the highlight
+ //to the same position on the screen then do so,
+ //else draw it at the top of the screen.
+ if (currentHighlight >= (originalDistanceOfHighlightFromTopOfView+1) )
+ ListBox()->SetTopItemIndex(currentHighlight
+ - originalDistanceOfHighlightFromTopOfView);
+ else
+ ListBox()->SetTopItemIndex(0);
+
+ ListBox()->SetCurrentItemIndex( currentHighlight );
+ ListBox()->DrawNow();
+ }
+
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+
+EXPORT_C void CAknSettingItemList::FocusChanged(TDrawNow aDrawNow)
+ {
+ TBool isFocused = IsFocused();
+ ListBox()->SetFocus(isFocused, aDrawNow);
+ }
+
+EXPORT_C void CAknSettingItemList::HandleResourceChange( TInt aType )
+ {
+ _AKNTRACE( "[%s][%s] aType = %d", "CAknSettingItemList", __FUNCTION__, aType );
+ if(aType == KEikDynamicLayoutVariantSwitch)
+ {
+ TRect mainpaneRect;
+ AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, mainpaneRect );
+
+ if ( OwnsWindow() )
+ {
+ SetRect(mainpaneRect);
+ }
+ else
+ {
+ SetRect( TRect( mainpaneRect.Size() ) );
+ }
+
+ ListBox()->SetRect( TRect( mainpaneRect.Size() ) );
+ }
+
+ if( aType == KAknsMessageSkinChange || aType == KEikDynamicLayoutVariantSwitch)
+ {
+ TRAP_IGNORE( UpdateAllListBoxTextsL() );
+ }
+ // put the list ok
+ CAknControl::HandleResourceChange(aType);
+ }
+
+EXPORT_C void CAknSettingItemList::HandlePointerEventL(const TPointerEvent& aPointerEvent)
+ {
+ _AKNTRACE_FUNC_ENTER;
+ CAknControl::HandlePointerEventL(aPointerEvent);
+ _AKNTRACE_FUNC_EXIT;
+ }
+
+EXPORT_C void* CAknSettingItemList::ExtensionInterface( TUid /*aInterface*/ )
+ {
+ return NULL;
+ }
+
+void CAknSettingItemList::UpdateAllListBoxTextsL() const
+ {
+ _AKNTRACE_FUNC_ENTER;
+ TUint number = SettingItemArray()->Count();
+ TUint index;
+ for ( index = 0; index < number; index++ )
+ {
+ SettingItemArray()->At( index )->UpdateListBoxTextL();
+ }
+ _AKNTRACE_FUNC_EXIT;
+ }
+// End of File