// Borland C++ Builder
// Copyright (c) 1995, 2005 by Borland Software Corporation
// All rights reserved

// (DO NOT EDIT: machine generated header) 'Actnmenus.pas' rev: 10.00

#ifndef ActnmenusHPP
#define ActnmenusHPP

#pragma delphiheader begin
#pragma option push
#pragma option -w-      // All warnings off
#pragma option -Vx      // Zero-length empty class member functions
#pragma pack(push,8)
#include <System.hpp>	// Pascal unit
#include <Sysinit.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <Messages.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Forms.hpp>	// Pascal unit
#include <Controls.hpp>	// Pascal unit
#include <Contnrs.hpp>	// Pascal unit
#include <Graphics.hpp>	// Pascal unit
#include <Actnlist.hpp>	// Pascal unit
#include <Toolwin.hpp>	// Pascal unit
#include <Extctrls.hpp>	// Pascal unit
#include <Actnman.hpp>	// Pascal unit
#include <Actnctrls.hpp>	// Pascal unit
#include <Menus.hpp>	// Pascal unit
#include <Stdctrls.hpp>	// Pascal unit
#include <Shadowwnd.hpp>	// Pascal unit
#include <Buttons.hpp>	// Pascal unit
#include <Stdactns.hpp>	// Pascal unit

//-- user supplied -----------------------------------------------------------

namespace Actnmenus
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TMenuStack;
class DELPHICLASS TCustomActionMenuBar;
#pragma option push -b-
enum TAnimationStyle { asNone, asDefault, asUnFold, asSlide, asFade };
#pragma option pop

typedef void __fastcall (__closure *TMenuPopupEvent)(System::TObject* Sender, Actnman::TCustomActionControl* Item);

typedef TMetaClass* TCustomPopupClass;

typedef void __fastcall (__closure *TGetPopupClassEvent)(System::TObject* Sender, TMetaClass* &PopupClass);

typedef void __fastcall (__closure *TExitMenuEvent)(TCustomActionMenuBar* Sender, bool Cancelled);

