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

// (DO NOT EDIT: machine generated header) 'AHMTMsgBoxHolder.pas' rev: 5.00

#ifndef AHMTMsgBoxHolderHPP
#define AHMTMsgBoxHolderHPP

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

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

namespace Ahmtmsgboxholder
{
//-- type declarations -------------------------------------------------------
typedef void __fastcall (__closure *TAHMMessageExEvent)(System::TObject* Sender, AnsiString &Message
	);

class DELPHICLASS TAHMButtonClass;
class PASCALIMPLEMENTATION TAHMButtonClass : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	AnsiString FCaption;
	bool FVisible;
	bool FEnabled;
	void __fastcall SetCaption(const AnsiString Value);
	void __fastcall SetEnabled(const bool Value);
	void __fastcall SetVisible(const bool Value);
	
public:
	__fastcall TAHMButtonClass(void);
	
__published:
	__property AnsiString Caption = {read=FCaption, write=SetCaption};
	__property bool Visible = {read=FVisible, write=SetVisible, default=1};
	__property bool Enabled = {read=FEnabled, write=SetEnabled, default=1};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TAHMButtonClass(void) { }
	#pragma option pop
	
};


class DELPHICLASS TAHMBaseButtonClass;
class PASCALIMPLEMENTATION TAHMBaseButtonClass : public TAHMButtonClass 
{
	typedef TAHMButtonClass inherited;
	
private:
	int FNumGlyphs;
	Graphics::TBitmap* FGlyph;
	void __fastcall SetGlyph(const Graphics::TBitmap* Value);
	void __fastcall SetNumGlyphs(const int Value);
	
public:
	__fastcall TAHMBaseButtonClass(void);
	__fastcall virtual ~TAHMBaseButtonClass(void);
	
__published:
	__property Graphics::TBitmap* Glyph = {read=FGlyph, write=SetGlyph};
	__property int NumGlyphs = {read=FNumGlyphs, write=SetNumGlyphs, default=1};
};


class DELPHICLASS TAHMCheckButtonClass;
class PASCALIMPLEMENTATION TAHMCheckButtonClass : public TAHMButtonClass 
{
	typedef TAHMButtonClass inherited;
	
private:
	Stdctrls::TCheckBoxState FState;
	bool FChecked;
	bool FAllowGrayed;
	void __fastcall SetCheckboxstate(const Stdctrls::TCheckBoxState Value);
	void __fastcall SetAllowGrayed(const bool Value);
	void __fastcall SetChecked(const bool Value);
	
public:
	__fastcall TAHMCheckButtonClass(void);
	
__published:
	__property Stdctrls::TCheckBoxState State = {read=FState, write=SetCheckboxstate, default=0};
	__property bool Checked = {read=FChecked, write=SetChecked, default=1};
	__property bool AllowGrayed = {read=FAllowGrayed, write=SetAllowGrayed, default=0};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TAHMCheckButtonClass(void) { }
	#pragma option pop
	
};


class DELPHICLASS TAHMMsgButtonClass;
class DELPHICLASS TAHMMessageEx;
class DELPHICLASS TAHMMsgBoxHolder;
class DELPHICLASS TAHMMessagesEx;
class PASCALIMPLEMENTATION TAHMMessagesEx : public Classes::TCollection 
{
	typedef Classes::TCollection inherited;
	
private:
	TAHMMsgBoxHolder* FAHMMsgBoxHolder;
	TAHMMessageEx* __fastcall GetAHMMessageEx(int Index);
	void __fastcall SetAHMMessageEx(int Index, TAHMMessageEx* Value);
	
protected:
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	
public:
	__fastcall TAHMMessagesEx(TAHMMsgBoxHolder* AOwner);
	HIDESBASE TAHMMessageEx* __fastcall Add(void);
	HIDESBASE bool __fastcall Delete(int Index);
	__property TAHMMsgBoxHolder* Owner = {read=FAHMMsgBoxHolder};
	__property TAHMMessageEx* Items[int Index] = {read=GetAHMMessageEx, write=SetAHMMessageEx/*, default
		*/};
public:
	#pragma option push -w-inl
	/* TCollection.Destroy */ inline __fastcall virtual ~TAHMMessagesEx(void) { }
	#pragma option pop
	
};


