/*

 * Copyright (c) 2002 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 (See Selection Service specification)

 *		Contains setting item classes (whole hierarchy) and the 

 *		array classes used to set up the setting item listbox

 *

 */

 #if !defined(__AKNSETTINGITEMLIST_H__)

 #define __AKNSETTINGITEMLIST_H__

 #include <in_sock.h>

 #include <AknControl.h>

 // For graphics API

 #include <gulicon.h>

 // For CEikFormattedListBox

 #include <eikfrlb.h>

 // For setting page

 #include <aknsettingpage.h>

 // For query stuff

 #include <AknQueryValueText.h>

 // Maximum length of the blanking text

 const TInt KMaxPasswordBlankingTextLength = 10;

 class CAknSettingItemExtension;

 /**

 * CAknSettingItem is the base class for all setting items. The abstracted functionality

 * is implemented in this class if possible.  

 *

 * All array of setting items is held in CAknSettingItemArray, which in turn is owned by

 * CAknSettingItemList, a listbox type.

 * 

 */

 class CAknSettingItem : public CBase, public MAknSettingPageObserver

 	{

 friend class CAknSettingItemArray;

 public:

 	enum TFlags

 		{

 		EIsHidden = 0x1,

 		EHasIcon = 0x2,

 		EIsNumberedStyle = 0x4,

         ENoProtection = 0x8,

         EViewOnly = 0x10,

         EProtected = 0x20

         };

         // Setting item protection states

    enum TSettingItemProtection

         {

         ENoSettingItemProtection,

         ESettingItemViewOnly,

         ESettingItemProtected

         };

 public:

 	/**

 	* Constructor

 	*

 	* @param the unique identifier fo the setting item (not its number)

 	*/

 	IMPORT_C CAknSettingItem( TInt identifier );

 	/**

 	* Destructor

 	*/

 	IMPORT_C ~CAknSettingItem();

 	/**

 	* 

 	* 2nd-stage constuctor.  Resource for setting item is read externally in setting item list

 	* and the values are passed here.

 	*/

 	IMPORT_C void ConstructL( 

 		const TBool aIsNumberedStyle,

 		const TInt aOrdinal, 

 		const TDesC& aSettingTitle, 

 		CArrayPtr<CGulIcon>* aIconArray,

 		const TInt aSettingPageResource, 

 		const TInt aEditorControlType,

 		const TInt aSettingEditorResource = 0, 

 		const TInt aAssociatedResource = 0 );

 	/**

 	* This command externalizes the current setting.  The displayed (internal) copy

 	* is transferred to the external copy (the one referenced in the constructor).

 	*

 	* This must be called by the client if he wants this to happen.  Note that StoreAllL() 

 	* on the setting item list will call this for each setting item.

 	*/

 	IMPORT_C virtual void StoreL();

 	/*

 	* The external value is transferred to the internal value

 	* This occurs at construction, but may be called by client code when required.

 	*/

 	IMPORT_C virtual void LoadL(); 

 	/**

 	*

 	* This launches the setting page 

 	*

 	* @param		aCalledFromMenu - ignored in this class

 	*

 	*/

 	IMPORT_C virtual void EditItemL( TBool aCalledFromMenu );

 	/**

 	*

 	* This method is called by framework in order to update the text in the setting

 	* item. It may be called by the client.

 	*

 	*/

 	IMPORT_C virtual void UpdateListBoxTextL();

 	/**

 	* Access to the setting Name 

 	*.@return	the setting name

 	*/

 	IMPORT_C TPtrC SettingName();

 	/**

 	* Access to the setting number

 	* @return the setting number

 	*/

 	IMPORT_C TInt SettingNumber() const;

 	/**

 	* Access to the setting visibility

 	* @return ETrue if the setting item is hidden

 	*/

 	IMPORT_C TBool IsHidden() const;

 	/**

 	* Access to the numbering style of the setting item

 	* @return	ETrue if it is numbered

 	*/

 	IMPORT_C TBool IsNumberedStyle() const;

 	/**

 	* Set the visibility 

 	* @param		Set to ETrue to hide the item; EFalse to make it visible

 	*

 	*				Note that the setting item array must have be notified of this

 	*				by calling CAknSettingItemList::HandleChangeInItemArrayOrVisibility

 	*/

 	IMPORT_C void SetHidden(TBool aHidden );

 	/*

 	* This method obtains the current value's setting text

 	*

 	* @return	Reference to descriptor with the text 

 	*/

 	IMPORT_C virtual const TDesC& SettingTextL();

 	/**

 	* This gives access to the listbox text content at this item (fully decorated)

 	*

 	* @return	pointer to listboxtext. No allocation is performed and no change of ownership

 	*/

 	IMPORT_C HBufC* ListBoxText();

 	/**

 	* Access to the setting item's identifier. This is set in the setting item's constructor

 	* but usually comes via resource in the setting item list read of its resource structure

 	*

 	* @return The identifier of this setting item

 	*/

 	IMPORT_C TInt Identifier() const;

 	/**

 	* Checks if the setting item has a bitmap in its setting contents 

 	* @return	ETrue if it has a bitmap

 	*/

 	IMPORT_C TBool HasIcon() const;

 	/**

 	* This sets the text to display if the current setting is empty. 

 	*

 	* @param		text to make display when there is empty setting. A copy is made in the setting item

 	*/

 	IMPORT_C void SetEmptyItemTextL( const TDesC& aEmptyItemText );

 	IMPORT_C void SetCompulsoryIndTextL( const TDesC& aCompulsoryInd );

 	// From MAknSettingPageObserver

 	IMPORT_C virtual void HandleSettingPageEventL(CAknSettingPage* aSettingPage,TAknSettingPageEvent aEventType );

 	/**

 	* Get the index at which this item appears in the listbox

 	*

 	* @return index in listbox

 	*/

 	IMPORT_C TInt VisibleIndex();

 	/**

 	* Set the flags that are required for some of the setting page constructors

 	*

 	* @param aFlagPattern	Flag pattern to set

 	*/

 	IMPORT_C void SetSettingPageFlags( TInt aFlagPattern);

 	/**

 	* Access method for the setting page specific flags

 	* @return the flag pattern

 	*/

 	IMPORT_C TInt SettingPageFlags( ) const;

     /**

     * Set the parent lisbox into the setting item

     *

     * @since 2.0

     * @param aListBox   listbox with which the setting item is associated.

     */

     void SetParentListBox( const CEikFormattedCellListBox* aListBox );

     /**

     * Set the protection state of the setting item

     *

     * The protection state is for protecting selected settings from editing. 

     * The protection can be set to:

     *   - prohibit opening of the setting page

     *   - allow access to the setting page, but prohibit editing of it

     *

     * The protected item is indicated in the setting item list with a lock icon. 

     * If a user tries to open a protected setting item, a notification is shown 

     * to the user.

     *

     * The "view only" -mode is only possible for pop-up setting page.

     *

     * @since 3.1

     * @param aProtected Sets the protection state of the setting item

     */

     IMPORT_C void SetProtectionState( CAknSettingItem::TSettingItemProtection aProtected );

     /**

     * Get the protection state

     *

     * See SetProtected for details for the different states.

     *

     * @since 3.1

     * @return Protection state of the setting item

     */

     IMPORT_C CAknSettingItem::TSettingItemProtection ProtectionState();

 protected:

 	/**

 	* Method called by framework to complete the construction.  Extra allocations of

 	* memory or extra resource reading can happen here.

 	*

 	*/

 	IMPORT_C virtual void CompleteConstructionL();

 	/**

 	*

 	* Method to obtain a new bitmap for the setting content

 	*

 	* This method is usually empty in setting items classes except for volume and slider.

     * Any derived implementations of this method should call SetIconMask().

 	*

 	*/

 	IMPORT_C virtual CFbsBitmap* CreateBitmapL();

 // Utilities

 	/**

 	*

 	* A setting page should know when it is "Editing". This is set in EditItemL

 	* and cleared to 0 when the dialog is finished.

 	*

 	* @param		pointer to the currently executing settting page dialog

 	*

 	*/

 	IMPORT_C void SetSettingPage( CAknSettingPage* aSettingPage );

 	/*

 	* Access to the current setting page

 	*

 	* @return	pointer to the currently executing setting page. 0 if there is none

 	*/

 	IMPORT_C CAknSettingPage* SettingPage() const;

 	/**

 	* Performs standard setup on a setting page

 	*

 	*/

 	IMPORT_C void SetUpStandardSettingPageL();

 	/**

 	* Access to the empty text that has been set, or is default

 	*

 	* @return	ref to empty text descriptor

 	*/

 	IMPORT_C TDesC& EmptyItemText() const; // Assumed only needs to be used by SettingTextL

 	/**

 	* Access to the setting page resource id that might have been read by

 	* the setting item resource.

 	* 

 	* @return	0 or the setting page resource id

 	*/

 	IMPORT_C TInt SettingPageResourceId() const;

 	/**

 	* Access to the setting page editor's resource id that might have been read by

 	* the setting item resource.

 	* 

 	* @return	0 or the setting page editor's id

 	*/

 	IMPORT_C TInt SettingEditorResourceId() const;

 	/**

 	* Returns the associate editor resource.  This is an LLINK in the seting item 

 	* resource that subclasses can use in CompleteContstructionL

 	*

 	* @return	0 or the extra resource id

 	*/

 	IMPORT_C TInt AssociatedResourceId() const;

 	/**

 	* 

 	* @return the control type of the settin page editor

 	*

 	*/

 	TInt EditorControlType() const;

     /**

     * This sets the mask of this setting item's icon array, if it exists.

     * The normal usage of this routine is inside a re-implementation of CAknSettingItem::CreateBitmapL.

     * It is used to set the mask of the setting item's setting icon as a side effect of a 

     * framework call to CreateBitmapL

     *

     * The return value may need to be looked at to decide how to dispose of, for example, an

     * a CGulIcon that may be holding the mask.

     * 

     * @since 2.0

     * @param aMask  bitmap to set as a mask for the CGulIcon in the setting listbox's icon array

     * @return TBool ETrue if the ownership of aMask has been passed

     */

     IMPORT_C TBool SetIconMask( CFbsBitmap* aMask );

     /**

     * This sets the mask of this setting item's icon array, if it exists, using the mask from the

     * passed icon.

     * It returns the bitmap from the aIcon. 

     * The method also takes ownership of aIcon and may delete it (but not its bitmap).

     * 

     * @since 2.0

     * @param aIcon  icon of which the mask is passed through to SetIconMask() and bitmap is returned

     * @return CFbsBitmap* bitmap from aIcon. Ownership of the bitmap is transfered to the caller

     */

     CFbsBitmap* SetIconMaskAndReturnBitmap( CGulIcon* aIcon );

 private:

 	/**

 	* This routine causes any bitmaps that are extracted from setting pages to be updated

 	* according to the current (internal) setting value

 	*/

 	void UpdateBitmapL();

 	/**

 	* Set the index at which the item is to appear in the setting item list 

 	* Only needed by CAknSettingItemArray

 	*/

 	void SetVisibleIndex( TInt aVisibleIndex );

 	/**

 	* Set the ordinal value. This is used for dynamic changing of the ordinal by 

 	* CAknSettingItemArray

 	*

 	*/

 	void SetOrdinal( TInt aOrdinal );

 	/**

 	*

 	* Clean up a setting text for display by replacing all non printing characters 

 	* by spaces

 	*

 	*/

 	TPtrC ReplaceNonPrintingCharacters( TDes& aTextToClean );

 private:

 	IMPORT_C void CAknSettingItem_Reserved();

 private:

 	TUint iFlags;

 	TInt iIdentifier;

 	TInt iOrdinal;

 	TInt iSettingIdentifier;

 	TInt iSettingPageResourceId;

 	TInt iEditorControlType;

 	TInt iSettingEditorResourceId;

 	TInt iAssociatedResourceId;

 	TInt iIconIndex; // Only valid if relevant bit is set in iFlags

 	HBufC* iEmptyItemText; // Owned 

 	HBufC* iSettingName;  // Owned

 	HBufC* iListBoxText;  // Owned

 	HBufC* iCompulsoryText; // Owned

 	// Following are not owned

 	CAknSettingPage* iSettingPage; // This is a ref that is valid when non-0 - when the SP is "up"

 	CArrayPtr<CGulIcon>* iIconArray;	// Reference to the array only !

 	TInt iVisibleIndex;

 	// Set flags that are in the Setting pages' constructors 

 	TInt iSettingPageFlags;

     // Pointer to the listbox that the setting item is providing data to

     const CEikFormattedCellListBox* iParentListBox; // Not owned

 	CAknSettingItemExtension* iExtension;

 	};

 /**

 * Support for abstact text setting type. Corresponds to CAknTextSettingPage

 *

 */

 class CAknTextSettingItem : public CAknSettingItem

 {

 public:

 	/*

 	* Constructor 

 	*

 	* @param		resource identifier for this setting item

 	* @param		Setting text

 	*

 	*/

 	IMPORT_C CAknTextSettingItem( TInt aIdentifier, TDes& aText );

 	/**

 	* Destructor

 	*/ 

 	IMPORT_C ~CAknTextSettingItem();

 	/**

 	* This command externalizes the current setting. The displayed (internal) copy

 	* is transferred to the external copy (the one referenced in the constructor).

 	*

 	* This must be called by the client if he wants this to happen. Note that StoreAllL() 

 	* on the setting item list will call this for each setting item.

 	*/

 	IMPORT_C virtual void StoreL();

 	/*

 	* The external value is transferred to the internal value

 	* This occurs at construction, but may be called by client code when required.

 	*/

 	IMPORT_C virtual void LoadL(); // Called from 2nd stage constructors

 	/*

 	* This method obtains the current value's setting text.

 	* 

 	* The reference is returned and is not a copy of the text, but refers to the current

 	* internal text value. This is the value that would be externalized if StoreL were called. 

 	* An exception to this is if the current text is zero length. In that case a reference to the 

 	* empty text is returned (which would not be externalized if StoreL is called).

 	*

 	* @return	Reference to descriptor with the current internal text 

 	*/

 	IMPORT_C virtual const TDesC& SettingTextL();

 	/**

 	*

 	* This launches the setting page for text editing

 	*

 	* @param		aCalledFromMenu - ignored in this class

 	*

 	*/

 	IMPORT_C virtual void EditItemL( TBool aCalledFromMenu );

 protected:

 	/**

 	*  Access for re-implementors to the internal text 

 	*

 	* @return	reference to a TPtr holding the internal text

 	*/

 	IMPORT_C TPtr& InternalTextPtr();

 	/**

 	*  Access for re-implementors to the external text

 	*

 	* @return	TPtrC pointing to the external text

 	*/

 	IMPORT_C TPtrC ExternalText();

 	/**

 	* Allows re-implementors to set the external text

 	* No change of ownership is implied.

 	*

 	* @param	 a reference to the external text

 	*

 	*/

 	IMPORT_C void SetExternalText( TDesC& aNewExternalText );

 private:

 	IMPORT_C void CAknSettingItem_Reserved();

 private:

 	TDes& iExternalText;

 	HBufC* iInternalText;	// Owned

 	TPtr iInternalTextPtr;

 	TInt iSpare_Text_1;

 };

 /**

 *

 * Abstract setting item for integer editing. 

 * 

 * This class is not disposed toward any particular type of setting page

 *

 */

 class CAknIntegerSettingItem : public CAknSettingItem 

 	{

 	public:

 	/*

 	* Constructor 

 	*

 	* @param		resource identifier for this setting item

 	* @param		integer value to edit. 

 	*

 	*/

 	IMPORT_C CAknIntegerSettingItem( TInt aIdentifier, TInt& aValue );

 	IMPORT_C ~CAknIntegerSettingItem();

 	/**

 	* This command externalizes the current setting. The displayed (internal) copy

 	* is transferred to the external copy (the one referenced in the constructor).

 	*

 	* This must be called by the client if he wants this to happen. Note that StoreAllL() 

 	* on the setting item list will call this for each setting item.

 	*/

 	IMPORT_C virtual void StoreL();

 	/*

 	* The external value is transferred to the internal value

 	* This occurs at construction, but may be called by client code when required.

 	*/

 	IMPORT_C virtual void LoadL();

 	/*

 	* This method obtains the current value's setting text

 	*

 	* @return	Reference to descriptor with the text 

 	*/

 	IMPORT_C virtual const TDesC& SettingTextL();

 	/**

 	*

 	* Pure virtual editItemL

 	*

 	* @param		aCalledFromMenu - ignored in this class

 	*

 	*/

 	virtual void EditItemL( TBool aCalledFromMenu ) = 0;

 	protected:

 	/**

 	* Method called by framework to complete the construction. Extra allocations of

 	* memory or extra resource reading can happen here.

 	*

 	*/

 	IMPORT_C virtual void CompleteConstructionL();

 	/**

 	* Method to access the internal value. 

 	*

 	* @return	 a reference to the internal integer value

 	*/

 	IMPORT_C TInt& InternalValueRef();

 	/**

 	* Method to access the external reference to the external value. Note that this class

 	* only accesses the external integer via a copy of a reference to it.

 	*

 	* @return	 a reference to the external integer value

 	*/

 	IMPORT_C TInt& ExternalValueRef();

 	/**

 	* Sets the external value's reference.  The external vlue is externally owned, so

 	* this does not make a copy.

 	* @param	TInt& aValue	a reference to the external value	

 	*/

 	IMPORT_C void SetExternalValue( TInt& aValue );

 private:

 	IMPORT_C void CAknSettingItem_Reserved();

 	private:

 	TInt iInternalValue;

 	TInt& iExternalValue;

 	HBufC* iInternalText;	// Owned

 	TPtr iInternalTextPtr;

 	};

 class CAknIntegerEdwinSettingItem : public CAknIntegerSettingItem 

 	{

 	public:

 	IMPORT_C CAknIntegerEdwinSettingItem( TInt aIdentifier, TInt& aValue );

 	/**

 	*

 	* This launches the setting page for editing using the integer edwin class

 	*

 	* @param		aCalledFromMenu - ignored in this class

 	*

 	*/

 	IMPORT_C virtual void EditItemL( TBool aCalledFromMenu );

 private:

 	IMPORT_C void CAknSettingItem_Reserved();

 	};

 /**

 *

 * Class for holding a password setting item

 *

 */

 class CAknPasswordSettingItem : public CAknTextSettingItem

 {

 public:

 	enum TAknPasswordSettingItemMode

 		{

 		EAlpha,		// password held is alphanumeric

 		ENumeric	// password is numeric ( digits 0 - 9 only used )

 		};

 	/*

 	* Constructor 

 	*

 	* @param		resource identifier for this setting item

 	* @param		password mode; text or numeric

 	* @param		password to change

 	*/

 	IMPORT_C CAknPasswordSettingItem( TInt aIdentifier, enum TAknPasswordSettingItemMode aMode, TDes& aPassword );

 	/*

 	* This method obtains the current value's setting text

 	*

 	* @return	Reference to descriptor with the text 

 	*/

 	IMPORT_C virtual const TDesC& SettingTextL();

 	/**

 	*

 	* This launches the setting page for password editing

 	*

 	* @param		aCalledFromMenu - ignored in this class

 	*

 	*/

 	IMPORT_C virtual void EditItemL( TBool aCalledFromMenu );

 protected:

 	/**

 	* Method called by framework to complete the construction.  Extra allocations of

 	* memory or extra resource reading can happen here.

 	*

 	*/

 	IMPORT_C virtual void CompleteConstructionL();

 private:

 	IMPORT_C void CAknSettingItem_Reserved();

 private:

 	TAknPasswordSettingItemMode iPasswordMode;

 	// For holding the text to blank the setting item text

 	TBuf<KMaxPasswordBlankingTextLength> iBlankingText;

 	// For holding the resouce for a password query

 	TInt iOldPasswordQueryResourceId;

 };

 /**

 * An abstract integer setting that uses the volume control as its editor

 *

 */

 class CAknVolumeSettingItem : public CAknSettingItem

 	{

 public:

 	/*

 	* Constructor 

 	*

 	* @param		resource identifier for this setting item

 	* @param		volume value. Must be in range 0 to 10, inclusive

 	*

 	*/

 	IMPORT_C CAknVolumeSettingItem( TInt aIdentifier, TInt& aExternalVolume );

 	/**

 	* This command externalizes the current setting. The displayed (internal) copy

 	* is transferred to the external copy (the one referenced in the constructor).

 	*

 	* This must be called by the client if he wants this to happen. Note that StoreAllL() 

 	* on the setting item list will call this for each setting item.

 	*/

 	IMPORT_C virtual void StoreL();

 	/*

 	* The external value is transferred to the internal value

 	* This occurs at construction, but may be called by client code when required.

 	*/

 	IMPORT_C virtual void LoadL();

 	/*

 	* This method obtains the current value's setting text

 	*

 	* @return	Reference to descriptor with the text 

 	*/

 	IMPORT_C virtual const TDesC& SettingTextL();

 	/**

 	*

 	* This launches the setting page for volume editing

 	*

 	* @param		aCalledFromMenu - ignored in this class

 	*

 	*/

 	IMPORT_C virtual void EditItemL( TBool aCalledFromMenu );

 protected:

 	/**

 	* Protected access to the volume value

 	*

 	* @return	Reference to the internal volume value

 	*/

 	IMPORT_C TInt& InternalVolumeValue(); // For access to internal value for derived classes

 	//From CAknSettingItem

 	/**

 	*

 	* Obtain a bitmap from the CAknVolume

 	*

 	*/

 	IMPORT_C virtual CFbsBitmap* CreateBitmapL();

 private:

 	IMPORT_C void CAknSettingItem_Reserved();

 private:

 	TInt& iExternalVolume;

 	TInt iInternalVolume;

 	};

 /**

 * Slider control setting item

 *

 *

 */

 class CAknSliderSettingItem : public CAknSettingItem

 	{

 public:

 	/*

 	* Constructor 

 	*

 	* @param		resource identifier for this setting item

 	* @param		Slider value; must be within the minimum and maximum values in resource

 	*

 	*/

 	IMPORT_C CAknSliderSettingItem( TInt aIdentifier, TInt& aExternalSliderValue );

 	/**

 	* This command externalizes the current setting. The displayed (internal) copy

 	* is transferred to the external copy (the one referenced in the constructor).

 	*

 	* This must be called by the client if he wants this to happen. Note that StoreAllL() 

 	* on the setting item list will call this for each setting item.

 	*/

 	IMPORT_C virtual void StoreL();

 	/*

 	* The external value is transferred to the internal value

 	* This occurs at construction, but may be called by client code when required.

 	*/

 	IMPORT_C virtual void LoadL(); 

 	/*

 	* This method obtains the current value's setting text

 	*

 	* @return	Reference to descriptor with the text 

 	*/

 	IMPORT_C virtual const TDesC& SettingTextL();

 	/**

 	*

 	* This launches the setting page for slider editing

 	*

 	* @param		aCalledFromMenu - ignored in this class

 	*

 	*/

 	IMPORT_C virtual void EditItemL( TBool aCalledFromMenu );

 protected:

 	/**

 	* Method to create a setting page 

 	*/

 	IMPORT_C virtual CAknSettingPage* CreateSettingPageL();

 	/**

 	* Method to contruct the setting page (via CreateSettingPageL), and execute it

 	*/

 	IMPORT_C virtual void CreateAndExecuteSettingPageL();

 	/**

 	* For access to internal value for derived classes

 	*

 	* @return	A ref to the internal value

 	*/

 	IMPORT_C TInt& InternalSliderValue();

 	// From CAknSettingItem

 	/**

 	*

 	* Obtain a bitmap from the CAknSlider

 	*

 	*/

 	IMPORT_C virtual CFbsBitmap* CreateBitmapL();

 private:

 	IMPORT_C void CAknSettingItem_Reserved();

 private:

 	TInt& iExternalSliderValue;

 	TInt iInternalSliderValue; // required for use in derived classes

 	};

 /**

 *

 * Time or Date Setting Item

 *

 * This class combines the time and the date functionality, as determined by a mode

 * passed to the constructor.

 *

 * Time or Date setting pages are launched from here, which use Time or date editor 

 * MFNEs to do the editing.

 *

 */

 class CAknTimeOrDateSettingItem : public CAknSettingItem

 	{

 public:

 	enum TAknTimeOrDateSettingItemMode

 		{

 		ETime,

 		EDate

 		};

 	/*

 	* Constructor 

 	*

 	* @param		resource identifier for this setting item

 	* @param		construct a Time or a Date setting item

 	* @param		IP address to be controlled by the setting editing

 	*

 	*/

 	IMPORT_C CAknTimeOrDateSettingItem( TInt aIdentifier, enum TAknTimeOrDateSettingItemMode aMode, TTime& aTime );

 	/**

 	* Destructor

 	*/

 	IMPORT_C ~CAknTimeOrDateSettingItem();

 	/**

 	* Method called by framework to complete the construction.  Extra allocations of

 	* memory or extra resource reading can happen here.

 	*

 	*/

 	IMPORT_C void CompleteConstructionL( );

 	/**

 	* This command externalizes the current setting.  The displayed (internal) copy

 	* is transferred to the external copy (the one referenced in the constructor).

 	*

 	* This must be called by the client if he wants this to happen.  Note that StoreAllL() 

 	* on the setting item list will call this for each setting item.

 	*/

 	IMPORT_C virtual void StoreL();

 	/*

 	* The external value is transferred to the internal value

 	* This occurs at construction, but may be called by client code when required.

 	*/

 	IMPORT_C virtual void LoadL(); 

 	/*

 	* This method obtains the current value's setting text

 	*

 	* @return	Reference to descriptor with the text 

 	*/

 	IMPORT_C virtual const TDesC& SettingTextL();

 	/**

 	*

 	* This launches the setting page for Time or Date editing

 	*

 	* @param		aCalledFromMenu - ignored in this class

 	*

 	*/

 	IMPORT_C virtual void EditItemL( TBool aCalledFromMenu );

 	/**

 	*

 	* Set the time or date format string.  If this is not called, then a 

 	* localized, default string is used

 	*

 	*/

 	IMPORT_C void SetTimeFormatStringL( const TDesC& aTimeFormat );

 	/**

 	*

 	* Obtain the time format string

 	*

 	* @return	A pointer descriptor to the date/time format string

 	*/

 	IMPORT_C const TPtrC TimeFormatString();

 private:

 	IMPORT_C void CAknSettingItem_Reserved();

 private:

 	TTime& iExternalTime;

 	TTime iInternalTime;

 	HBufC* iInternalText; // Owned

 	TPtr iInternalTextPtr;

 	HBufC* iTimeFormat;

 	TPtr iTimeFormatPtr;

 	TAknTimeOrDateSettingItemMode iTimeOrDateMode;

 	};

 /**

 *

 * Time Offset Setting Item

 *

 * Time Offset page as launched from here, which use Offset editor 

 * MFNEs to do the editing.

 *

 *  @lib avkon

 *  @since 2.0

 */

 class CAknTimeOffsetSettingItem : public CAknSettingItem

 	{

 public:

 	/*

 	* Constructor 

 	*

 	* @param		resource identifier for this setting item

 	* @param		construct a Time offset setting item

 	*

 	*/

 	IMPORT_C CAknTimeOffsetSettingItem( TInt aIdentifier, TTimeIntervalSeconds& aTime );

 	/**

 	* Destructor

 	*/

 	IMPORT_C ~CAknTimeOffsetSettingItem();

 	/**

 	* Method called by framework to complete the construction.  Extra allocations of

 	* memory or extra resource reading can happen here.

 	*

     * @since 2.0

 	*/

 	IMPORT_C void CompleteConstructionL( );

 	/**

 	* This command externalizes the current setting.  The displayed (internal) copy

 	* is transferred to the external copy (the one referenced in the constructor).

 	*

 	* This must be called by the client if he wants this to happen.  Note that StoreAllL() 

 	* on the setting item list will call this for each setting item.

     *

     * @since 2.0

 	*/

 	IMPORT_C virtual void StoreL();

 	/*

 	* The external value is transferred to the internal value

 	* This occurs at construction, but may be called by client code when required.

     *

     * @since 2.0

 	*/

 	IMPORT_C virtual void LoadL(); 

 	/*

 	* This method obtains the current value's setting text

 	*

     * @since 2.0

 	* @return	Reference to descriptor with the text 

 	*/

 	IMPORT_C virtual const TDesC& SettingTextL();

 	/**

 	*

 	* This launches the setting page for Time or Date editing

 	*

     * @since 2.0

 	* @param		aCalledFromMenu - ignored in this class

 	*

 	*/

 	IMPORT_C virtual void EditItemL( TBool aCalledFromMenu );

 	/**

 	*

 	* Set the time or date format string. If this is not called, then a 

 	* localized, default string is used

 	*

     * @since 2.0

 	*/

 	IMPORT_C void SetTimeFormatStringL( const TDesC& aTimeFormat );

 	/**

 	*

 	* Obtain the time format string

 	*

     * @since 2.0

 	* @return	A pointer descriptor to the date/time format string

 	*/

 	IMPORT_C const TPtrC TimeFormatString();

 private:

 	IMPORT_C void CAknSettingItem_Reserved();

 private:

 	TTimeIntervalSeconds iExternalTime;

 	TTimeIntervalSeconds iInternalTime;

 	HBufC* iInternalText; // Owned

 	TPtr iInternalTextPtr;

 	HBufC* iTimeFormat;

 	TPtr iTimeFormatPtr;

 	TInt iSpare;

 	};

 /**

 *

 * IP Address setting item

 *

 * Abstract data type for IP address setting. Launches a CAknIpFieldSettingPage 

 * that in turn uses the CAknIpFieldEditor

 *

 */

 class CAknIpFieldSettingItem : public CAknSettingItem

 	{

 public:

 	/*

 	* Constructor 

 	*

 	* @param		resource identifier for this setting item

 	* @param		IP address to be controlled by the setting editing

 	*

 	*/

 	IMPORT_C CAknIpFieldSettingItem( TInt aIdentifier, TInetAddr& aIpAddress );

 	/**

 	*

 	* Destructor

 	*

 	*/

 	IMPORT_C ~CAknIpFieldSettingItem();

 	/**

 	* Method called by framework to complete the construction. Extra allocations of

 	* memory or extra resource reading can happen here.

 	*

 	*/

 	IMPORT_C void CompleteConstructionL( );

 	/**

 	* This command externalizes the current setting. The displayed (internal) copy

 	* is transferred to the external copy (the one referenced in the constructor).

 	*

 	* This must be called by the client if he wants this to happen. Note that StoreAllL() 

 	* on the setting item list will call this for each setting item.

 	*/

 	IMPORT_C virtual void StoreL();

 	/*

 	* The external value is transferred to the internal value

 	* This occurs at construction, but may be called by client code when required.

 	*

 	*/

 	IMPORT_C virtual void LoadL(); // Called from 2nd stage constructors

 	/*

 	* This method obtains the current value's setting text

 	*

 	* @return	Reference to descriptor with the text 

 	*/

 	IMPORT_C virtual const TDesC& SettingTextL();

 	/**

 	*

 	* This launches the setting page for IP address editing

 	*

 	* @param		aCalledFromMenu - ignored in this class

 	*

 	*/

 	IMPORT_C virtual void EditItemL( TBool aCalledFromMenu );

 private:

 	IMPORT_C void CAknSettingItem_Reserved();

 private:

 	TInetAddr& iExternalIpAddress;

 	TInetAddr iInternalIpAddress;

 	HBufC* iInternalText; // Owned

 	TPtr iInternalTextPtr;

 	};

 /**

 * Base class for a data object to hold a pointer and a corresponding integer value.

 * This is used to make a template class by CAknEnumeratedItem

 *

 */

 class CAknEnumeratedItemBase : public CBase

 	{

 public:

 	/**

 	* Construct an item consisting of an integer value and its co-ordinate pointer

 	*/

 	IMPORT_C CAknEnumeratedItemBase( TInt aEnumeratedValue, TAny* aValue );

 	/**

 	* Destructor

 	*/

 	IMPORT_C ~CAknEnumeratedItemBase();

 	/** 

 	* Access the integer value

 	*

 	* @return the integer value of this item

 	*/

 	IMPORT_C TInt EnumerationValue() const;

 	/**

 	* Set the integer part of the object

 	*

 	* @param aNewValue	Value to set

 	*/

 	IMPORT_C void SetEnumerationValue( TInt aNewValue );

 	/**

 	* Access the pointer part of the object

 	*

 	* @return TAny* pointer to any type

 	*/

 	IMPORT_C TAny* Value() const;

 	/**

 	* Set the pointer part of the object

 	*

 	* @param	pointer to store in the object; no copy model, no ownership transfer

 	*/

 	IMPORT_C void SetValue( TAny* aPtr );

 private:

 	TInt iEnumerationValue;

 	TAny* iValue;

 	};

 /**

 * Makes a template class from CAknEnumeratedItemBase

 *

 */

 template <class T>

 class CAknEnumeratedItem : public CAknEnumeratedItemBase

 	{

 public:

 	inline CAknEnumeratedItem( TInt aEnumeratedValue, T* aValue );

 	inline ~CAknEnumeratedItem();

 	inline T* Value();

 	inline void SetValue( T* );

 	};

 template <class T>

 inline CAknEnumeratedItem<T>::CAknEnumeratedItem( TInt aEnumValue, T* aValue ) : 

 	CAknEnumeratedItemBase( aEnumValue, (TAny*)aValue)

 	{

 	}

 template <class T>

 inline CAknEnumeratedItem<T>::~CAknEnumeratedItem()

 	{

 	delete (T*)Value();

 	}

 template <class T>

 inline T* CAknEnumeratedItem<T>::Value()

 	{

 	return ( ( T* ) CAknEnumeratedItemBase::Value() );

 	}

 template <class T>

 inline void CAknEnumeratedItem<T>::SetValue( T* aNewValue )

 	{

 	CAknEnumeratedItemBase::SetValue( aNewValue );

 	}

 /**

 * Definition of CAknEnumeratedText

 */

 typedef CAknEnumeratedItem<HBufC> CAknEnumeratedText;

 /**

 * CAknEnumeratedTextSettingItem

 * 

 * Abstract Base class for deriving listbox setting page related setting items

 * 

 * The class provides standard array support for these setting items and their

 * listboxes. Then approach is centred upon the CAknEnumeratedText type. 

 *

 * The texts are exposed to the user, and appear in two versions, if desired - the text shown

 * in the setting list when not being edited, and the "popped-up" version of the texts.

 * 

 */

 class CAknEnumeratedTextSettingItem : public CAknSettingItem

 	{

 public:

 	/**

 	* Constructor.  Resource Id for the setting item

 	*

 	*/

 	IMPORT_C CAknEnumeratedTextSettingItem( TInt aResourceId );

 	/**

 	* Destructor

 	*/

 	IMPORT_C ~CAknEnumeratedTextSettingItem();

 //

 // From CAknSettingItem

 //

 protected:

 	/**

 	*

 	* Virtual method called by framework to complete the construction.  

 	* In this class, the two arrays, pointers to which can be obtained by calling 

 	* EnumeratedTextArray() and PoppedUpTextArray() are created.

 	*

 	*/

 	IMPORT_C void CompleteConstructionL();

 private:

 	IMPORT_C void CAknSettingItem_Reserved();

 public:

 	/**

 	* Access to the enumerated text array. Texts here are used in the setting item list

 	* display.

 	* No ownership of the array or its contents is transferred

 	*

 	* @return a pointer to an array of HBufC*s

 	*/

 	IMPORT_C CArrayPtr<CAknEnumeratedText>* EnumeratedTextArray() const;

 	/**

 	* Access to the "popped up" array of texts. They may be defined differently from 

 	* those in the enumerated text array so that the setting page items can be different

 	* from those displayed in the setting item editing list

 	* No ownership of the array or its contents is transferred

 	*

 	* @return a pointer to an array of HBufC*s

 	*/

 	IMPORT_C CArrayPtr<HBufC>* PoppedUpTextArray() const;

 	/**

 	* Set the enumerated arrays. 

 	* Ownership of these arrays and their contents is wholly given over to the setting item 

 	* object. The client must call HandleTextArrayUpdateL() after making this call.

 	* 

 	* After calling SetEnumeratedTextArrays(), it is the client code's responsibility to ensure that 

 	* the current value of the external Tint value corresponds to one of the enumerated texts. This can

 	* be done, for instance, after calling SetEnumeratedTextArrays() by calling IndexFromValue() and

 	* ensuring a return value of a valid index (not -1 ). Otherwise, there will be a panic in 

 	* HandleTextArrayUpdateL() when it is called.

 	* 

 	* This call transfers the ownership of the arrays, and the items pointed to by the arrays

 	* 

 	* @param	aEnumeratedTextArray	array of Integer-Text pairs to be the new basis for display

 	*			This is the master array, and its Count() determines the number of entries to display

 	* @param	aPoppedUpTextArray		array of Text descriptors that provide versions of the text

 	*			to display in the setting page listbox. The array pointer must be valid, but the 

 	*			array need not contain any entries. Only those entries that need to be different

 	*			from those in aEnumeratedTextArray needs be present; 

 	*/

 	IMPORT_C void SetEnumeratedTextArrays( CArrayPtr<CAknEnumeratedText>* aEnumeratedTextArray,

 													CArrayPtr<HBufC>* PoppedUpTextArray );

 	/**

 	* Called to execute any code that might need to run when the text arrays are replaced.

 	* This class has a null implementation

 	*

 	*/

 	IMPORT_C virtual void HandleTextArrayUpdateL();

 	/** 

 	* Access to the number of items in the arrays

 	*

 	* @return	The number of items in the array returned by EnumeratedTextArray()

 	*/

 	IMPORT_C TInt NumberOfItems() const;

 	/**

 	* Routine to find the index in the enumerated text list that corresponds to the value

 	* passed in. 

 	*

 	* @param	aInputValue		value to search for in the enumerated items

 	* @return	0 - based index in the item found. -1 if not found.

 	*

 	*/

 	IMPORT_C TInt IndexFromValue( TInt aInputValue ) const;

 protected:

 	/**

 	* Implementors of subclasses can call this non-virtual method to set up the list of texts

 	* to be used for the setting page. (Although it is not useful for CAknCheckBoxSettingPage)

 	* The list is constructed from the contents of the two 

 	* text arrays, EnumeratedTextArray() and PoppedUpTextArray(). This is usually to be done 

 	* "On the fly" immediately prior to the raising of a setting page. 

 	*/

 	IMPORT_C void SetSettingPageTextL();

 	/** 

 	* Accessor for the setting page text array

 	*/

 	IMPORT_C CDesCArray* SettingPageTextArray() const;

 private:

 	/**

 	* The primary text arrays (those set by SetEnumeratedTextArrays) are deleted and their 

 	* references zeroed.

 	*/

 	void DeleteAndZeroPrimaryArrays();

 private:

 	TInt iTextPopupFlags;

 	CArrayPtr<CAknEnumeratedText>* iEnumeratedTextArray; // Owned and pointed to objects are owned

 	CArrayPtr<HBufC>* iPoppedUpTextArray; // Owned and the HBufCs are owned here

 	TInt iEnumeratedTextArrayResourceId;

 	TInt iPoppedUpTextArrayResourceId;

 	CDesCArrayFlat* iSettingPageText; // Owned

 	HBufC* iSpare; // Formerly space was used by iEmptyText;

 	};

 /**

 * Setting item type for CAknEnumeratedItems. 

 * 

 * The main use case for this is for list of texts that are being manipulated in the 

 * client source code as a set of enumerations, while the texts, read from resource, 

 * are not strongly exposed to the client.

 *

 * They are exposed to the user, and appear in two versions, if desired - the text shown

 * in the setting list when not being edited, and the "popped-up" version of the texts.

 *

 */

 class CAknEnumeratedTextPopupSettingItem : public CAknEnumeratedTextSettingItem

 	{

 public:

 	/**

 	* Construct a list, storing in it a resource (to be read at 2nd stage construction)

 	* and a reference to na externally owned integer - the value to be manipulated

 	*

 	*/

 	IMPORT_C CAknEnumeratedTextPopupSettingItem( TInt aResourceId, TInt& aValue );

 	/**

 	* Destructor

 	*/

 	IMPORT_C ~CAknEnumeratedTextPopupSettingItem();

 	/**

 	* This command externalizes the current setting.  The displayed (internal) copy

 	* is transferred to the external copy (the one referenced in the constructor).

 	*

 	* This must be called by the client if he wants this to happen. Note that StoreAllL() 

 	* on the setting item list will call this for each setting item.

 	*/

 	IMPORT_C virtual void StoreL();

 	/*

 	* The external value is transferred to the internal value

 	* This occurs at construction, but may be called by client code when required.

 	*/

 	IMPORT_C virtual void LoadL(); 

 	/*

 	* This method obtains the current value's setting text

 	*

 	* @return	Reference to descriptor with the text 

 	*/

 	IMPORT_C virtual const TDesC& SettingTextL();

 	/**

 	*

 	* This launches the setting page for popup list setting page 

 	*

 	* @param		aCalledFromMenu - ignored in this class

 	*

 	*/

 	IMPORT_C virtual void EditItemL( TBool aCalledFromMenu );

 public:

 	/**

 	* Access to the enumerated text array. Texts here are used in the setting item list

 	* display.

 	*

 	* @return a pointer to an array of HBufC*s

 	*/

 	IMPORT_C CArrayPtr<CAknEnumeratedText>* EnumeratedTextArray() const;

 	/**

 	* Access to the "popped up" array of texts. They may be defined differently from 

 	* those in the enumerated text arry

 	*

 	* @return a pointer to an array of HBufC*s

 	*/

 	IMPORT_C CArrayPtr<HBufC>* PoppedUpTextArray() const;

 protected:

 	/**

 	* Framework method for constructing the launching setting page

 	* @return	a constructed CAknSettingPage object on the heap

 	*/

 	IMPORT_C virtual CAknSettingPage* CreateSettingPageL();

 	/**

 	* Framework method to create and execute setting page

 	*/

 	IMPORT_C virtual void CreateAndExecuteSettingPageL();

 	/**

 	* Method called by framework to complete the construction. Extra allocations of

 	* memory or extra resource reading can happen here.

 	*

 	*/

 	IMPORT_C virtual void CompleteConstructionL();

 	/**

 	* Sets the value of the (unowned) external value using the reference to it held 

 	* internally. 

 	* Note that this does not change the value of the reference itself.  

 	* That is, aNewValue's address is not copied in to be used as the external reference.

 	* @param	aNewValue	Value to be copied via the external reference.  

 	*/

 	IMPORT_C void SetExternalValue( TInt aNewValue );

 	/** 

 	* Sets the internal value. The value of aNewValue is copied into the internal storage

 	* holding the internal value

 	* @param aNewValue

 	*/ 

 	IMPORT_C void SetInternalValue( TInt aNewValue );

 	/**

 	* Set the item that is selected in the associated popup. This should be done so

 	* as to keep the selected index consistent with the internal value

 	*

 	* @param aNewIndex

 	*/

 	IMPORT_C void SetSelectedIndex( TInt aNewIndex );

 	/**

 	* Returns the index in the enumerated item array, given the value of the enumeration 

 	*

 	* @param aInputValue	Value to look up; Returns -1 if value is not found

 	*/

 	IMPORT_C TInt IndexFromValue( TInt aInputValue ) const ;

 	/**

 	* Get the external value 

 	* @return	TInt

 	*/

 	IMPORT_C TInt ExternalValue() const;

 	/**

 	* Access the internal value

 	* @return	TInt

 	*/

 	IMPORT_C TInt InternalValue() const;

 	/**

 	* Return a reference to the MAknQueryValue that is constructed for the CAknPopupListSettingPage

 	* @return MAknQueryValue

 	*/

 	IMPORT_C MAknQueryValue* QueryValue() const;

 private:

 	IMPORT_C void CAknSettingItem_Reserved();

 private:

 	void SetSettingPageTextL();

 	void CreateTextArrayL();

 	void CreateQueryValueL();

 	void UpdateInternalValuesL();

 	/**

 	*

 	* This routine looks at the current enumeration values and returns the next integer

 	* higher than the highest enumeration. For internal use only, although it is possible

 	* that clients or derivers might want to use somthing like it.

 	*

 	* @return a new unique value that can be used for extending the enumeration

 	*/

 	TInt FindNextEnumerationValue() const;

 private:

 	TInt& iExternalValue;

 	TInt iInternalValue;

 	TInt iNumberOfItems;

 	TInt iSelectedIndex;

 	CAknQueryValueText* iQueryValue;

 	CAknQueryValueTextArray* iQueryTextArray; 

 	TInt iSpare_EnumeratedTextPopup_1;

 	};

 class CAknBinaryPopupSettingItem : public CAknEnumeratedTextPopupSettingItem

 	{

 public:

 	/**

 	* Constructs a binary setting value, given a resource id and a reference to

 	* an externally owned external boolen setting item.

 	* Resource supplied is just as for CAknEnumeratedTextPopupSettingItem

 	*

 	* @param aIdentifier	Resource id for the associated values and texts; 

 	*

 	*/

 	IMPORT_C CAknBinaryPopupSettingItem( TInt aIdentifier, TBool& aBinaryValue );

 	/**

 	* This command externalizes the current setting. The displayed (internal) copy

 	* is transferred to the external copy (the one referenced in the constructor).

 	*

 	* This must be called by the client if he wants this to happen.  Note that StoreAllL() 

 	* on the setting item list will call this for each setting item.

 	*/

 	IMPORT_C virtual void StoreL();

 	/*

 	* The external value is transferred to the internal value

 	* This occurs at construction, but may be called by client code when required.

 	*/

 	IMPORT_C virtual void LoadL(); 

 	/**

 	*

 	* This launches the setting page (or just toggles) the binary setting

 	*

 	* @param		aCalledFromMenu - This flag determines if the setting page actually

 	*				launches or not. It does not if this flag is EFalse - the value is just toggled

 	*

 	*/

 	IMPORT_C virtual void EditItemL( TBool aCalledFromMenu );

 protected:

 	/**

 	* Method called by framework to complete the construction. Extra allocations of

 	* memory or extra resource reading can happen here.

 	*

 	*/

 	IMPORT_C virtual void CompleteConstructionL();

 private:

 	IMPORT_C void CAknSettingItem_Reserved();

 private:

 	TAny* iUnused;

 	};

 /**

  * This class can be used as a base class for "Big Settings". The additional 

  * functionality is small - merely to ensure that there is an empty string

  * in the list box text.

  * 

  * To derive from this class, the client code is usually expected to add a new constructor,

  * re-implement StoreL, LoadL() and EditItemL().

  *

  */

 class CAknBigSettingItemBase : public CAknSettingItem

 	{

 public:

 	/**

 	* Contruct the "Big" setting item. The passed resource identifier all that is needed

 	* There is no external value to reference.

 	*/

 	IMPORT_C CAknBigSettingItemBase( TInt aIdentifier );

 protected: 

 	/*

 	* This method obtains the current value's setting text

 	*

 	* @return	Reference to descriptor with the text 

 	*/

 	IMPORT_C virtual const TDesC& SettingTextL();

 private:

 	IMPORT_C void CAknSettingItem_Reserved();

 private:

 	const TDesC& iEmptyString;

 	};

 /**

  * This class holds the setting items themselves and also manages the bitmap array

  */

 class CAknSettingItemArray : public CArrayPtrFlat<CAknSettingItem>, public MDesCArray

 	{

 public:

 	/**

 	* CAknSettingItemArray is constructed as a numbered or unnumbered array.

 	* @param aGranularity	- number of items to extend when the aarray needs extention

 	* @param aIsNumbered	- flags the array as numbered or not

 	* @param aInitialOrdinal - value to start the numbering at

 	*/

 	IMPORT_C CAknSettingItemArray( TInt aGranularity, TBool aIsNumbered, TInt aInitialOrdinal );

 	/**

 	* Destructor

 	*/

 	IMPORT_C virtual ~CAknSettingItemArray();

 	// from MDesC16Array

 	/**

 	* Method by which the CAknSetStyleListBox accesses the number of items in the array

 	* @return	number of items in the array

 	*/ 

 	IMPORT_C TInt MdcaCount() const;

 	/**

 	* Method by which the setting item list accesses the text for the aIndex-th item in the 

 	* array.

 	*

 	* @param	aIndex	index at which to access the listbox text

 	* @return	Descriptor for this item to be used by the listbox.

 	*/

 	IMPORT_C TPtrC16 MdcaPoint(TInt aIndex) const;

 	// For hidden item support

 	/**

 	* This method returns the true index in the array given the index as would be 

 	* calculated by looking at the visible items. 

 	*

 	* @param aVisibleIndex	- index among the visible items

 	* @return the corresponding "true" index in the array

 	*/

 	IMPORT_C TInt ItemIndexFromVisibleIndex( TInt aVisibleIndex ) const;

 	/**

 	* Update date the mapping of visible indices. To be called when an item is made

 	* visible or invisible.

 	* 

 	*/

 	IMPORT_C virtual void RecalculateVisibleIndicesL();

 	/**

 	* This is used to update the initial setting number for the top index.  The number set 

 	* is the for the 0-th "true" or data index. That is, this numbered item may not show up

 	*

 	*/

 	IMPORT_C void SetInitialOrdinal( TInt aInitialOrdinal );

 	/*

 	* Method used to transfer flags from the CAknSettingItemList to this array

 	*/

 	IMPORT_C void SetFlags( TInt aFlags );

 protected:

 	/** 

 	* Set the number of visible items. 

 	* @param aCount	number of items that are visible.

 	*/

 	IMPORT_C void SetVisibleCount( TInt aCount );

 	/**

 	* Returns the number of visible items

 	*

 	* @return the number of visible items

 	*/

 	IMPORT_C TInt VisibleCount() const;

 private:

 	TBool iIsNumbered;

 	TInt iInitialOrdinal;

 	TInt iVisibleCount;

 	TInt iFlags;

 	};

 class CAknSettingItemList : public CAknControl , public MEikListBoxObserver

     {

 public:

 	enum TAknSettingItemStyle

 	{

 	ENumberedStyle,		// The setting item list displays number

 	EUnnumberedStyle	// The setting item list does not disply number

 	};

 public:

 	/**

 	* Constructs the setting item list

 	*/

 	IMPORT_C CAknSettingItemList();

 	/**

 	* Destructor

 	*/

 	IMPORT_C ~CAknSettingItemList();

 	// From CCoeControl

 	/**

 	* 2nd-stage construction from resource id

 	*/

 	IMPORT_C void ConstructFromResourceL(TInt aResourceId );

 	/**

 	* 2nd-stage construction from constructed resource reader

 	*/

 	IMPORT_C void ConstructFromResourceL( TResourceReader& aReader );

 	/**

 	* @return the number of component controls

 	*/ 

 	IMPORT_C TInt CountComponentControls() const;

 	/**

 	* @param TInt aId

 	* @return  a reference to the component control at index aId

 	*/

 	IMPORT_C CCoeControl* ComponentControl(TInt aId ) const;

 	/**

 	* Handles keys sent to this control

 	*/

 	IMPORT_C virtual TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType);

 	/**

 	* Take action necessary when the focus is change

 	*/

 	IMPORT_C virtual void FocusChanged(TDrawNow aDrawNow);

     /**

     * Handles a change to the control's resources of type aType

     * which are shared across the environment, e.g. colors or fonts.

     *

     * @since 2.0

     * @param aType  Reason for the "resource" change, usually an system event UID

     */

 	IMPORT_C void HandleResourceChange(TInt aType);

 // from MEikListBoxObserver

 	IMPORT_C virtual void HandleListBoxEventL(CEikListBox* aListBox, TListBoxEvent aEventType);

 public:

 	// Framework methods

 	/**

 	*

 	* This launches the setting page for the current item by calling EditItemL on it

 	*

 	* @param		aIndex			- current item's (Visible) index in the list

 	*				aCalledFromMenu- ignored in most classes; may alter the behaviour

 	*									of the setting page

 	*/

 	IMPORT_C virtual void EditItemL(TInt aIndex, TBool aCalledFromMenu);

 	/**

 	*

 	* Calls LoadL() on each item in the MAknSettingItemArray. 

 	*

 	*/

 	IMPORT_C virtual void LoadSettingsL();

 	/**

 	* This command calls StoreL on all the setting items (hidden or not)

 	*

 	* This must be called by the client if he wants it to occur

 	*/

 	IMPORT_C virtual void StoreSettingsL(); //  call StoreL() on each item in MAknSettingItemArray

 	/**

 	* @param	aInclude	If EFalse, numbering does not include hidden items

 	*						Otherwise, they are

 	*/

 	IMPORT_C void SetIncludeHiddenInOrdinal( TBool aInclude );

 	/** 

 	* @return	EFalse if the listbox is not numbered style; Not EFalse otherwise

 	*/

 	IMPORT_C TBool IsNumberedStyle();

 	/**

 	* @return	the listbox used by setting item list

 	*/

 	IMPORT_C CEikFormattedCellListBox* ListBox(); // get the listbox

 	/**

 	* @return	a pointer to the setting item array; No ownership is transferred

 	*/

 	IMPORT_C CAknSettingItemArray* SettingItemArray() const;

 	/**

 	* Method to be called when the client code has added or removed items or their visibility;

 	* This should be called when a single event's batch of array or visibility changes

 	* is complete in order to avoid more re-draws than is necessary

 	*/

 	IMPORT_C void HandleChangeInItemArrayOrVisibilityL();

     /**

      * From CCoeControl.     

      * Handles pointer events

      */

     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);

 protected:

 	/**

 	* Framework method to create a setting item based upon the user id aSettingId. The 

 	* client code decides what type to contruct. new (ELeave) must then be used and the resulting 

 	* pointer returned. Ownership is thereafter base class's responsiblity.

 	*

 	* @param aSettingId	ID to use to determine the type of the setting item

 	* @return a constructed (not 2nd-stage constructed) setting item.

 	*/

 	IMPORT_C virtual CAknSettingItem* CreateSettingItemL( TInt aSettingId );

 private:

     /**

     * From CAknControl

     */

     IMPORT_C void* ExtensionInterface( TUid aInterface );

 private:

     void UpdateAllListBoxTextsL() const;

 private:

 	// Owned objects:

 	CEikFormattedCellListBox* iSettingItemListBox;

 	CAknSettingItemArray* iSettingItemArray;

 	// Other non-CBase classes 

 	HBufC* iSettingItemListTitle;	// Owned

 	// Internal information

 	TInt iFlags;

 	TInt iInitialOrdinal;

 	TInt iSpare_1;

 	TInt iSpare_2;

 };

 #endif