/*

 * Copyright (c) 1997-1999 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:

 *

 */

 #if !defined(__EIKMFNE_H__)

 #define __EIKMFNE_H__

 #if !defined(__EIKBCTRL_H__)

 #include <eikbctrl.h>

 #endif

 #if !defined(__COEDEF_H__)

 #include <coedef.h>

 #endif

 #if !defined(__COEINPUT_H__)

 #include <coeinput.h>

 #endif

 // For MEikCalendarObserver

 #if !defined(__EIKCAL_H__)

 #include <eikcal.h>	

 #endif

 #if !defined(__EIKDEF_H__)

 #include <eikdef.h>

 #endif

 #if !defined(__BABITFLAGS_H__)

 #include <babitflags.h>

 #endif

 // For MAknMfneCommandObserver

 #if !defined(__AKNMFNECOMMANDOBSERVER)

 #include <aknmfnecommandobserver.h>

 #endif //!defined(__AKNMFNECOMMANDOBSERVER)

 //

 // Forward Declarations

 //

 class CEikonEnv;

 class CTimeEditor;

 class CDateEditor;

 // Skin-related API forward declarations

 class MAknsControlContext;

 // Extension object within CEikMfne

 class CEikMfneExtension;

 //

 /**

  * Abstract base class for fields within a multi-field numeric editor.

  */

 class CEikMfneField : public CBase

 	{

 public:

     /**

      * The type of highlight.

      */

 	enum THighlightType

 		{

 		/** Inverse video. */

 		EInverseVideo,

 		/** The cursor is visible in the field so that highlighting is not used. */

 		ECursor

 		};

 protected:

     /**

      * Protected default constructor.

      *

      * Sets the minimum width of the field to zero pixels.

      */

 	IMPORT_C CEikMfneField();

 public:

 	void Draw(CWindowGc& aGc, const CFont& aFont, const TPoint& aTopLeft) const;

 	TInt WidthInPixels(const CFont& aFont) const;

 	TInt DistanceFromStartOfFieldToEndOfTextInPixels(const CFont& aFont) const;

     /**

      * An implementation of this pure virtual function should

      * get the field's maximum width in pixels.

      *

      * @param aFont The font.

      * @param aShrinkToMinimumSize ETrue to shrink the width to the minimum required.

      * @return The field's maximum width in pixels.

      */

 	virtual TInt MaximumWidthInPixels(const CFont& aFont, TBool aShrinkToMinimumSize)=0;

     /**

      * An implementation of this pure virtual function should

      * return the field's input capabilities.

      *

      * @return The field's input capabilities.

      */

 	virtual TCoeInputCapabilities InputCapabilities() const=0;

 	/**

 	 * Derived classes' implementation of function should

 	 * return whether the field is editable.

 	 *

 	 * This implementation returns EFalse.

 	 *

 	 * @return EFalse.

      */

 	IMPORT_C virtual TBool IsEditable() const;

 	/**

 	 * Derived classes' implementation of function should

 	 * return whether the field is valid

 	 *

 	 * This implementation returns ETrue.

 	 *

 	 * @return ETrue.

      */	

 	IMPORT_C virtual TBool IsValid() const;

 	/**

 	 * An implementation of this function should get the

 	 * field's highlight type.

      * 

      * May only be called if IsEditable() returns ETrue.

      * 

      * This implementation panics in debug builds and returns

      * a dummy value in release builds.

      *

      * @return EInverseVideo.

      */

 	IMPORT_C virtual THighlightType HighlightType() const;

 	/**

 	 * An implementation of this function should handle a key event.

      *

      * May only be called if IsEditable() returns ETrue.

      * This implementation panics in debug builds and is

      * empty in release builds.

      *

      * @param aFont The control's font.

      * @param aKeyEvent The key event passed on from the multi-field numeric editor.

      * @param aInterpretLeftAndRightAsEarEvents Not used. 

      * @param aDataAltered On return, indicates whether or not the field

      *                     contents changed. If EFalse, left and right arrow

      *                     key presses indicate a movement to the preceding of

      *                     following field, if ETrue they are ignored.

      * @param aHighlightIncrement On return: -1 indicates the previous field is

      *                            highlighted,0 indicates the highlight is

      *                            unchanged and 1 indicates the following field

      *                            is highlighted.

      */

 	IMPORT_C virtual void HandleKey(const CFont& aFont, const TKeyEvent& aKeyEvent, TBool aInterpretLeftAndRightAsEarEvents, TBool& aDataAltered, TInt& aHighlightIncrement);

  	/**

  	* An implementation of this function should

  	* handle de-highlighting the field.

     *

     * May only be called if IsEditable() returns ETrue.

     *

     * This implementation panics in debug builds and is empty

     * in release builds.

     * 

     * @param aFont The control's font.

     * @param aEikonEnv The control's environment.

     * @param aDataAltered On return, set to ETrue if the function caused

     *                     the field's contents to change, otherwise unchanged.

     * @param aError On return, changed to ETrue if an error occurred e.g.

     *               the user entered an invalid value, otherwise unchanged.

     */

 	IMPORT_C virtual void HandleDeHighlight(const CFont& aFont, CEikonEnv& aEikonEnv, TBool& aDataAltered, TBool& aError);

 	const TDesC& FieldText() const;

 protected:

     /**

      * Handles a left or right arrow key press.

      *

      * @param aKey Left or right arrow key: either EKeyLeftArrow or EKeyRightArrow. 

      * @param aDataAltered On return, ETrue if data is altered as a result of this function.

      * @param aHighlightIncrement On return, the direction to move the cursor:

      *                            either -1 if aKey is a left arrow key, or 1 if aKey is a right arrow key.

      * @panic 3 In debug builds, if aKey is neither a left nor a right arrow key.

      */

 	IMPORT_C void HandleLeftOrRightArrow(TChar aKey, TBool& aDataAltered, TInt& aHighlightIncrement);

     TInt AdditionalWidthForHighlights(const CFont& aFont) const;

 private:

 	virtual const TDesC& Text() const=0;

 protected:

     /**

      * The field's minimum width in pixels.

      */

 	TInt iMinimumWidthInPixels;

 	};

 //

 /**

  * A separator field for a multi-field numeric editor.

  *

  * For instance, the character that separates time or date components.

  */

 NONSHARABLE_CLASS(CEikMfneSeparator) : public CEikMfneField

 	{

 private:

 	CEikMfneSeparator(HBufC* aText);

 public:

     /**

      * Destructor.

      *

      * Deletes the separator text that is owned by the object.

      */

 	IMPORT_C virtual ~CEikMfneSeparator();

 	/**

 	 * Allocates and constructs a CEikMfneSeparator from resource.

      * 

      * Uses an MFNE_SEPARATOR resource.

      * 

      * @param aResourceReader The resource reader to use.

      * @return A newly constructed separator field.

      */

 	IMPORT_C static CEikMfneSeparator* NewL(TResourceReader& aResourceReader);

 	/**

 	 * Allocates and constructs a separator.

      *

      * @param aText The separator's text. Ownership of aText is transferred.

      * @return A newly constructed separator.

      */

 	IMPORT_C static CEikMfneSeparator* NewL(HBufC* aText); // ownership of aText is transferred when everything that can leave has successfully been done

 	/**

 	 * Sets the separator's text.

      *

      * This function transfers ownership of the text and can only be called if the field's text was previously NULL.

      * 

      * @param aText The separator's text.

      * @panic 4 If the separator's text was not previously Null.

      */

 	IMPORT_C void SetText(HBufC* aText); // allows later transfer of ownership of text - can only be called if aText was previously NULL

 private: // framework

 	virtual TInt MaximumWidthInPixels(const CFont& aFont, TBool aShrinkToMinimumSize);

 	virtual TCoeInputCapabilities InputCapabilities() const;

 	virtual const TDesC& Text() const;

 private:

 	HBufC* iText;

 	};

 //

 /**

  * A number field within a multi-field numeric editor.

  */

 NONSHARABLE_CLASS(CEikMfneNumber) : public CEikMfneField

 	{

 public:

     /**

      * Flags for the number field.

      *

      * EFillWithLeadingZeros, EPreserveOldWidthBeforeEditing and ERepresentsYear can only be set if EPublicallySettableFlags is set.

      */

 	enum

 		{

 		/** Prepends the number field's value with leading zeros up to the maximum allowable width of the field. */

 		EFillWithLeadingZeros			=0x1,

 		/** The field's minimum width in pixels is set to the current text's width in pixels. */

 		EPreserveOldWidthBeforeEditing	=0x2,

 		/** The number is a year. */

 		ERepresentsYear					=0x4,

 		/** Used internally to make sure only the previous three values are set. */

 		EPublicallySettableFlags		=EFillWithLeadingZeros|EPreserveOldWidthBeforeEditing|ERepresentsYear

 		};

 private:

 	enum

 		{

 		EIsBeingEditedWithCursor		=0x8,

 		EIsUninitialised				=0x10,

 		EFillWithTrailingZeros          =0x20

 		};

 private:

 	CEikMfneNumber(TInt aMinimumValue, TInt aMaximumValue, TUint32 aFlags);

 	void ConstructL();

 public:

     /**

      * Destructor.

      *

      * Deletes the number field's text.

      */

 	IMPORT_C virtual ~CEikMfneNumber();

 	/**

 	 * Allocates and constructs a CEikMfneNumber from resource.

      *

      * Obtains flags and the minimum and maximum values from an MFNE_NUMBER resource. Then calls the overloaded NewL() function.

      *

      * @param aFont The font to use.

      * @param aResourceReader The resource reader to use.

      * @return A newly constructed number field.

 	 */

 	IMPORT_C static CEikMfneNumber* NewL(const CFont& aFont, TResourceReader& aResourceReader);

     /**

      * Allocates and constructs a CEikMfneNumber with the specified parameters.

      *

      * @param aFont The font to use.

      * @param aMinimumValue The minimum value.

      * @param aMaximumValue The maximum value.

      * @param aInitialValue The initial value. This must be greater than the minimum value and less than the maximum value.

      * @param aFlags The number field's flags. See the Anonymous enum.

      * @return A newly constructed number field.

      * @panic 8 If the initial value is not greater than or equal to the minimum value and less than or equal to the maximum value.

      */

 	IMPORT_C static CEikMfneNumber* NewL(const CFont& aFont, TInt aMinimumValue, TInt aMaximumValue, TInt aInitialValue, TUint32 aFlags);

 	/**

 	 * Sets the minimum and maximum allowable values.

      *

      * @param aMinimumValue The minimum value. Must be less than or equal to the maximum value.

      * @param aMaximumValue The maximum value.

      * @param aFont The font in use.

      * @panic 9 If the minimum value is greater than the maximum value or if the minimum/maximum text length is greater than the maximum number of digits.

      */

 	IMPORT_C void SetMinimumAndMaximum(TInt aMinimumValue, TInt aMaximumValue, const CFont& aFont); // only values inside the initial minimum and maximum are permitted

 	/**

 	 * Gets the minimum and maximum allowable values.

 	 *

 	 * @param aMinimumValue On return, the minimum allowable value.

 	 * @param aMaximumValue On return, the maximum allowable value.

      */

 	IMPORT_C void GetMinimumAndMaximum(TInt& aMinimumValue, TInt& aMaximumValue) const;

 	/** 

 	 * Sets the field's current value.

      * @param aValue The field's current value. This must be between the minimum value and the maximum value.

      * @param aFont The font.

      * @panic 11 In debug builds only, if the value is less than the minimum value or greater than the maximum value.

      */

 	IMPORT_C void SetValue(TInt aValue, const CFont& aFont);

  	/**

  	 * Gets the number field's value. Note that this function will leave

  	 * if the value is not valid, i.e. the number of digits is zero

  	 * or the value is outside of the minimum and maximum range.

      *

      * @return The field's value.

      */

 	IMPORT_C TInt Value() const;

     /**

 	 * Returns ETrue if the field contains more than zero

 	 * digits.

      *

 	 * @return ETrue if the field contains more than zero digits.

      */	

 	IMPORT_C virtual TBool IsValid() const;

     /**

      * Sets the uninitialized status of the field.

      * 

      * @param aUninitialised If ETrue, sets the field as uninitialized,

      *                       i.e. it doesn't display anything.

      */

 	IMPORT_C void SetUninitialised(TBool aUninitialised);

 	/**

 	 * Gets the uninitialized status of the field.

 	 * 

 	 * @return ETrue, if the field is set as uninitialized.

 	 */

 	IMPORT_C TBool IsUninitialised() const;

 public:

     /**

      * Sets the digit display type.

      *

      * @since S60 v3.1

      * @param aDigitType The digit display type to bet set for this number field

      * @param aFont The font of the MFNE that owns this field, usually retrieved with CEikMfne::Font()

      */

 	IMPORT_C void SetDigitType(TDigitType aDigitType, const CFont& aFont);

     /**

      * Gets the digit display type.

      *

      * @since S60 v3.1

      * @return The digit display type of this number field

      */

 	IMPORT_C TDigitType DigitType() const;

 	/**

 	 * Derive and set digit display type from locale information.

 	 *

 	 * @since S60 v3.1

 	 * @param aFont The font of the MFNE that owns this field, usually retrieved with CEikMfne::Font()

 	 */

 	IMPORT_C void RefreshDigitType(const CFont& aFont);

 	void SetTrailingZeros();

 public:

 	TBool IsTextNull() const;

 private: // framework

 	virtual TInt MaximumWidthInPixels(const CFont& aFont, TBool aShrinkToMinimumSize);

 	virtual TCoeInputCapabilities InputCapabilities() const;

 	virtual TBool IsEditable() const;

 	virtual THighlightType HighlightType() const;

 	virtual void HandleKey(const CFont& aFont, const TKeyEvent& aKeyEvent, TBool aInterpretLeftAndRightAsEarEvents, TBool& aDataAltered, TInt& aHighlightIncrement);

 	virtual void HandleDeHighlight(const CFont& aFont, CEikonEnv& aEikonEnv, TBool& aDataAltered, TBool& aError);

 	virtual const TDesC& Text() const;

 private:

 	TInt MaximumNumberOfDigits() const;

 	TInt NumberOfDigits() const;

 	void SetTextToValue(TInt aValue, const CFont& aFont);

 	TInt ValueFromText() const;

 	TBool ConvertsIntoValidValue(TInt& aValue) const;

 private: // International digit support

 	TChar NormalizeDigit(TChar aChar);

 	TText ZeroCharacter() const;

 	TText NegativeCharacter() const;

 private:

 	TInt iMinimumValue;

 	TInt iMaximumValue;

 	TInt iMaxDigits;

 	TUint32 iFlags;

 	HBufC* iText;

 	TChar iNudgeCharMinus;

 	TChar iNudgeCharPlus;

 	TInt iMaxDigitsMinimumValue;

     TInt iMaxDigitsMaximumValue;

 	TDigitType	iDigitType;

 	};

 //

 /**

  * A symbol field for a multi-field numeric editor.

  *

  * For instance, the AM / PM text in a time editor. In this case, the field contains 2 symbolic items one each for the AM and PM text strings.

  */

 NONSHARABLE_CLASS(CEikMfneSymbol) : public CEikMfneField

 	{

 public:

     /**

      * An item within a symbol field in an MFNE.

      */

 	NONSHARABLE_CLASS(CItem) : public CBase

 		{

 	private:

 		CItem(TInt aId, TChar aKeyToMatch, HBufC* aText);

 	public:

 	    /**

 	     * Destructor.

          *

          * Deletes the item's text.

          */

 		IMPORT_C virtual ~CItem();

 		/**

 		 * Allocates and constructs a symbolic item from resource.

          *

          * Uses a MFNE_SYMBOLIC_ITEM resource.

          * @param aResourceReader The resource reader to use.

          * @return A newly constructed symbolic item.

          */

 		IMPORT_C static CItem* NewL(TResourceReader& aResourceReader);

 		/**

 		 * Allocates and constructs a symbolic item.

          *

          * @param aId The ID of the symbolic item that uniquely identifies the item in the field.

          * @param aKeyToMatch The key that represents the item. This is for character matching, not for display.

          * @param aText The text to be drawn. Ownership of aText is transferred when everything that can leave has successfully completed.

          * @return A newly constructed symbolic item.

          */

 		IMPORT_C static CItem* NewL(TInt aId, TChar aKeyToMatch, HBufC* aText); // ownership of aText is transferred when everything that can leave has successfully been done

         /**

          * Sets the symbolic item's text. 

          * 

          * The item takes ownership of aText.

          * 

          * @param aText The symbolic item's text.

          * @panic 19 In debug builds if the symbolic item's text was not

          *           previously Null.

          */

 		IMPORT_C void SetText(HBufC* aText); // allows later transfer of ownership of text - can only be called if aText was previously NULL

 	private:

 		friend class CEikMfneSymbol;

 	private:

 		TInt iId;

 		TCharF iKeyToMatch;

 		HBufC* iText;

 		};

 private:

 	CEikMfneSymbol(TInt aNumSymbolicItems);

 public:

     /**

      * Destructor.

      * 

      * Deletes the array of symbolic items owned by the object.

      */

 	IMPORT_C virtual ~CEikMfneSymbol();

 	/**

      * Allocates and constructs a CEikMfneSymbol from resource.

      * 

      * Uses a MFNE_SYMBOL resource. The first item is set as current.

      * 

      * @param aResourceReader The resource reader to use.

      * @return A newly constructed symbol.

      * @panic 15 If there is not more than one symbol.

      */

 	IMPORT_C static CEikMfneSymbol* NewL(TResourceReader& aResourceReader);

     /**

      * Allocates and constructs a CEikMfneSymbol.

      * 

      * The first item is set as current.

      * 

      * @param aNumSymbolicItems The number of symbolic items. Must be

      * greater than one. All items are set to NULL.

      * @return A newly constructed symbol.

      * @panic 15 If there is not more than one symbol.

      */

 	IMPORT_C static CEikMfneSymbol* NewL(TInt aNumSymbolicItems);

     /**

      * Adds the specified symbolic item at the first available position in

      * the array.

      * 

      * This should be called by the container only if construction was not

      * made from resource.

      * 

      * @param aSymbolicItem The symbol to add. Ownership of aSymbolicItem

      * is transferred to this.

      * @param aMakeCurrent ETrue to make the added symbol current.

      * @panic 16 In debug build if the symbolic item array has not yet been

      * created.

      * @panic 17 If the array is full.

      */

 	IMPORT_C void AddSymbolicItem(CItem* aSymbolicItem, TBool aMakeCurrent); // to be called by container only if not constructed from resource - ownership of aSymbolicItem is transferred to "this"

 	/**

      * Sets the current item to the one specified.

      * 

      * 

      * @param aId The id of the new current item.

      * @panic 18 If the specified item does not exist.

      */

 	IMPORT_C void SetCurrentSymbolicItemToId(TInt aId);

     /**

      * Gets the current symbol's ID.

      * 

      * @return The current symbol's ID.

      */

 	IMPORT_C TInt IdOfCurrentSymbolicItem() const;

     /**

      * Sets the uninitialized status of the field.

      * 

      * @param aUninitialised If ETrue, sets the field as uninitialized,

      *                       i.e. doesn't display anything.

      */

 	IMPORT_C void SetUninitialised(TBool aUninitialised);

 	/**

 	 * Gets the uninitialized status of the field.

 	 * 

 	 * @return ETrue, if the field is set as uninitialized.

 	 */

 	IMPORT_C TBool IsUninitialised() const;

 private: // framework

 	virtual TInt MaximumWidthInPixels(const CFont& aFont, TBool aShrinkToMinimumSize);

 	virtual TCoeInputCapabilities InputCapabilities() const;

 	virtual TBool IsEditable() const;

 	virtual THighlightType HighlightType() const;

 	virtual void HandleKey(const CFont& aFont, const TKeyEvent& aKeyEvent, TBool aInterpretLeftAndRightAsEarEvents, TBool& aDataAltered, TInt& aHighlightIncrement);

 	virtual void HandleDeHighlight(const CFont& aFont, CEikonEnv& aEikonEnv, TBool& aDataAltered, TBool& aError);

 	virtual const TDesC& Text() const;

 private:

 	TInt CurrentSymbolicItem() const;

 	void SetCurrentSymbolicItem(TInt aCurrentSymbolicItem);

 private:

 	TInt iNumSymbolicItems;

 	TInt iCurrentSymbolicItem;

 	CItem** iSymbolicItems;

 	};

 //

 /**

  * Multi-field numeric editor abstract base class.

  * 

  * This is a set of fields, where a field can be a number, a symbol or

  * a separator. Field classes are derived from CEikMfneField.

  * 

  * Concrete multi-field numeric editors are derived from this class and

  * should provide the following:

  * 

  * * A virtual destructor if the class introduces new data members which

  * are allocated on the heap.

  * 

  * * A ConstructL() function; this is used to initialise a multi-field

  * numeric editor.

  * 

  * * A ConstructFromResourceL() function; this is used to initialise a

  * multi-field numeric editor from a resource.

  * 

  * * A data member to store the editor's value.

  * 

  * * Functions to set and get the editor's value.

  * 

  * * Functions to set the minimum and maximum allowable values.

  */

 class CEikMfne : public CEikBorderedControl, public MAknMfneCommandObserver

 	{

 public:

 	// miscellaneous functions

     /**

      * Default constructor.

      */

 	IMPORT_C CEikMfne();

 	/**

      * Destructor.

      * 

      * This function is virtual which ensures that if delete is explicitly

      * called on a CEikMfne pointer which points to a derived class

      * instance, the derived class destructor is called.

      */

 	IMPORT_C virtual ~CEikMfne();

     /**

      * Allocates a field array containing aNumFields elements. 

      * 

      * This should be called by the container only if a derived control is

      * not constructed from a resource.

      * 

      * @param aNumFields The number of fields.

      * @panic 20 In debug builds, if there is already a field in the editor.

      */

 	IMPORT_C void CreateFieldArrayL(TInt aNumFields); // to be called by container only if not constructed from resource

     /**

      * Adds a field.

      * 

      * The field is added as the first empty element in the field array or,

      * if there is no current field, aField becomes the current field.

      * 

      * This should be called by the container only if a derived control is

      * not constructed from a resource.

      * 

      * Ownership of aField is transferred to this multi-field numeric

      * editor.

      * 

      * @param aField A field.

      * @panic 22 If the field array has not been allocated.

      */

 	IMPORT_C void AddField(CEikMfneField* aField); // to be called by container only if not constructed from resource - ownership of aField is transferred to "this"

     /**

      * Deletes the editor's field and the field array.

      * 

      * After a call to this, CreateFieldArrayL() can be called again.

      */

 	IMPORT_C void ResetFieldArray(); // after this CreateFieldArrayL() can be called again

 	/**

      * Gets the control's border margins.

      * 

      * @return The control's margins.

      */

 	IMPORT_C TMargins BorderMargins() const;

     /**

      * Draws immediately, and then leaves with an info message containing a

      * formatted time/date string.

      * 

      * The time/date is passed to the function, as is the resource which

      * contains the format string which defines how it is to be formatted.

      * 

      * @param aResourceId The resource containing the time/date format. See

      * TTime::FormatL().

      * @param aTimeDate The object containing the time/date to be displayed.

      */

 	IMPORT_C void DrawNowAndLeaveWithTimeDateFormatInfoMsgL(TInt aResourceId, const TTime& aTimeDate) const;

     /**

      * Gets the CEikMfneField at the specified index.

      * 

      * @param aField The field index.

      * @return The requested field, or NULL if the index is less than zero

      * or greater than the number of fields.

      */

 	IMPORT_C CEikMfneField* Field(TInt aField) const;

 public:

 	// some utility functions which other classes may find useful

 	/**

      * A utility function which reads seconds, minutes and hours from a

      * resource and returns the corresponding TTime value.

      * 

      * @param aResourceReader A resource reader.

      * @return The time value read from the resource.

      */

 	IMPORT_C static TTime ReadTime(TResourceReader& aResourceReader);

     /**

      * A utility function which reads days, months and years from a resource

      * and returns the corresponding TTime value.

      * 

      * @param aResourceReader A resource reader.

      * @return The date value read from the resource. The hours, minutes,

      * seconds values are set to zero.

      */

 	IMPORT_C static TTime ReadDate(TResourceReader& aResourceReader);

     /**

      * A utility function which reads seconds, minutes, hours, days, months

      * and years from a resource and returns the corresponding TTime value.

      * 

      * @param aResourceReader A resource reader.

      * @return The time/date value read from the resource.

      */

 	IMPORT_C static TTime ReadTimeAndDate(TResourceReader& aResourceReader);

     /**

      * Reads a duration value from a resource.

      * 

      * @param aResourceReader A resource reader.

      * @return The duration, in seconds.

      */

 	IMPORT_C static TTimeIntervalSeconds ReadDuration(TResourceReader& aResourceReader);

     /**

      * Reads a time offset from a resource. 

      * 

      * This is identical to ReadDuration(), except that negative offsets

      * are allowed.

      * 

      * @param aResourceReader A resource reader.

      * @return The duration, in seconds.

      */

 	IMPORT_C static TTimeIntervalSeconds ReadTimeOffset(TResourceReader& aResourceReader);

     /**

      * Converts a time duration to seconds.

      * 

      * @param aTime The date and time to be converted.

      * @return The time duration in seconds.

      */

 	IMPORT_C static TTimeIntervalSeconds Convert(const TTime& aTime);

     /**

      * Converts a time duration in seconds to hours, minutes and seconds.

      * 

      * @param aTimeIntervalSeconds The number of seconds to be converted.

      * @return The date/time duration.

      */

 	IMPORT_C static TTime Convert(const TTimeIntervalSeconds& aTimeIntervalSeconds);

     //

     /**

      * Gets the index into the field array of the current field.

      * 

      * @return The current field's index.

      */

     inline TInt CurrentField() const;

     /**

      * Gets the number of fields.

      * 

      * @return The number of fields in the editor.

      */

     inline TInt NumFields() const;

 public: // AVKON addition

     /**

      * Settable features for MFNE. See SetFeature().

      *

      * @since S60 3.2

      */

     enum TFeatureId

         {

         /** Tries to prevent MFNE drawing outside its rect,

             event if it smaller than MinimumSize().

             0 (or EFalse) parameter disables this, non-zero

             (or ETrue) enables the feature. */

         EClipGcToRect,

         /** Disables VKB. Non-zero (or ETrue) parameter disables VKB, 

             0 (or EFalse) enables VKB. When disabled, 

             editor doesn't request PenInputServer to start VKB */ 

         EDisablePenInput,

         /** Support finger input. Paramter is TFingerSupportParams.*/ 

         EFingerSupport,

         ELaunchPenInputAutomatic,

         EPartialScreenInput

         };

     /** Parameter for finger support feature: 

       * 0 means disable the suppor; 

       * 1 means enable the support;

       * 2 means enable the support with highlight of whole text.

       */

     enum TFingerSupportParams

         {

         EDisaleFingerSupport,

         EnableFingerSupport,

         EnableWithAllHighlight

         };

     /**

      * Sets the alignment of the editor. The editor alignments, defined in

      * avkon.hrh, are EAknEditorAlignNone, EAknEditorAlignCenter,

      * EAknEditorAlignLeft, EAknEditorAlignRight or EAknEditorAlignBidi.

      * 

      * @param aAlignment The editor's alignment

      */

     IMPORT_C void SetMfneAlignment(TInt aAlignment);

     /**

      * Sets whether the editor consumes up and down key events. If this is

      * set to EFalse, the editor returns EKeyWasNotConsumed upon receiving

      * EKeyDownArrow or EKeyUpArrow key event and doesn't send the key event to

      * the current field.

      * 

      * @param aConsume If EFalse, OfferKeyEventL() returns

      * EKeyWasNotConsumed when up and down key events are received.

      */

     IMPORT_C void SetUpAndDownKeysConsumed(TBool aConsume);

     /**

      * Used for suppressing all editor's background drawing. This is

      * intended for internal use.

      *

      * Note that when this is set, the background is not drawn with skin

      * nor cleared, so the background MUST be drawn by the parent control

      * every time the editor changes.

      *

      * @param aSuppress If ETrue, suppress background drawing

      */

     IMPORT_C void SetSuppressBackgroundDrawing( TBool aSuppress );

     /**

      * Used for setting various flag-like features to the editor.

      *

      * @param aFeatureId The feature id, see TFeatureId

      * @param aFeatureParam The feature parameter. This is usually

      *                      enabled or disabled. For more info, see

      *                      the feature documentation in TFeatureId.

      * @return KErrNone if the feature modification succeeded

      * @since S60 3.2

      **/

     IMPORT_C TInt SetFeature( TInt aFeatureId, TInt aFeatureParam );

     /**

      * Used to getting feature statuses.

      *

      * @param aFeatureId The feature id, see TFeatureId

      * @param aFeatureParam On return, the parameter for the feature

      *                      (usually non-zero for an enabled feature

      *                      and zero for disabled)

      * @return KErrNone if the feature is supported and fetching its value

      *                  succeeded

      * @since S60 3.2

      */

     IMPORT_C TInt GetFeature( TInt aFeatureId, TInt& aFeatureParam ) const;

     /**

      * Used for checking if the editor supports a feature.

      * For features, see TFeatureId.

      *

      * @param aFeatureId

      * @return ETrue if the feature is supported

      * @since S60 3.2

      */

     IMPORT_C TBool SupportsFeature( TInt aFeatureId ) const;

     // Highlights a field

     void HighlightField(  TInt aFieldPosition );

     /**

      * Gets a pointer to the CFont object that is used to draw the fields in

      * this editor.

      * 

      * @return A pointer to the CFont object used to draw the fields in

      * this editor.

      */

 	IMPORT_C const CFont* Font() const;

     /**

      * Sets the font that is used to draw the fields in this editor.

      * 

      * @param aFont A pointer to a CFont object that is used to draw the

      * fields in this editor.

      */

 	IMPORT_C void SetFont(const CFont* aFont);

     /**

      * Sets within in the editor an externally owned Skins background control context.

      * This background control context will then be used by the editor to draw background.

      *

      * If this API is not called, then the editor IS skin enabled, (that is CEikMfnes are skin

      * enabled by default) but it will try to find a control context with which to perform background 

      * drawing from the Control Environment, via the Object Provider.

      *

      * Setting this control context to NULL will have the effect of turning off background 

      * skinning. 

      *

      * @param aBackgroundControlContext   Control context to store. Not owned. Can be NULL

      */

     IMPORT_C void SetSkinBackgroundControlContextL( MAknsControlContext* aControlContext );

     /**

      * From MAknMfneCommandObserver. Allows owning controls to give commands to 

      * MFNE editors. This is interface was added to enable modifying the current field

      * value with touch buttons.

      *

      * @param aCommand Command ID defined in MAknMfneCommandObserver::TMfneCommand

      */

     IMPORT_C void HandleMfneCommandL(TInt aCommand);

     /**

      * Sets the MFNE to use the CCoeControl::OverrideColorL() defined

      * color in drawing. If this is set, no skinning will be used

      * in drawing.

      *

      * @param aUseOverrideColors ETrue to make the MFNE use overridden colors.

      * @since S60 v3.2

      */

     IMPORT_C void SetUseOverrideColors( TBool aUseOverrideColors );

 public:	// from CCoeControl

     /**

      * Handles key events.

      * 

      * Overrides CCoeControl::OfferKeyEventL(). The key event is passed

      * onto the current field to handle.

      * 

      * @param aKeyEvent The key event.

      * @param aType The type of key event.

      * @return Indicates whether or not the key event was used by this

      * control.

      */

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

     /**

      * Prepares for focus loss.

      * 

      * Overrides CCoeControl::PrepareForFocusLossL().

      * 

      * This function should be called when an attempt is made to remove

      * focus from a multi-field numeric editor. It redraws the control, removing

      * highlighting from the current field.

      * 

      * It may be overridden in derived classes to test the validity of

      * information entered into the editor. Derived class versions should include

      * a base function call.

      */

 	IMPORT_C virtual void PrepareForFocusLossL();

     /**

      * Gets the minimum size of the control. 

      * 

      * Overrides CCoeControl::MinimumSize().

      *

      * @return The minimum control size.

      */

 	IMPORT_C virtual TSize MinimumSize();

     /**

      * Gets the list of logical colours used to draw the control.

      * 

      * The colours are appended to aColorUseList.

      * 

      * Overrides CCoeControl::GetColorUseListL().

      * 

      * @param aColorUseList On return, the colour list.

      */

 	IMPORT_C virtual void GetColorUseListL(CArrayFix<TCoeColorUse>& aColorUseList) const; // not available before Release 005u

     /**

      * Handles a change to the control's resources. 

      * 

      * The types of resources handled are those which are shared across the

      * environment, e.g. colours or fonts.

      * 

      * Overrides CCoeControl::HandleResourceChange().

      * 

      * @param aType A message UID value.

      */

 	IMPORT_C virtual void HandleResourceChange(TInt aType);			// not available before Release 005u

     /**

      * Gets the total of the input capabilities of all the editor's fields.

      * 

      * Overrides CCoeControl::InputCapabilities().

      *

      * If this function is overrided in a subclass, the subclass should

      * obtain this class' InputCapabilities' object provider through

      * TCoeInputCapabilities::ObjectProvider() and set that as a part of

      * the subclass' InputCapabilities object provider chain to ensure

      * maximum functionality.

      * 

      * @return The control's input capabilities.

      */

 	IMPORT_C virtual TCoeInputCapabilities InputCapabilities() const;

     /**

      * From @c CCoeControl.

      * 

      * Handles pointer events.

      *

      * @param aPointerEvent The pointer event.

      */

 	IMPORT_C virtual void HandlePointerEventL(const TPointerEvent& aPointerEvent);

     /**

      * Retrieves an object of the same type as that encapsulated in aId.

      * 

      * Overrides CCoeControl::MopSupplyObject().

      * 

      * @param aId An encapsulated object type ID. 

      * @return Encapsulates the pointer to the object provided. Note that

      * the encapsulated pointer may be NULL. 

      */

 	IMPORT_C virtual TTypeUid::Ptr MopSupplyObject( TTypeUid aId );

 public: // new 

     /**

      * Sets the colors for text and background as skin IDs. Please note that

      * bgcolor overrides skinned draw if set

      * 

      * @since 3.0

      * @param aAknSkinIDForTextColor ID for text color.

      * @param aAknSkinIDForBgColor ID for background color.

      */

     IMPORT_C void SetSkinTextColorL(TInt aAknSkinIDForTextColor, TInt aAknSkinIDForBgColor=KErrNotFound);

 protected:

 	// framework

     /**

      * Redraws the current field, so removing or displaying the cursor.

      * 

      * If the editor has lost focus, the current field is reset to the

      * first editable field.

      * 

      * @param aDrawNow Whether to draw the control immediately.

      */

 	IMPORT_C virtual void FocusChanged(TDrawNow aDrawNow);

     /**

      * Writes the internal state of the control and its components to

      * aStream.

      * 

      * This function is empty in release builds.

      */

 	IMPORT_C void WriteInternalStateL(RWriteStream& aWriteStream) const;

 	// miscellaneous functions

     /**

      * Handles the redrawing associated with a change to the current field.

      * 

      * Called by OfferKeyEventL(), HandlePointerEventL() and

      * PrepareForFocusLossL().

      * 

      * @param aHandleDeHighlight ETrue if the current field has changed so

      * requires de-highlighting.

      * @param aNewCurrentField The index of the field to which the user has

      * moved.

      * @param aOldWidthInPixelsOfOldCurrentField The width in pixels of the

      * previous current field.

      * @param aOldHighlightTypeOfOldCurrentField The highlight type of the

      * previously current field.

      * @param aDataAltered ETrue if the data has been changed.

      * @param aError On return, ETrue if successful, EFalse if not

      * successful.

      */

 	IMPORT_C void HandleInteraction(TBool aHandleDeHighlight, TInt aNewCurrentField, TInt aOldWidthInPixelsOfOldCurrentField,

 								CEikMfneField::THighlightType aOldHighlightTypeOfOldCurrentField, TBool& aDataAltered, TBool& aError);

     /**

      * Empty virtual function.

      * 

      * Called by HandleInteraction() when switching from the current field.

      * Can be implemented by derived classes to maintain consistency between

      * fields, e.g. in a range editor.

      * 

      * @param aField The current field.

      * @param aDrawAllFields On return, whether all fields have changed and

      * need to be redrawn.

      */

 	IMPORT_C virtual void FieldIsAboutToBeDeHighlighted(CEikMfneField* aField, TBool& aDrawAllFields); // first occurrence of this virtual function - does nothing by default

     /**

      * Gets the size of the multi-field numeric editor.

      * 

      * The width is the sum of the maximum widths of every field.

      * 

      * @return The size of the multi-field numeric editor.

      */

 	IMPORT_C TSize MfneSize() const;

     /**

      * Gets the size of the multi-field numeric editor.

      * 

      * The width is the sum of the maximum widths of every field.

      * 

      * @param aShrinkToMinimumSize ETrue to shrink the width to the minimum

      * required for each field.

      * @return The size of the multi-field numeric editor.

      */

 	IMPORT_C TSize MfneSize(TBool aShrinkToMinimumSize);

     IMPORT_C virtual void SizeChanged();

 public:

 	static void InvalidFieldAlert();

 	static void LeaveWithAlert(TInt aResourceId);	

 	void GetCursorInfo( TPoint& aPos, TInt& aHeight, TInt& aWidth, TInt& aAscent );

     void ReportUpdate();

     IMPORT_C virtual void MakeVisible(TBool aVisible);

     void SetCurrentField( TInt aCurrentField );

     void SetValidateCallBack( TCallBack aCallBack );

     void ReportStateChangeEventL();

     void SetFirstEditableField();

 private:

 	// framework

 	IMPORT_C virtual void Draw(const TRect& aRect) const;

 	// new virtual functions

 	IMPORT_C virtual void CreatePopoutIfRequiredL();

 	// miscellaneous functions

 	/**

 	 * Draws the specified fields within the MFNE.

 	 * All fields between and including the @c aFirstField and @c aLastField

 	 * will be drawn.

 	 *

 	 * @param  aGc                    The graphics context to draw to.

 	 * @param  aFirstField            First field to be drawn.

 	 * @param  aLastField             Last field to be drawn.

 	 * @param  aSkipBackgroundDrawer  @c ETrue to skip the background drawing

 	 *                                with a background drawer if it's used

 	 *                                for the MFNE. 

 	 */

 	void DrawRange( CWindowGc& aGc,

                     TInt aFirstField,

                     TInt aLastField,

                     TBool aSkipBackgroundDrawer = EFalse ) const;

 	CWindowGc& PreparedGc() const;

 	void SetGcToNormalVideo(CWindowGc& aGc) const;

 	void SetGcToInverseVideo(CWindowGc& aGc) const;

 	void SetGcToDimmedVideo(CWindowGc& aGc) const;

 	void DrawCursor();

 	void HideCursor();	

 	IMPORT_C void Reserved_2();

 	IMPORT_C virtual void CEikMfne_Reserved();

 	void LaunchPenInputL();

 private:

     /**

     * From CAknControl

     */

     IMPORT_C void* ExtensionInterface( TUid aInterface );

 private:

 	enum {ENullIndex=KMaxTInt};

 	/**

 	 * Access to state of whether up/down keys are eaten and used to increment/decrement.  If

 	 * these keys are not consumed, then the events are passed on.

 	 * 

 	 * @return EFalse iff Up and Down keys are not consumed (and acted upon)

 	 */

 	TBool ConsumesUpAndDownKeys() const;

 	/**

 	 * This state of enabling means that skinning will actually be drawn

 	 * It is a combination of 

 	 * - application is skin enabled

 	 * - current skin has a background or frame bitmap

 	 * It is set during construction and does not change its value after except if the Skin is 

 	 * changed, whereupon the control context is re-accessed and checked for bitmaps present

 	 *

 	 * @return EFalse iff background skin will not be drawn.

 	 */

 	TBool SkinningBackground() const;

 	/** 

 	 * Checks if app is skin enabled and that the current control context has bitmap. 

 	 * If so, then state is set true.

 	 * This should be called at constuction and when HandleResourceChange is called

 	 *

 	 */ 

 	void EvaluateSkinningBackground(); 

     /**

      * Access to Skins background control context that is potentially being used by the Editor.

      *

      * This API will first check to see if an control context has been set by API, and if so, 

      * return that.  If the background control context has been set to NULL by API, then it will

      * return NULL. If the background control context has never been set by API, then this returns

      * the control context (if one exists) that the object obtains from Object Provider.

      * 

      * @return Pointer to control context potentially in use, or NULL.

      */

     MAknsControlContext* SkinBackgroundControlContext() const;

     /**

      * Check for the existence of the extension and create if required.

      */

     void CreateExtensionIfRequiredL();

 private:

 	TInt iNumFields;

 	TInt iCurrentField;

 	CEikMfneField** iFields;

 	CEikMfneExtension* iExtension;

 	const CFont* iFont;

     TInt iAlignment;

     TBitFlags iFlags;

 	};

 inline TInt CEikMfne::CurrentField() const

     {

     return(iCurrentField);

     }

 inline TInt CEikMfne::NumFields() const

     {

     return(iNumFields);

     }

 //

 /**

  * Integer editor.

  * 

  * This control supports editing a single integer value. If a number is

  * entered which is not within the range specified by the maximum and

  * minimum control values it is automatically reset to the nearest

  * allowable value.

  * 

  * The editor has an associated resource struct NUMBER_EDITOR and

  * control factory identifier EEikCtNumberEditor.

  */

 class CEikNumberEditor : public CEikMfne

 	{

 public:

 	// miscellaneous functions

     /**

      * Constructor.

      * 

      * This function should be used as the first stage in two stage

      * construction, followed by a call to either ConstructFromResourceL() to

      * initialise the editor's field values from a resource file, or ConstructL()

      * if no resource file is used.

      */

 	IMPORT_C CEikNumberEditor();

 	/**

      * Second-phase constructor.

      * 

      * Completes the construction of an integer editor. It should be called

      * by container only if the editor is not constructed from a resource.

      * 

      * Sets the minimum and maximum values that can be entered into the

      * editor, and the initial value.

      * 

      * @param aMinimumValue The minimum allowable value.

      * @param aMaximumValue The maximum allowable value.

      * @param aInitialValue The initial value.

      */

 	IMPORT_C void ConstructL(TInt aMinimumValue, TInt aMaximumValue, TInt aInitialValue); // to be called by container only if not constructed from resource

     /**

      * Sets the minimum and maximum editor values.

      * 

      * Only values inside the initial minimum and maximum are permitted.

      * 

      * If the editor's value is outside the new bounds when the function is

      * called, it is reset to the nearest allowable value.

      * 

      * @param aMinimumValue The minimum allowable value.

      * @param aMaximumValue The maximum allowable value.

      * @panic 9 If the minimum is greater than the maximum allowable value.

      */

 	IMPORT_C void SetMinimumAndMaximum(TInt aMinimumValue, TInt aMaximumValue); // only values inside the initial minimum and maximum are permitted

     /**

      * Gets the integer editor's minimum and maximum values.

      * 

      * @param aMinimumValue On return, contains the integer editor's

      * minimum allowable value.

      * @param aMaximumValue On return, contains the integer editor's

      * maximum allowable value.

      */

 	IMPORT_C void GetMinimumAndMaximum(TInt& aMinimumValue, TInt& aMaximumValue) const;

     /**

      * Sets the integer editor's value.

      * 

      * The control is not redrawn.

      * 

      * @param aNumber The editor's new value.

      * @panic 11 In debug builds, if aNumber is outside the valid range.

      */

 	IMPORT_C void SetNumber(TInt aNumber);

     /**

      * Gets the integer editor's value.

      * 

      * @return The integer editor's value.

      * @panic 12 In debug builds, if the editor has no content.

      */

 	IMPORT_C TInt Number() const; // can only be called if PrepareForFocusLossL() succeeded

 	// framework

 	/**

      * Second-phase construction from a resource file.

      * 

      * The function reads the maximum and minimum editor values from a

      * NUMBER_EDITOR resource, and sets the initial number to be the same as the

      * maximum value.

      * 

      * @param aResourceReader A resource file reader.

      */

 	IMPORT_C virtual void ConstructFromResourceL(TResourceReader& aResourceReader);

     // From CCoeControl

     /**

      * From @c CCoeControl.

      * 

      * Handles pointer events.

      *

      * @param aPointerEvent The pointer event.

      */    

     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);	

 private:

 	IMPORT_C virtual void CEikMfne_Reserved();

 private:

 	void RefreshFromLocale();

 private:

     /**

     * From CAknControl

     */

     IMPORT_C void* ExtensionInterface( TUid aInterface );

 private:

 	// none of these pointers owns anything

 	CEikMfneNumber* iNumber;

 	TInt iSpare;

 	};

 //

 /**

  * Range struct for CEikRangeEditor.

  */

 struct SEikRange

 	{

 	/**

 	 * The lower limit.

 	 */

 	TInt iLowerLimit;

 	/**

 	 * The upper limit.

 	 */

 	TInt iUpperLimit;

 	};

 //

 /**

  * Numeric range editor.

  * 

  * This editor supports editing an integer range. It has two fields;

  * the first represents the lower value and the second the upper value. The

  * second value must be greater than, or equal to, the first.

  * 

  * Minimum and maximum values for the editor are specified during

  * construction. If a number is entered which is not within the editor's

  * minimum and maximum values, it is automatically reset to the nearest

  * allowable value.

  * 

  * The editor has an associated resource struct RANGE_EDITOR and

  * control factory identifier EEikCtRangeEditor. 

  */

 class CEikRangeEditor : public CEikMfne

 	{

 public:

 	// miscellaneous functions

     /**

      * Default constructor.

      * 

      * This function should be used as the first stage in two stage

      * construction, followed by a call to either ConstructFromResourceL() to

      * initialise the editor's field values from a resource file, or ConstructL()

      * if no resource file is used.

      */

 	IMPORT_C CEikRangeEditor();

 	// ConstructL to be called by container only if not constructed from resource, also ownership of aSeparatorText is transferred when everything that can leave has successfully been done

     /**

      * Second phase constructor.

      * 

      * This function completes construction of a range editor. It sets the

      * minimum and maximum values, initial range and separator text. It

      * should be called by the container only if the control is not constructed

      * from a resource file. 

      * 

      * @param aMinimumValue The minimum value for the range editor.

      * @param aMaximumValue The maximum value for the range editor.

      * @param aInitialRange Struct containing upper and lower range limits.

      * Must be within the minimum and maximum values.

      * @param aSeparatorText The text to be used to separate the numeric

      * values.

      * @panic 8 If the initial lower or upper limit is outside the minimum

      * or maximum bounds.

      */

 	IMPORT_C void ConstructL(TInt aMinimumValue, TInt aMaximumValue, const SEikRange& aInitialRange, HBufC* aSeparatorText);

     /**

      * Sets the range editor's minimum and maximum values.

      * 

      * Any values are permitted. If the range values are outside the new

      * minimum / maximum they are changed to be within the new minimum /

      * maximum.

      * 

      * @param aMinimumValue The minimum value for the range editor.

      * @param aMaximumValue The maximum value for the range editor.

      */

 	IMPORT_C void SetMinimumAndMaximum(TInt aMinimumValue, TInt aMaximumValue); // only values inside the initial minimum and maximum are permitted

     /**

      * Gets the range editor's minimum and maximum values.

      * 

      * @param aMinimumValue On return, the minimum value for the range

      * editor.

      * @param aMaximumValue On return, the maximum value for the range

      * editor.

      */

 	IMPORT_C void GetMinimumAndMaximum(TInt& aMinimumValue, TInt& aMaximumValue) const;

     /**

      * Sets the range editor's current values.

      * 

      * @param aRange Struct containing new range values.

      */

 	IMPORT_C void SetRange(const SEikRange& aRange);

     /**

      * Gets the range editor's current values.

      * 

      * Can only be called if CEikMfne::PrepareForFocusLossL() succeeded

      * 

      * @return Struct containing current range values.

      */

 	IMPORT_C SEikRange Range() const; // can only be called if PrepareForFocusLossL() succeeded

 	// framework

     /**

      * Second phase constructor from resource.

      * 

      * This function completes construction of a newly-allocated range

      * editor. It sets the minimum and maximum values, initial range and

      * separator text as specified by the resource.

      * 

      * @param aResourceReader A resource reader.

      */

 	IMPORT_C virtual void ConstructFromResourceL(TResourceReader& aResourceReader);

     // From CCoeControl

     /**

      * From @c CCoeControl.

      * 

      * Handles pointer events.

      *

      * @param aPointerEvent The pointer event.

      */    

     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);

 private:

 	virtual void FieldIsAboutToBeDeHighlighted(CEikMfneField* aField, TBool& aDrawAllFields);

 	IMPORT_C virtual void CEikMfne_Reserved();

 	void RefreshFromLocale();

 private:

     /**

     * From CAknControl

     */

     IMPORT_C void* ExtensionInterface( TUid aInterface );

 private:

 	// none of these pointers owns anything

 	CEikMfneNumber* iLowerLimit;

 	CEikMfneNumber* iUpperLimit;

 	TInt iSpare;

 	};

 //

 /**

  * Specifies an abstract interface for time and date editors where the

  * time and date are set and retrieved using the TTime class.

  */

 class CEikTTimeEditor : public CEikMfne

 	{

 public:

     /**

      * An implementation (of this pure virtual function) should set the

      * range of allowable time values.

      * 

      * This defines the maximum and minimum values that may be entered by

      * the user. 

      * 

      * @param aMinimumTime The minimum allowable value.

      * @param aMaximumTime The maximum allowable value.

      */

 	virtual void SetMinimumAndMaximum(const TTime& aMinimumTime, const TTime& aMaximumTime)=0;

     /**

      * An implementation (of this pure virtual function) should get the

      * range of allowable time values.

      * 

      * @param aMinimumTime The minimum allowable value.

      * @param aMaximum The maximum allowable value.

      */

 	virtual void GetMinimumAndMaximum(TTime& aMinimumTime, TTime& aMaximum) const=0;

     /**

      * An implementation (of this pure virtual function) should set the time

      * in the editor.

      * 

      * @param aTime The time.

      */

 	virtual void SetTTime(const TTime& aTime)=0;

     /**

      * An implementation (of this pure virtual function) should get the time

      * from the editor.

      * 

      * Can only be called if CEikMfne::PrepareForFocusLossL() succeeded.

      * 

      * @return The time.

      */

 	virtual TTime GetTTime() const=0; // can only be called if PrepareForFocusLossL() succeeded

 	};

 /**

  * Time editor.

  * 

  * This control allows a time value to be displayed and edited. By

  * default the editor has hours, minutes and seconds fields, although the

  * seconds and hours fields may be omitted. 12 and 24-hour format are

  * supported. When 12-hour format is used, am or pm text will be included as

  * another field, either before or after the time. Locale information is

  * used to determine the time separator characters. Locale information is

  * set and retrieved using class TLocale. 

  * 

  * The upper and lower field bounds are set depending on the format,

  * and times outside these bounds are invalid.

  * 

  * The editor has an associated resource struct TIME_EDITOR and control

  * factory identifier EEikCtTimeEditor. 

  */

 class CEikTimeEditor : public CEikTTimeEditor

 	{

 public:

 	// miscellaneous functions

     /**

      * Default constructor.

      * 

      * This function should be used as the first stage in two stage

      * construction, followed by a call to either: ConstructFromResourceL() to

      * initialise the editor's field values from a resource file, or ConstructL()

      * if no resource file is used.

      */

 	IMPORT_C CEikTimeEditor();

     /**

      * Destructor.

      * 

      * This frees the resources owned by the time editor, prior to its

      * destruction.

      */

 	IMPORT_C virtual ~CEikTimeEditor();

     /**

      * Second phase construction.

      * 

      * This function completes the construction of a newly-allocated time

      * editor, by setting its minimum, maximum and initial values, and the

      * AM/PM text settings - the AM/PM settings and time separator characters

      * specified in class TLocale are honoured. It should be called by the

      * container only if the control is not constructed from a resource file.

      * 

      * If the initial time is outside the bounds specified, it is reset to

      * the nearest available setting.

      * 

      * The aFlags parameter is used to determine whether the seconds or

      * hours fields are required. The minutes field is always present. It may

      * also be used to specify whether or not to force 24 hour time format,

      * overriding the locale's setting.

      * 

      * A panic will occur if the minimum time is later than the maximum

      * time.

      * 

      * @param aMinimumTime The minimum allowable time.

      * @param aMaximumTime The maximum allowable time.

      * @param aInitialTime The initial time.

      * @param aFlags Determines which fields are required and whether or

      * not to force 24 hour formatting. See eikon.hrh EEiktime etc.

      */

 	IMPORT_C void ConstructL(const TTime& aMinimumTime, const TTime& aMaximumTime, const TTime& aInitialTime, TUint32 aFlags); // to be called by container only if not constructed from resource

     /**

      * Sets the time editor's value.

      * 

      * @param aTime The new value to which to set the editor's fields.

      */

 	IMPORT_C void SetTime(const TTime& aTime);

     /**

      * Gets the time editor's value.

      * 

      * @return The editor's value. (Date values are all zero.)

      */

 	IMPORT_C TTime Time() const;

     /**

      * Sets the uninitialized status of the editor.

      * 

      * @param aUninitialised If ETrue, sets the editor as uninitialized,

      *                       i.e. it doesn't display anything.

      */

 	IMPORT_C void SetUninitialised(TBool aUninitialised);

 	/**

 	 * Gets the uninitialized status of the editor.

 	 * 

 	 * @return ETrue, if the editor is set as uninitialized.

 	 */	

 	IMPORT_C TBool IsUninitialised() const;

 	// from CEikTTimeEditor

     /**

      * Sets the range of allowable time values.

      * 

      * These define the maximum and minimum values that may be entered by

      * the user.

      * 

      * If the existing time value is outside the bounds set by this

      * function, it is reset to the nearest boundary value.

      * 

      * @param aMinimumTime The minimum allowable value.

      * @param aMaximumTime The maximum allowable value.

      * @panic 38 If the minimum value exceeds the maximum.

      */

 	IMPORT_C virtual void SetMinimumAndMaximum(const TTime& aMinimumTime, const TTime& aMaximumTime); // only values inside the initial minimum and maximum are permitted

     /**

      * Gets the range of allowable values that may be entered by the user.

      * 

      * @param aMinimumTime On return, contains the time editor's minimum

      * allowable value.

      * @param aMaximumTime On return, contains the time editor's maximum

      * allowable value.

      */

 	IMPORT_C virtual void GetMinimumAndMaximum(TTime& aMinimumTime, TTime& aMaximumTime) const;

 	// from CCoeControl

     /**

      * Second phase construction from a resource.

      * 

      * This function completes the construction of a newly-allocated time

      * editor from a TIME_EDITOR resource. The minimum and maximum times, and

      * the flags settings are read from the resource, and ConstructL() is

      * called with these settings. The initial time is set to the maximum time

      * value. Honours the locale's AM/PM text setting and time separators.

      * 

      * @param aResourceReader A resource file reader.

      * 

      */

 	IMPORT_C virtual void ConstructFromResourceL(TResourceReader& aResourceReader);

     /**

      * Prepares the editor for focus loss.

      * 

      * This function should be called to validate the editor's contents

      * when an attempt is made to remove focus from the control. If the control

      * value is not within the bounds specified by the minimum and maximum

      * time values, it is reset to the nearest allowable value, the function

      * will leave and will display an appropriate message.

      */

 	IMPORT_C virtual void PrepareForFocusLossL();

     /**

      * From @c CCoeControl.

      * 

      * Handles pointer events.

      *

      * @param aPointerEvent The pointer event.

      */

     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);

 private:

 	// from CEikTTimeEditor

 	virtual void SetTTime(const TTime& aTime);

 	virtual TTime GetTTime() const; // can only be called if PrepareForFocusLossL() succeeded

 private:

 	// miscellaneous functions

 	void DoSetMinimumAndMaximum(const TTime& aMinimumTime, const TTime& aMaximumTime);

 	IMPORT_C virtual void CEikMfne_Reserved();

 private:

     /**

     * From CAknControl

     */

     IMPORT_C void* ExtensionInterface( TUid aInterface );

 private:

 	CTimeEditor* iTimeEditor;

 	TTime iMinimumTime;

 	TTime iMaximumTime;

 	TInt iSpare;

 	};

 //

 // note: TDateTime uses zero based day numbers, so -1 on the day field

 #define KAknMinimumDate (TTime(TDateTime(0001, EJanuary, 1-1, 0, 0, 0, 0)))

 #define KAknMaximumDate (TTime(TDateTime(9999, EDecember, 31-1, 23, 59, 59, 999999)))

 /**

  * Date editor.

  *

  * A date editor has five fields: day, month and year, and two separator 

  * characters. The order of the fields varies depending on the locale's 

  * date format setting. Locale information, which is set and retrieved using 

  * class @c TLocale, is used to determine field order and the characters used 

  * to separate the date components. The upper and lower field bounds are set, 

  * and dates outside these bounds are invalid.

  *

  * The editor can be configured to launch a pop-out calendar dialog, 

  * @c CEikCalendar. This may be used to directly set the day, month and year 

  * values. 

  *

  * The editor has an associated resource struct @c DATE_EDITOR and control 

  * factory identifier @c EEikCtDateEditor.

  *

  */

 class CEikDateEditor : public CEikTTimeEditor, private MEikCalendarObserver

 	{

 public:

     // miscellaneous functions

     /**

      * C++ default constructor.

      */

     IMPORT_C CEikDateEditor();

     /**

      * Destructor.

      */

     IMPORT_C virtual ~CEikDateEditor();

     // to be called by container only if not constructed from resource

     /**

      * Handles 2nd phase construction.

      *

      * This function completes the construction of a newly-allocated date 

      * editor. This function should be used instead of 

      * @c ConstructFromResourceL() when not initialising from a resource file.

      * The editor's minimum, maximum and initial date values are set and the 

      * date format and date separator characters specified in class @c TLocale

      * are honoured.

      * 

      * @param aMinimumDate The minimum allowable date.

      * @param aMaximumDate The maximum allowable date.

      * @param aInitialDate The initial value.

      * @param aWithoutPopoutCalendar If @c ETrue the editor will not have a 

      *        pop-out calendar dialog / icon. If @c EFalse the editor will have

      *        a pop-out calendar dialog / icon.

      */

     IMPORT_C void ConstructL(const TTime& aMinimumDate, 

                              const TTime& aMaximumDate, 

                              const TTime& aInitialDate, 

                              TBool aWithoutPopoutCalendar); 

     /**

      * Sets the date editor's value.

      * 

      * @param aDate The editor's value. Time components are ignored.

      */

     IMPORT_C void SetDate(const TTime& aDate);

     /**

      * Gets the date editor's value.

      *

      * @return The editor's date value.

      */

 	IMPORT_C TTime Date() const;

     /**

      * Sets date editor to initialised or uninitialised.

      * 

      * @param aUninitialised If @c ETrue then the date editor is set 

      *        to be uninitialised.

      */

 	IMPORT_C void SetUninitialised(TBool aUninitialised);

     /**

      * Tests whether the editor is uninitialised.

      * 

      * @return @c ETrue if uninitialised.

      */

 	IMPORT_C TBool IsUninitialised() const;

 	// from CEikTTimeEditor

 	// only values inside the initial minimum and maximum are permitted

     /**

      * From @c CEikTTimeEditor.

      * 

      * Sets the minimum and maximum allowable dates.

      *

      * If the current date is outside the new bounds it is changed to be within

      * them.

      *

      * @param aMinimumDate The minimum allowable value.

      * @param aMaximumDate The maximum allowable value.

      */

     IMPORT_C virtual void SetMinimumAndMaximum(const TTime& aMinimumDate, 

                                                const TTime& aMaximumDate); 

     /**

      * From @c CEikTTimeEditor.

      *

      * Gets the date editor's minimum and maximum values.

      *

      * @param aMinimumDate On return, the minimum allowable value.

      * @param aMaximumDate On return, the maximum allowable value.

      */

     IMPORT_C virtual void GetMinimumAndMaximum(TTime& aMinimumDate, 

                                                TTime& aMaximumDate) const;

     // from CCoeControl

     /**

      * From @c CCoeControl.

      *

      * Handles key events.

      *

      * @param aKeyEvent The key event.

      * @param aType The type of key event.

      * @return @c EKeyConsumed if the key has beend handled. 

      */

     IMPORT_C virtual TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent, 

                                                  TEventCode aType);

     /**

      * From @c CCoeControl.

      * 

      * Second-phase construction from a resource file.

      *

      * The function reads the maximum and minimum date values and whether 

      * or not the editor should support a pop-out calendar and/or date icon 

      * from a @c DATE_EDITOR resource. It sets the initial date to be the same 

      * as the maximum date and honours the locale's date format and separators.

      * 

      * @param aResourceReader A resource file reader.

      */

     IMPORT_C virtual void ConstructFromResourceL(TResourceReader& 

                                                  aResourceReader);

     /**

      * From @c CCoeControl.

      * 

      * Editor validation.

      *

      * This function should be called before an attempt is made to remove focus

      * from a date editor. If the control value is not within the bounds 

      * specified by the minimum and maximum date values, it is reset to the 

      * nearest allowable value, the function then leaves.

      */

     IMPORT_C virtual void PrepareForFocusLossL();

     /**

      * From @c CCoeControl.

      * 

      * Handles pointer events.

      *

      * @param aPointerEvent The pointer event.

      */

     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);

 private:

     // from CEikMfne

     virtual void CreatePopoutIfRequiredL();

     // from CEikTTimeEditor

     virtual void SetTTime(const TTime& aDate);

     virtual TTime GetTTime() const; // can only be called if PrepareForFocusLossL() succeeded

 private:

     // from MEikCalendarDialogObserver

     virtual void GetMinimumAndMaximumAndInitialDatesForCalendarL(TTime& aMinimumDate, 

                                                                  TTime& aMaximumDate, 

                                                                  TTime& aInitialDate) const;

     virtual void SetDateFromCalendarAndDrawNow(const TTime& aDate);

     // miscellaneous functions

     void DoSetMinimumAndMaximum(const TTime& aMinimumDate, const TTime& aMaximumDate);

     IMPORT_C virtual void CEikMfne_Reserved();

 private:

     /**

     * From CAknControl

     */

     IMPORT_C void* ExtensionInterface( TUid aInterface );

 private:

 	CDateEditor* iDateEditor;

 	TTime iMinimumDate;

 	TTime iMaximumDate;

 	TInt iSpare;

 	};

 //

 /**

  * Time and date editor.

  * 

  * This control allows both a time and date to be displayed and edited.

  * It contains the following time fields: hours, minutes and seconds,

  * two time separator characters and am/pm text, and the following date

  * fields: year, month and day, with two date separator characters. The

  * seconds and hours fields are optional and the order of the date fields and

  * the separator characters are locale-dependent. The upper and lower

  * field bounds are set, and dates and times outside these bounds are

  * invalid.

  * 

  * Date field values may be edited directly or via a pop-out calendar

  * dialog.

  * 

  * The editor has an associated resource struct TIME_AND_DATE_EDITOR

  * and control factory identifier EEikCtTimeAndDateEditor. 

  */

 class CEikTimeAndDateEditor : public CEikTTimeEditor, private MEikCalendarObserver

 	{

 public:

 	// miscellaneous functions

     /**

      * Default constructor.

      * 

      * This function should be used as the first stage in two stage

      * construction, followed by a call to either ConstructFromResourceL() to

      * initialise the editor's field values from a resource file, or ConstructL()

      * (if no resource file is used). 

      */

 	IMPORT_C CEikTimeAndDateEditor();

     /**

      * Destructor. 

      * 

      * This frees the resources owned by the time and date editor, prior to

      * its destruction.

      */

 	IMPORT_C virtual ~CEikTimeAndDateEditor();

 	// ConstructL to be called by container only if not constructed from resource, also ownership of aInterveningText is transferred when everything that can leave has successfully been done

     /**

      * Second phase construction.

      * 

      * This function completes construction of a newly-allocated date and

      * time editor, by setting the minimum, maximum and initial date and time

      * values. It should be called by the container only if the control is

      * not constructed from a resource file.

      * 

      * The aFlags parameter is used to set whether the seconds or hours

      * fields are not required. The minutes field is always present. It may also

      * be used to specify whether or not to force 24 hour time format,

      * overriding the locale's setting, and whether the editor should have a

      * pop-out calendar dialog.

      * 

      * The locale-dependant date and time settings specified in class

      * TLocale are honoured.

      * 

      * If the initial date/time is outside the bounds specified by the

      * minimum and maximum, it is set to the nearest valid setting.

      * 

      * A panic will occur if the minimum date/time is later than the

      * maximum date/time.

      * 

      * @param aMinimumTimeAndDate The minimum date and time value.

      * @param aMaximumTimeAndDate The maximum date and time value.

      * @param aInitialTimeAndDate The initial date and time value.

      * @param aFlags A bitmask of flags. See eikon.hrh file, EEikTime,

      * EEikDate etc.

      * @param aInterveningText Descriptor containing the text to use to

      * separate the time and date portions of the editor.     

      */

 	IMPORT_C void ConstructL(const TTime& aMinimumTimeAndDate, const TTime& aMaximumTimeAndDate, const TTime& aInitialTimeAndDate, TUint32 aFlags, HBufC* aInterveningText=NULL);

     /**

      * Sets the values of the time and date editor's fields.

      * 

      * @param aTimeAndDate The new value for the date and time editor's

      * fields.

      */

 	IMPORT_C void SetTimeAndDate(const TTime& aTimeAndDate);

     /**

      * Gets the time and date editor's value.

      * 

      * @return The editor's value.

      */

 	IMPORT_C TTime TimeAndDate() const;

     /**

      * Sets the uninitialized status of the editor.

      * 

      * @param aUninitialised If ETrue, sets the editor as uninitialized,

      *                       i.e. it doesn't display anything.

      */

 	IMPORT_C void SetUninitialised(TBool aUninitialised);

 	/**

 	 * Gets the uninitialized status of the editor.

 	 * 

 	 * @return ETrue, if the editor is set as uninitialized.

 	 */	

 	IMPORT_C TBool IsUninitialised() const;

 	// from CEikTTimeEditor

     /**

      * Sets the range of allowable values.

      * 

      * These define the maximum and minimum time/date values that may be

      * entered by the user.

      * 

      * If the existing date/time value is outside the new bounds, it is

      * reset to the nearest allowable value.

      * 

      * @param aMinimumTimeAndDate The minimum allowable value.

      * @param aMaximumTimeAndDate The maximum allowable value.

      */

 	IMPORT_C virtual void SetMinimumAndMaximum(const TTime& aMinimumTimeAndDate, const TTime& aMaximumTimeAndDate); // only values inside the initial minimum and maximum are permitted

     /**

      * Gets the range of allowable values that may be entered by the user.

      * 

      * @param aMinimumTimeAndDate On return, contains the time and date

      * editor's minimum allowable value.

      * @param aMaximumTimeAndDate On return, contains the time and date

      * editor's maximum allowable value.

      */

 	IMPORT_C virtual void GetMinimumAndMaximum(TTime& aMinimumTimeAndDate, TTime& aMaximumTimeAndDate) const;

 	// from CCoeControl

     /**

      * Handles key events.

      * 

      * For example, the Tab key validates and launches a calendar popout.

      * 

      * Calls CEikMfne::OfferKeyEventL() if the control does not consume the

      * key.

      * 

      * @param aKeyEvent The key event.

      * @param aType The type of key event.

      * @return Returns EKeyWasConsumed if the control consumes the key.

      */

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

     /**

      * Second phase construction from a resource.

      * 

      * This function completes the construction of a newly-allocated

      * date/time editor from a TIME_AND_DATE_EDITOR resource. The minimum and

      * maximum date/times, the date and time flag settings, and the intervening

      * text are read from the resource, and ConstructL() is called with these

      * settings. The initial date/time is set to the maximum date/time value. 

      * 

      * @param aResourceReader A resource file reader.

      */

 	IMPORT_C virtual void ConstructFromResourceL(TResourceReader& aResourceReader);

     /**

      * Prepares the editor for focus loss.

      * 

      * This function should be called to validate the editor's contents

      * when an attempt is made to remove focus from the control. If the control

      * value is not within the bounds specified by the minimum and maximum

      * date/time values, it is reset to the nearest allowable value, the

      * function will leave and display an appropriate message.

      */

 	IMPORT_C virtual void PrepareForFocusLossL();

     /**

      * From @c CCoeControl.

      * 

      * Handles pointer events.

      *

      * @param aPointerEvent The pointer event.

      */

     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);	

 private:

 	// from CEikMfne

 	virtual void CreatePopoutIfRequiredL();	

 	IMPORT_C virtual void CEikMfne_Reserved();

 	// from CEikTTimeEditor

 	virtual void SetTTime(const TTime& aTimeAndDate);

 	virtual TTime GetTTime() const; // can only be called if PrepareForFocusLossL() succeeded

 private:

 	// from MEikCalendarDialogObserver

 	virtual void GetMinimumAndMaximumAndInitialDatesForCalendarL(TTime& aMinimumDate, TTime& aMaximumDate, TTime& aInitialDate) const;

 	virtual void SetDateFromCalendarAndDrawNow(const TTime& aDate);

 	// miscellaneous functions

 	void DoSetMinimumAndMaximum(const TTime& aMinimumTimeAndDate, const TTime& aMaximumTimeAndDate);

 private:

     /**

     * From CAknControl

     */

     IMPORT_C void* ExtensionInterface( TUid aInterface );

 private:

 	CTimeEditor* iTimeEditor;

 	CDateEditor* iDateEditor;

 	TTime iMinimumTimeAndDate;

 	TTime iMaximumTimeAndDate;

 	TInt iSpare;

 	};

 //

 /**

  * Duration editor.

  * 

  * The duration editor allows a time duration to be displayed and

  * edited. The editor has a clock icon and an edit field with separators for

  * hours, minutes, and seconds. These fields can all be suppressed using

  * the appropriate flags in the resource declaration.

  * 

  * Unlike the time editor control, the duration editor has no am or pm

  * text. This is because the duration is a length of time (from 0 to 24

  * hours), rather than a point in time.

  * 

  * The minimum and maximum values are set, and values outside these

  * limits are invalid.

  * 

  * The editor has an associated resource struct DURATION_EDITOR and

  * control factory identifier EEikCtDurationEditor. 

  */

 class CEikDurationEditor : public CEikMfne

 	{

 public:

 	// miscellaneous functions

     /**

      * Default constructor.

      * 

      * This function should be used as the first stage in two stage

      * construction, followed by a call to either ConstructFromResourceL() to

      * initialise the editor's field values from a resource file, or ConstructL()

      * if no resource file is used.

      */

 	IMPORT_C CEikDurationEditor();

     /**

      * Destructor.

      * 

      * The destructor frees the resources owned by the duration editor,

      * prior to its destruction.

      */

 	IMPORT_C virtual ~CEikDurationEditor();

     /**

      * Second phase construction.

      * 

      * This function completes the construction of a newly-allocated

      * duration editor. This function should be used instead of

      * ConstructFromResourceL() when not initialising from a resource file.

      * 

      * The function sets the editor's minimum, maximum and initial values.

      * The time separator characters specified in class TLocale are honoured.

      * If the initial duration is less than the minimum value the minimum

      * value is used as the initial setting. If the initial duration is greater

      * than the maximum value the maximum value is used as the initial

      * setting.

      * 

      * The aFlags parameter is used to determine whether the seconds or

      * hours fields are not required. The minutes field is always present.

      * Regardless of the value specified in aFlags, 24 hour time format is set,

      * overriding the locale's setting.

      * 

      * @param aMinimumDuration The minimum interval in seconds.

      * @param aMaximumDuration The maximum interval in seconds.

      * @param aInitialDuration The initial interval in seconds.

      * @param aFlags Duration editor flags.

      */

 	IMPORT_C void ConstructL(const TTimeIntervalSeconds& aMinimumDuration, const TTimeIntervalSeconds& aMaximumDuration, const TTimeIntervalSeconds& aInitialDuration, TUint32 aFlags);

     /**

      * Sets the minimum and maximum duration values.

      * 

      * The user can only enter values between these bounds.

      * 

      * @param aMinimumDuration The minimum duration.

      * @param aMaximumDuration The maximum duration.

      * @panic 48 If the minimum duration exceeds the maximum.

      */

 	IMPORT_C void SetMinimumAndMaximum(const TTimeIntervalSeconds& aMinimumDuration, const TTimeIntervalSeconds& aMaximumDuration); // only values inside the initial minimum and maximum are permitted

     /**

      * Gets the duration editor's minimum and maximum values.

      * 

      * @param aMinimumDuration On return, the minimum value.

      * @param aMaximumDuration On return, the maximum value.

      */

 	IMPORT_C void GetMinimumAndMaximum(TTimeIntervalSeconds& aMinimumDuration, TTimeIntervalSeconds& aMaximumDuration) const;

     /**

      * Sets the duration editor's value.

      * 

      * @param aDuration The new value to convert into hours, minutes and

      * seconds and to which the duration editor's fields will be set.

      */

 	IMPORT_C void SetDuration(const TTimeIntervalSeconds& aDuration);

     /**

      * Gets the duration editor's value and returns it as a period of

      * seconds.

      * 

      * @return The editor's value in seconds.

      */

 	IMPORT_C TTimeIntervalSeconds Duration() const; // can only be called if PrepareForFocusLossL() succeeded

 	// framework

     /**

      * Second-phase construction from a resource.

      * 

      * The function reads the maximum and minimum duration values, and the

      * flags settings, from a DURATION_EDITOR resource. It sets the initial

      * duration to be the same as the maximum value and honours the locale's

      * time separators.

      * 

      * @param aResourceReader A resource file reader.

      */

 	IMPORT_C void ConstructFromResourceL(TResourceReader& aResourceReader);

     /**

      * Editor validation.

      * 

      * This function should be called when an attempt is made to remove

      * focus from a duration editor. If the editor value is not within the

      * bounds specified by the minimum and maximum duration values, it is reset to

      * the nearest allowable value - the function will leave.

      */

 	IMPORT_C void PrepareForFocusLossL();

     // From CCoeControl    

     /**

      * From @c CCoeControl.

      * 

      * Handles pointer events.

      *

      * @param aPointerEvent The pointer event.

      */

     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);	

 private:

 	// miscellaneous functions

 	void DoSetMinimumAndMaximum(const TTimeIntervalSeconds& aMinimumDuration, const TTimeIntervalSeconds& aMaximumDuration);

 	IMPORT_C virtual void CEikMfne_Reserved();

 private:

     /**

     * From CAknControl

     */

     IMPORT_C void* ExtensionInterface( TUid aInterface );

 private:

 	CTimeEditor* iTimeEditor;

 	TTimeIntervalSeconds iMinimumDuration;

 	TTimeIntervalSeconds iMaximumDuration;

 	TInt iSpare;

 	};

 /**

  * Time offset editor.

  * 

  * This control allows a signed time offset to be displayed and edited.

  * It has the same fields as the time editor control CEikTimeEditor,

  * except there is no AM or PM text because the value is a time offset,

  * positive or negative, from 0 to 24 hours rather than a point in time.

  * 

  * The editor has an associated resource struct TIME_OFFSET_EDITOR and

  * control factory identifier EEikCtTimeOffsetEditor. 

  */

 class CEikTimeOffsetEditor : public CEikMfne

 	{

 public:

 	// miscellaneous functions

     /**

      * Default constructor.

      * 

      * This function should be used as the first stage in two stage

      * construction, followed by a call to either ConstructFromResourceL() to

      * initialise the editor's field values from a resource file, or ConstructL()

      * if no resource file is used.

      */

 	IMPORT_C CEikTimeOffsetEditor();

     /**

      * Destructor. This frees the resources owned by the time offset editor,

      * prior to its destruction.

      */

 	IMPORT_C virtual ~CEikTimeOffsetEditor();

     /**

      * Second phase constructor.

      * 

      * This function completes the construction of a time offset editor, by

      * setting its minimum, maximum and initial values. The time separator

      * characters specified in the system's locale are honoured. It should be

      * called by the container only if the control is not constructed from a

      * resource file.

      * 

      * The aFlags parameter is used to determine whether the seconds or

      * hours fields are displayed by the editor. The minutes field is always

      * displayed. This function forces 24 hour time format for the time offset

      * editor, overriding the locale's setting.

      * 

      * If the initial time offset is outside the bounds specified, it is

      * invalid and will be reset to the upper or lower bound.

      * 

      * The minimum value for a time offset editor is -23:59:59, and the

      * maximum value is 23:59:59.

      * 

      * @param aMinimumTimeOffset The minimum allowable value, in seconds.

      * @param aMaximumTimeOffset The maximum allowable value, in seconds.

      * @param aInitialTimeOffset The initial value, in seconds.

      * @param aFlags Determines which fields are required. Specify

      * CTimeEditor::EWithoutSecondsField for no seconds field,

      * CTimeEditor::EWithoutHoursField for no hours field. 24 hour clock format is set, regardless

      * of the flag setting specified in this parameter.

      */

 	IMPORT_C void ConstructL(const TTimeIntervalSeconds& aMinimumTimeOffset, const TTimeIntervalSeconds& aMaximumTimeOffset, const TTimeIntervalSeconds& aInitialTimeOffset, TUint32 aFlags);

     /**

      * Sets the range of allowable offset values. 

      * 

      * These define the maximum and minimum values that may be entered by

      * the user.

      * 

      * If the existing offset value is outside the bounds set by this

      * function, it is reset to the nearest boundary value.

      * 

      * @param aMinimumTimeOffset The minimum allowable value.

      * @param aMaximumTimeOffset The maximum allowable value.

      * @panic 49 If the minimum exceeds the maximum.

      */

 	IMPORT_C void SetMinimumAndMaximum(const TTimeIntervalSeconds& aMinimumTimeOffset, const TTimeIntervalSeconds& aMaximumTimeOffset); // only values inside the initial minimum and maximum are permitted

     /**

      * Gets the range of allowable values that may be entered by the user.

      * 

      * @param aMinimumTimeOffset On return, contains the time offset

      * editor’s minimum allowable value.

      * @param aMaximumTimeOffset On return, contains the time offset

      * editor’s maximum allowable value.

      */

 	IMPORT_C void GetMinimumAndMaximum(TTimeIntervalSeconds& aMinimumTimeOffset, TTimeIntervalSeconds& aMaximumTimeOffset) const;

     /**

      * Sets the time offset editor's value.

      * 

      * The sign is set according to whether the value specified is positive

      * or negative.

      * 

      * @param aTimeOffset The new offset value to which to assign to the

      * editor.

      */

 	IMPORT_C void SetTimeOffset(const TTimeIntervalSeconds& aTimeOffset);

     /**

      * Gets the time offset editor's value converted into seconds.

      * 

      * @return The editor's value in seconds.

      */

 	IMPORT_C TTimeIntervalSeconds TimeOffset() const; // can only be called if PrepareForFocusLossL() succeeded

 	// framework

     /**

      * Second phase construction from a resource. 

      * 

      * This function completes the construction of a time offset editor

      * from a TIME_OFFSET_EDITOR resource.

      * 

      * The minimum and maximum time offsets, and the flags settings are

      * read from the resource, and ConstructL() is called with these settings.

      * The initial time offset is set to the maximum time offset value.

      * 

      * @param aResourceReader A resource file reader.

      */

 	IMPORT_C void ConstructFromResourceL(TResourceReader& aResourceReader);

     /**

      * Prepares editor for focus loss.

      * 

      * This function should be called to validate the editor’s contents

      * when an attempt is made to remove focus from the control.

      * 

      * If the control value is not within the bounds specified by the

      * minimum and maximum time offset values, it is reset to the nearest

      * allowable value. The function then leaves.

      */

 	IMPORT_C void PrepareForFocusLossL();

     // From CCoeControl    

     /**

      * From @c CCoeControl.

      * 

      * Handles pointer events.

      *

      * @param aPointerEvent The pointer event.

      */

     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);	

 private:

 	// miscellaneous functions

 	void DoSetMinimumAndMaximum(const TTimeIntervalSeconds& aMinimumTimeOffset, const TTimeIntervalSeconds& aMaximumTimeOffset);

 	IMPORT_C virtual void CEikMfne_Reserved();

 private:

     /**

     * From CAknControl

     */

     IMPORT_C void* ExtensionInterface( TUid aInterface );

 private:

 	CTimeEditor* iTimeEditor;

 	TTimeIntervalSeconds iMinimumTimeOffset;

 	TTimeIntervalSeconds iMaximumTimeOffset;

 	// none of these pointers owns anything

 	CEikMfneSymbol* iSign;

 	TInt iSpare;

 	};

 //

 // Longitude and Latitude editors removed 2.4.2002:

 enum

 	{

 	EEikOrientationNorthSouth   =0x1000,

 	EEikOrientationWestEast     =0x2000,

 	EEikOrientationMask=EEikOrientationNorthSouth|EEikOrientationWestEast

 	};

 enum

 	{

 	EEikDirectionNegative,

 	EEikDirectionPositive,

 	EEikDirectionMask=EEikDirectionNegative|EEikDirectionPositive

 	};

 enum TEikCompass

 	{

 	EEikCompassNorth=EEikOrientationNorthSouth|EEikDirectionNegative,

 	EEikCompassSouth=EEikOrientationNorthSouth|EEikDirectionPositive,

 	EEikCompassEast=EEikOrientationWestEast|EEikDirectionNegative,

 	EEikCompassWest=EEikOrientationWestEast|EEikDirectionPositive

 	};

 struct SEikDegreesMinutesDirection

 	{

 	TInt iDegrees;

 	TInt iMinutes;

 	TInt iSeconds;

 	TEikCompass iDirection;

 	};

 #endif  // __EIKMFNE_H__

 // End of file