// Borland C++ Builder
// Copyright (c) 1995, 1999 by Borland International
// All rights reserved

// (DO NOT EDIT: machine generated header) 'AHMTFormManager.pas' rev: 4.00

#ifndef AHMTFormManagerHPP
#define AHMTFormManagerHPP

#pragma delphiheader begin
#pragma option push -w-
#include <AHMTHookClass.hpp>	// Pascal unit
#include <AHMSystemConst.hpp>	// Pascal unit
#include <ExtCtrls.hpp>	// Pascal unit
#include <Forms.hpp>	// Pascal unit
#include <AHMTStoreData.hpp>	// Pascal unit
#include <Menus.hpp>	// Pascal unit
#include <ShellAPI.hpp>	// Pascal unit
#include <AHMSystemClass.hpp>	// Pascal unit
#include <Graphics.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <Controls.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Messages.hpp>	// Pascal unit
#include <SysUtils.hpp>	// Pascal unit
#include <Dialogs.hpp>	// Pascal unit
#include <SysInit.hpp>	// Pascal unit
#include <System.hpp>	// Pascal unit

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

namespace Ahmtformmanager
{
//-- type declarations -------------------------------------------------------
#pragma option push -b-
enum TAHMFormFillStyle { Circle, Horizontal, Vertical, LeftBottom, RoundMiddle, SquareMiddle, Spectral, 
	DoppelFlash, Singleflash, MiddleHBar, MiddleVBar, VerticalDoppelBar, HorizontalDoppelBar };
#pragma option pop

#pragma option push -b-
enum TAHMFormImageStyle { isTile, isCenter, isStretched };
#pragma option pop

class DELPHICLASS TAHMFormGradient;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TAHMFormGradient : public Graphics::TGraphicsObject 
{
	typedef Graphics::TGraphicsObject inherited;
	
private:
	TAHMFormFillStyle FFillstyle;
	Graphics::TColor FBeginColor;
	Graphics::TColor FEndcolor;
	int FColorCount;
	Classes::TStrings* FColorStrings;
	void __fastcall SetColorStrings(Classes::TStrings* value);
	void __fastcall SetStyle(TAHMFormFillStyle value);
	void __fastcall SetBeginColor(Graphics::TColor value);
	void __fastcall SetEndColor(Graphics::TColor value);
	void __fastcall SetColorCount(int Value);
	
public:
	__fastcall virtual TAHMFormGradient(void);
	__fastcall virtual ~TAHMFormGradient(void);
	void __fastcall MultiDraw(const HDC Cdc, int iWidth, int iHeight, Classes::TStrings* CStrings, Graphics::TColor 
		NoGrad, bool Norm);
	
__published:
	__property Graphics::TColor BeginColor = {read=FBeginColor, write=SetBeginColor, default=-2147483632
		};
	__property Graphics::TColor EndColor = {read=FEndcolor, write=SetEndColor, default=-2147483628};
	__property TAHMFormFillStyle FillStyle = {read=FFillstyle, write=SetStyle, default=1};
	__property int ColorCount = {read=FColorCount, write=SetColorCount, default=32};
	__property Classes::TStrings* ColorsInBetween = {read=FColorStrings, write=SetColorStrings};
};

#pragma pack(pop)

class DELPHICLASS TAHMFormTexture;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TAHMFormTexture : public Graphics::TGraphicsObject 
{
	typedef Graphics::TGraphicsObject inherited;
	
private:
	Graphics::TBitmap* FImage;
	TAHMFormImageStyle FImageStyle;
	Graphics::TColor FTransparentColor;
	Graphics::TColor FTransparentBackground;
	void __fastcall SetTransparentColor(Graphics::TColor Value);
	void __fastcall SetTransparentBackground(Graphics::TColor Value);
	void __fastcall SetImage(Graphics::TBitmap* Value);
	void __fastcall SetImageStyle(TAHMFormImageStyle value);
	
public:
	__fastcall virtual TAHMFormTexture(void);
	__fastcall virtual ~TAHMFormTexture(void);
	void __fastcall Draw(const HDC Cdc, int Width, int Height, Graphics::TColor Noimg);
	
__published:
	__property Graphics::TBitmap* Image = {read=FImage, write=SetImage};
	__property TAHMFormImageStyle ImageStyle = {read=FImageStyle, write=SetImageStyle, default=0};
	__property Graphics::TColor TransparentColor = {read=FTransparentColor, write=SetTransparentColor, 
		default=536870911};
	__property Graphics::TColor TransparentBackground = {read=FTransparentBackground, write=SetTransparentBackground
		, default=-2147483633};
};

#pragma pack(pop)

class DELPHICLASS TAHMFormBrushFill;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TAHMFormBrushFill : public Graphics::TGraphicsObject 
{
	typedef Graphics::TGraphicsObject inherited;
	
private:
	Graphics::TBrushStyle FBrushStyle;
	Graphics::TColor FBrushColor;
	void __fastcall SetBrushStyle(Graphics::TBrushStyle value);
	void __fastcall SetBrushColor(Graphics::TColor value);
	
public:
	__fastcall virtual TAHMFormBrushFill(void);
	
__published:
	__property Graphics::TBrushStyle BrushStyle = {read=FBrushStyle, write=SetBrushStyle, default=0};
	__property Graphics::TColor BrushColor = {read=FBrushColor, write=SetBrushColor, default=-2147483633
		};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TAHMFormBrushFill(void) { }
	#pragma option pop
	
};

#pragma pack(pop)

#pragma option push -b-
enum TAHMFormBackStyle { bNormal, bGradient, bTexture, bBrushFillUseCurrent, bBrushFillFormColor };
#pragma option pop

class DELPHICLASS TAHMFormBackground;
class DELPHICLASS TAHMFormManager;
typedef void __fastcall (__closure *TAHMFormMessage)(System::TObject* Sender, Messages::TMessage &WndMessage
	);

#pragma option push -b-
enum TAHMFormProperties { dsgnPreview, wsDlgFrame, wsThickframe, wsBorder, wsCaption, wsMinimizeBox, 
	wsMaximizeBox, wsSysMenu, wsexAppWindow, wsexClientEdge, wsexDlgModalFrame, wsexStaticEdge, wsexToolwindow, 
	wsexContextHelp, wsexTransparent, wsexAcceptFiles };
#pragma option pop

typedef Set<TAHMFormProperties, dsgnPreview, wsexAcceptFiles>  TAHMFormPropertySet;

class DELPHICLASS TAHMFormConstraints;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TAHMFormConstraints : public Graphics::TGraphicsObject 
{
	typedef Graphics::TGraphicsObject inherited;
	
private:
	int FMaxWidth;
	int FMinWidth;
	int FMaxHeight;
	int FMinHeight;
	void __fastcall SetMaxHeight(const int Value);
	void __fastcall SetMaxWidth(const int Value);
	void __fastcall SetMinHeight(const int Value);
	void __fastcall SetMinWidth(const int Value);
	
__published:
	__property int MinWidth = {read=FMinWidth, write=SetMinWidth, default=0};
	__property int MinHeight = {read=FMinHeight, write=SetMinHeight, default=0};
	__property int MaxWidth = {read=FMaxWidth, write=SetMaxWidth, default=0};
	__property int MaxHeight = {read=FMaxHeight, write=SetMaxHeight, default=0};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TAHMFormConstraints(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TAHMFormConstraints(void) : Graphics::TGraphicsObject() { }
	#pragma option pop
	
};

#pragma pack(pop)

typedef void __fastcall (__closure *TAHMFormGetConstraints)(System::TObject* Sender, int &MinWidth, 
	int &MaxWidth, int &MinHeight, int &MaxHeight);

typedef void __fastcall (__closure *TAHMFormOnSysMemLow)(System::TObject* Sender, int CompactRatio);
	

typedef void __fastcall (__closure *TAHMOnFormDropFile)(System::TObject* Sender, int X, int Y, Classes::TStringList* 
	Files, int FileCount);

typedef void __fastcall (__closure *TAHMFormGetFile)(System::TObject* Sender, AnsiString FileAndPath
	);

class DELPHICLASS TAHMFormStore;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TAHMFormStore : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	bool FState;
	bool FVisible;
	bool FSize;
	bool FLocation;
	AnsiString FStoreKey;
	Ahmtstoredata::TAHMStoreData* FStore;
	TAHMFormManager* FormManager;
	void __fastcall SetLocation(const bool Value);
	void __fastcall SetSize(const bool Value);
	void __fastcall SetState(const bool Value);
	void __fastcall SetStoreKey(const AnsiString Value);
	void __fastcall SetVisible(const bool Value);
	void __fastcall SetStore(const Ahmtstoredata::TAHMStoreData* Value);
	
protected:
	void __fastcall SaveToStore(void);
	void __fastcall LoadFromStore(void);
	
public:
	__fastcall TAHMFormStore(TAHMFormManager* AOwner);
	__fastcall virtual ~TAHMFormStore(void);
	
__published:
	__property Ahmtstoredata::TAHMStoreData* Store = {read=FStore, write=SetStore};
	__property AnsiString StoreKey = {read=FStoreKey, write=SetStoreKey};
	__property bool Size = {read=FSize, write=SetSize, default=0};
	__property bool Location = {read=FLocation, write=SetLocation, default=0};
	__property bool State = {read=FState, write=SetState, default=0};
	__property bool Visible = {read=FVisible, write=SetVisible, default=0};
};

#pragma pack(pop)

class DELPHICLASS TAHMCButtons;
class DELPHICLASS TAHMCButton;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TAHMCButtons : public Classes::TCollection 
{
	typedef Classes::TCollection inherited;
	
private:
	TAHMFormManager* FAHMFormManager;
	TAHMCButton* __fastcall GetAHMCButtons(int Index);
	void __fastcall SetAHMCButtons(int Index, TAHMCButton* Value);
	
protected:
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	
public:
	__fastcall TAHMCButtons(TAHMFormManager* AOwner);
	HIDESBASE TAHMCButtons* __fastcall Add(void);
	bool __fastcall Delete(int Index);
	__property TAHMFormManager* Owner = {read=FAHMFormManager};
	__property TAHMCButton* Items[int Index] = {read=GetAHMCButtons, write=SetAHMCButtons/*, default*/}
		;
public:
	#pragma option push -w-inl
	/* TCollection.Destroy */ inline __fastcall virtual ~TAHMCButtons(void) { }
	#pragma option pop
	
};

#pragma pack(pop)

#pragma pack(push, 4)
class PASCALIMPLEMENTATION TAHMFormManager : public Ahmsystemclass::TAHMSystemsComponent 
{
	typedef Ahmsystemclass::TAHMSystemsComponent inherited;
	
private:
	unsigned FMdiHandle;
	TAHMFormMessage FMessage;
	bool FTopMost;
	TAHMFormPropertySet FFormProperties;
	TAHMFormConstraints* FConstraints;
	TAHMFormGetConstraints FOnGetConstraints;
	TAHMFormOnSysMemLow FOnSysMemLow;
	TAHMOnFormDropFile FOnDropFiles;
	TAHMFormGetFile FOnEachDroppedFile;
	Classes::TNotifyEvent FOnMove;
	TAHMFormStore* FFormStore;
	Extctrls::TCustomPanel* FParent;
	Classes::TNotifyEvent FOnSysNextWindow;
	Classes::TNotifyEvent FOnSysMaximize;
	Classes::TNotifyEvent FOnSysPrevWindow;
	Classes::TNotifyEvent FOnSysDefault;
	Classes::TNotifyEvent FOnSysContextHelp;
	Classes::TNotifyEvent FOnSysMove;
	Classes::TNotifyEvent FOnSysTaskList;
	Classes::TNotifyEvent FOnSysClose;
	Classes::TNotifyEvent FOnSysSize;
	Classes::TNotifyEvent FOnSysScreenSave;
	Classes::TNotifyEvent FOnSysREstore;
	Classes::TNotifyEvent FOnSysHotkey;
	Classes::TNotifyEvent FOnSysOther;
	Classes::TNotifyEvent FOnSysMinimize;
	Classes::TNotifyEvent FOnSysMonitorPower;
	TAHMFormBackground* FAHMFormBackGround;
	bool isWMSize;
	TAHMCButtons* FAHMCButtons;
	Controls::TWinControl* FOwnerForm;
	Controls::TAlign FAlign;
	Ahmthookclass::TAHMHookClass* FOwnerHookClass;
	Ahmthookclass::TAHMHookClass* FMDIHookClass;
	void __fastcall Setalign(const Controls::TAlign Value);
	void __fastcall SetConstraints(System::TObject* Sender);
	void __fastcall SetAHMCButtons(TAHMCButtons* Value);
	void __fastcall SetTopMost(const bool Value);
	TAHMFormPropertySet __fastcall GetFormProperties(void);
	void __fastcall SetFormProperties(TAHMFormPropertySet Value);
	void __fastcall SetParent(const Extctrls::TCustomPanel* Value);
	void __fastcall OnBackChange(System::TObject* Sender);
	HWND __fastcall GetOwnerHandle(void);
	HWND __fastcall GetMDIHandle(void);
	void __fastcall MDIHooked(Messages::TMessage &AHMMsg, bool &Handled);
	void __fastcall OwnerHooked(Messages::TMessage &AHMMsg, bool &Handled);
	void __fastcall ReloadMDIHook(System::TObject* Sender);
	void __fastcall ReloadOwnerHook(System::TObject* Sender);
	void __fastcall ResetProperties(void);
	
protected:
	virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation
		);
	__property HWND OwnerHandle = {read=GetOwnerHandle, nodefault};
	
public:
	__fastcall virtual TAHMFormManager(Classes::TComponent* AOwner);
	virtual void __fastcall Loaded(void);
	__fastcall virtual ~TAHMFormManager(void);
	void __fastcall Update(void);
	void __fastcall LoadStore(void);
	void __fastcall SaveStore(void);
	
__published:
	__property About ;
	__property TAHMCButtons* Buttons = {read=FAHMCButtons, write=SetAHMCButtons};
	__property TAHMFormBackground* Background = {read=FAHMFormBackGround, write=FAHMFormBackGround};
	__property TAHMFormStore* FormStore = {read=FFormStore, write=FFormStore};
	__property bool TopMost = {read=FTopMost, write=SetTopMost, default=0};
	__property TAHMFormConstraints* Constraints = {read=FConstraints, write=FConstraints};
	__property Extctrls::TCustomPanel* Parent = {read=FParent, write=SetParent};
	__property Controls::TAlign ParentAlign = {read=FAlign, write=Setalign, default=0};
	__property TAHMOnFormDropFile OnDropFiles = {read=FOnDropFiles, write=FOnDropFiles};
	__property TAHMFormGetFile OnEachDroppedFile = {read=FOnEachDroppedFile, write=FOnEachDroppedFile};
		