class PASCALIMPLEMENTATION TAHMMsgBoxHolder : public Ahmsystemclass::TAHMSystemsComponent 
{
	typedef Ahmsystemclass::TAHMSystemsComponent inherited;
	
private:
	TAHMMessagesEx* FAHMMessagesEx;
	TAHMMessageExEvent FBeforePopup;
	void __fastcall SetAHMMessagesEx(TAHMMessagesEx* Value);
	
public:
	__fastcall virtual TAHMMsgBoxHolder(Classes::TComponent* AOwner);
	__fastcall virtual ~TAHMMsgBoxHolder(void);
	Forms::TModalResult __fastcall Execute(int Index);
	Forms::TModalResult __fastcall ForceExecute(int Index);
	
__published:
	__property TAHMMessageExEvent BeforePopup = {read=FBeforePopup, write=FBeforePopup};
	__property TAHMMessagesEx* Messages = {read=FAHMMessagesEx, write=SetAHMMessagesEx};
};


class DELPHICLASS TAHMHelpButtonClass;
class PASCALIMPLEMENTATION TAHMHelpButtonClass : public TAHMBaseButtonClass 
{
	typedef TAHMBaseButtonClass inherited;
	
private:
	int FHelpContext;
	
public:
	__fastcall TAHMHelpButtonClass(void);
	
__published:
	__property int HelpContext = {read=FHelpContext, write=FHelpContext, default=0};
public:
	#pragma option push -w-inl
	/* TAHMBaseButtonClass.Destroy */ inline __fastcall virtual ~TAHMHelpButtonClass(void) { }
	#pragma option pop
	
};


class PASCALIMPLEMENTATION TAHMMessageEx : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
private:
	TAHMMsgBoxHolder* FAHMMsgBoxHolder;
	AnsiString FMessage;
	AnsiString FCaption;
	Graphics::TFont* FFont;
	Ahmsystemclass::TAHMBeeptype FBeepType;
	TAHMMsgButtonClass* FMsgButton1;
	TAHMMsgButtonClass* FMsgButton2;
	TAHMMsgButtonClass* FMsgButton3;
	TAHMHelpButtonClass* FHelpButton;
	TAHMCheckButtonClass* FCheckBox;
	int FButtonWidth;
	int FFormWidth;
	Classes::TNotifyEvent FOnCheckClick;
	Classes::TNotifyEvent FOnBtn1Click;
	Classes::TNotifyEvent FOnBtn3Click;
	Classes::TNotifyEvent FOnBtn2Click;
	Classes::TNotifyEvent FOnHelpClick;
	Dialogs::TMsgDlgType FMsgType;
	Graphics::TIcon* FIcon;
	Classes::TNotifyEvent FOnmrAll;
	Classes::TNotifyEvent FOnmrCancel;
	Classes::TNotifyEvent FOnmrYes;
	Classes::TNotifyEvent FOnmrIgnore;
	Classes::TNotifyEvent FOnmrNone;
	Classes::TNotifyEvent FOnmrYesToAll;
	Classes::TNotifyEvent FOnmrOk;
	Classes::TNotifyEvent FOnmrNoToAll;
	Classes::TNotifyEvent FOnmrNo;
	Classes::TNotifyEvent FOnmrRetry;
	Classes::TNotifyEvent FOnmrAbort;
	TAHMMessageExEvent FBeforePopup;
	void __fastcall SetFont(const Graphics::TFont* Value);
	void __fastcall SetMessage(const AnsiString Value);
	void __fastcall SetButtonWidth(const int Value);
	void __fastcall SetFormWidth(const int Value);
	void __fastcall Button1Click(System::TObject* Sender);
	void __fastcall Button2Click(System::TObject* Sender);
	void __fastcall Button3Click(System::TObject* Sender);
	void __fastcall HelpButtonClick(System::TObject* Sender);
	void __fastcall CheckBoxClick(System::TObject* Sender);
	void __fastcall SetMessageType(const Dialogs::TMsgDlgType Value);
	void __fastcall SetIcon(const Graphics::TIcon* Value);
	void __fastcall ProcessMessages(Forms::TModalResult Value);
	
protected:
	virtual AnsiString __fastcall GetDisplayName();
	
public:
	__fastcall virtual TAHMMessageEx(Classes::TCollection* Collection);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	__property TAHMMsgBoxHolder* Owner = {read=FAHMMsgBoxHolder};
	__property AnsiString DisplayName = {read=GetDisplayName};
	__fastcall virtual ~TAHMMessageEx(void);
	Forms::TModalResult __fastcall Execute(void);
	Forms::TModalResult __fastcall ForceExecute(void);
	