class DELPHICLASS TCustomActionPopupMenu;
class PASCALIMPLEMENTATION TCustomActionMenuBar : public Actnctrls::TCustomActionDockBar 
{
	typedef Actnctrls::TCustomActionDockBar inherited;
	
private:
	Extctrls::TTimer* FActionIdleTimer;
	bool FAnimatePopups;
	TAnimationStyle FAnimationStyle;
	bool FCancelMenu;
	Actnman::TCustomActionControl* FDelayItem;
	Actnman::TCustomActionControl* FDragItem;
	bool FExpandable;
	bool FExpanded;
	bool FInMenuLoop;
	bool FItemKeyed;
	Controls::TControl* FMouseControl;
	#pragma pack(push,1)
	Types::TPoint FMousePos;
	#pragma pack(pop)
	Forms::TCustomForm* FParentForm;
	TCustomActionMenuBar* FParentMenu;
	Actnman::TCustomActionControl* FParentControl;
	TMenuStack* FPopupStack;
	TMenuPopupEvent FOnPopup;
	int FExpandDelay;
	TCustomActionMenuBar* FRootMenu;
	bool FDefaultFont;
	TGetPopupClassEvent FOnGetPopupClass;
	int FAnimateDuration;
	Classes::TNotifyEvent FOnEnterMenuLoop;
	TExitMenuEvent FOnExitMenuLoop;
	bool FUseSystemFont;
	bool FAutoFocus;
	void __fastcall ActionIdleTimerProc(System::TObject* Sender);
	HIDESBASE MESSAGE void __fastcall WMKeyDown(Messages::TWMKey &Message);
	MESSAGE void __fastcall CMEnterMenuLoop(Messages::TMessage &Message);
	HIDESBASE MESSAGE void __fastcall CMFontchanged(Messages::TMessage &Message);
	MESSAGE void __fastcall CMItemClicked(Actnman::TCMItemMsg &Message);
	HIDESBASE MESSAGE void __fastcall WMMouseActivate(Messages::TWMMouseActivate &Message);
	HIDESBASE MESSAGE void __fastcall WMSysKeyDown(Messages::TWMKey &Message);
	void __fastcall SetParentMenu(const TCustomActionMenuBar* Value);
	MESSAGE void __fastcall CMItemKeyed(Actnman::TCMItemMsg &Message);
	void __fastcall SetAnimateDuration(const int Value);
	void __fastcall DoActionIdle(void);
	void __fastcall SetMouseControl(const Controls::TControl* Value);
	void __fastcall SetUseSystemFont(const bool Value);
	
protected:
	Actnman::TActionClientItem* FSelectedItem;
	TCustomActionPopupMenu* FCachedMenu;
	TCustomActionMenuBar* FChildMenu;
	Extctrls::TTimer* FExpandTimer;
	Extctrls::TTimer* FPopupTimer;
	void __fastcall Animate(bool Show = true);
	void __fastcall Idle(const tagMSG &Msg);
	void __fastcall ClearSubMenus(void);
	void __fastcall CleanupStack(void);
	virtual Actnman::TCustomActionControl* __fastcall CreateControl(Actnman::TActionClientItem* AnItem);
	virtual TCustomActionPopupMenu* __fastcall CreatePopup(TCustomActionMenuBar* AOwner, Actnman::TCustomActionControl* Item);
	Controls::TControl* __fastcall DoMouseIdle(void);
	void __fastcall DoItemSelected(Actnman::TCustomActionControl* AnItem);
	DYNAMIC TMetaClass* __fastcall DoGetPopupClass(void);
	virtual Actnman::TActionClientItem* __fastcall DoItemClicked(Actnman::TCustomActionControl* AnItem);
	virtual Actnman::TActionClientItem* __fastcall DoItemKeyed(Actnman::TCustomActionControl* AnItem);
	void __fastcall DoMenuDelay(System::TObject* Sender);
	virtual void __fastcall DoneMenuLoop(void);
	virtual void __fastcall DoPopup(Actnman::TCustomActionControl* Item);
	virtual void __fastcall ExecAction(Actnlist::TContainedAction* Action);
	virtual void __fastcall Expand(bool Full);
	void __fastcall ExpandTimer(System::TObject* Sender);
	void __fastcall GetDefaultSounds(void);
	virtual bool __fastcall GetDesignMode(void);
	virtual TMetaClass* __fastcall GetPopupClass(void);
	Actnman::TCustomActionControl* __fastcall GetMouseHoverItem(const tagMSG &Msg);
	Actnman::TActionClientItem* __fastcall GetSelected(void);
	virtual void __fastcall InitMenuLoop(void);
	bool __fastcall IsDesignMsg(tagMSG &Msg);
	virtual void __fastcall Loaded(void);
	DYNAMIC Controls::TMouseActivate __fastcall MouseActivate(Controls::TMouseButton Button, Classes::TShiftState Shift, int X, int Y, int HitTest);
	virtual TCustomActionPopupMenu* __fastcall NewPopup(void);
	virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation);
	virtual Actnman::TActionClientItem* __fastcall ProcessMenuLoop(void);
	bool __fastcall ProcessMessage(tagMSG &Msg);
	void __fastcall ProcessMessages(void);
	virtual void __fastcall ProcessMouseMsg(tagMSG &Msg);
	void __fastcall SelectItem(Actnman::TCustomActionControl* AnItem);
	void __fastcall Select(const bool Forward);
	virtual void __fastcall SetDesignMode(const bool Value);
	virtual void __fastcall SetParent(Controls::TWinControl* AParent);
	virtual void __fastcall SetPersistentHotKeys(const bool Value);
	virtual void __fastcall WndProc(Messages::TMessage &Message);
	__property int AnimateDuration = {read=FAnimateDuration, write=SetAnimateDuration, nodefault};
	__property Actnman::TCustomActionControl* DelayItem = {read=FDelayItem, write=FDelayItem};
	__property bool Expandable = {read=FExpandable, write=FExpandable, nodefault};
	__property bool Expanded = {read=FExpanded, write=FExpanded, nodefault};
	__property Controls::TControl* MouseControl = {read=FMouseControl, write=SetMouseControl};
	__property TCustomActionMenuBar* ParentMenu = {read=FParentMenu, write=SetParentMenu};
	__property TMenuStack* PopupStack = {read=FPopupStack};
	__property Actnman::TActionClientItem* Selected = {read=GetSelected};
	