	__property TAHMFormOnSysMemLow OnSysMemLow = {read=FOnSysMemLow, write=FOnSysMemLow};
	__property TAHMFormMessage OnMessage = {read=FMessage, write=FMessage};
	__property TAHMFormGetConstraints OnGetConstraints = {read=FOnGetConstraints, write=FOnGetConstraints
		};
	__property Classes::TNotifyEvent OnMove = {read=FOnMove, write=FOnMove};
	__property Classes::TNotifyEvent OnSysClose = {read=FOnSysClose, write=FOnSysClose};
	__property Classes::TNotifyEvent OnSysMove = {read=FOnSysMove, write=FOnSysMove};
	__property Classes::TNotifyEvent OnSysMaximize = {read=FOnSysMaximize, write=FOnSysMaximize};
	__property Classes::TNotifyEvent OnSysMinimize = {read=FOnSysMinimize, write=FOnSysMinimize};
	__property Classes::TNotifyEvent OnSysHotkey = {read=FOnSysHotkey, write=FOnSysHotkey};
	__property Classes::TNotifyEvent OnSysContextHelp = {read=FOnSysContextHelp, write=FOnSysContextHelp
		};
	__property Classes::TNotifyEvent OnSysDefault = {read=FOnSysDefault, write=FOnSysDefault};
	__property Classes::TNotifyEvent OnSysMonitorPower = {read=FOnSysMonitorPower, write=FOnSysMonitorPower
		};
	__property Classes::TNotifyEvent OnSysNextWindow = {read=FOnSysNextWindow, write=FOnSysNextWindow};
		
