diff -r 000000000000 -r 2f259fa3e83a uifw/AvKon/src/AknSettingItemList.cpp --- /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 +#include + +//For TResourceReader +#include + +#include +#include +#include + +// For Numbered and unnumbered setting style lists +#include +#include + +#include +#include + +// 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 + +#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* 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* 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* 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 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 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( KAknSettingItemArrayGranularity ); + iPoppedUpTextArray = new (ELeave) CArrayPtrFlat(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* CAknEnumeratedTextSettingItem::EnumeratedTextArray() const + { + return iEnumeratedTextArray; + } + +EXPORT_C CArrayPtr* 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* aEnumeratedTextArray, + CArrayPtr* 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* CAknEnumeratedTextPopupSettingItem::EnumeratedTextArray() const + { + return CAknEnumeratedTextSettingItem::EnumeratedTextArray(); + } + +EXPORT_C CArrayPtr* 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( 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* 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