__published:
	__property int Buttonwidth = {read=FButtonWidth, write=SetButtonWidth, default=80};
	__property Ahmsystemclass::TAHMBeeptype Sound = {read=FBeepType, write=FBeepType, default=0};
	__property TAHMMsgButtonClass* MsgButton1 = {read=FMsgButton1, write=FMsgButton1};
	__property TAHMMsgButtonClass* MsgButton2 = {read=FMsgButton2, write=FMsgButton2};
	__property TAHMMsgButtonClass* MsgButton3 = {read=FMsgButton3, write=FMsgButton3};
	__property Dialogs::TMsgDlgType MsgType = {read=FMsgType, write=SetMessageType, default=2};
	__property TAHMHelpButtonClass* HelpButton = {read=FHelpButton, write=FHelpButton};
	__property TAHMCheckButtonClass* CheckBox = {read=FCheckBox, write=FCheckBox};
	__property int FormWidth = {read=FFormWidth, write=SetFormWidth, default=320};
	__property AnsiString Message = {read=FMessage, write=SetMessage};
	__property Graphics::TIcon* CustomIcon = {read=FIcon, write=SetIcon};
	__property AnsiString Caption = {read=FCaption, write=FCaption};
	__property Graphics::TFont* Font = {read=FFont, write=SetFont};
	__property TAHMMessageExEvent BeforePopup = {read=FBeforePopup, write=FBeforePopup};
	__property Classes::TNotifyEvent OnCheckClick = {read=FOnCheckClick, write=FOnCheckClick};
	__property Classes::TNotifyEvent OnBtn1Click = {read=FOnBtn1Click, write=FOnBtn1Click};
	__property Classes::TNotifyEvent OnBtn2Click = {read=FOnBtn2Click, write=FOnBtn2Click};
	__property Classes::TNotifyEvent OnBtn3Click = {read=FOnBtn3Click, write=FOnBtn3Click};
	__property Classes::TNotifyEvent OnHelpClick = {read=FOnHelpClick, write=FOnHelpClick};
	__property Classes::TNotifyEvent OnmrNone = {read=FOnmrNone, write=FOnmrNone};
	__property Classes::TNotifyEvent OnmrAbort = {read=FOnmrAbort, write=FOnmrAbort};
	__property Classes::TNotifyEvent OnmrAll = {read=FOnmrAll, write=FOnmrAll};
	__property Classes::TNotifyEvent OnmrCancel = {read=FOnmrCancel, write=FOnmrCancel};
	__property Classes::TNotifyEvent OnmrIgnore = {read=FOnmrIgnore, write=FOnmrIgnore};
	__property Classes::TNotifyEvent OnmrNo = {read=FOnmrNo, write=FOnmrNo};
	__property Classes::TNotifyEvent OnmrOk = {read=FOnmrOk, write=FOnmrOk};
	__property Classes::TNotifyEvent OnmrRetry = {read=FOnmrRetry, write=FOnmrRetry};
	__property Classes::TNotifyEvent OnmrYes = {read=FOnmrYes, write=FOnmrYes};
	__property Classes::TNotifyEvent OnmrNoToAll = {read=FOnmrNoToAll, write=FOnmrNoToAll};
	__property Classes::TNotifyEvent OnmrYesToAll = {read=FOnmrYesToAll, write=FOnmrYesToAll};
};


class PASCALIMPLEMENTATION TAHMMsgButtonClass : public TAHMBaseButtonClass 
{
	typedef TAHMBaseButtonClass inherited;
	
private:
	Forms::TModalResult FModalResult;
	bool FDefault;
	TAHMMessageEx* FMessage;
	void __fastcall SetDefault(const bool Value);
	void __fastcall OnChangeDefault(System::TObject* Sender);
	
public:
	__fastcall virtual TAHMMsgButtonClass(TAHMMessageEx* AMessage);
	
__published:
	__property Forms::TModalResult ModalResult = {read=FModalResult, write=FModalResult, default=0};
	__property bool Default = {read=FDefault, write=SetDefault, default=0};
public:
	#pragma option push -w-inl
	/* TAHMBaseButtonClass.Destroy */ inline __fastcall virtual ~TAHMMsgButtonClass(void) { }
	#pragma option pop
	
};


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

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

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