	__property Classes::TNotifyEvent OnSysPrevWindow = {read=FOnSysPrevWindow, write=FOnSysPrevWindow};
		
	__property Classes::TNotifyEvent OnSysRestore = {read=FOnSysREstore, write=FOnSysREstore};
	__property Classes::TNotifyEvent OnSysScreenSave = {read=FOnSysScreenSave, write=FOnSysScreenSave};
		
	__property Classes::TNotifyEvent OnSysSize = {read=FOnSysSize, write=FOnSysSize};
	__property Classes::TNotifyEvent OnSysTasklist = {read=FOnSysTaskList, write=FOnSysTaskList};
	__property Classes::TNotifyEvent OnSysOther = {read=FOnSysOther, write=FOnSysOther};
	__property TAHMFormPropertySet Properties = {read=FFormProperties, write=SetFormProperties, default=254
		};
};

#pragma pack(pop)

#pragma pack(push, 4)
class PASCALIMPLEMENTATION TAHMFormBackground : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	TAHMFormTexture* FTexture;
	TAHMFormBrushFill* FBrushFill;
	TAHMFormBackStyle FBackStyle;
	Classes::TNotifyEvent FOnchanged;
	TAHMFormGradient* FGradient;
	TAHMFormManager* FFormManager;
	void __fastcall SetTexture(TAHMFormTexture* value);
	void __fastcall SetGradient(TAHMFormGradient* value);
	void __fastcall SetBrushFill(TAHMFormBrushFill* value);
	void __fastcall SetBackStyle(TAHMFormBackStyle value);
	void __fastcall BackChange(System::TObject* Sender);
	