public:
	__fastcall virtual TCustomActionMenuBar(Classes::TComponent* AOwner);
	__fastcall virtual ~TCustomActionMenuBar(void);
	virtual void __fastcall CloseMenu(void);
	virtual void __fastcall RecreateControls(void);
	virtual Actnman::TActionBarStyle* __fastcall Style(void);
	virtual void __fastcall TrackMenu(void);
	__property TAnimationStyle AnimationStyle = {read=FAnimationStyle, write=FAnimationStyle, nodefault};
	__property bool AutoFocus = {read=FAutoFocus, write=FAutoFocus, nodefault};
	__property int ExpandDelay = {read=FExpandDelay, write=FExpandDelay, nodefault};
	__property bool InMenuLoop = {read=FInMenuLoop, write=FInMenuLoop, nodefault};
	__property Actnman::TCustomActionControl* ParentControl = {read=FParentControl, write=FParentControl};
	__property TCustomActionMenuBar* RootMenu = {read=FRootMenu, write=FRootMenu};
	__property bool UseSystemFont = {read=FUseSystemFont, write=SetUseSystemFont, nodefault};
	__property Classes::TNotifyEvent OnEnterMenuLoop = {read=FOnEnterMenuLoop, write=FOnEnterMenuLoop};
	__property TExitMenuEvent OnExitMenuLoop = {read=FOnExitMenuLoop, write=FOnExitMenuLoop};
	__property TGetPopupClassEvent OnGetPopupClass = {read=FOnGetPopupClass, write=FOnGetPopupClass};
	__property TMenuPopupEvent OnPopup = {read=FOnPopup, write=FOnPopup};
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TCustomActionMenuBar(HWND ParentWindow) : Actnctrls::TCustomActionDockBar(ParentWindow) { }
	#pragma option pop
	
};


class DELPHICLASS TCustomMenuExpandBtn;
class PASCALIMPLEMENTATION TCustomMenuExpandBtn : public Actnctrls::TCustomUtilityButton 
{
	typedef Actnctrls::TCustomUtilityButton inherited;
	
private:
	TCustomActionMenuBar* __fastcall GetMenu(void);
	
protected:
	virtual void __fastcall DrawBackground(Types::TRect &PaintRect);
	virtual void __fastcall DrawFrame(const Types::TRect &ARect, bool Down);
	DYNAMIC void __fastcall DragOver(System::TObject* Source, int X, int Y, Controls::TDragState State, bool &Accept);
	__property TCustomActionMenuBar* Menu = {read=GetMenu};
	
public:
	__fastcall virtual TCustomMenuExpandBtn(Classes::TComponent* AOwner);
public:
	#pragma option push -w-inl
	/* TCustomUtilityButton.Destroy */ inline __fastcall virtual ~TCustomMenuExpandBtn(void) { }
	#pragma option pop
	
};


class DELPHICLASS TCustomMenuItem;
typedef TMetaClass* TCustomMenuExpandBtnClass;

