/*

* 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 the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members

* which accompanies this distribution, and is available

* at the URL "http://www.symbianfoundation.org/legal/licencesv10.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

        };

    /** 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.