AknUtils.h

00001 /*
00002 * ============================================================================
00003 *  Name     : AknUtils.h
00004 *  Part of  : Avkon
00005 *
00006 *  Description:
00007 *     General Avkon Utilities. Includes:
00008 *       - listbox utilities
00009 *       - layout utilities
00010 * 
00011 *  Version: %version:  e003sa02#24.1.3 %
00012 *
00013 *  Copyright © 2002-2007 Nokia Corporation.
00014 *  This material, including documentation and any related 
00015 *  computer programs, is protected by copyright controlled by 
00016 *  Nokia Corporation. All rights are reserved. Copying, 
00017 *  including reproducing, storing,  adapting or translating, any 
00018 *  or all of this material requires the prior written consent of 
00019 *  Nokia Corporation. This material also contains confidential 
00020 *  information which may not be disclosed to others without the 
00021 *  prior written consent of Nokia Corporation.
00022 * ============================================================================
00023 */
00025 #ifndef __AKNUTILS_H__
00026 #define __AKNUTILS_H__
00027 
00028 #include <eiktxlbm.h>
00029 #include <avkon.hrh>
00030 #include <avkon.rsg>
00031 #include <coedef.h>
00032 #include <coecobs.h>
00033 #include <w32std.h>
00034 #include <gulalign.h>
00035 #include <gulutil.h>
00036 #include <eikenv.h>
00037 #include <biditext.h>
00038 #include <eiksbfrm.h>
00039 #include <AknsConstants.h>
00040 #include <aknenv.h>
00042 #include <aknlayout.lag>
00044 // These are for listbox column lengths (These are used to allocate memory from stack while drawing listboxes, they should be as small as possible, but not smaller!)
00045 const TInt KMaxColumnDataLength = 80; // This is maximum length of data for one listbox column -- after that the data is truncated before drawing.
00046 const TInt KMaxTotalDataLength = 8*KMaxColumnDataLength;  // max of 5 columns can have full 80 characters...
00063 class CCoeControl;
00064 class CEikTextListBox;
00065 class CEikColumnListBox;
00066 class CEikFormattedCellListBox;
00067 class CGulIcon;
00068 class CEikSettingsListBox;
00069 class CAknLAF;
00070 class CEikImage;
00071 class CEikMfne;
00072 class CEikListBox;
00073 class CEikLabel;
00074 class CEikEdwin;
00075 class CEikMenuPane;
00076 class CAknPopupField;
00077 class CListBoxView;
00078 class CAknColumnListBox;
00079 class CEikSecretEditor;
00080 class CFindExtension;
00081 class CAknLayoutFont;
00082 class TAknFontSpecification;
00083 class CAknAppUiBase;
00084 class TAknWindowLineLayout;
00085 class TAknMultiLineTextLayout;
00086 class TAknTextLineLayout;
00092 const TInt  KDefaultClipWidth = -1;
00093 const TUint KDefaultClipChar  = TUint(0x2026);
00095 // Constant to use in AknLayoutUtils to indicate that the parameter is not to be used as a override value
00096 const TInt KAknLayoutUtilsDoNotOverride = -1;
00105 class AknTextUtils 
00106     {
00107 public:
00108     enum TClipDirection
00109     {
EDoNotClip,
EClipFromEnd,
EClipFromBeginning
00113     };
00126     IMPORT_C static TBool ClipToFit(TDes& aBuffer,
00127                                     const CFont& aFont, 
00128                                     TInt aMaxWidthInPixels,
TClipDirection aDir=EClipFromEnd,
00130                                     TInt aClipWidth = KDefaultClipWidth,
00131                                     const TDesC &aClipString=_L("..."));
00139     IMPORT_C static TBool ClipToFit(TDes& aBuffer, 
TClipDirection aDir,
CEikFormattedCellListBox *aListBox,
00142                                     TInt aItemIndex,
00143                                     TInt aSubCellNumber);
00151     IMPORT_C static TBool ClipToFit(TDes& aBuffer,
TClipDirection aDir,
CEikColumnListBox *aListBox,
00154                                     TInt aItemIndex,
00155                                     TInt aColumnNumber);
00157     // implementation
00159     static TBool DoClipToFit(
00160         TDes& aBuffer,
00161         const CFont& aFont,
00162         TInt aMaxWidthInPixels,
TClipDirection aDir,
00164         TInt aClipWidth,
00165         const TDesC& aClipString );
00177     IMPORT_C static void WrapToArrayL( 
00178         const TDesC& aStringToWrap,
00179         const CArrayFix<TInt>& aLineWidthArray,
00180         const CFont& aFont,
00181         CArrayFix<TPtrC>& aWrappedArray);
00193     IMPORT_C static void WrapToArrayL( 
00194         const TDesC& aStringToWrap,
00195         TInt aLineWidth,
00196         const CFont& aFont,
00197         CArrayFix<TPtrC>& aWrappedArray );
00215     IMPORT_C static void WrapToArrayAndClipL( 
00216         TDes& aStringToWrap,             
00217         const CArrayFix<TInt>& aLineWidthArray, 
00218         const CFont& aFont,                     
00219         CArrayFix<TPtrC>& aWrappedArray );       
00238     IMPORT_C static void ChopToArrayAndClipL(
00239         TDes& aStringToChop,             
00240         const CArrayFix<TInt>& aLineWidthArray, 
00241         const CFont& aFont,                    
00242         CArrayFix<TPtrC>& aChoppedArray);
00261     IMPORT_C static void ChopToArrayAndClipL(
00262         TDes& aStringToChop,             
00263         TInt aLineWidth, 
00264         const CFont& aFont,                    
00265         CArrayFix<TPtrC>& aChoppedArray );
00279     IMPORT_C static void WrapToStringL( 
00280         const TDesC& aStringToWrap,
00281         const CArrayFix<TInt>& aLineWidthArray,
00282         const CFont& aFont,
00283         TDes& aWrappedString );
00299     IMPORT_C static void WrapToStringAndClipL(
00300         const TDesC& aStringToWrap, 
00301         const CArrayFix<TInt>& aLineWidthArray, 
00302         const CFont& aFont, 
00303         TDes& aWrappedString ); 
00320     IMPORT_C static void StripCharacters(TDes &aDes, const TDesC &aCharacters);
00333     IMPORT_C static void ReplaceCharacters(TDes &aDes, const TDesC &aChars, TChar aReplacement);
00342     IMPORT_C static void PackWhiteSpaces(TDes &aDes, const TDesC &aWhiteSpaceChars);
00344     // non-exported implementation
00346     static void WrapToStringL(
00347         const TDesC& aStringToWrap, 
00348         const CArrayFix<TInt>& aLineWidthArray, 
00349         const CFont& aFont, 
00350         TDes& aWrappedString,
00351         TInt aFlags,
00352         TInt aDirectionality );
00354     static void WrapToArrayL( 
00355         TDes& aStringToWrap,
00356         const CArrayFix<TInt>* aLineWidthArray, 
00357         const CFont& aFont,
00358         CArrayFix<TPtrC>& aWrappedArray,
00359         TInt aLineWidth,
00360         TInt aFlags,
00361         TInt aDirectionality );
00363     static void ChopToArrayAndClipL(
00364         TDes& aStringToChop,             
00365         const CArrayFix<TInt>* aLineWidthArray,
00366         const CFont& aFont,                 
00367         CArrayFix<TPtrC>& aChoppedArray,
00368         TInt aLineWidth );    
00377     static TBool IsEmptyText( const TDesC& aTextToTest );
00393     IMPORT_C static void LanguageSpecificNumberConversion(TDes &aDes);
00403     IMPORT_C static void ConvertDigitsTo( TDes& aDes, TDigitType aDigitType );
00417     IMPORT_C static TBidiText::TDirectionality CurrentScriptDirectionality();
00425     static TDigitType InputLanguageFilteredDigitType();
00433     static TDigitType DisplayTextLanguageFilteredDigitType();
00441     IMPORT_C static TDigitType NumericEditorDigitType();
00459     IMPORT_C static void DisplayTextLanguageSpecificNumberConversion(TDes &aDes);
00472     IMPORT_C static TDigitType TextEditorDigitType();
00474     enum TDigitModeQueryType {
EDigitModeEditorDefault, // in editors by default whether western or foreign digits are used (gen.editors, both text and numbers)
EDigitModeUserModifiableEditor, // in editors whether user can modify digitmode with keypad
EDigitModeShownToUser, // in all components when displaying digits
EDigitModeNumberEditor, // number, time, date, notification texts (1st group of editors)
EDigitModeLatinNumberEditor // e-mail, password, PIN codes, etc. (3rd group, where only latin can be used)
00480     };
00495     IMPORT_C static TBool DigitModeQuery(TDigitModeQueryType aQueryType = EDigitModeShownToUser);
00508     IMPORT_C static HBufC* ConvertFileNameL(const TDesC& aDes);
00515     IMPORT_C static HBufC* LoadScalableTextL(CCoeEnv& aCoe, TInt aResourceId);
00521     IMPORT_C static HBufC* LoadScalableTextLC(CCoeEnv& aCoe, TInt aResourceId);
00527     IMPORT_C static TInt LoadScalableText(CCoeEnv& aCoe, TInt aResourceId, TDes& aBuffer ); 
00533     IMPORT_C static HBufC* ClipAccordingScreenOrientationLC(CCoeEnv& aCoe, HBufC* aBuf); 
00555     IMPORT_C static TPtrC ChooseScalableText(
00556         const TDesC& aText,
00557         const CFont& aFont,
00558         TInt aMaxWidthInPixels );
00559     };
_LIT(KAknStripTabs, "\t");
_LIT(KAknStripListControlChars, "\t\n");
_LIT(KAknReplaceTabs, "\t");
_LIT(KAknReplaceListControlChars, "\t\n");
_LIT(KAknCommonWhiteSpaceCharacters, " \n\t\r");
00577 class AknSelectionService
00578     {
00579 public:
00582     IMPORT_C static void HandleSelectionListProcessCommandL(
00583         TInt aCommand,
CEikListBox* aListBox);
00588     IMPORT_C static void HandleMultiselectionListProcessCommandL(
00589         TInt aCommand,
CEikListBox* aListBox);
00594     IMPORT_C static void HandleMarkableListProcessCommandL(
00595         TInt aCommand,
CEikListBox* aListBox);
00600     IMPORT_C static TKeyResponse HandleMenuListOfferKeyEventL(
00601         const TKeyEvent& aKeyEvent,
00602         TEventCode aType,
CEikListBox* aListBox);
00607     IMPORT_C static void HandleMarkableListDynInitMenuPane(
00608         TInt aResourceId,
CEikMenuPane *aMenu,
CEikListBox *aListBox);
00614     IMPORT_C static void HandleMarkableListDynInitMenuItem(
CEikMenuPane *aMenu,
CEikListBox *aListBox,
00617         TInt aCommandId,
00618         TBool aCanBeAppliedToMultipleItems);
00622     IMPORT_C static void HandleMarkableListUpdateAfterCommandExecution(
CEikListBox *aListBox);
00627     IMPORT_C static void HandleItemRemovalAndPositionHighlightL(
CEikListBox *aListBox,
00629         TInt aValueOfCurrentItemIndexBeforeRemoval,
00630         TBool aCurrentItemWasRemoved);
00632     // This one updates selectionindexes too.
00638     IMPORT_C static void HandleItemRemovalAndPositionHighlightL(
CEikListBox *aListBox,
00640         TInt aValueOfCurrentItemIndexBeforeRemoval,
00641         CArrayFix<TInt> &aIndexesOfRemovedItemsBeforeRemoval);
00642     };
00646 class CAknSearchField;
00660 class AknFind
00661     {
00662 public:
00664     /*
00665      * Implements the event handlers for the find pane. This method must be
00666      * called when a @c ProcessCommandL event is received and a find pane is on
00667      * the screen.
00668      *
00669      * @param aCommand Command id.
00670      * @param aListBox Pointer to listbox control.
00671      * @param aSearchField Pointer to search field control.
00672      * @param aParentControl Parent control.
00673      */
00674     IMPORT_C static void HandleFindPopupProcessCommandL(
00675                         TInt aCommand, 
CEikListBox* aListBox, 
CAknSearchField* aSearchField, 
00678                         CCoeControl* aParentControl);
00680     /*
00681      * Handles key events for the find pane. This method must be called when
00682      * control receives @c OfferKeyEventL event.
00683      *
00684      * @param aKeyEvent The key event.
00685      * @param aType The type of key event:@c TEventCode.
00686      * @param aListBoxParent Pointer to the parent control.
00687      * @param aListBox Pointer to listbox control.
00688      * @param aSearchField Pointer to search field control.
00689      * @param isFindPopup @c ETrue if popup find pane, @c EFalse if normal find
00690      *        pane.
00691      * @param aNeedRefresh @c ETrue when find pane is redrawn.
00692      */    
00693     IMPORT_C static TKeyResponse HandleFindOfferKeyEventL(
00694                         const TKeyEvent& aKeyEvent, 
00695                         TEventCode aType, 
00696                         CCoeControl* aListBoxParent, 
CEikListBox* aListBox, 
CAknSearchField* aSearchField, 
00699                         TBool isFindPopup, 
00700                         TBool &aNeedRefresh);
00702     /*
00703      * Do not use this method.
00704      *
00705      * @deprecated Use @c AknFind::HandleFixedFindSizeChanged() and 
00706      *             @c AknFind::HandlePopupFindSizeChanged instead.
00707      *        
00708      */
00709     IMPORT_C static void HandleFindSizeChanged(
00710             CCoeControl* aParentControl, 
CEikListBox* aListBox, 
CAknSearchField* aSearchField, 
00713             TBool ispopup = ETrue, 
00714             TInt aFindWindowResourceId = R_AVKON_POPUP_FIND_WINDOW, 
00715             TInt aListAreaId = R_AVKON_LIST_GEN_PANE, 
00716             TInt aListResourceIdWithFindPopup = 
00717                                 R_AVKON_LIST_GEN_PANE_WITH_FIND_POPUP, 
00718             TInt aFindWindowParentResourceId = 
00719                                 R_AVKON_MAIN_PANE_WITH_STATUS_PANE);
00731     IMPORT_C static void HandleFixedFindSizeChanged(
00732             CCoeControl* aParentControl,
CAknColumnListBox* aListBox, // only available with column lists
CAknSearchField* aSearchField);
00745     IMPORT_C static void HandlePopupFindSizeChanged(
00746                             CCoeControl* aParentControl,
CEikListBox* aListBox,  //available with all lists.
CAknSearchField* aSearchField);
00765     IMPORT_C static void HandleFindSizeChangedLayouts(
00766                             CCoeControl* aParentControl, 
CEikListBox* aListBox, 
CAknSearchField* aSearchField, 
00769                             const TAknWindowLineLayout& aFindWindow,
00770                             const TAknWindowLineLayout& aListArea,
00771                             TBool aIsPopup,
00772                             const TAknWindowLineLayout& aFindWindowParent );
00774 public:
00785     IMPORT_C static TBool IsFindMatch(const TDesC& aItemText, 
00786                                       const TDesC& aSearchText);
00796     IMPORT_C static TBool IsFindWordSeparator(TChar aCh);
00813     IMPORT_C static TBool IsAdaptiveFindMatch( const TDesC& aItemText, 
00814                                                const TDesC& aSearchText,                        
00815                                                HBufC*& aNextChars );
00824     static void UpdateNextCharsL( HBufC*& aNextChars, TChar aCh );
00834     static void UpdateNextCharsL( HBufC*& aNextChars, const TDesC& aItemString );
00847     IMPORT_C static void UpdateNextCharsFromString( HBufC*& aNextChars, const TDesC& aItemString );
00858     IMPORT_C static void UpdateItemTextAccordingToFlag( const TDesC& aInputText, 
00859                                                         TBitFlags32 aColumnFlag, 
00860                                                         TDes& aOutText );
00871     static void HandleFindPaneVisibility(CAknSearchField* aSearchField, 
00872                                          TBool ispopup, 
00873                                          TBool textchanged, 
00874                                          TBool &aNeedRefresh);
00875     };
00882 class AknEditUtils
00883     {
00884     public:
00887     struct SAknEditorParameters 
00888     {
00890         TInt iEditingSpace;
00893         TInt iEditingWindow;
00899         TInt iCharacterCase;
00905         TInt iJustification;
00908         TBool iAllowedToMoveInsertionPoint;
00911         TBool iCursorYesNo;
00914         TBool iOverflowYesNo;
00915     };
00917     IMPORT_C static void ConstructEditingL(CEikEdwin* aEdwin, TInt aResourceId);
00918     IMPORT_C static void ConstructEditingL(CEikEdwin* aEdwin, TResourceReader& aReader);
00919     IMPORT_C static void ConstructEditingL(CEikEdwin* aEdwin, const SAknEditorParameters &aParams);
00939     IMPORT_C static void ConstructEditingL(CEikEdwin* aEdwin, 
00940                        TInt aEditingSpace, 
00941                        TInt aEditingWindow, 
00942                        TInt aCharacterCase, 
00943                        TInt aJustification, 
00944                        TBool aAllowedToMoveInsertionPoint, 
00945                        TBool aCursorYesNo, 
00946                        TBool aOverflowYesNo);
00967     IMPORT_C static void ConstructEditingL(CEikEdwin* aEdwin, 
00968                                               TInt aEditingSpace, 
00969                                               TInt aEditingWindow, 
00970                                               TInt aCharacterCase, 
00971                                               TInt aJustification, 
00972                                               TBool aAllowedToMoveInsertionPoint, 
00973                                               TBool aCursorYesNo, 
00974                                               TBool aOverflowYesNo,
00975                                               TBool aIsResizable);
00977     };
00986 class CListBoxNumbers : public CBase
00987     {
00988 public:
00989     IMPORT_C CListBoxNumbers(CEikTextListBox* aListBox);
00990     IMPORT_C void ConstructL();
00991     IMPORT_C void UpdateL();
00992 private:
CEikTextListBox* iListBox;
00994     };
00996 class CAknListBoxFilterItems;
01007 class CAknFilteredTextListBoxModel : public CTextListBoxModel, public MDesCArray
01008     {
01009 public: // public interface for apps
01016     IMPORT_C void CreateFilterL(CEikListBox* aListBox, CAknSearchField* aSearchField);
01020     IMPORT_C void RemoveFilter();
01025     IMPORT_C CAknListBoxFilterItems* Filter() const;
01029     IMPORT_C ~CAknFilteredTextListBoxModel();
01030 public: // from CTextListBoxMode
01035     IMPORT_C virtual TInt NumberOfItems() const;
01041     IMPORT_C virtual TPtrC ItemText(TInt aItemIndex) const;
01042 public: // from MEikTextListBoxModel (default filtering string conversions)
01047     IMPORT_C const MDesCArray* MatchableTextArray() const;
01049 private:
CAknListBoxFilterItems* iFilter; // owned
01051 private: // From MdesCArray (these implement default matchabletextarray for filtering.)
01052     IMPORT_C TInt MdcaCount() const;
01053     IMPORT_C TPtrC MdcaPoint(TInt aIndex) const;
01054 private: // from MListBoxModel
01055     IMPORT_C virtual TAny* MListBoxModel_Reserved();
01056     };
01075 class CAknListBoxFilterItems : public CBase, public MCoeControlObserver
01076     {
01077 public:
01086     IMPORT_C CAknListBoxFilterItems(
CEikListBox *aListBox,
CAknSearchField *aSearchField,
MListBoxModel *aModel,
CListBoxView *aView);
01095     IMPORT_C void ConstructL(); // for setting empty list text.
01099     IMPORT_C void ResetFilteringL();
01104     IMPORT_C void UpdateCachedDataL(); // updates iOldSearchCriteria and selection indexes.
01109     IMPORT_C ~CAknListBoxFilterItems();    
01111 public: 
01116     IMPORT_C CArrayFix<TInt> *SelectionIndexes();
01122     IMPORT_C void UpdateSelectionIndexesL();
01129     IMPORT_C void UpdateSelectionIndexL(TInt aVisibleIndex);
01131 public: // Applications should call this in their listbox model implementation
01137     IMPORT_C TInt FilteredNumberOfItems() const;
01144     IMPORT_C TInt FilteredItemIndex(TInt aVisibleItemIndex) const;
01146 public: // Needed to change the correct item.
01152     IMPORT_C TInt NonFilteredNumberOfItems() const; // this always returns >= FilteredNumberOfItems()
01159     IMPORT_C TInt VisibleItemIndex(TInt aOriginalIndex) const;
01160 public: 
01167     IMPORT_C TPtrC DefaultMatchableItemFromItem(TPtrC aText);
01169 public: 
01174     IMPORT_C void HandleOfferkeyEventL();
01180     IMPORT_C void HandleItemArrayChangeL();
01182 public: // MCoeControlObserver
01187     IMPORT_C void SetObserver(MCoeControlObserver *aObserver);
01193     IMPORT_C void HandleControlEventL(CCoeControl *aControl, TCoeEvent aEventType);
01195 public: // For FEP
01203     IMPORT_C void DeferredSendKeyEventToFepL(TUint aValue);
01211     static TInt IdleCallBack(TAny *aFilterItems);
01213 public: // For size changed
01221     IMPORT_C void SetParentControl(CCoeControl *aControl);
01226     IMPORT_C void SetPopup();
01228 public: // For detaching and attaching list, findbox, model and view...
01234     IMPORT_C void SetListBox(CEikListBox *aListBox);
01240     IMPORT_C void SetSearchField(CAknSearchField *aSearchField);
01246     IMPORT_C void SetModel(MListBoxModel *aModel);
01252     IMPORT_C void SetView(CListBoxView *aView);
01254 public:
01259     IMPORT_C CCoeControl *FindBox() const;
01268     void DeferredSendFullKeyEventToFepL(const TKeyEvent& aEvent);
01270 private:
01271     void NoCriteriaL(); // remove criteria completely.
01272     void TightenCriteriaL(const TDesC& aCriteria); // slow operation (do when adding new characters to search criteria)
01273     void ReleaseCriteriaL(const TDesC& aCriteria); // very slow operation (do when removing characters from search criteria)
01274     // EmptyListText handling
01275     void InstallEmptyTextL();
01276     void UninstallEmptyTextL();
01277     // Selections -- these methods form a pair, 
01278     // you must call Fetch first and then push.
01279     void FetchSelectionIndexesFromListBoxL();
01280     void PushSelectionIndexesToListBoxL();
01281     void ClearNextChars();
01282     TBool IsAdaptiveSearch() const;     
01284     // HandleItemAddition without ResetFilteringL() call
01285     void HandleItemAdditionL();
01286     void HandleItemRemovalL();
01287 private:
01288     TBool IsItemVisible(const TDesC& aMatchableItemString, const TDesC& aSearchText);
01289     static TBool IsSeparatorCharacter(TChar c);
01290     TBool IsItemSelected(TInt aRealIndex) const;
01291 private:
01292     CArrayFix<TInt> *iShownIndexes; // own // uses non-filtered indexes
01293     CArrayFix<TInt> *iSelectionIndexes; // own   // this uses non-filtered indexes
01294     HBufC *iOldSearchCriteria; // own
MListBoxModel *iModel;
CListBoxView *iView;
01297     TInt iOldItemCount;
01298     HBufC* iEmptyListText; // own
CEikListBox* iListBox;
CAknSearchField* iSearchField;
01301     TBuf<256> iMatchableText;
01302     MCoeControlObserver *iObserver;
01303     CFindExtension *iExtension;
01304     TUint iKeyValue;
01305     CCoeControl *iParentControl;
01306     TBool iIsPopup;
01307     TBool iDisableChangesToShownIndexes;  
01308     };
01317 template<class T>
01318 class NoOptimizationView : public T
01319     {
01320 public:
01321     virtual void VScrollTo(TInt aNewTopItemIndex, TRect& aMinRedrawRect)
01322     {
01323     // AVKON LAF
01324     if (this->RedrawDisabled())
01325         return;
01326     if (this->iTopItemIndex == aNewTopItemIndex)
01327         return;
01328     aMinRedrawRect.SetRect(this->iViewRect.iTl,this->iViewRect.Size());
01329     this->SetTopItemIndex(aNewTopItemIndex);
01330     this->Draw(&aMinRedrawRect);
01331     // end of AVKON LAF
01332     }
01333     };
01342 class AknLAFUtils 
01343     {
01344 public:
01345     static void DrawLines(CGraphicsContext* aGc, 
01346                   const TRect& mainpane,
01347                   TInt x);
01348     IMPORT_C static void ReplaceColumn(TPtr aTarget, TDesC* aSource,
01349                                        TDesC* aReplacement, TChar aColumnSeparator,
01350                                        TInt aColumn);
01351     };
01363 struct SAknLayoutGfx;
01364 struct SAknLayoutText;
01365 struct SAknLayoutCmd;
01366 struct SAknLayoutGfx;
01367 // Not for apps
01368 struct SAknLayoutPos 
01369     {
01370     TInt l, t, r, b, W, H;
01372     typedef SAknLayoutPos ItemType;
01373     static void ReadResource(TResourceReader& aReader, ItemType& aTarget);    
01374     };
01375 template<class T> class CArrayReader;
01376 class CAknGenericReader : public CBase
01377     {
01378 public:
01379     IMPORT_C void ConstructL(TInt aResourceId);
01380     IMPORT_C virtual void ConstructFromResourceL(TResourceReader& aReader);
01381     IMPORT_C ~CAknGenericReader();
01383     IMPORT_C const SAknLayoutGfx* GfxItem(TInt aIndex) const;
01384     IMPORT_C const SAknLayoutText* TextItem(TInt aIndex) const;
01385     IMPORT_C const SAknLayoutCmd* CmdItem(TInt aIndex) const;
01386     IMPORT_C const SAknLayoutGfx* AreaItem(TInt aIndex) const;
01388     CArrayReader<SAknLayoutGfx>* iGfx;
01389     CArrayReader<SAknLayoutText>* iText;
01390     CArrayReader<SAknLayoutCmd>* iCmd;
01391     CArrayReader<SAknLayoutGfx>* iArea;
01392     };
01398 // Use this to mark that the position in LAF specification is empty.
01399 const TInt AknLayoutUtilsNoValue = ELayoutEmpty;
01432 class AknLayoutUtils
01433     {
01434 public:
01436     struct SAknLayoutText
01437     {
01438     TInt iFont, iC, iL, iR, iB, iW, iJ;
01439     };
01440     struct SAknLayoutTextMultiline
01441     {
01442     TInt iFont, iC, iL, iR, iB, iW, iJ, iNumberOfLinesShown, iNextLineB;
01443     };
01444     typedef SAknLayoutTextMultiline SAknLayoutLabel;
01445     typedef SAknLayoutTextMultiline SAknLayoutEdwin;
01446     typedef SAknLayoutText SAknLayoutMfne;
01447     typedef SAknLayoutText SAknLayoutSecEd;
01448     struct SAknLayoutRect
01449     {
01450     TInt iC, iL, iT, iR, iB, iW, iH;
01451     };
01452     typedef SAknLayoutRect SAknLayoutControl;
01453     typedef SAknLayoutRect SAknLayoutImage;
01458     IMPORT_C static void LayoutLabel(CEikLabel* aLabel,
01459                                      const TRect& aLabelParent,
01460                                      TInt aResourceId,
01461                                      const CFont* aCustomFont=0);
01466     IMPORT_C static void LayoutLabel(CEikLabel* aLabel,
01467                                      const TRect& aLabelParent,
01468                                      TResourceReader& aReader,
01469                                      const CFont* aCustomFont=0);
01474     IMPORT_C static void LayoutLabel(CEikLabel* aLabel,
01475                                      const TRect& aLabelParent,
01476                                      const SAknLayoutLabel& aLayout,
01477                                      const CFont *aCustomFont=0);
01482     IMPORT_C static void LayoutLabel(CEikLabel* aLabel,
01483                                      const TRect& aLabelParent,
01484                                      const TAknMultiLineTextLayout& aLayout,
01485                                      const CFont *aCustomFont=0);
01490     IMPORT_C static void LayoutLabel(CEikLabel* aLabel,
01491                                      const TRect& aLabelParent,
01492                                      const TAknTextLineLayout& aLayout,
01493                                      const CFont *aCustomFont=0);
01507     IMPORT_C static void LayoutLabel(CEikLabel* aLabel,
01508                                      const TRect& aLabelParent,
01509                                      TInt font, TInt C,
01510                                      TInt l, TInt r,
01511                                      TInt B, TInt W,
01512                                      TInt J, TInt NextLineB=0,
01513                                      const CFont* aCustomFont=0);
01518     IMPORT_C static void LayoutEdwin(CEikEdwin* aEdwin,
01519                                      const TRect& aEdwinParent,
01520                                      TInt aResourceId,
01521                                      TInt aNumberOfLines = 0,
01522                                      const CFont* aCustomFont=0,
01523                                      TBool aMinimizeEdwinView=EFalse);
01527     IMPORT_C static void LayoutEdwin(CEikEdwin* aEdwin,
01528                                      const TRect& aEdwinParent,
01529                                      TResourceReader& aReader,
01530                                      TInt aNumberOfLines = 0,
01531                                      const CFont* aCustomFont=0,
01532                                      TBool aMinimizeEdwinView=EFalse);
01537     IMPORT_C static void LayoutEdwin(CEikEdwin* aEdwin,
01538                                      const TRect& aEdwinParent,
01539                                      const SAknLayoutEdwin& aLayout,
01540                                      const CFont* aCustomFont=0,
01541                                      TBool aMinimizeEdwinView=EFalse);
01547     IMPORT_C static void LayoutEdwin( CEikEdwin* aEdwin,
01548                                       const TRect& aEdwinParent,
01549                                       const TAknMultiLineTextLayout& aLayout,
01550                                       const CFont* aCustomFont=0,
01551                                       TBool aMinimizeEdwinView=EFalse);
01553     IMPORT_C static void LayoutEdwin( CEikEdwin* aEdwin,
01554                                       const TRect& aEdwinParent,
01555                                       const TAknMultiLineTextLayout& aLayout,
TAknsQsnTextColorsIndex aOverrideColor,
01557                                       const CFont* aCustomFont=0,
01558                                       TBool aMinimizeEdwinView=EFalse ); 
01562     IMPORT_C static void LayoutEdwin( CEikEdwin* aEdwin,
01563                                       const TRect& aEdwinParent,
01564                                       const TAknTextLineLayout& aLayout,
01565                                       const CFont* aCustomFont=0,
01566                                       TBool aMinimizeEdwinView=EFalse );
01568     IMPORT_C static void LayoutEdwin( CEikEdwin* aEdwin,
01569                                       const TRect& aEdwinParent,
01570                                       const TAknTextLineLayout& aLayout,
TAknsQsnTextColorsIndex aOverrideColor,
01572                                       const CFont* aCustomFont=0,
01573                                       TBool aMinimizeEdwinView=EFalse );
01602     IMPORT_C static void LayoutEdwin( CEikEdwin* aEdwin,
01603                          const TRect& aEdwinParent,
01604                          const TAknTextLineLayout& aLayout,
01605                          TInt aNumberOfLinesToShowOverRide,
01606                          TInt aBaselineSeparationOverRide,
TAknsQsnTextColorsIndex aOverrideColor, 
01608                          TInt& aNumberOfVisibleLines );
01623     IMPORT_C static void LayoutEdwin( CEikEdwin* aEdwin,
01624                                       const TRect& aEdwinParent,
01625                                       TInt font,
01626                                       TInt C,
01627                                       TInt l,
01628                                       TInt r,
01629                                       TInt B,
01630                                       TInt W,
01631                                       TInt J,
01632                                       TInt aNumberOfLinesShown,
01633                                       TInt aNextLineBaseline,
01634                                       const CFont* aCustomFont=0 ,
01635                                       TBool aMinimizeEdwinView=EFalse );
01637     IMPORT_C static void LayoutEdwin( CEikEdwin* aEdwin,
01638                                       const TRect& aEdwinParent,
01639                                       TInt font,
01640                                       TInt C,
01641                                       TInt l,
01642                                       TInt r,
01643                                       TInt B,
01644                                       TInt W,
01645                                       TInt J,
01646                                       TInt aNumberOfLinesShown,
01647                                       TInt aNextLineBaseline,
TAknsQsnTextColorsIndex aOverrideColor,
01649                                       const CFont* aCustomFont=0 ,
01650                                       TBool aMinimizeEdwinView=EFalse );
01654     IMPORT_C static TRect MinimizedEdwinRect(const CEikEdwin *aEdwin);
01660     IMPORT_C static void LayoutMfne(CEikMfne* aMfne,
01661                                     const TRect& aMfneParent,
01662                                     TInt aResourceId);
01666     IMPORT_C static void LayoutMfne(CEikMfne* aMfne,
01667                                     const TRect& aMfneParent,
01668                                     TResourceReader& aReader);
01670     IMPORT_C static void LayoutMfne(CEikMfne* aMfne,
01671                                     const TRect& aMfneParent,
01672                                     const SAknLayoutMfne& aLayout);
01674     IMPORT_C static void LayoutMfne(CEikMfne* aMfne,
01675                                     const TRect& aMfneParent,
01676                                     const TAknTextLineLayout& aLayout);
01678     IMPORT_C static void LayoutMfne(CEikMfne* aMfne,
01679                                     const TRect& aMfneParent,
01680                                     TInt font, TInt C, TInt l, TInt r,
01681                                     TInt B, TInt W, TInt J);
01686     IMPORT_C static void LayoutControl(CCoeControl* aControl, 
01687                                        const TRect& aControlParent,
01688                                        TInt aResourceId);
01692     IMPORT_C static void LayoutControl(CCoeControl* aControl,
01693                                        const TRect& aControlParent,
01694                                        TResourceReader& aReader);
01696     IMPORT_C static void LayoutControl(CCoeControl* aControl,
01697                                        const TRect& aControlParent,
01698                                        const SAknLayoutControl& aLayout);
01700     IMPORT_C static void LayoutControl(CCoeControl* aControl, 
01701                                        const TRect& aControlParent,
01702                                        const TAknWindowLineLayout& aLayout);
01704     IMPORT_C static void LayoutControl(CCoeControl* aControl,
01705                                        const TRect& aControlParent,
01706                                        TInt /*C*/, TInt l, TInt t, TInt r, TInt b,
01707                                        TInt W, TInt H);
01712     IMPORT_C static void LayoutImage(CEikImage* aImage,
01713                                      const TRect& aParent,
01714                                      TInt aResourceId);
01718     IMPORT_C static void LayoutImage(CEikImage* aImage, 
01719                                      const TRect& aParent,
01720                                      TResourceReader& aReader);
01722     IMPORT_C static void LayoutImage(CEikImage* aImage, 
01723                                      const TRect& aParent,
01724                                      const SAknLayoutControl& aLayout);
01726     IMPORT_C static void LayoutImage(CEikImage* aImage,
01727                                      const TRect& aParent,
01728                                      const TAknWindowLineLayout& aLayout);
01730     IMPORT_C static void LayoutImage(CEikImage* aImage,
01731                                      const TRect& aParent,
01732                                      TInt C, TInt l, TInt t, TInt r, TInt b,
01733                                      TInt W, TInt H);
01738     IMPORT_C static void LayoutSecretEditor(CEikSecretEditor* aSecEd,
01739                                             const TRect& aParent,
01740                                             const SAknLayoutText& aLayout);
01742     IMPORT_C static void LayoutSecretEditor(CEikSecretEditor* aSecEd,
01743                                             const TRect& aParent,
01744                                             const TAknTextLineLayout& aLayout);
01746 public:
01752     IMPORT_C static TRect TextRectFromCoords(const TRect& aParent,
01753                                              const CFont* aFont,
01754                                              TInt l, TInt r,
01755                                              TInt B, TInt W,
01756                                              TInt LB = 0);
01758     IMPORT_C static TRect RectFromCoords(const TRect& aParent,
01759                                          TInt l, TInt t, TInt r, TInt b,
01760                                          TInt W, TInt H);
01780     IMPORT_C static const CFont* FontFromId(TInt aFontId, const CFont* aCustomFont=0);
01799     IMPORT_C static const CAknLayoutFont* LayoutFontFromId(TInt aId, 
01800                                                            const CAknLayoutFont *aCustomFont = 0);
01811     IMPORT_C static CAknLayoutFont* CreateLayoutFontFromSpecificationL( 
01812         const TAknFontSpecification& aSpec );
01826     IMPORT_C static CAknLayoutFont* CreateLayoutFontFromSpecificationL( 
01827         const TTypeface& aTypeface, 
01828         const TAknFontSpecification& aSpec);
01833     IMPORT_C static const CFont* FontFromName(const TDesC& aName); 
01835     IMPORT_C static CGraphicsContext::TTextAlign TextAlignFromId(TInt aId);
01837     IMPORT_C static TGulAlignment GulAlignFromId(TInt aId);
01839     IMPORT_C static TInt CursorHeightFromFont(const TFontSpec& aFont);
01841     IMPORT_C static TInt CursorWidthFromFont (const TFontSpec& aFont);
01843     IMPORT_C static TInt CursorAscentFromFont(const TFontSpec& aFont);
01845     IMPORT_C static void CursorExtensionsFromFont(const TFontSpec& /*aFont*/,
01846                                                   TInt& aFirstExtension,
01847                                                   TInt& aSecondExtension);
01849     IMPORT_C static TInt HighlightLeftPixelsFromFont (const TFontSpec& aFont);
01851     IMPORT_C static TInt HighlightRightPixelsFromFont(const TFontSpec& aFont);
01852     static void HighlightExtensionsFromFont(const TInt fontid,
01853                                             TInt& aLeft, TInt& aRight,
01854                                             TInt&  aTop, TInt& aBottom);
01868     static const CAknLayoutFont* MatchFontFromSystemFontArray( 
01869         const TFontSpec& aSpec, MGraphicsDeviceMap* aMap );
01871     IMPORT_C static TBool LayoutMirrored();
01873     /*
01874     * This method returns build variant based on which flag is active,
01875     * __AVKON_ELAF__ or __AVKON_APAC__.
01876     *
01877     * If you need to decide which layout to use, do not do it based on this method.
01878     * Instead, use CAknEnv::GetCurrentLayoutId().
01879     *
01880     * @return current variant
01881     */
01882     IMPORT_C static EVariantFlag Variant();
01884     IMPORT_C static ESubVariantFlag SubVariant();
01886     IMPORT_C static void OverrideControlColorL(
01887         CCoeControl& aControl,
01888         TLogicalColor aLogicalColor,
01889         TRgb aColor);
01891     /*
01892     * This method returns the default scrollbar type for the given application. 
01893     * For non-layout aware applications (e.g. legacy apps designed for 176x208 screen) 
01894     * this method returns always EArrowHead. But for layout aware apps the returned type 
01895     * may vary depending on the type of scrollbar which has been set as preferred 
01896     * scrollbar type in the device.
01897     *
01898     * Note that applications may use freely whatever scrollbartype, this method only 
01899     * returns the default scrollbartype for the application.
01900     * 
01901     * @since  2.6
01902     * @param  aApplication Application of which default scrollbar type is requested.
01903     * @return Default scrollbar type for the given application
01904     */
01905     IMPORT_C static CEikScrollBarFrame::TScrollBarType DefaultScrollBarType(CAknAppUiBase* aApplication);
01907     /*
01908     * This method sets the layout for vertical scrollbar of the given scrollbar frame. Layout
01909     * can freely only be set for EDoubleSpan type scrollbars.
01910     * 
01911     * @since  2.6
01912     * @param  aScrollBarFrame   Scrollbarframe of which vertical scrollbar layout will be set.
01913     * @param  aControlParent    Rect of the parent control of the scrollbarframe.
01914     * @param  aLayout           Layout for the vertical scrollbar.
01915     *
01916     *
01917     * This method can also be useful when layout of the scrollbar needs to be changed for scrollbars
01918     * which are owned by some other components such as e.g. ListBoxes, Editors or Grids.
01919     *
01920     * Example of use:
01921     *
01922     *  // Get a pointer to scrollbarframe of the listbox
01923     *  CEikScrollBarFrame* frame = iListBox->ScrollBar();
01924     *  
01925     *  // Get the layout data
01926     *  TAknWindowLineLayout layout = GetMyListBoxLayout();
01927     *  Trect parentRect = GetMyListBoxParentRect();
01928     *
01929     *  // Set the layout
01930     *  AknLayoutUtils::LayoutVerticalScrollBar(frame, parentRect, layout);
01931     *
01932     *  // The layout for scrollbar is now set.
01933     *
01934     */
01935     IMPORT_C static void LayoutVerticalScrollBar(
CEikScrollBarFrame* aScrollBarFrame,
01937         const TRect& aControlParent,
01938         const TAknWindowLineLayout& aLayout);
01940     /*
01941     * This method sets the layout for horizontal scrollbar of the given scrollbar frame. Layout
01942     * can freely only be set for EDoubleSpan type scrollbars.
01943     * 
01944     * @since  2.6
01945     * @param  aScrollBarFrame   Scrollbarframe of which horizontal scrollbar layout will be set.
01946     * @param  aControlParent    Rect of the parent control of the scrollbarframe.
01947     * @param  aLayout           Layout for the horizontal scrollbar.
01948     *
01949     *
01950     * Usage of this method is similar as for LayoutVerticalScrollBar().
01951     *
01952     */
01953     IMPORT_C static void LayoutHorizontalScrollBar(
CEikScrollBarFrame* aScrollBarFrame,
01955         const TRect& aControlParent,
01956         const TAknWindowLineLayout& aLayout);
01958 public:   // Metrics API
01963     enum TAknLayoutMetrics
01964     {
EScreen,
EApplicationWindow,
EStatusPane,
EMainPane,
EControlPane,   
ESignalPane,
EContextPane,
ETitlePane,
EBatteryPane,
EUniversalIndicatorPane,
ENaviPane,
EFindPane,
EWallpaperPane,
EIndicatorPane,
EAColunm,
EBColunm,
ECColunm,
EDColunm,
EStatusPaneSecondary,
EControlPaneSecondary,
EStaconTop,
EStaconBottom,
EPopupParent,
EStatusPaneBottom = EStatusPaneSecondary,
EControlPaneBottom = EControlPaneSecondary,
EControlPaneTop = EControlPane,
EStatusPaneTop = EStatusPane
02063     };
02079     IMPORT_C static TBool LayoutMetricsRect(TAknLayoutMetrics aParam, TRect& aRect);
02094     IMPORT_C static TBool LayoutMetricsSize(TAknLayoutMetrics aParam, TSize& aSize);
02109     IMPORT_C static TBool LayoutMetricsPosition(TAknLayoutMetrics aParan, TPoint& aPos);
02110 public:
02125     static TInt CorrectBaseline(TInt aParentHeight, TInt aBaseline, TInt aFontId);
02130     static void CorrectFontId(TRect aParent, TInt at, TInt aH, TInt ab, TInt &aFontId);
02138     IMPORT_C static TBool ScalableLayoutInterfaceAvailable();
02140     /*
02141     * Enumeration of CBA's possible locations.
02142     * @since 3.0
02143     */
02144     enum TAknCbaLocation
02145         {
EAknCbaLocationBottom, //landscape and portrait
EAknCbaLocationRight,  //only landscape
EAknCbaLocationLeft    //only landscape
02149         };
02159     IMPORT_C static TAknCbaLocation CbaLocation();
02167     static TRect HighlightBasedRect( const TRect& aHighlightRect, CCoeControl* aControl );
02172     enum TAknMainPaneState 
02173         {
EAknMainPaneForTinyStatusPane = 0x0001  // for 3x4 grid or app shell list views
02175         };
02176     IMPORT_C static TAknMainPaneState MainPaneState();
02182     IMPORT_C static TBool PenEnabled();
02188     IMPORT_C static TBool MSKEnabled();
02215     IMPORT_C static void GetEdwinVerticalPositionAndHeightFromLines(
02216         TInt aParentHeight,
02217         const TAknTextLineLayout& aLayout,
02218         TInt aBaselineSeparationOverRide,
02219         TInt aNumberOfLinesToShowOverRide,
02220         TInt& aEdwinVerticalPositionRelativeToParent,
02221         TInt& aEdwinHeight
02222         );
02244     IMPORT_C static TInt EdwinLinesWithinHeight (
02245         const TAknTextLineLayout& aLayout,
02246         TInt aBaselineSeparationOverride,
02247         TInt aMaxHeight,
02248         TInt& aUsedHeight
02249         );
02250 };
02256 class TAknLayoutText
02257     {
02258 public:
02259     IMPORT_C TAknLayoutText();
02264     IMPORT_C void LayoutText(const TRect& aParent, TInt aResourceId,
02265                              const CFont* aCustomFont=0);
02267     IMPORT_C void LayoutText(const TRect& aParent, TResourceReader& aReader,
02268                              const CFont* aCustomFont=0);
02270     IMPORT_C void LayoutText(const TRect& aParent, 
02271                              const AknLayoutUtils::SAknLayoutText& aLayout,
02272                              const CFont* aCustomFont=0);
02274     IMPORT_C void LayoutText(const TRect& aParent,
02275                              const TAknTextLineLayout& aLayout,
02276                              const CFont* aCustomFont=0);
02278     IMPORT_C void LayoutText(const TRect& aParent, TInt fontid, 
02279                              TInt C, TInt l, TInt r, TInt B, TInt W, TInt J,
02280                              const CFont* aCustomFont=0);
02284     IMPORT_C void DrawText(CGraphicsContext& aGc, const TDesC& aText) const;
02291     IMPORT_C void DrawText(
02292         CGraphicsContext& aGc,
02293         const TDesC& aText,
02294         TBool aUseLogicalToVisualConversion ) const;
02296     IMPORT_C void DrawText(
02297         CGraphicsContext& aGc,
02298         const TDesC& aText,
02299         TBool aUseLogicalToVisualConversion,
02300         const TRgb &aColor) const;
02303 public:
02310     IMPORT_C TRect TextRect() const;
02311     const CFont *Font() const { return iFont; }
02312     TRgb Color() const { return AKN_LAF_COLOR_STATIC(iColor); }
02313     CGraphicsContext::TTextAlign Align() const { return iAlign; }
02334     TInt BaselineOffset() const;
02335 private:
02336     TRect iTextRect;
02337     const CFont *iFont; // not owned..
02338     TInt iColor;
02339     TInt iOffset;
02340     CGraphicsContext::TTextAlign iAlign;
02341     friend class CBubbleOutlookNumberEntry;
02342     };
02352 class TAknLayoutRect
02353     {    
02354 public:
02355     IMPORT_C TAknLayoutRect();
02358     IMPORT_C void LayoutRect(const TRect &aParent, TInt aResourceId);
02359     IMPORT_C void LayoutRect(const TRect &aParent, TResourceReader &aReader);
02360     IMPORT_C void LayoutRect(const TRect &aParent, 
02361                              const AknLayoutUtils::SAknLayoutRect &aLayout);
02363     IMPORT_C void LayoutRect(const TRect &aParent,
02364                              const TAknWindowLineLayout &aLayout);
02366     IMPORT_C void LayoutRect(const TRect &aParent, 
02367                              TInt C, TInt l, TInt t, TInt r, TInt b,
02368                              TInt W, TInt H);
02378     IMPORT_C TRgb Color() const;
02381     IMPORT_C TRect Rect() const;
02382     TBool Valid() const;
02386     IMPORT_C void DrawRect(CWindowGc& aGc) const;
02387     IMPORT_C void DrawOutLineRect(CWindowGc& aGc) const;
02388     IMPORT_C void DrawImage(CBitmapContext& aGc, CFbsBitmap* aBitmap, CFbsBitmap* aMask) const;
02389 private:
02390     TInt iColor;
02391     TRect iRect;
02392     };
02397 class AknDraw 
02398     {
02399 public:
02406     IMPORT_C static void DrawEmptyList(
02407         const TRect& aRect,
02408         CWindowGc& aGc,
02409         TPtrC aText);
02417     IMPORT_C static void DrawEmptyListForSettingPage(
02418         const TRect &aRect,
02419         CWindowGc &aGc,
02420         TPtrC text); // only for setting page with empty layout.
02428     IMPORT_C static void DrawEmptyListWithFind(
02429         const TRect& aClientRect,
02430         CWindowGc& aGc,
02431         TPtrC aText); // only for fixed find pane used with single graphics listbox.
02439     IMPORT_C static void DrawEmptyListHeading(
02440         const TRect &aClientRect,
02441         CWindowGc& aGc,
02442         TPtrC aText); // only heading style lists.
02444     // The following is optimization for drawing window shadows.
02453     IMPORT_C static void DrawWindowShadow(
02454         CWindowGc& aGc,
02455         const TAknLayoutRect& aCoverRect,
02456         const TAknLayoutRect& aSecondShadowRect,
02457         const TAknLayoutRect& aFirstShadowRect,
02458         const TAknLayoutRect& aOutlineFrameRect,
02459         const TAknLayoutRect& aInsideAreaRect);
02461 public:
02481     IMPORT_C static void DrawEmptyListImpl( const TRect& aRect,
02482                                             CWindowGc& aGc,
02483                                             TPtrC aText,
02484                                             TInt aLayoutLine1,
02485                                             TInt aLayoutLine2 );
02487     };
02492 class AknDrawWithSkins
02493     {
02494 public:
02501     IMPORT_C static void DrawEmptyList(
02502         const TRect& aRect,
02503         CWindowGc& aGc,
02504         TPtrC aText,
02505         CCoeControl *aControl);
02513     IMPORT_C static void DrawEmptyListForSettingPage(
02514         const TRect &aRect,
02515         CWindowGc &aGc,
02516         TPtrC text,
02517         CCoeControl *aControl); // only for setting page with empty layout.
02525     IMPORT_C static void DrawEmptyListWithFind(
02526         const TRect& aClientRect,
02527         CWindowGc& aGc,
02528         TPtrC aText,
02529         CCoeControl *aControl); // only for fixed find pane used with single graphics listbox.
02537     IMPORT_C static void DrawEmptyListHeading(
02538         const TRect &aClientRect,
02539         CWindowGc& aGc,
02540         TPtrC aText,
02541         CCoeControl *aControl); // only heading style lists.
02543     // The following is optimization for drawing window shadows.
02552     IMPORT_C static void DrawWindowShadow(
02553         CWindowGc& aGc,
02554         const TAknLayoutRect& aCoverRect,
02555         const TAknLayoutRect& aSecondShadowRect,
02556         const TAknLayoutRect& aFirstShadowRect,
02557         const TAknLayoutRect& aOutlineFrameRect,
02558         const TAknLayoutRect& aInsideAreaRect,
02559         CCoeControl *aControl);
02561     };
02566 // Browser and calculator fonts will not be placed here. Application
02567 // can use them themselves with CEikonEnv::Static()->Font() call.
02568 IMPORT_C const CFont *LatinPlain12();
02569 IMPORT_C const CFont *LatinBold12();
02570 IMPORT_C const CFont *LatinBold13();
02571 IMPORT_C const CFont *LatinBold16(); // since 2.0
02572 IMPORT_C const CFont *LatinBold17();
02573 IMPORT_C const CFont *LatinBold19(); 
02574 IMPORT_C const CFont *NumberPlain5();
02575 IMPORT_C const CFont *ClockBold30();
02576 IMPORT_C const CFont *LatinClock14();
02577 const CFont *CalcBold21();
02578 const CFont *CalcOperBold21();
02579 const CFont *CalcOperBold13();
02583 IMPORT_C const CFont *ApacPlain12();
02584 IMPORT_C const CFont *ApacPlain16();
02613 IMPORT_C TInt CompleteWithAppPath( TDes& aFileName );
02623 TBool IsParentRelative(TInt aVal);
02632 IMPORT_C TInt DefaultInputLanguageFromUILanguage(const TInt aUiLanguage);
02642 IMPORT_C void SetKeyblockMode( TAknKeyBlockMode aMode );
02644 namespace AknDateTimeUtils
02645     {
02655     IMPORT_C void ConvertUtcTimeToHomeTime( TTime& aTime );
02656     }
02658 namespace AknLangUtils
02659     {
02665     IMPORT_C HBufC* DisplayLanguageTagL();
02666     }
02668 #endif //  __AKNUTILS_H__
02669 
02670 // End of file