class PASCALIMPLEMENTATION TCustomActionPopupMenu : public TCustomActionMenuBar 
{
	typedef TCustomActionMenuBar inherited;
	
private:
	Shadowwnd::TShadowWindow* FBShadow;
	TCustomMenuExpandBtn* FExpandBtn;
	Shadowwnd::TShadowWindow* FRShadow;
	bool FShadow;
	void __fastcall SetShadow(const bool Value);
	
protected:
	virtual void __fastcall AddEdges(TCustomMenuItem* AnItem);
	virtual void __fastcall DrawBackground(void);
	virtual bool __fastcall CanAutoSize(int &NewWidth, int &NewHeight);
	HIDESBASE MESSAGE void __fastcall CMMouseLeave(Messages::TMessage &Message);
	HIDESBASE MESSAGE void __fastcall CMVisibleChanged(Messages::TMessage &Message);
	virtual Actnman::TCustomActionControl* __fastcall CreateControl(Actnman::TActionClientItem* AnItem);
	virtual void __fastcall CreateControls(void);
	virtual void __fastcall CreateParams(Controls::TCreateParams &Params);
	DYNAMIC bool __fastcall DesignWndProc(Messages::TMessage &Message);
	virtual void __fastcall DisplayShadow(void);
	virtual void __fastcall ExecAction(Actnlist::TContainedAction* Action);
	void __fastcall ExpandClick(System::TObject* Sender);
	virtual Types::TRect __fastcall GetClientRect();
	virtual TMetaClass* __fastcall GetExpandBtnClass(void);
	virtual void __fastcall HideShadow(void);
	virtual TCustomActionPopupMenu* __fastcall NewPopup(void);
	virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation);
	virtual void __fastcall PositionPopup(Actnman::TCustomActionBar* AnOwner, Actnman::TCustomActionControl* ParentItem);
	virtual void __fastcall SetColorMap(const Actnman::TCustomActionBarColorMap* Value);
	void __fastcall SetupExpandBtn(void);
	virtual void __fastcall SetOrientation(const Actnman::TBarOrientation Value);
	HIDESBASE MESSAGE void __fastcall WMKeyDown(Messages::TWMKey &Message);
	MESSAGE void __fastcall WMPrint(Messages::TMessage &Message);
	HIDESBASE MESSAGE void __fastcall WMPrintClient(Messages::TWMPrint &Message);
	DYNAMIC void __fastcall VisibleChanging(void);
	
public:
	__fastcall virtual TCustomActionPopupMenu(Classes::TComponent* AOwner);
	__fastcall virtual ~TCustomActionPopupMenu(void);
	virtual void __fastcall CloseMenu(void);
	virtual void __fastcall Expand(bool Full);
	void __fastcall Popup(int X, int Y);
	__property TCustomMenuExpandBtn* ExpandBtn = {read=FExpandBtn, write=FExpandBtn};
	__property bool Shadow = {read=FShadow, write=SetShadow, nodefault};
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TCustomActionPopupMenu(HWND ParentWindow) : TCustomActionMenuBar(ParentWindow) { }
	#pragma option pop
	
};



class PASCALIMPLEMENTATION TMenuStack : public Contnrs::TStack 
{
	typedef Contnrs::TStack inherited;
	
private:
	TCustomActionMenuBar* FMenu;
	TCustomActionMenuBar* __fastcall GetBars(const int Index);
	
protected:
	__property TCustomActionMenuBar* Bars[int Index] = {read=GetBars};
	
public:
	__fastcall TMenuStack(TCustomActionMenuBar* AMenu);
	HIDESBASE void __fastcall Push(TCustomActionMenuBar* Container);
	HIDESBASE TCustomActionMenuBar* __fastcall Pop(void);
	HIDESBASE TCustomActionMenuBar* __fastcall Peek(void);
public:
	#pragma option push -w-inl
	/* TOrderedList.Destroy */ inline __fastcall virtual ~TMenuStack(void) { }
	#pragma option pop
	
};


typedef TMetaClass* TCustomAddRemoveItemClass;

class DELPHICLASS TActionBarStyleEx;
class PASCALIMPLEMENTATION TActionBarStyleEx : public Actnman::TActionBarStyle 
{
	typedef Actnman::TActionBarStyle inherited;
	
__published:
	virtual TMetaClass* __fastcall GetPopupClass(Actnman::TCustomActionBar* ActionBar) = 0 ;
	virtual TMetaClass* __fastcall GetAddRemoveItemClass(Actnman::TCustomActionBar* ActionBar) = 0 ;
	virtual TMetaClass* __fastcall GetScrollBtnClass(void) = 0 ;
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TActionBarStyleEx(void) : Actnman::TActionBarStyle() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TActionBarStyleEx(void) { }
	#pragma option pop
	
};


typedef TMetaClass* TCustomizeActionToolBarClass;

