/*
* Copyright (c) 1997-1999 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
#if !defined(__EIKMENUP_H__)
#define __EIKMENUP_H__
#if !defined(__EIKBCTRL_H__)
#include <eikbctrl.h>
#endif
#if !defined(__EIKDEF_H__)
#include <eikdef.h>
#endif
#if !defined(__EIKSBOBS_H__)
#include <eiksbobs.h> // for TEikScrollEvent
#endif
#include <bidi.h>
// FORWARD DECLARATIONS
class MEikMenuObserver;
class CEikHotKeyTable;
class CEikMenuPaneTitle;
class CEikButtonBase;
class CEikScrollBarFrame;
class CEikScrollBar;
class TEikScrollBarModel;
class CGulIcon;
class CEikMenuPaneExtension ;
class CEikCba;
class CAknItemActionMenuData;
// CONSTANTS
const TInt KScaleableTextSeparator = 0x0001;
/**
* A helper class for extending CEikMenuPaneItem without breaking binary
* compability.
*/
class CExtendedItemData : public CBase
{
public:
/**
* Destructor.
*/
~CExtendedItemData();
public:
/** Two packaked bitmaps: bitmap icon and mask for it. */
CGulIcon* iIcon;
/** Scalable text buffer. */
HBufC* iScaleableText;
};
/**
* The @c CEikMenuPaneItem class encapsulates the data needed to define a menu
* pane item and provides some of the functionality required to display the
* item.
*
* @since ER5U
*/
class CEikMenuPaneItem : public CBase
{
public:
/** Struct to menu pane item. */
struct SData
{
/** Nominal text length.*/
enum { ENominalTextLength=40 };
/**
* ID of the command to issue when the menu item using this @c SData is
* selected.
*/
TInt iCommandId;
/** Resource ID of a menu pane to cascade from this item. */
TInt iCascadeId;
/**
* Flags used internally by @c CEikMenuPane and accessible through
* functions such as @c CEikMenuPane::SetItemDimmed().
*/
TInt iFlags;
/** The text buffer displayed in the main area of the menu item. */
TBuf<ENominalTextLength> iText; // less than this actually stored
/**
* Additional descriptive text about the item. This is used by @c
* CEikMenuPane to display hotkey names.
*/
TBuf<1> iExtraText;
};
public:
/**
* C++ default constructor.
*/
IMPORT_C CEikMenuPaneItem();
/**
* Destructor.
*/
IMPORT_C ~CEikMenuPaneItem();
/**
* Sets a menu item icon. This replaces any icon already set for the menu
* item.
*
* @param aIcon Menu item icon consisting of a picture bitmap and a mask
* bitmap.
*/
IMPORT_C void SetIcon(CGulIcon* aIcon);
/**
* Draws the menu item icon.
*
* @param aGc Graphics context to which the icon is drawn.
* @param aRect Rectangle in which the icon is drawn.
* @param aDimmed If @c ETrue the icon is drawn dimmed.
* @param aBitmapSpaceRequired Length of one side of the square required to
* contain the bitmap.
*/
IMPORT_C void DrawItemIcon(CWindowGc& aGc,
TRect aRect,
TBool aDimmed,
TInt aBitmapSpaceRequired) const;
/**
* Construct an icon from bitmaps.
*
* Constructs a new icon for the menu item, taking ownership of the picture
* bitmap aBitmap and the mask bitmap aMask unless the bitmaps are
* externally owned.
*
* @param aBitmap Picture bitmap.
* @param aMask Mask bitmap.
*/
IMPORT_C void CreateIconL(CFbsBitmap* aBitmap,
CFbsBitmap* aMask);
/**
* Gets a pointer to the menu item's icon picture bitmap. This does not
* imply transfer of ownership.
*
* @return Picture bitmap.
*/
IMPORT_C CFbsBitmap* IconBitmap() const;
/**
* Gets a pointer to the menu item's icon mask bitmap. This does not imply
* transfer of ownership.
*
* @return Mask bitmap.
*/
IMPORT_C CFbsBitmap* IconMask() const;
/**
* Sets icon bitmap ownership.
* Sets the menu item's icon bitmaps as externally owned if @c
* aOwnedExternally is @c ETrue.
*
* @param aOwnedExternally If @c ETrue bitmaps are set as externally owned.
* @c If EFalse bitmaps are set as not being externally owned.
*/
IMPORT_C void SetBitmapsOwnedExternally(TBool aOwnedExternally);
/**
* Sets the picture bitmap. Transfers ownership unless the bitmaps are
* already owned externally.
*
* @param aBitmap Picture bitmap.
*/
IMPORT_C void SetIconBitmapL(CFbsBitmap* aBitmap);
/**
* Sets the mask bitmap. Transfers ownership unless the bitmaps are already
* owned externally.
*
* @param aMask Mask bitmap.
*/
IMPORT_C void SetIconMaskL(CFbsBitmap* aMask);
/**
* Returns scaleable text. If there isn't scaleable text available then
* this method returns @c iData.iText.
*
* @return Pointer to TPtrC object that contains scaleable text.
*/
IMPORT_C TPtrC ScaleableText() const;
/**
* Sets scaleable text. @c iData.iText is set to first text version.
*
* @param aText Scalable text.
*/
IMPORT_C void SetScaleableTextL(const TDesC& aText);
private:
inline void CreateExtendedDataBlock();
inline TBool IsScaleableText(const TDesC& aText) const;
TPtrC GetNominalText(const TDesC& aText);
public:
/** The y position of the menu pane item. */
TInt iPos;
/** The menu pane item's hotkey text. */
TInt iHotKeyCode;
/** Information from an SData struct. */
SData iData;
private:
CExtendedItemData* iExtendedData;
};
inline void CEikMenuPaneItem::CreateExtendedDataBlock()
{
if (!iExtendedData)
{
TRAPD(err, ( iExtendedData = new (ELeave) CExtendedItemData() ) );
}
}
inline TBool CEikMenuPaneItem::IsScaleableText(const TDesC& aText) const
{
return aText.Locate( TChar( KScaleableTextSeparator ) ) != KErrNotFound;
}
/**
* Menu panes are opened by activating the menu title
* @c (CEikMenuPaneTitle / MENU_TITLE) which is displayed in the menu bar @c
* (CEikMenuBar / MENU_BAR). They can also be cascaded from a menu item @c
* (CEikMenuPaneItem / MENU_ITEM) or launched by a menu button @c
* (CEikMenuButton).
*
* Menu panes may be defined using a @c MENU_PANE resource.
*/
class CEikMenuPane : public CEikBorderedControl
{
private:
enum {ENothingSelected=-1};
class CMenuScroller;
friend class CMenuScroller;
friend class CEikMenuPaneExtension;
public:
/** The text to be displayed for a hotkey. */
typedef TBuf<20> THotKeyDisplayText;
public:
/**
* This class provides a constructor to create an array of menu pane items
* and a destructor to destroy an array of menu pane items.
*/
class CItemArray:public CArrayPtrFlat<CEikMenuPaneItem>
{
public:
/**
* C++ default constructor that creates a flat array of menu pane
* items.
*/
IMPORT_C CItemArray();
/**
* Destructor.
*/
IMPORT_C ~CItemArray();
/**
* Appends @c CEikMenuPaneItem class object to array.
*
* @param aMenuItem The menu item to add.
*/
IMPORT_C void AddItemL(CEikMenuPaneItem* aMenuItem);
};
public:
/**
* Destructor.
*/
IMPORT_C ~CEikMenuPane();
/**
* C++ default constructor. Constructs a menu pane object with the
* specified observer.
*
* @param aMenuObserver Menu observer.
*/
IMPORT_C CEikMenuPane(MEikMenuObserver* aMenuObserver);
/**
* Handles 2nd base construction. Completes construction of a menu pane object.
*
* @param aOwner Menu pane owner ( for cascade menu ).
* @param aEditMenuObserver Observer for the edit menu. In default this is
* @c NULL.
*/
IMPORT_C void ConstructL(CEikMenuPane* aOwner,
MEikMenuObserver* aEditMenuObserver = NULL);
/**
* Destroys the menu pane's item array.
*/
IMPORT_C void Reset();
public: // framework
/**
* From @c CcoeControl.
*
* Handles key events offered to the menu by the control environment and
* provides an appropriate implementation of @c
* CCoeControl::OfferKeyEventL().
*
* @param aKeyEvent The key event.
* @param aType The type of key event: @c EEventKey, @c EEventKeyUp or @c
* EEventKeyDown.
*/
IMPORT_C TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent,
TEventCode aType);
/**
* From @c CcoeControl.
*
* Handles a pointer event on the menu.
*
* @param aPointerEvent The pointer event to handle.
*/
IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);
/**
* From @c CcoeControl.
*
* Gets the list of logical colours employed in the drawing of the control,
* paired with an explanation of how they are used. Appends the list into
* @c aColorUseList.
*
* @since 005u
* @param aColorUseList The list of colours paired with explanations.
*/
IMPORT_C virtual void GetColorUseListL(
CArrayFix<TCoeColorUse>& aColorUseList) const;
/**
* From @c CcoeControl.
*
* Handles a change to the menu's resources which are shared across the
* environment. For example, colours or fonts.
*
* @since 005u
* @param aType The type of resource that has changed.
*/
IMPORT_C virtual void HandleResourceChange(TInt aType); // not available before Release 005u
private: // from base class
/**
* Not implemented.
*
* @param Not used.
* @return NULL
*/
IMPORT_C void* ExtensionInterface( TUid aInterface );
public: // from MCoeInputObserver
/**
* From @c CCoeControl.
*
* Gets the list box’s input capabilities as set through the list box flags.
*
* @return List box input capabilities.
*/
IMPORT_C TCoeInputCapabilities InputCapabilities() const;
protected: // from base class
/**
* From @c CCoeControl
*
* Draw a control called by window server.
*
* All controls, except blank controls, should implement this function. The
* default implementation draws a blank control. This function is used for
* window server-initiated redrawing of controls, and for some
* application-initiated drawing. It should be implemented by each control,
* but is only called from within @c CCoeControl's member functions, and
* not from the derived class. For this reason it is a private member
* function of @c CCoeControl.
*
* The rectangle aRect indicates the region of the control that needs to be
* redrawn. The implementation of @c Draw() must always draw to every pixel
* within this rectangle.
*
* @param aRect The region of the control to be redrawn.
* Co-ordinates are relative to the control's origin (top left
* corner). Optional, not used currently.
*/
IMPORT_C void Draw(const TRect& aRect) const;
/**
* From @c CCoeControl.
*
* Takes any action required when the menu pane gains or loses focus,
* to change its appearance for example.
*
* @param aDrawNow If @c EDrawNow the menu pane is redrawn. If @c
* ENoDrawNow the menu pane is not redrawn.
*/
IMPORT_C void FocusChanged(TDrawNow aDrawNow);
/**
* From @c CCoeControl.
*
* Constructs the menu pane using the specified resource reader.
* Fills the menu item array with the list of menu items provided by the
* resource file.
*
* @param aReader The resource reader to use.
* @leave KErrNoMemory Memory allocation failure earlier construction.
*/
IMPORT_C void ConstructFromResourceL(TResourceReader& aReader);
public: // new functions
/**
* Adds a menu item dynamically by creating a new menu item, setting its
* data to @c aMenuItem and appending it to the pane's menu item array.
* Updates the menu's scroll bar to take account of the new item.
*
* @param aMenuItem The menu item to add.
* NOTICE that @c SData is a structure so all fields in it should be
* set to avoid any unexpected behaviour.
*/
IMPORT_C void AddMenuItemL(const CEikMenuPaneItem::SData& aMenuItem);
/**
* Adds a menu item dynamically by creating a new menu item, setting its
* data to @c aMenuItem and inserting it into the pane's menu item array.
* Updates the menu's scroll bar to take account of the new item.
*
* @param aMenuItem The menu item to add. NOTICE that @c SData is a
* structure so all fields in it should be set to avoid any
* unexpected behaviour.
* @param aPreviousId The id of the item after which the new item should be
* added.
*/
IMPORT_C void AddMenuItemL(const CEikMenuPaneItem::SData& aMenuItem,
TInt aPreviousId);
/**
* Adds menu items dynamically by creating new menu items from resource
* and inserts them into the pane's menu item array.
*
* @param aResourceId The ID of the resource for the menu item.
* @param aPreviousId The ID of the previous menu item, after which this
* newly created item should be added.
* @param aAddSeperator Shouldn't be used as separator is not not supported
* anymore.
*/
IMPORT_C void AddMenuItemsL(TInt aResourceId,
TInt aPreviousId = 0,
TBool aAddSeperator = EFalse);
/**
* Deletes the specified item in the menu pane.
*
* @param aCommandId The ID for the item to be deleted.
*/
IMPORT_C void DeleteMenuItem(TInt aCommandId);
/**
* Deletes the items between specified items.
*
* @param aStartIndex The index of the item after which items should be
* deleted.
* @param aEndIndex The index of the item up to which items should be
* deleted.
*/
IMPORT_C void DeleteBetweenMenuItems(TInt aStartIndex,
TInt aEndIndex);
/**
* Gets a reference to the data in the specified menu item.
*
* @param aCommandId The command ID of the menu item for which data is
* obtained.
* @return Reference to struct that contains command id.
*/
IMPORT_C CEikMenuPaneItem::SData& ItemData(TInt aCommandId);
/**
* Gets a pointer to the specified menu item. Also gets the position of the
* item within the menu pane. Panics if there are no menu items in the menu
* pane. Panics if the menu pane id does not identify any menu pane item in
* the array.
*
* @param aCommandId The ID of the menu item for which a pointer is
* returned.
* @param aPos On return, the position of the menu item with an ID of
* aCommandId.
* @return A pointer to the menu item.
* @panic EEikPanicNoSuchMenuItem Panics if there are no menu items in the
* menu pane or if the menu pane id does not
* identify any menu pane item in the array.
*/
IMPORT_C CEikMenuPaneItem* ItemAndPos(TInt aCommandId,TInt& aPos);
/**
* Displays the menu pane with the corner identified by @c aTargetType in
* the position specified by @c aTargetPos. This function uses @c
* aMinTitleWidth to calculate the area required to display the menu pane,
* taking into account whether the menu is a cascading menu or popup menu.
*
* @param aHotKeyTable Optional hotkey table.
* @param aTargetPos Position of the corner of the menu pane identified by
* @c aTargetType.
* @param aMenuPaneTitle The menu pane's title.
* @param aMinWidth Minimum width of the menu's title.
* @param aTargetType The corner of the menu pane to which @c aTargetPos
* relates. The default is the top left corner. Possible: @c
* EPopupTargetTopLeft, @c EPopupTargetTopRight,
* @cEPopupTargetBottomLeft, @c EPopupTargetBottomRight.
*/
IMPORT_C void StartDisplayingMenuPane(
const CEikHotKeyTable* aHotKeyTable,
const TPoint& aTargetPos,
const CEikMenuPaneTitle* aMenuPaneTitle,
TInt aMinWidth,
TPopupTargetPosType aTargetType = EPopupTargetTopLeft);
/**
* Sets the text in a menu item.
*
* @param aCommandId The command (as defined in an .hrh file) associated
* with this menu item. This identifies the menu item whose text is
* to be set.
* @param aDes New item text.
*/
IMPORT_C void SetItemTextL(TInt aCommandId,
const TDesC& aDes);
/**
* Sets the text in a menu item from resource.
*
* @param aCommandId The command (as defined in an .hrh file) associated
* with this menu item. This identifies the menu item whose text is
* to be set.
* @param aRid The resource ID of the menu item text.
*/
IMPORT_C void SetItemTextL(TInt aCommandId,
TInt aRid);
/**
* Dims (greys out) or undims a menu item. Dimming indicates that user
* input is not accepted.
*
* @param aCommandId The command (as defined in an .hrh file) associated
* with this menu item. This identifies the menu item whose text is
* to be dimmed or un-dimmed.
* @param aDimmed @c ETrue to dim this menu item. @c EFalse to un-dim this
* menu item.
*/
IMPORT_C void SetItemDimmed(TInt aCommandId,
TBool aDimmed);
/**
* Sets the item to be indicated or not. It should be used to change the
* state of radio buttons or check box items. It has real effect only
* starting from S60 v3.0.
*
* @param aCommandId The command (as defined in an .hrh file) associated
* with this menu item. This identifies the menu item for which the
* state is set or unset.
* @param aButtonState should be @c EEikMenuItemSymbolOn or @c
* EEikMenuItemSymbolIndeterminate
*/
IMPORT_C void SetItemButtonState(TInt aCommandId,
TInt aButtonState);
/**
* Sets the selected menu item.
*
* @param aSelectedItem The index of the item to get selected
*/
IMPORT_C void SetSelectedItem(TInt aSelectedItem);
/**
* Gets the position of the selected menu item.
*
* @return The position of the selected menu item.
*/
IMPORT_C TInt SelectedItem() const;
/**
* Closes and destroys any current cascade menu and takes focus back. Does
* nothing if no cascade menu exists.
*/
IMPORT_C void CloseCascadeMenu();
/**
* Sets the array containing the list of menu items for the current menu
* pane.
*
* @param aItemArray The menu item array for the menu pane.
*/
IMPORT_C void SetItemArray(CItemArray* aItemArray);
/**
* Set menu item array ownership.
*
* @param aOwnedExternally If @c ETrue the menu pane's menu item array is
* set as externally owned. If @c EFalse the menu pane's menu item
* array is set as not externally owned.
*/
IMPORT_C void SetItemArrayOwnedExternally(TBool aOwnedExternally);
/**
* Sets the specified button to launch the menu pane. Doesn't have any
* effect in current implementation.
*
* @param aButton The button to set as launching the menu.
*/
IMPORT_C void SetLaunchingButton(CEikButtonBase* aButton);
/**
* Moves the menu pane highlight to a newly selected menu item identified
* by @c aNewSelectedItem. Scrolls the menu to show the new selected item
* if necessary and redraws only the newly selected item and the currently
* selected item if possible.
*
* @param aNewSelectedItem The newly selected menu item index.
*/
IMPORT_C void MoveHighlightTo(TInt aNewSelectedItem);
/**
* Gets the number of menu items within the menu pane.
*
* @return Number of menu items within menu pane.
*/
IMPORT_C TInt NumberOfItemsInPane() const;
/**
* Closes the menu pane.
*/
IMPORT_C void Close();
/**
* From @ CCoeControl
*
* Handles key events offered to the menu by the control environment.
*
* @since Platform 004.
* @param aKeyEvent The key event.
* @param aType The type of key event: @c EEventKey, @c EEventKeyUp or @c
* EEventKeyDown.
* @param aConsumeAllKeys If @c ETrue this function returns @c
* EKeyWasConsumed regardless of whether it was used. If @c EFalse
* the key event is consumed if possible and either @c
* EKeyWasConsumed or @c EKeyWasNotConsumed is returned as
* appropriate.
*/
IMPORT_C TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent,
TEventCode aType,
TBool aConsumeAllKeys); // not available before Platform 004
/**
* Sets whether the scroll bar occupies the left side of the menu pane.
*
* @param aOnLeft If @c ETrue the scroll bar will occupy the left side of
* the menu pane.
*/
IMPORT_C void SetScrollBarOnLeft(TBool aOnLeft);
/**
* Sets whether the menu pane uses an arrow head scroll bar.
*
* @param aArrowHead If @c ETrue the menu pane uses an arrow head scroll
* bar.
*/
IMPORT_C void SetArrowHeadScrollBar(TBool aArrowHead);
// new for AVKON
/**
* Moves highlight to the next item or to the first one if last item is
* selected.
*/
IMPORT_C void NavigateToNextItem();
/**
* Inserts the menu item to the specified position.
*
* @param aMenuItem The menu item to add. NOTICE @c SData is the structure
* and all fileds should be initialized.
* @param aPosition The position of newly created item in the array.
*/
IMPORT_C void InsertMenuItemL(const CEikMenuPaneItem::SData& aMenuItem,
TInt aPosition);
/**
* Checks whether menu pane contains the menu item and returns position of
* it if the item is found.
*
* @param[in] aCommandId The command ID of the item to be searched for.
* @param[out] aPosition On return contains position of the item.
* @return @c ETrue if item was found. Otherwise @c EFalse.
*/
IMPORT_C TBool MenuItemExists(TInt aCommandId,
TInt& aPosition);
/**
* Checks whether the menu pane is a cascade menu or a main menu.
*
* @return @c ETrue if the menu pane is cascade menu and @c EFalse if the
* menu pane is the main menu.
*/
IMPORT_C TBool IsCascadeMenuPane() const;
/**
* Enables or disables text scrolling functionality. It is disabled by
* default.
*
* @param aEnable @c ETrue to enable text scrolling functionality.
*/
IMPORT_C void EnableMarqueeL(const TBool aEnable);
/**
* Report that selection was done for the currently highlighted item.
*/
void ActivateCurrentItemL();
/**
* Closes cascade menu if there is one and it is active.
*/
TBool CancelActiveMenuPane();
/**
* Deletes dimmed items from the menu item array.
*/
void FilterDimmedItems();
/**
* Gets the menu pane for the cascade menu.
*
* @return The menu pane for the cascade menu.
*/
IMPORT_C CEikMenuPane* CascadeMenuPane();
/**
* Gets a reference to the data in the specified menu item.
*
* @since S60 3.1
* @param aItemIndex The index of the item in the items array.
* @return The menu item's data.
* @leave KErrArgument Wrong @aItemIndex.
*/
IMPORT_C CEikMenuPaneItem::SData& ItemDataByIndexL(TInt aItemIndex);
/**
* Creates and enables a special characters row to be used in the edit
* menu.
*
* @since S60 3.1
* @param aSpecialChars Buffer that holds the selected characters after
* user has selected them.
*/
IMPORT_C void ConstructMenuSctRowL( TDes& aSpecialChars );
/**
* Returns the command id of the specified menu item. The function panics
* if aIndex doesn't exist or is out of range.
* @param aIndex The index of the menu item for which the command ID is returned.
* @since 3.1
*/
IMPORT_C TInt MenuItemCommandId( TInt aIndex ) const;
/**
* Creates and enables a special characters row to be used in the edit menu.
* The special character row is constructed from the given special character table.
*
* @param aSpecialChars Buffer that holds the selected characters after
* user has selected them.
* @param aResourceId The special character table resource id to define the
* characters in the row.
*
* @since S60 3.1
*/
IMPORT_C void ConstructMenuSctRowL( TDes& aSpecialChars, TInt aResourceId );
/**
* Creates and enables a special characters row to be used in the edit menu.
* The special character row is constructed from the given special character dialog.
*
* @param aSpecialChars Buffer that holds the selected characters after
* user has selected them.
* @param aResourceId The special character dialog resource id that contains a special character table
*
* @since S60 3.2
*/
IMPORT_C void ConstructMenuSctRowFromDialogL( TDes& aSpecialChars, TInt aResourceId );
/**
* Creates and enables a special characters row to be used in the edit menu.
* The special character row is constructed from the given special character dialog.
*
* @param aCharCase the charcase used by menu sct
* @param aSpecialChars Buffer that holds the selected characters after
* user has selected them.
* @param aResourceId The special character dialog resource id that contains a special character table
*
* @since S60 3.2
*/
IMPORT_C void ConstructMenuSctRowFromDialogL( TInt aCharCase, TDes& aSpecialChars, TInt aResourceId );
/**
* Sets menu item as item specific command.
*
* @param aCommandId The command associated with this menu item.
* @param aItemSpecific ETrue to define the menu item item specific,
* EFalse otherwise.
*/
IMPORT_C void SetItemSpecific( TInt aCommandId, TBool aItemSpecific );
/**
* Sets the embedded cba to options menu
*
* @param aCba Cba to embed to menu
*
* @since S60 v5.2
*/
void SetEmbeddedCba( CEikCba* aCba );
/**
* Closes and destroys any current cascade menu and takes focus back. Does
* nothing if no cascade menu exists.
*
* @param aMainMenuClosing ETrue if main menu is also to be closed.
*/
void CloseCascadeMenu( TBool aMainMenuClosing );
/**
* Symbian two-phased constructor for menu panes that are created for
* item specific menus.
*
* @internal
* @since S60 v5.2
* @return Created menu pane. Ownership transfers to caller.
*/
static CEikMenuPane* NewItemCommandMenuL( MEikMenuObserver* aObserver );
/**
* Sets item specific commands dimmed.
*
* @internal
* @since S60 v5.2
*/
void SetItemCommandsDimmed();
/**
* Adds menu items to this menu and item action menu data.
*
* @internal
* @since S60 v5.2
* @param aMenuData Item action menu data.
*/
void AddMenuItemsToItemActionMenuL(
CAknItemActionMenuData& aMenuData );
/**
* Adds cascade menu items to item action menu data.
*
* @internal
* @since S60 v5.2
* @param aCascadeId Cascade menu id.
* @param aItemSpecific If ETrue, adds only item specific items.
* @param aMenuData Item action menu data.
*/
void AddCascadeMenuItemsToActionMenuL(
TInt aCascadeId,
TBool aItemSpecific,
CAknItemActionMenuData& aMenuData );
/**
* Enables the default highlight in menu
*/
void SetDefaultHighlight();
private:
enum { EInvalidCurrentSize=0x01, EBackgroundFaded=0x02 };
private: // new functions
TRect CalculateSizeAndPosition() ;
enum THighlightType {ENoHighlight,EDrawHighlight,ERemoveHighlight};
void DrawItem( TInt aItem, THighlightType aHighlight ) const;
void DrawItem(CWindowGc& aGc,TInt aItem, THighlightType aHighlight) const;
void ReportSelectionMadeL( TBool aAbortTransition = ETrue );
void ReportCanceled();
void LaunchCascadeMenuL(TInt aCascadeMenuId);
void DoLaunchCascadeMenuL(TInt aCascadeMenuId);
void TryLaunchCascadeMenuL(const CEikMenuPaneItem& aItem);
void PrepareGcForDrawingItems(CGraphicsContext& aGc) const;
TBool ItemArrayOwnedExternally() const;
TBool IsHotKeyL(const TInt modifiers,const TInt aCode);
TBool MoveToItemL(TInt aCode, TInt aModifiers);
void HandleScrollEventL(CEikScrollBar* aScrollBar,TEikScrollEvent aEventType);
void CreateScrollBarFrame();
void UpdateScrollBar();
void DoUpdateScrollBarL();
void UpdateScrollBarThumbs();
static TInt UpdateScrollBarCallBackL(TAny* aObj);
TRect ViewRect() const;
TInt TotalItemHeight() const;
void ScrollToMakeItemVisible(TInt aItemIndex);
void Scroll(TInt aAmount);
TBool CheckCreateScroller();
void CheckCreateScrollerL();
void ResetItemArray();
void CreateItemArrayL();
void CreateIconFromResourceL(TResourceReader& aReader, CEikMenuPaneItem& aItem) const;
// Skin support for menu
void UpdateBackgroundContext(const TRect& aWindowRect);
// Support method for highlight animation
void RepaintHighlight() const;
private: // from CCoeControl
IMPORT_C void Reserved_1();
IMPORT_C void Reserved_2();
private : // new functions
void LoadCascadeBitmapL() ;
// Support for check mark, from v3.0
void LoadCheckMarkBitmapL();
TBool MenuHasCheckBoxOn() const;
// Support for radio button, from v3.0
void LoadRadioButtonBitmapL();
TBool IsItemMemberOfRadioButtonGroup(TInt aItem) const ;
// for drawing,from v3.0
TBool MenuHasIcon() const;
TRect CalculateSizeAndPositionScalable( const TRect& aWindowRect, TInt aNumItemsInPane ) ;
TRect HighlightRect() const;
void PrepareHighlightFrame() const;
void SetCascadedIconSize() const;
// fixes marquee flickering
friend class CAknMarqueeControl;
CEikMenuPaneExtension* Extension() const;
/**
* Creates menu pane's extension object if it doesn't exist yet.
*/
void CheckCreateExtensionL();
/**
* Calculates the rectangle occupied by an item.
*
* @param aItemIndex Item's index.
* @return Item's rectangle.
*/
TRect ItemRect( TInt aItemIndex ) const;
/**
* Calculates the height of menu items.
*
* @return Item height.
*/
TInt CalculateItemHeight() const;
protected: // from CoeControl
/**
* From @c CCoeControl.
*
* Retrieves an object of the same type as that encapsulated in aId. Other
* than in the case where @c NULL is returned, the object returned must be
* of the same object type - that is, the @c ETypeId member of the object
* pointed to by the pointer returned by this function must be equal to the
* @c iUid member of @c aId.
*
* @since SDK 7.0s
* @param aId An encapsulated object type ID.
* @return Encapsulates the pointer to the object provided. Note that the
* encapsulated pointer may be @c NULL.
*/
IMPORT_C TTypeUid::Ptr MopSupplyObject(TTypeUid aId);
public: // From CoeControl.
/**
* From @c CoeControl.
*
* Gets the number of controls contained in a compound control. This
* function should be implemented by all compound controls.
*
* Note:
* In SDK 6.1 this was changed from protected to public.
*
* @return The number of component controls contained by this control.
*/
IMPORT_C TInt CountComponentControls() const;
/**
* From @c CoeControl.
*
* Gets the specified component of a compound control. This function should?
* be implemented by all compound controls.
*
* Note:
* Within a compound control, each component control is identified by an
* index, where the index depends on the order the controls were added: the
* first is given an index of 0, the next an index of 1, and so on.
*
* @param[in, out] aIndex The index of the control to get.
* @return The component control with an index of @c aIndex.
*/
IMPORT_C CCoeControl* ComponentControl(TInt aIndex) const;
protected: // new functions
/**
* Gets the maximum number of items which can be seen simultaneously.
*
* @return The maximum number of items which can be seen simultaneously.
*/
TInt NumberOfItemsThatFitInView() const;
private: // data
friend class CEikMenuButton;
MEikMenuObserver* iMenuObserver;
MEikMenuObserver* iEditMenuObserver;
CEikMenuPane* iCascadeMenuPane;
const CEikMenuPaneTitle* iMenuPaneTitle;
const CEikHotKeyTable* iHotKeyTable;
CEikMenuPane* iOwner;
CItemArray* iItemArray;
TBool iArrayOwnedExternally;
TBool iAllowPointerUpEvents;
TInt iNumberOfDragEvents;
TInt iSelectedItem;
TInt iItemHeight;
TInt iBaseLine;
TInt iHotkeyColWidth;
TInt iFlags;
CEikScrollBarFrame* iSBFrame;
CMenuScroller* iScroller;
CEikButtonBase* iLaunchingButton; // for popouts only
TInt iSubPopupWidth; // 0..2
TInt iSpare;
CEikMenuPaneExtension* iExtension;
};
#endif