S60 3rd Edition API Reference: eikmfne.h Source File

eikmfne.h

Go to the documentation of this file.
00001 // EIKMFNE.H
00002 //
00003 // Copyright (c) 1997-1999 Symbian Ltd.  All rights reserved.
00004 //
00005 
00006 #if !defined(__EIKMFNE_H__)
00007 #define __EIKMFNE_H__
00008 
00009 #if !defined(__EIKBCTRL_H__)
00010 #include <eikbctrl.h>
00011 #endif
00012 
00013 #if !defined(__COEDEF_H__)
00014 #include <coedef.h>
00015 #endif
00016 
00017 #if !defined(__COEINPUT_H__)
00018 #include <coeinput.h>
00019 #endif
00020 
00021 // For MEikCalendarObserver
00022 #if !defined(__EIKCAL_H__)
00023 #include <eikcal.h>     
00024 #endif
00025 
00026 #if !defined(__EIKDEF_H__)
00027 #include <eikdef.h>
00028 #endif
00029 
00030 #if !defined(__BABITFLAGS_H__)
00031 #include <babitflags.h>
00032 #endif
00033 
00034 // For MAknMfneCommandObserver
00035 #if !defined(__AKNMFNECOMMANDOBSERVER)
00036 #include <AknMfneCommandObserver.h>
00038 #endif
00039 
00040 //
00041 // Forward Declarations
00042 //
00043 class CEikonEnv;
00044 class CTimeEditor;
00045 class CDateEditor;
00046 
00047 // Skin-related API forward declarations
00048 class MAknsControlContext;
00049 
00050 // Extension object within CEikMfne
00051 class CEikMfneExtension;
00052 
00053 //
00057 class CEikMfneField : public CBase
00058         {
00059 public:
00063         enum THighlightType
00064                 {
00066                 EInverseVideo,
00068                 ECursor
00069                 };
00070 protected:
00076         IMPORT_C CEikMfneField();
00077 public:
00078         void Draw(CWindowGc& aGc, const CFont& aFont, const TPoint& aTopLeft) const;
00079         TInt WidthInPixels(const CFont& aFont) const;
00080         TInt DistanceFromStartOfFieldToEndOfTextInPixels(const CFont& aFont) const;
00081 
00090         virtual TInt MaximumWidthInPixels(const CFont& aFont, TBool aShrinkToMinimumSize)=0;
00091 
00098         virtual TCoeInputCapabilities InputCapabilities() const=0;
00099         
00108         IMPORT_C virtual TBool IsEditable() const;
00109         
00118         IMPORT_C virtual TBool IsValid() const;
00119         
00131         IMPORT_C virtual THighlightType HighlightType() const;
00132         
00152         IMPORT_C virtual void HandleKey(const CFont& aFont, const TKeyEvent& aKeyEvent, TBool aInterpretLeftAndRightAsEarEvents, TBool& aDataAltered, TInt& aHighlightIncrement);
00153         
00170         IMPORT_C virtual void HandleDeHighlight(const CFont& aFont, CEikonEnv& aEikonEnv, TBool& aDataAltered, TBool& aError);
00171         
00172 protected:
00182         IMPORT_C void HandleLeftOrRightArrow(TChar aKey, TBool& aDataAltered, TInt& aHighlightIncrement);
00183 
00184     TInt AdditionalWidthForHighlights(const CFont& aFont) const;
00185 private:
00186         virtual const TDesC& Text() const=0;
00187 protected:
00191         TInt iMinimumWidthInPixels;
00192         };
00193 
00194 //
00195 
00201 NONSHARABLE_CLASS(CEikMfneSeparator) : public CEikMfneField
00202         {
00203 private:
00204         CEikMfneSeparator(HBufC* aText);
00205 public:
00211         IMPORT_C virtual ~CEikMfneSeparator();
00212         
00221         IMPORT_C static CEikMfneSeparator* NewL(TResourceReader& aResourceReader);
00222         
00229         IMPORT_C static CEikMfneSeparator* NewL(HBufC* aText); // ownership of aText is transferred when everything that can leave has successfully been done
00230         
00239         IMPORT_C void SetText(HBufC* aText); // allows later transfer of ownership of text - can only be called if aText was previously NULL
00240     
00241 private: // framework
00242         virtual TInt MaximumWidthInPixels(const CFont& aFont, TBool aShrinkToMinimumSize);
00243         virtual TCoeInputCapabilities InputCapabilities() const;
00244         virtual const TDesC& Text() const;
00245 private:
00246         HBufC* iText;
00247         };
00248 
00249 //
00250 
00254 NONSHARABLE_CLASS(CEikMfneNumber) : public CEikMfneField
00255         {
00256 public:
00262         enum
00263                 {
00265                 EFillWithLeadingZeros                   =0x1,
00267                 EPreserveOldWidthBeforeEditing  =0x2,
00269                 ERepresentsYear                                 =0x4,
00271                 EPublicallySettableFlags                =EFillWithLeadingZeros|EPreserveOldWidthBeforeEditing|ERepresentsYear
00272                 };
00273 private:
00274         enum
00275                 {
00276                 EIsBeingEditedWithCursor                =0x8,
00277                 EIsUninitialised                                =0x10
00278 #start_since SINCE_3_1_SDK
00279                 ,EFillWithTrailingZeros          =0x20
00280 #end_since SINCE_3_1_SDK
00281                 };
00282 private:
00283         CEikMfneNumber(TInt aMinimumValue, TInt aMaximumValue, TUint32 aFlags);
00284         void ConstructL();
00285 public:
00291         IMPORT_C virtual ~CEikMfneNumber();
00292         
00302         IMPORT_C static CEikMfneNumber* NewL(const CFont& aFont, TResourceReader& aResourceReader);
00303 
00315         IMPORT_C static CEikMfneNumber* NewL(const CFont& aFont, TInt aMinimumValue, TInt aMaximumValue, TInt aInitialValue, TUint32 aFlags);
00316         
00325         IMPORT_C void SetMinimumAndMaximum(TInt aMinimumValue, TInt aMaximumValue, const CFont& aFont); // only values inside the initial minimum and maximum are permitted
00326         
00333         IMPORT_C void GetMinimumAndMaximum(TInt& aMinimumValue, TInt& aMaximumValue) const;
00334         
00341         IMPORT_C void SetValue(TInt aValue, const CFont& aFont);
00342         
00350         IMPORT_C TInt Value() const;
00351         
00358         IMPORT_C virtual TBool IsValid() const;
00359 
00366         IMPORT_C void SetUninitialised(TBool aUninitialised);
00367         
00373         IMPORT_C TBool IsUninitialised() const;
00374 
00375 public:
00376 #start_since SINCE_3_1_SDK
00377 
00385         IMPORT_C void SetDigitType(TDigitType aDigitType, const CFont& aFont);
00386 #end_since SINCE_3_1_SDK
00387 
00388 #start_since SINCE_3_1_SDK
00389 
00396         IMPORT_C TDigitType DigitType() const;
00397 #end_since SINCE_3_1_SDK
00398 
00399 #start_since SINCE_3_1_SDK
00400 
00407         IMPORT_C void RefreshDigitType(const CFont& aFont);
00408         
00409         void SetTrailingZeros();
00410 #end_since SINCE_3_1_SDK
00411 
00412 public:
00413         TBool IsTextNull() const;
00414 private: // framework
00415         virtual TInt MaximumWidthInPixels(const CFont& aFont, TBool aShrinkToMinimumSize);
00416         virtual TCoeInputCapabilities InputCapabilities() const;
00417         virtual TBool IsEditable() const;
00418         virtual THighlightType HighlightType() const;
00419         virtual void HandleKey(const CFont& aFont, const TKeyEvent& aKeyEvent, TBool aInterpretLeftAndRightAsEarEvents, TBool& aDataAltered, TInt& aHighlightIncrement);
00420         virtual void HandleDeHighlight(const CFont& aFont, CEikonEnv& aEikonEnv, TBool& aDataAltered, TBool& aError);
00421         virtual const TDesC& Text() const;
00422 private:
00423         TInt MaximumNumberOfDigits() const;
00424         TInt NumberOfDigits() const;
00425         void SetTextToValue(TInt aValue, const CFont& aFont);
00426         TInt ValueFromText() const;
00427         TBool ConvertsIntoValidValue(TInt& aValue) const;
00428 
00429 private: // International digit support
00430         TChar NormalizeDigit(TChar aChar);
00431         TText ZeroCharacter() const;
00432         TText NegativeCharacter() const;
00433 
00434 private:
00435         TInt iMinimumValue;
00436         TInt iMaximumValue;
00437         TInt iMaxDigits;
00438         TUint32 iFlags;
00439         HBufC* iText;
00440         TChar iNudgeCharMinus;
00441         TChar iNudgeCharPlus;
00442         TInt iMaxDigitsMinimumValue;
00443     TInt iMaxDigitsMaximumValue;
00444         TDigitType      iDigitType;
00445         };
00446 
00447 //
00448 
00454 NONSHARABLE_CLASS(CEikMfneSymbol) : public CEikMfneField
00455         {
00456 public:
00460         NONSHARABLE_CLASS(CItem) : public CBase
00461                 {
00462         private:
00463                 CItem(TInt aId, TChar aKeyToMatch, HBufC* aText);
00464         public:
00470                 IMPORT_C virtual ~CItem();
00471                 
00479                 IMPORT_C static CItem* NewL(TResourceReader& aResourceReader);
00480                 
00489                 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
00490         
00500                 IMPORT_C void SetText(HBufC* aText); // allows later transfer of ownership of text - can only be called if aText was previously NULL
00501         private:
00502                 friend class CEikMfneSymbol;
00503         private:
00504                 TInt iId;
00505                 TCharF iKeyToMatch;
00506                 HBufC* iText;
00507                 };
00508 private:
00509         CEikMfneSymbol(TInt aNumSymbolicItems);
00510 public:
00516         IMPORT_C virtual ~CEikMfneSymbol();
00517         
00527         IMPORT_C static CEikMfneSymbol* NewL(TResourceReader& aResourceReader);
00528         
00539         IMPORT_C static CEikMfneSymbol* NewL(TInt aNumSymbolicItems);
00540 
00555         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"
00556         
00564         IMPORT_C void SetCurrentSymbolicItemToId(TInt aId);
00565         
00571         IMPORT_C TInt IdOfCurrentSymbolicItem() const;
00572         
00579         IMPORT_C void SetUninitialised(TBool aUninitialised);
00580         
00586         IMPORT_C TBool IsUninitialised() const;
00587         
00588 private: // framework
00589         virtual TInt MaximumWidthInPixels(const CFont& aFont, TBool aShrinkToMinimumSize);
00590         virtual TCoeInputCapabilities InputCapabilities() const;
00591         virtual TBool IsEditable() const;
00592         virtual THighlightType HighlightType() const;
00593         virtual void HandleKey(const CFont& aFont, const TKeyEvent& aKeyEvent, TBool aInterpretLeftAndRightAsEarEvents, TBool& aDataAltered, TInt& aHighlightIncrement);
00594         virtual void HandleDeHighlight(const CFont& aFont, CEikonEnv& aEikonEnv, TBool& aDataAltered, TBool& aError);
00595         virtual const TDesC& Text() const;
00596 private:
00597         TInt CurrentSymbolicItem() const;
00598         void SetCurrentSymbolicItem(TInt aCurrentSymbolicItem);
00599 private:
00600         TInt iNumSymbolicItems;
00601         TInt iCurrentSymbolicItem;
00602         CItem** iSymbolicItems;
00603         };
00604 
00605 //
00606 
00631 class CEikMfne : public CEikBorderedControl, public MAknMfneCommandObserver
00632         {
00633 public:
00634         // miscellaneous functions
00638         IMPORT_C CEikMfne();
00639         
00647         IMPORT_C virtual ~CEikMfne();
00648 
00658         IMPORT_C void CreateFieldArrayL(TInt aNumFields); // to be called by container only if not constructed from resource
00659 
00675         IMPORT_C void AddField(CEikMfneField* aField); // to be called by container only if not constructed from resource - ownership of aField is transferred to "this"
00676 
00677 #start_since SINCE_3_1_SDK
00678 
00684         IMPORT_C void ResetFieldArray(); // after this CreateFieldArrayL() can be called again
00685 #end_since SINCE_3_1_SDK
00686         
00692         IMPORT_C TMargins BorderMargins() const;
00693         
00705         IMPORT_C void DrawNowAndLeaveWithTimeDateFormatInfoMsgL(TInt aResourceId, const TTime& aTimeDate) const;
00706 
00714         IMPORT_C CEikMfneField* Field(TInt aField) const;
00715         
00716 public:
00717         // some utility functions which other classes may find useful
00718         
00726         IMPORT_C static TTime ReadTime(TResourceReader& aResourceReader);
00727 
00736         IMPORT_C static TTime ReadDate(TResourceReader& aResourceReader);
00737 
00745         IMPORT_C static TTime ReadTimeAndDate(TResourceReader& aResourceReader);
00746         
00753         IMPORT_C static TTimeIntervalSeconds ReadDuration(TResourceReader& aResourceReader);
00754         
00764         IMPORT_C static TTimeIntervalSeconds ReadTimeOffset(TResourceReader& aResourceReader);
00765     
00772         IMPORT_C static TTimeIntervalSeconds Convert(const TTime& aTime);
00773     
00780         IMPORT_C static TTime Convert(const TTimeIntervalSeconds& aTimeIntervalSeconds);
00781     //
00787     inline TInt CurrentField() const;
00788 
00794     inline TInt NumFields() const;
00795 
00796 public: // AVKON addition
00804     IMPORT_C void SetMfneAlignment(TInt aAlignment);
00805     
00815     IMPORT_C void SetUpAndDownKeysConsumed(TBool aConsume);
00816 
00817 #start_since SINCE_3_1_SDK
00818 
00829     IMPORT_C void SetSuppressBackgroundDrawing( TBool aSuppress );
00830 #end_since SINCE_3_1_SDK
00831 
00832     // Highlights a field
00833     void HighlightField(  TInt aFieldPosition );
00834 
00842         IMPORT_C const CFont* Font() const;
00843         
00850         IMPORT_C void SetFont(const CFont* aFont);
00851 
00865     IMPORT_C void SetSkinBackgroundControlContextL( MAknsControlContext* aControlContext );
00866     
00867     
00875     IMPORT_C void HandleMfneCommandL(TInt aCommand);
00876     
00877 
00878 
00879 public: // from CCoeControl
00891         IMPORT_C virtual TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType);
00892 
00906         IMPORT_C virtual void PrepareForFocusLossL();
00907 
00915         IMPORT_C virtual TSize MinimumSize();
00916 
00926         IMPORT_C virtual void GetColorUseListL(CArrayFix<TCoeColorUse>& aColorUseList) const; // not available before Release 005u
00927 
00938         IMPORT_C virtual void HandleResourceChange(TInt aType);                 // not available before Release 005u
00939 
00947         IMPORT_C virtual TCoeInputCapabilities InputCapabilities() const;
00948 
00956         IMPORT_C virtual void HandlePointerEventL(const TPointerEvent& aPointerEvent);
00957 
00967         IMPORT_C virtual TTypeUid::Ptr MopSupplyObject( TTypeUid aId );
00968 
00969 public: // new 
00978     IMPORT_C void SetSkinTextColorL(TInt aAknSkinIDForTextColor, TInt aAknSkinIDForBgColor=KErrNotFound);
00979 
00980 protected:
00981         // framework
00990         IMPORT_C virtual void FocusChanged(TDrawNow aDrawNow);
00991 
00998         IMPORT_C void WriteInternalStateL(RWriteStream& aWriteStream) const;
00999 
01000         // miscellaneous functions
01001         
01020         IMPORT_C void HandleInteraction(TBool aHandleDeHighlight, TInt aNewCurrentField, TInt aOldWidthInPixelsOfOldCurrentField,
01021                                                                 CEikMfneField::THighlightType aOldHighlightTypeOfOldCurrentField, TBool& aDataAltered, TBool& aError);
01022                                                                 
01034         IMPORT_C virtual void FieldIsAboutToBeDeHighlighted(CEikMfneField* aField, TBool& aDrawAllFields); // first occurrence of this virtual function - does nothing by default
01035         
01043         IMPORT_C TSize MfneSize() const;
01044 
01054         IMPORT_C TSize MfneSize(TBool aShrinkToMinimumSize);
01055 
01056 public:
01057         static void InvalidFieldAlert();
01058         static void LeaveWithAlert(TInt aResourceId);
01059 
01060 private:
01061         // framework
01062         IMPORT_C virtual void Draw(const TRect& aRect) const;
01063         // new virtual functions
01064         IMPORT_C virtual void CreatePopoutIfRequiredL();
01065         // miscellaneous functions
01066         void DrawRange(CWindowGc& aGc, TInt aFirstField, TInt aLastField) const;
01067         CWindowGc& PreparedGc() const;
01068         void SetGcToNormalVideo(CWindowGc& aGc) const;
01069         void SetGcToInverseVideo(CWindowGc& aGc) const;
01070         void SetGcToDimmedVideo(CWindowGc& aGc) const;
01071         void DrawCursor();
01072         void HideCursor();
01073         IMPORT_C void Reserved_2();
01074         IMPORT_C virtual void CEikMfne_Reserved();
01075 private:
01079     IMPORT_C void* ExtensionInterface( TUid aInterface );
01080 
01081 private:
01082         enum {ENullIndex=KMaxTInt};
01083 
01090         TBool ConsumesUpAndDownKeys() const;
01091 
01102         TBool SkinningBackground() const;
01103 
01110         void EvaluateSkinningBackground(); 
01111 
01122     MAknsControlContext* SkinBackgroundControlContext() const;
01123 
01127     void CreateExtensionIfRequiredL();
01128 
01129 private:
01130         TInt iNumFields;
01131         TInt iCurrentField;
01132         CEikMfneField** iFields;
01133         CEikMfneExtension* iExtension;
01134         const CFont* iFont;
01135     TInt iAlignment;
01136     TBitFlags iFlags;
01137         };
01138 
01139 inline TInt CEikMfne::CurrentField() const
01140     {
01141     return(iCurrentField);
01142     }
01143 
01144 inline TInt CEikMfne::NumFields() const
01145     {
01146     return(iNumFields);
01147     }
01148 
01149 //
01150 
01162 class CEikNumberEditor : public CEikMfne
01163         {
01164 public:
01165         // miscellaneous functions
01166     
01175         IMPORT_C CEikNumberEditor();
01176         
01190         IMPORT_C void ConstructL(TInt aMinimumValue, TInt aMaximumValue, TInt aInitialValue); // to be called by container only if not constructed from resource
01191         
01204         IMPORT_C void SetMinimumAndMaximum(TInt aMinimumValue, TInt aMaximumValue); // only values inside the initial minimum and maximum are permitted
01205 
01214         IMPORT_C void GetMinimumAndMaximum(TInt& aMinimumValue, TInt& aMaximumValue) const;
01215 
01224         IMPORT_C void SetNumber(TInt aNumber);
01225 
01232         IMPORT_C TInt Number() const; // can only be called if PrepareForFocusLossL() succeeded
01233 
01234         // framework
01235 
01245         IMPORT_C virtual void ConstructFromResourceL(TResourceReader& aResourceReader);
01246 
01247     // From CCoeControl
01248 
01256     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);      
01257 private:
01258         IMPORT_C virtual void CEikMfne_Reserved();
01259 private:
01260         void RefreshFromLocale();
01261 private:
01265     IMPORT_C void* ExtensionInterface( TUid aInterface );
01266 private:
01267         // none of these pointers owns anything
01268         CEikMfneNumber* iNumber;
01269         TInt iSpare;
01270         };
01271 
01272 
01273 //
01277 struct SEikRange
01278         {
01282         TInt iLowerLimit;
01283 
01287         TInt iUpperLimit;
01288         };
01289 
01290 //
01291 
01307 class CEikRangeEditor : public CEikMfne
01308         {
01309 public:
01310         // miscellaneous functions
01311     
01320         IMPORT_C CEikRangeEditor();
01321 
01322         // 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
01340         IMPORT_C void ConstructL(TInt aMinimumValue, TInt aMaximumValue, const SEikRange& aInitialRange, HBufC* aSeparatorText);
01341 
01352         IMPORT_C void SetMinimumAndMaximum(TInt aMinimumValue, TInt aMaximumValue); // only values inside the initial minimum and maximum are permitted
01353 
01362         IMPORT_C void GetMinimumAndMaximum(TInt& aMinimumValue, TInt& aMaximumValue) const;
01363 
01369         IMPORT_C void SetRange(const SEikRange& aRange);
01370         
01378         IMPORT_C SEikRange Range() const; // can only be called if PrepareForFocusLossL() succeeded
01379         
01380         // framework
01381         
01391         IMPORT_C virtual void ConstructFromResourceL(TResourceReader& aResourceReader);
01392 
01393     // From CCoeControl
01394 
01402     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);
01403 private:
01404         virtual void FieldIsAboutToBeDeHighlighted(CEikMfneField* aField, TBool& aDrawAllFields);
01405         IMPORT_C virtual void CEikMfne_Reserved();
01406         void RefreshFromLocale();
01407 private:
01411     IMPORT_C void* ExtensionInterface( TUid aInterface );
01412 private:
01413         // none of these pointers owns anything
01414         CEikMfneNumber* iLowerLimit;
01415         CEikMfneNumber* iUpperLimit;
01416         TInt iSpare;
01417         };
01418 
01419 
01420 //
01421 
01426 class CEikTTimeEditor : public CEikMfne
01427         {
01428 public:
01439         virtual void SetMinimumAndMaximum(const TTime& aMinimumTime, const TTime& aMaximumTime)=0;
01440 
01448         virtual void GetMinimumAndMaximum(TTime& aMinimumTime, TTime& aMaximum) const=0;
01449     
01456         virtual void SetTTime(const TTime& aTime)=0;
01457 
01466         virtual TTime GetTTime() const=0; // can only be called if PrepareForFocusLossL() succeeded
01467         };
01468 
01486 class CEikTimeEditor : public CEikTTimeEditor
01487         {
01488 public:
01489         // miscellaneous functions
01498         IMPORT_C CEikTimeEditor();
01499 
01506         IMPORT_C virtual ~CEikTimeEditor();
01507 
01534         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
01535 
01541         IMPORT_C void SetTime(const TTime& aTime);
01542 
01548         IMPORT_C TTime Time() const;
01549 
01556         IMPORT_C void SetUninitialised(TBool aUninitialised);
01557         
01563         IMPORT_C TBool IsUninitialised() const;
01564         // from CEikTTimeEditor
01565         
01579         IMPORT_C virtual void SetMinimumAndMaximum(const TTime& aMinimumTime, const TTime& aMaximumTime); // only values inside the initial minimum and maximum are permitted
01580 
01589         IMPORT_C virtual void GetMinimumAndMaximum(TTime& aMinimumTime, TTime& aMaximumTime) const;
01590 
01591         // from CCoeControl
01592 
01605         IMPORT_C virtual void ConstructFromResourceL(TResourceReader& aResourceReader);
01606         
01616         IMPORT_C virtual void PrepareForFocusLossL();
01617 
01625     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);
01626 private:
01627         // from CEikTTimeEditor
01628         virtual void SetTTime(const TTime& aTime);
01629         virtual TTime GetTTime() const; // can only be called if PrepareForFocusLossL() succeeded
01630 private:
01631         // miscellaneous functions
01632         void DoSetMinimumAndMaximum(const TTime& aMinimumTime, const TTime& aMaximumTime);
01633         IMPORT_C virtual void CEikMfne_Reserved();
01634 private:
01638     IMPORT_C void* ExtensionInterface( TUid aInterface );
01639 private:
01640         CTimeEditor* iTimeEditor;
01641         TTime iMinimumTime;
01642         TTime iMaximumTime;
01643         TInt iSpare;
01644         };
01645 
01646 
01647 //
01648 
01649 // note: TDateTime uses zero based day numbers, so -1 on the day field
01650 #define KAknMinimumDate (TTime(TDateTime(0001, EJanuary, 1-1, 0, 0, 0, 0)))
01651 #define KAknMaximumDate (TTime(TDateTime(9999, EDecember, 31-1, 23, 59, 59, 999999)))
01652 
01671 class CEikDateEditor : public CEikTTimeEditor, private MEikCalendarObserver
01672         {
01673 
01674 public:
01675 
01676     // miscellaneous functions
01680     IMPORT_C CEikDateEditor();
01681 
01685     IMPORT_C virtual ~CEikDateEditor();
01686 
01687     // to be called by container only if not constructed from resource
01705     IMPORT_C void ConstructL(const TTime& aMinimumDate, 
01706                              const TTime& aMaximumDate, 
01707                              const TTime& aInitialDate, 
01708                              TBool aWithoutPopoutCalendar); 
01709     
01715     IMPORT_C void SetDate(const TTime& aDate);
01716 
01722         IMPORT_C TTime Date() const;
01723 
01730         IMPORT_C void SetUninitialised(TBool aUninitialised);
01731 
01737         IMPORT_C TBool IsUninitialised() const;
01738 
01739         // from CEikTTimeEditor
01740         // only values inside the initial minimum and maximum are permitted
01752     IMPORT_C virtual void SetMinimumAndMaximum(const TTime& aMinimumDate, 
01753                                                const TTime& aMaximumDate); 
01754         
01763     IMPORT_C virtual void GetMinimumAndMaximum(TTime& aMinimumDate, 
01764                                                TTime& aMaximumDate) const;
01765         
01766     // from CCoeControl
01776     IMPORT_C virtual TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent, 
01777                                                  TEventCode aType);
01778         
01791     IMPORT_C virtual void ConstructFromResourceL(TResourceReader& 
01792                                                  aResourceReader);
01793         
01804     IMPORT_C virtual void PrepareForFocusLossL();
01805     
01813     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);
01814 
01815 private:
01816 
01817     // from CEikMfne
01818     virtual void CreatePopoutIfRequiredL();
01819     // from CEikTTimeEditor
01820     virtual void SetTTime(const TTime& aDate);
01821     virtual TTime GetTTime() const; // can only be called if PrepareForFocusLossL() succeeded
01822 
01823 private:
01824 
01825     // from MEikCalendarDialogObserver
01826     virtual void GetMinimumAndMaximumAndInitialDatesForCalendarL(TTime& aMinimumDate, 
01827                                                                  TTime& aMaximumDate, 
01828                                                                  TTime& aInitialDate) const;
01829     virtual void SetDateFromCalendarAndDrawNow(const TTime& aDate);
01830     // miscellaneous functions
01831     void DoSetMinimumAndMaximum(const TTime& aMinimumDate, const TTime& aMaximumDate);
01832     IMPORT_C virtual void CEikMfne_Reserved();
01833 
01834 private:
01835 
01839     IMPORT_C void* ExtensionInterface( TUid aInterface );
01840 
01841 private:
01842 
01843         CDateEditor* iDateEditor;
01844         TTime iMinimumDate;
01845         TTime iMaximumDate;
01846         TInt iSpare;
01847         };
01848 
01849 
01850 //
01851 
01870 class CEikTimeAndDateEditor : public CEikTTimeEditor, private MEikCalendarObserver
01871         {
01872 public:
01873         // miscellaneous functions
01874 
01883         IMPORT_C CEikTimeAndDateEditor();
01884 
01891         IMPORT_C virtual ~CEikTimeAndDateEditor();
01892 
01893         // 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
01894 
01926         IMPORT_C void ConstructL(const TTime& aMinimumTimeAndDate, const TTime& aMaximumTimeAndDate, const TTime& aInitialTimeAndDate, TUint32 aFlags, HBufC* aInterveningText=NULL);
01927         
01934         IMPORT_C void SetTimeAndDate(const TTime& aTimeAndDate);
01935 
01941         IMPORT_C TTime TimeAndDate() const;
01942 
01949         IMPORT_C void SetUninitialised(TBool aUninitialised);
01950         
01956         IMPORT_C TBool IsUninitialised() const;
01957         
01958         // from CEikTTimeEditor
01959 
01972         IMPORT_C virtual void SetMinimumAndMaximum(const TTime& aMinimumTimeAndDate, const TTime& aMaximumTimeAndDate); // only values inside the initial minimum and maximum are permitted
01973 
01982         IMPORT_C virtual void GetMinimumAndMaximum(TTime& aMinimumTimeAndDate, TTime& aMaximumTimeAndDate) const;
01983 
01984         // from CCoeControl
01985         
01998         IMPORT_C virtual TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType);
01999 
02011         IMPORT_C virtual void ConstructFromResourceL(TResourceReader& aResourceReader);
02012 
02022         IMPORT_C virtual void PrepareForFocusLossL();
02023 
02031     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);      
02032     
02033 private:
02034         // from CEikMfne
02035         virtual void CreatePopoutIfRequiredL(); 
02036         IMPORT_C virtual void CEikMfne_Reserved();
02037         // from CEikTTimeEditor
02038         virtual void SetTTime(const TTime& aTimeAndDate);
02039         virtual TTime GetTTime() const; // can only be called if PrepareForFocusLossL() succeeded
02040 private:
02041         // from MEikCalendarDialogObserver
02042         virtual void GetMinimumAndMaximumAndInitialDatesForCalendarL(TTime& aMinimumDate, TTime& aMaximumDate, TTime& aInitialDate) const;
02043         virtual void SetDateFromCalendarAndDrawNow(const TTime& aDate);
02044         // miscellaneous functions
02045         void DoSetMinimumAndMaximum(const TTime& aMinimumTimeAndDate, const TTime& aMaximumTimeAndDate);
02046 private:
02050     IMPORT_C void* ExtensionInterface( TUid aInterface );
02051 private:
02052         CTimeEditor* iTimeEditor;
02053         CDateEditor* iDateEditor;
02054         TTime iMinimumTimeAndDate;
02055         TTime iMaximumTimeAndDate;
02056         TInt iSpare;
02057         };
02058 
02059 
02060 //
02061 
02080 class CEikDurationEditor : public CEikMfne
02081         {
02082 public:
02083         // miscellaneous functions
02084 
02093         IMPORT_C CEikDurationEditor();
02094 
02101         IMPORT_C virtual ~CEikDurationEditor();
02102 
02127         IMPORT_C void ConstructL(const TTimeIntervalSeconds& aMinimumDuration, const TTimeIntervalSeconds& aMaximumDuration, const TTimeIntervalSeconds& aInitialDuration, TUint32 aFlags);
02128 
02138         IMPORT_C void SetMinimumAndMaximum(const TTimeIntervalSeconds& aMinimumDuration, const TTimeIntervalSeconds& aMaximumDuration); // only values inside the initial minimum and maximum are permitted
02139 
02146         IMPORT_C void GetMinimumAndMaximum(TTimeIntervalSeconds& aMinimumDuration, TTimeIntervalSeconds& aMaximumDuration) const;
02147 
02154         IMPORT_C void SetDuration(const TTimeIntervalSeconds& aDuration);
02155 
02162         IMPORT_C TTimeIntervalSeconds Duration() const; // can only be called if PrepareForFocusLossL() succeeded
02163 
02164         // framework
02165 
02176         IMPORT_C void ConstructFromResourceL(TResourceReader& aResourceReader);
02177 
02186         IMPORT_C void PrepareForFocusLossL();
02187 
02188     // From CCoeControl    
02196     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);      
02197 private:
02198         // miscellaneous functions
02199         void DoSetMinimumAndMaximum(const TTimeIntervalSeconds& aMinimumDuration, const TTimeIntervalSeconds& aMaximumDuration);
02200         IMPORT_C virtual void CEikMfne_Reserved();
02201 private:
02205     IMPORT_C void* ExtensionInterface( TUid aInterface );
02206 private:
02207         CTimeEditor* iTimeEditor;
02208         TTimeIntervalSeconds iMinimumDuration;
02209         TTimeIntervalSeconds iMaximumDuration;
02210         TInt iSpare;
02211         };
02212 
02224 class CEikTimeOffsetEditor : public CEikMfne
02225         {
02226 public:
02227         // miscellaneous functions
02228 
02237         IMPORT_C CEikTimeOffsetEditor();
02238 
02243         IMPORT_C virtual ~CEikTimeOffsetEditor();
02244 
02273         IMPORT_C void ConstructL(const TTimeIntervalSeconds& aMinimumTimeOffset, const TTimeIntervalSeconds& aMaximumTimeOffset, const TTimeIntervalSeconds& aInitialTimeOffset, TUint32 aFlags);
02274 
02288         IMPORT_C void SetMinimumAndMaximum(const TTimeIntervalSeconds& aMinimumTimeOffset, const TTimeIntervalSeconds& aMaximumTimeOffset); // only values inside the initial minimum and maximum are permitted
02289 
02298         IMPORT_C void GetMinimumAndMaximum(TTimeIntervalSeconds& aMinimumTimeOffset, TTimeIntervalSeconds& aMaximumTimeOffset) const;
02299 
02309         IMPORT_C void SetTimeOffset(const TTimeIntervalSeconds& aTimeOffset);
02310 
02316         IMPORT_C TTimeIntervalSeconds TimeOffset() const; // can only be called if PrepareForFocusLossL() succeeded
02317 
02318         // framework
02319 
02332         IMPORT_C void ConstructFromResourceL(TResourceReader& aResourceReader);
02333 
02344         IMPORT_C void PrepareForFocusLossL();
02345 
02346     // From CCoeControl    
02347 
02355     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);      
02356     
02357 private:
02358         // miscellaneous functions
02359         void DoSetMinimumAndMaximum(const TTimeIntervalSeconds& aMinimumTimeOffset, const TTimeIntervalSeconds& aMaximumTimeOffset);
02360         IMPORT_C virtual void CEikMfne_Reserved();
02361 private:
02365     IMPORT_C void* ExtensionInterface( TUid aInterface );
02366 private:
02367         CTimeEditor* iTimeEditor;
02368         TTimeIntervalSeconds iMinimumTimeOffset;
02369         TTimeIntervalSeconds iMaximumTimeOffset;
02370         // none of these pointers owns anything
02371         CEikMfneSymbol* iSign;
02372         TInt iSpare;
02373         };
02374 
02375 
02376 //
02377 // Longitude and Latitude editors removed 2.4.2002:
02378 
02379 enum
02380         {
02381         EEikOrientationNorthSouth   =0x1000,
02382         EEikOrientationWestEast     =0x2000,
02383         EEikOrientationMask=EEikOrientationNorthSouth|EEikOrientationWestEast
02384         };
02385 
02386 
02387 enum
02388         {
02389         EEikDirectionNegative,
02390         EEikDirectionPositive,
02391         EEikDirectionMask=EEikDirectionNegative|EEikDirectionPositive
02392         };
02393 
02394 
02395 enum TEikCompass
02396         {
02397         EEikCompassNorth=EEikOrientationNorthSouth|EEikDirectionNegative,
02398         EEikCompassSouth=EEikOrientationNorthSouth|EEikDirectionPositive,
02399         EEikCompassEast=EEikOrientationWestEast|EEikDirectionNegative,
02400         EEikCompassWest=EEikOrientationWestEast|EEikDirectionPositive
02401         };
02402 
02403 
02404 struct SEikDegreesMinutesDirection
02405         {
02406         TInt iDegrees;
02407         TInt iMinutes;
02408         TInt iSeconds;
02409         TEikCompass iDirection;
02410         };
02411 
02412 // __EIKMFNE_H__
02413 #endif
02414 // End of file
Copyright © Nokia Corporation 2001-2007
Back to top