class DELPHICLASS TCustomizeActionToolBar;
class PASCALIMPLEMENTATION TCustomizeActionToolBar : public TCustomActionPopupMenu 
{
	typedef TCustomActionPopupMenu inherited;
	
private:
	Actnctrls::TCustomActionToolBar* FActionBar;
	Actnman::TActionClientItem* FAddlItem;
	Actnlist::TCustomAction* FResetAction;
	Actnman::TActionClientItem* FResetItem;
	MESSAGE void __fastcall CMItemSelected(Actnman::TCMItemMsg &Message);
	
protected:
	virtual bool __fastcall CanAutoSize(int &NewWidth, int &NewHeight);
	virtual void __fastcall Clear(void);
	virtual Actnman::TActionClientItem* __fastcall DoItemClicked(Actnman::TCustomActionControl* AnItem);
	virtual TMetaClass* __fastcall GetAddRemoveItemClass(void);
	virtual Actnman::TCustomActionControl* __fastcall GetActionControl(const int Index);
	virtual void __fastcall GetSubMenuControlClass(Actnman::TCustomActionBar* Sender, Actnman::TActionClient* AnItem, TMetaClass* &ControlClass);
	virtual TCustomActionPopupMenu* __fastcall NewPopup(void);
	virtual void __fastcall SetActionClient(const Actnman::TActionClient* Value);
	__property Actnman::TActionClientItem* AddlItem = {read=FAddlItem};
	
public:
	__fastcall virtual TCustomizeActionToolBar(Classes::TComponent* AOwner);
	virtual int __fastcall ItemCount(void);
	__fastcall virtual ~TCustomizeActionToolBar(void);
	__property Actnman::TActionClientItem* AdditionalItem = {read=FAddlItem};
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TCustomizeActionToolBar(HWND ParentWindow) : TCustomActionPopupMenu(ParentWindow) { }
	#pragma option pop
	
};


class DELPHICLASS TCustomizeActionLink;
class PASCALIMPLEMENTATION TCustomizeActionLink : public Actnman::TActionClientLink 
{
	typedef Actnman::TActionClientLink inherited;
	
protected:
	virtual void __fastcall SetEnabled(bool Value);
public:
	#pragma option push -w-inl
	/* TBasicActionLink.Create */ inline __fastcall virtual TCustomizeActionLink(System::TObject* AClient) : Actnman::TActionClientLink(AClient) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TBasicActionLink.Destroy */ inline __fastcall virtual ~TCustomizeActionLink(void) { }
	#pragma option pop
	
};


class DELPHICLASS TCustomizeActionClientItem;
class PASCALIMPLEMENTATION TCustomizeActionClientItem : public Actnman::TActionClientItem 
{
	typedef Actnman::TActionClientItem inherited;
	
protected:
	DYNAMIC TMetaClass* __fastcall GetActionLinkClass(void);
public:
	#pragma option push -w-inl
	/* TActionClientItem.Create */ inline __fastcall virtual TCustomizeActionClientItem(Classes::TCollection* Collection) : Actnman::TActionClientItem(Collection) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TActionClientItem.Destroy */ inline __fastcall virtual ~TCustomizeActionClientItem(void) { }
	#pragma option pop
	
};


#pragma option push -b-
enum TMDIButtonStyle { mbMinimize, mbRestore, mbClose };
#pragma option pop