public:
	__fastcall virtual TAHMFormBackground(TAHMFormManager* AOwner);
	__fastcall virtual ~TAHMFormBackground(void);
	bool __fastcall Draw(HDC DC, int fWidth, int fHeight, bool Norm);
	void __fastcall DrawTrans(Graphics::TCanvas* Canvas, int Width, int Height, bool Norm, Graphics::TColor 
		TRC);
	
__published:
	__property TAHMFormTexture* Texture = {read=FTexture, write=SetTexture};
	__property TAHMFormGradient* Gradient = {read=FGradient, write=SetGradient};
	__property TAHMFormBrushFill* BrushFill = {read=FBrushFill, write=SetBrushFill};
	__property Classes::TNotifyEvent OnChanged = {read=FOnchanged, write=FOnchanged};
	__property TAHMFormBackStyle BackgroundStyle = {read=FBackStyle, write=SetBackStyle, default=0};
};

#pragma pack(pop)

#pragma pack(push, 4)
class PASCALIMPLEMENTATION TAHMCButton : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
private:
	TAHMFormManager* FAHMFormManager;
	bool FDestroy;
	Windows::TRect FButtonRect;
	bool FPressed;
	bool FDrawPressed;
	bool FVisible;
	bool FEnabled;
	int FWidth;
	AnsiString FCaption;
	Graphics::TFont* FFont;
	Classes::TNotifyEvent FOnClick;
	Graphics::TColor FColor;
	Menus::TPopupMenu* FPopupMenu;
	bool WMViS;
	void __fastcall SetCaption(const AnsiString Value);
	void __fastcall SetEnabled(const bool Value);
	void __fastcall SetVisible(const bool Value);
	void __fastcall SetWidth(const int Value);
	unsigned __fastcall GetBorder(void);
	unsigned __fastcall GetBorderEx(void);
	void __fastcall Paint(void);
	void __fastcall CalcArea(void);
	void __fastcall OnFontChange(System::TObject* Sender);
	void __fastcall SetColor(const Graphics::TColor Value);
	void __fastcall SetPopupMenu(const Menus::TPopupMenu* Value);
	