class DELPHICLASS TCustomMDIMenuButton;
class PASCALIMPLEMENTATION TCustomMDIMenuButton : public Buttons::TSpeedButton 
{
	typedef Buttons::TSpeedButton inherited;
	
private:
	TMDIButtonStyle FButtonStyle;
	
protected:
	virtual void __fastcall Paint(void);
	
public:
	__property TMDIButtonStyle ButtonStyle = {read=FButtonStyle, write=FButtonStyle, nodefault};
public:
	#pragma option push -w-inl
	/* TSpeedButton.Create */ inline __fastcall virtual TCustomMDIMenuButton(Classes::TComponent* AOwner) : Buttons::TSpeedButton(AOwner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TSpeedButton.Destroy */ inline __fastcall virtual ~TCustomMDIMenuButton(void) { }
	#pragma option pop
	
};


class DELPHICLASS TCustomActionMainMenuBar;
class PASCALIMPLEMENTATION TCustomActionMainMenuBar : public TCustomActionMenuBar 
{
	typedef TCustomActionMenuBar inherited;
	
private:
	Actnlist::TActionList* FMDIActions;
	bool FMDIActivate;
	bool FInActive;
	bool FShadows;
	AnsiString FWindowMenu;
	TCustomMDIMenuButton* FMinimizeBtn;
	TCustomMDIMenuButton* FRestoreBtn;
	TCustomMDIMenuButton* FCloseBtn;
	Actnman::TActionClientItem* FMDISeparator;
	void __fastcall SetInActive(const bool Value);
	HIDESBASE MESSAGE void __fastcall CMEnabledchanged(Messages::TMessage &Message);
	void __fastcall SetWindowMenu(const AnsiString Value);
	void __fastcall SetShadows(const bool Value);
	
protected:
	Actnman::TActionClientItem* FWindowMenuItem;
	virtual Actnman::TCustomActionControl* __fastcall CreateControl(Actnman::TActionClientItem* AnItem);
	virtual void __fastcall CreateControls(void);
	virtual void __fastcall CustomAlignPosition(Controls::TControl* Control, int &NewLeft, int &NewTop, int &NewWidth, int &NewHeight, Types::TRect &AlignRect, const Controls::TAlignInfo &AlignInfo);
	DYNAMIC bool __fastcall DesignWndProc(Messages::TMessage &Message);
	virtual void __fastcall DoneMenuLoop(void);
	void __fastcall GetActiveMDIChild(void);
	void __fastcall MDIChildMaximized(Forms::TCustomForm* ChildForm);
	void __fastcall MDIChildRestored(void);
	virtual TCustomActionPopupMenu* __fastcall NewPopup(void);
	virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation);
	virtual void __fastcall ProcessMouseMsg(tagMSG &Msg);
	void __fastcall RefreshMDIMenu(void);
	virtual void __fastcall SetDesignMode(const bool Value);
	void __fastcall SetupWindowMenu(void);
	HIDESBASE MESSAGE void __fastcall CMWininichange(Messages::TWMWinIniChange &Message);
	HIDESBASE MESSAGE void __fastcall WMKeyDown(Messages::TWMKey &Message);
	HIDESBASE MESSAGE void __fastcall WMNCHitTest(Messages::TWMNCHitTest &Message);
	HIDESBASE MESSAGE void __fastcall WMSysCommand(Messages::TWMSysCommand &Message);
	HIDESBASE MESSAGE void __fastcall WMSysKeyDown(Messages::TWMKey &Message);
	HIDESBASE MESSAGE void __fastcall WMSysKeyUp(Messages::TWMKey &Message);
	bool __fastcall MainWndHook(Messages::TMessage &Message);
	
public:
	__fastcall virtual TCustomActionMainMenuBar(Classes::TComponent* AOwner);
	__fastcall virtual ~TCustomActionMainMenuBar(void);
	DYNAMIC bool __fastcall CanFocus(void);
	virtual void __fastcall CloseMenu(void);
	virtual void __fastcall TrackMenu(void);
	__property bool Inactive = {read=FInActive, write=SetInActive, nodefault};
	__property PersistentHotKeys ;
	__property bool Shadows = {read=FShadows, write=SetShadows, default=1};
	__property AnsiString WindowMenu = {read=FWindowMenu, write=SetWindowMenu};
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TCustomActionMainMenuBar(HWND ParentWindow) : TCustomActionMenuBar(ParentWindow) { }
	#pragma option pop
	
};


class DELPHICLASS TActionMainMenuBar;
class PASCALIMPLEMENTATION TActionMainMenuBar : public TCustomActionMainMenuBar 
{
	typedef TCustomActionMainMenuBar inherited;
	
public:
	__property Canvas ;
	
__published:
	__property UseSystemFont  = {default=1};
	__property ActionManager ;
	__property Align  = {default=1};
	__property AllowHiding  = {default=0};
	__property Anchors  = {default=3};
	__property AnimateDuration  = {default=150};
	__property AnimationStyle  = {default=1};
	__property AutoFocus  = {default=1};
	__property BiDiMode  = {default=0};
	__property Caption ;
	__property Color  = {default=-16777201};
	__property ColorMap ;
	__property Constraints ;
	__property DragCursor  = {default=-12};
	__property DragKind  = {default=1};
	__property DragMode  = {default=0};
	__property EdgeBorders  = {default=0};
	__property EdgeInner  = {default=1};
	__property EdgeOuter  = {default=2};
	__property Enabled  = {default=1};
	__property ExpandDelay  = {default=4000};
	__property Font ;
	__property HorzMargin  = {default=1};
	__property ParentBiDiMode  = {default=1};
	__property ParentBackground  = {default=0};
	__property ParentColor  = {default=0};
	__property ParentFont  = {default=0};
	__property ParentShowHint  = {default=1};
	__property PersistentHotKeys  = {default=0};
	__property Shadows  = {default=1};
	__property ShowHint ;
	__property Spacing ;
	__property VertMargin  = {default=1};
	__property Visible  = {default=1};
	__property WindowMenu ;
	__property OnAlignInsertBefore ;
	__property OnAlignPosition ;
	__property OnCanResize ;
	__property OnClick ;
	__property OnControlCreated ;
	__property OnConstrainedResize ;
	__property OnContextPopup ;
	__property OnDockDrop ;
	__property OnDockOver ;
	__property OnDblClick ;
	__property OnDragDrop ;
	__property OnDragOver ;
	__property OnEndDock ;
	__property OnEndDrag ;
	__property OnEnter ;
	__property OnEnterMenuLoop ;
	__property OnExit ;
	__property OnExitMenuLoop ;
	__property OnGetControlClass ;
	__property OnGetPopupClass ;
	__property OnGetSiteInfo ;
	__property OnMouseActivate ;
	__property OnMouseDown ;
	__property OnMouseMove ;
	__property OnMouseUp ;
	__property OnPaint ;
	__property OnPopup ;
	__property OnResize ;
	__property OnStartDock ;
	__property OnStartDrag ;
	__property OnUnDock ;
public:
	#pragma option push -w-inl
	/* TCustomActionMainMenuBar.Create */ inline __fastcall virtual TActionMainMenuBar(Classes::TComponent* AOwner) : TCustomActionMainMenuBar(AOwner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TCustomActionMainMenuBar.Destroy */ inline __fastcall virtual ~TActionMainMenuBar(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TActionMainMenuBar(HWND ParentWindow) : TCustomActionMainMenuBar(ParentWindow) { }
	#pragma option pop
	
};


typedef Set<Toolwin::TEdgeBorder, ebLeft, ebBottom>  TMenuEdges;

class PASCALIMPLEMENTATION TCustomMenuItem : public Actnman::TCustomActionControl 
{
	typedef Actnman::TCustomActionControl inherited;
	
private:
	TMenuEdges FEdges;
	TCustomActionMenuBar* FMenu;
	bool FMouseSelected;
	#pragma pack(push,1)
	Types::TRect FShortCutBounds;
	#pragma pack(pop)
	int FCYMenu;
	void __fastcall SetEdges(const TMenuEdges Value);
	HIDESBASE MESSAGE void __fastcall CMMouseEnter(Messages::TMessage &Message);
	HIDESBASE MESSAGE void __fastcall CMTextchanged(Messages::TMessage &Message);
	
protected:
	AnsiString FNoPrefix;
	virtual void __fastcall CalcLayout(void);
	virtual void __fastcall DoDragDrop(System::TObject* DragObject, int X, int Y);
	virtual void __fastcall DrawEdge(TMenuEdges Edges);
	virtual void __fastcall DrawSubMenuGlyph(void);
	virtual void __fastcall DrawShadowedText(const Types::TRect &Rect, unsigned Flags, AnsiString Text, Graphics::TColor TextColor, Graphics::TColor ShadowColor);
	virtual void __fastcall DrawText(Types::TRect &ARect, unsigned &Flags, AnsiString Text);
	virtual void __fastcall DrawUnusedEdges(void);
	DYNAMIC void __fastcall MouseUp(Controls::TMouseButton Button, Classes::TShiftState Shift, int X, int Y);
	virtual void __fastcall Paint(void);
	virtual void __fastcall PositionChanged(void);
	virtual void __fastcall SetSelected(bool Value);
	DYNAMIC void __fastcall DragOver(System::TObject* Source, int X, int Y, Controls::TDragState State, bool &Accept);
	__property TCustomActionMenuBar* Menu = {read=FMenu};
	__property bool MouseSelected = {read=FMouseSelected, nodefault};
	__property Types::TRect ShortCutBounds = {read=FShortCutBounds, write=FShortCutBounds};
	
public:
	__fastcall virtual TCustomMenuItem(Classes::TComponent* AOwner);
	virtual void __fastcall CalcBounds(void);
	DYNAMIC void __fastcall Click(void);
	__fastcall virtual ~TCustomMenuItem(void);
	virtual void __fastcall Keyed(void);
	DYNAMIC void __fastcall DragDrop(System::TObject* Source, int X, int Y);
	__property TMenuEdges Edges = {read=FEdges, write=SetEdges, nodefault};
};


class DELPHICLASS TCustomMenuButton;
class PASCALIMPLEMENTATION TCustomMenuButton : public Actnctrls::TCustomButtonControl 
{
	typedef Actnctrls::TCustomButtonControl inherited;
	
private:
	bool FCloseMenu;
	bool FDoClick;
	TCustomActionMenuBar* __fastcall GetMenu(void);
	HIDESBASE MESSAGE void __fastcall CMDialogChar(Messages::TWMKey &Message);
	
protected:
	DYNAMIC void __fastcall BeginAutoDrag(void);
	virtual void __fastcall DoDragDrop(System::TObject* DragObject, int X, int Y);
	DYNAMIC void __fastcall DragOver(System::TObject* Source, int X, int Y, Controls::TDragState State, bool &Accept);
	virtual void __fastcall DrawText(Types::TRect &ARect, unsigned &Flags, AnsiString Text);
	HIDESBASE MESSAGE void __fastcall CMMouseEnter(Messages::TMessage &Message);
	DYNAMIC void __fastcall MouseDown(Controls::TMouseButton Button, Classes::TShiftState Shift, int X, int Y);
	DYNAMIC void __fastcall MouseUp(Controls::TMouseButton Button, Classes::TShiftState Shift, int X, int Y);
	virtual void __fastcall Paint(void);
	__property TCustomActionMenuBar* Menu = {read=GetMenu};
	
public:
	__fastcall virtual TCustomMenuButton(Classes::TComponent* AOwner);
	__fastcall virtual ~TCustomMenuButton(void);
	DYNAMIC void __fastcall Click(void);
	virtual void __fastcall Keyed(void);
};


class DELPHICLASS TCustomAddRemoveItem;
class PASCALIMPLEMENTATION TCustomAddRemoveItem : public TCustomMenuItem 
{
	typedef TCustomMenuItem inherited;
	
protected:
	bool __fastcall IsActionVisible(void);
	DYNAMIC void __fastcall MouseUp(Controls::TMouseButton Button, Classes::TShiftState Shift, int X, int Y);
	virtual void __fastcall SetEnabled(bool Value);
	
public:
	virtual void __fastcall CalcBounds(void);
public:
	#pragma option push -w-inl
	/* TCustomMenuItem.Create */ inline __fastcall virtual TCustomAddRemoveItem(Classes::TComponent* AOwner) : TCustomMenuItem(AOwner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TCustomMenuItem.Destroy */ inline __fastcall virtual ~TCustomAddRemoveItem(void) { }
	#pragma option pop
	
};


typedef TMetaClass* TMenuItemControlClass;

typedef TMetaClass* TAddRemoveItemClass;

typedef TMetaClass* TMenuButtonControlClass;

typedef void __fastcall (*TUpdateActnMenusProc)(void);

//-- var, const, procedure ---------------------------------------------------
extern PACKAGE TMetaClass* MenuItemControlClass;
extern PACKAGE TMetaClass* MenuAddRemoveItemClass;
extern PACKAGE TMetaClass* MenuButtonControlClass;
extern PACKAGE TMetaClass* MenuPopupClass;
extern PACKAGE TMetaClass* MenuCustomizePopupClass;
extern PACKAGE TUpdateActnMenusProc UpdateActnMenusProc;
extern PACKAGE void __fastcall RegisterActnBarStyle(TActionBarStyleEx* AStyle);
extern PACKAGE void __fastcall UnRegisterActnBarStyle(TActionBarStyleEx* AStyle);

}	/* namespace Actnmenus */
using namespace Actnmenus;
#pragma pack(pop)
#pragma option pop

#pragma delphiheader end.
//-- end unit ----------------------------------------------------------------
#endif	// Actnmenus