protected:
	bool OFVisible;
	virtual AnsiString __fastcall GetDisplayName(void);
	virtual void __fastcall Click(void);
	
public:
	__fastcall virtual TAHMCButton(Classes::TCollection* Collection);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	__property TAHMFormManager* Owner = {read=FAHMFormManager};
	__property AnsiString DisplayName = {read=GetDisplayName};
	__fastcall virtual ~TAHMCButton(void);
	
__published:
	__property Graphics::TColor Color = {read=FColor, write=SetColor, default=-2147483633};
	__property Menus::TPopupMenu* DropDownmenu = {read=FPopupMenu, write=SetPopupMenu};
	__property int Width = {read=FWidth, write=SetWidth, default=0};
	__property bool Enabled = {read=FEnabled, write=SetEnabled, default=1};
	__property bool Visible = {read=FVisible, write=SetVisible, default=1};
	__property AnsiString Caption = {read=FCaption, write=SetCaption, stored=true};
	__property Graphics::TFont* Font = {read=FFont, write=FFont};
	__property Classes::TNotifyEvent OnClick = {read=FOnClick, write=FOnClick};
};

#pragma pack(pop)

//-- var, const, procedure ---------------------------------------------------

}	/* namespace Ahmtformmanager */
#if !defined(NO_IMPLICIT_NAMESPACE_USE)
using namespace Ahmtformmanager;
#endif
#pragma option pop	// -w-

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