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

// (DO NOT EDIT: machine generated header) 'ahmenhancedclass.pas' rev: 6.00

#ifndef ahmenhancedclassHPP
#define ahmenhancedclassHPP

#pragma delphiheader begin
#pragma option push -w-
#pragma option push -Vx
#include <Graphics.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <SysInit.hpp>	// Pascal unit
#include <System.hpp>	// Pascal unit

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

namespace Ahmenhancedclass
{
//-- type declarations -------------------------------------------------------
#pragma option push -b-
enum TAHMStyle3D { fontRaised, fontInset, fontOnlyShadow, fontOnlyHighlight, fontOutLineShadow };
#pragma option pop

#pragma option push -b-
enum TAHMRepeat { repeatOnShadow, repeatOnHighLight, repeatNone };
#pragma option pop

#pragma option push -b-
enum TAHMKind { kVertical, kHorizontal };
#pragma option pop

#pragma option push -b-
enum TAHMPosition { pLeft, pRight, pTop, pBottom };
#pragma option pop

typedef AnsiString TAHMAboutEnhancedStr;

typedef AnsiString TAHMEnhancedExecStr;

class DELPHICLASS TAHMEnhancedExecComponent;
class PASCALIMPLEMENTATION TAHMEnhancedExecComponent : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	AnsiString FAHMAboutStr;
	AnsiString FAHMExecDlgStr;
	
public:
	virtual bool __fastcall Execute(void);
	
__published:
	__property AnsiString About = {read=FAHMAboutStr, write=FAHMAboutStr, stored=false};
	__property AnsiString DesignExecute = {read=FAHMExecDlgStr, write=FAHMExecDlgStr, stored=false};
public:
	#pragma option push -w-inl
	/* TComponent.Create */ inline __fastcall virtual TAHMEnhancedExecComponent(Classes::TComponent* AOwner) : Classes::TComponent(AOwner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TComponent.Destroy */ inline __fastcall virtual ~TAHMEnhancedExecComponent(void) { }
	#pragma option pop
	
};


class DELPHICLASS TAHMFont3D;
class PASCALIMPLEMENTATION TAHMFont3D : public Graphics::TGraphicsObject 
{
	typedef Graphics::TGraphicsObject inherited;
	
private:
	bool f3db;
	TAHMStyle3D fstyle3D;
	Byte foffset;
	TAHMRepeat frep;
	System::TObject* fOwner;
	Graphics::TColor frepcolor;
	Byte frepwidth;
	bool fmask;
	Graphics::TColor fshadow;
	Graphics::TColor fhighlight;
	void __fastcall Set3d(const bool Value);
	void __fastcall SetMask(const bool Value);
	void __fastcall SetHighlight(const Graphics::TColor Value);
	void __fastcall SetShadow(const Graphics::TColor Value);
	void __fastcall SetOffset(const Byte Value);
	void __fastcall SetStyle3D(const TAHMStyle3D Value);
	void __fastcall Setrepwidth(const Byte Value);
	void __fastcall Setrep(const TAHMRepeat Value);
	void __fastcall SetrepColor(const Graphics::TColor Value);
	void __fastcall Invalidate(System::TObject* Sender);
	int __fastcall GetDrawingwidth(void);
	
public:
	__fastcall TAHMFont3D(System::TObject* AOwner);
	__fastcall virtual ~TAHMFont3D(void);
	void __fastcall write(const Graphics::TFont* xFont, const HDC Cdc, const Types::TRect &TXTRect, AnsiString Caption, int flags, bool Enabled);
	
__published:
	__property int DrawingWidth = {read=GetDrawingwidth, nodefault};
	__property bool ThreeDimensional = {read=f3db, write=Set3d, default=1};
	__property bool MaskFont = {read=fmask, write=SetMask, default=1};
	__property Graphics::TColor Highlight = {read=fhighlight, write=SetHighlight, default=-2147483628};
	__property Graphics::TColor Shadow = {read=fshadow, write=SetShadow, default=-2147483632};
	__property Graphics::TColor RepetitionColor = {read=frepcolor, write=SetrepColor, default=0};
	__property TAHMRepeat Repetition = {read=frep, write=Setrep, default=2};
	__property Byte Repetitionwidth = {read=frepwidth, write=Setrepwidth, default=0};
	__property Byte Offset = {read=foffset, write=SetOffset, default=1};
	__property TAHMStyle3D Style3D = {read=fstyle3D, write=SetStyle3D, default=3};
};


#pragma option push -b-
enum TAHMFrameStyle { frameSolid, frameRaised, frameLowered, frameNone, frameFramedUp, frameFramedDown, framePanelUp, framePanelDown, frameLightBordered };
#pragma option pop

#pragma option push -b-
enum TAHMFrameEdge { EdgeLeft, EdgeRight, EdgeTop, EdgeBottom };
#pragma option pop

typedef Set<TAHMFrameEdge, EdgeLeft, EdgeBottom>  TAHMFrameEdges;

class DELPHICLASS TAHMFrame;
class PASCALIMPLEMENTATION TAHMFrame : public Graphics::TGraphicsObject 
{
	typedef Graphics::TGraphicsObject inherited;
	
private:
	Classes::TNotifyEvent FOnUpdate;
	TAHMFrameStyle FFramestyle;
	Graphics::TColor fhighlight;
	Graphics::TColor fshadow;
	Graphics::TColor fsolid;
	System::TObject* fOwner;
	Byte fwidth;
	int cwidth;
	TAHMFrameEdges FEdges;
	Types::TRect __fastcall GetEdgePoints();
	void __fastcall SetEdges(const TAHMFrameEdges Value);
	void __fastcall Setwidth(const Byte Value);
	void __fastcall SetFrameStyle(const TAHMFrameStyle Value);
	void __fastcall SetHighlight(const Graphics::TColor Value);
	void __fastcall SetShadow(const Graphics::TColor Value);
	void __fastcall SetSolid(const Graphics::TColor Value);
	void __fastcall Invalidate(System::TObject* Sender);
	
protected:
	int __fastcall Calcwidth(void);
	
public:
	__fastcall TAHMFrame(System::TObject* AOwner);
	__fastcall virtual ~TAHMFrame(void);
	void __fastcall Drawbutton(Graphics::TCanvas* Canvas, Types::TRect &Rect, bool down);
	void __fastcall Draw(const HDC Cdc, Types::TRect &Rect);
	__property int Totalwidth = {read=Calcwidth, nodefault};
	__property Types::TRect EdgePoints = {read=GetEdgePoints};
	__property Classes::TNotifyEvent OnUpdate = {read=FOnUpdate, write=FOnUpdate};
	
__published:
	__property TAHMFrameStyle FrameStyle = {read=FFramestyle, write=SetFrameStyle, default=1};
	__property TAHMFrameEdges Edges = {read=FEdges, write=SetEdges, default=15};
	__property Graphics::TColor Highlight = {read=fhighlight, write=SetHighlight, default=-2147483628};
	__property Graphics::TColor Shadow = {read=fshadow, write=SetShadow, default=-2147483632};
	__property Graphics::TColor Solid = {read=fsolid, write=SetSolid, default=0};
	__property Byte FrameWidth = {read=fwidth, write=Setwidth, default=1};
};


typedef Shortint TAHMNumGlyphs;

class DELPHICLASS TAHMGlyph;
class PASCALIMPLEMENTATION TAHMGlyph : public Graphics::TGraphicsObject 
{
	typedef Graphics::TGraphicsObject inherited;
	
private:
	Graphics::TColor FTransparentColor;
	System::TObject* FOwner;
	Graphics::TBitmap* FBitmap;
	bool FVisible;
	TAHMNumGlyphs FNumGlyphs;
	bool FTransparent;
	int __fastcall GetWidth(void);
	int __fastcall GetHeight(void);
	void __fastcall SetBitmap(const Graphics::TBitmap* Value);
	void __fastcall SetNumGlyphs(const TAHMNumGlyphs Value);
	void __fastcall SetTransparent(const bool Value);
	void __fastcall SetVisible(const bool Value);
	void __fastcall SetTransparentColor(const Graphics::TColor Value);
	
protected:
	void __fastcall DrawGrayed(Graphics::TBitmap* &PGrayBitmap, Graphics::TColor PTransparentColor, int Times);
	
public:
	__property System::TObject* Owner = {read=FOwner};
	__property int Width = {read=GetWidth, nodefault};
	__property int Height = {read=GetHeight, nodefault};
	__fastcall TAHMGlyph(System::TObject* AOwner);
	__fastcall virtual ~TAHMGlyph(void);
	void __fastcall Draw(Graphics::TCanvas* PCanvas, int Px, int Py, bool PEnabled, bool PPressed, bool PGrayed);
	
__published:
	__property bool Visible = {read=FVisible, write=SetVisible, default=1};
	__property Graphics::TBitmap* Bitmap = {read=FBitmap, write=SetBitmap};
	__property TAHMNumGlyphs NumGlyphs = {read=FNumGlyphs, write=SetNumGlyphs, default=1};
	__property bool Transparent = {read=FTransparent, write=SetTransparent, default=1};
	__property Graphics::TColor TransparentColor = {read=FTransparentColor, write=SetTransparentColor, default=0};
};


class DELPHICLASS TAHMEnhancedThread;
class DELPHICLASS TAHMEnhancedTimer32;
class PASCALIMPLEMENTATION TAHMEnhancedTimer32 : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	bool FEnabled;
	Word FInterval;
	Classes::TNotifyEvent FOnTimer;
	TAHMEnhancedThread* FTimerThread;
	Classes::TThreadPriority FThreadPriority;
	void __fastcall SetEnabled(const bool Value);
	void __fastcall SetInterval(const Word Value);
	void __fastcall SetThreadPriority(const Classes::TThreadPriority Value);
	
protected:
	void __fastcall UpdateTimer(void);
	DYNAMIC void __fastcall Timer(void);
	
public:
	__fastcall virtual TAHMEnhancedTimer32(void);
	__fastcall virtual ~TAHMEnhancedTimer32(void);
	
__published:
	__property bool Enabled = {read=FEnabled, write=SetEnabled, default=1};
	__property Word Interval = {read=FInterval, write=SetInterval, default=1000};
	__property Classes::TNotifyEvent OnTimer = {read=FOnTimer, write=FOnTimer};
	__property Classes::TThreadPriority Priority = {read=FThreadPriority, write=SetThreadPriority, default=3};
};


class PASCALIMPLEMENTATION TAHMEnhancedThread : public Classes::TThread 
{
	typedef Classes::TThread inherited;
	
public:
	TAHMEnhancedTimer32* OwnerTimer;
	virtual void __fastcall Execute(void);
	void __fastcall DoTimer(void);
public:
	#pragma option push -w-inl
	/* TThread.Create */ inline __fastcall TAHMEnhancedThread(bool CreateSuspended) : Classes::TThread(CreateSuspended) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TThread.Destroy */ inline __fastcall virtual ~TAHMEnhancedThread(void) { }
	#pragma option pop
	
};


//-- var, const, procedure ---------------------------------------------------
extern PACKAGE void __fastcall AHMDrawButtonFrame(Graphics::TCanvas* Canvas, int width, int height, int BtnType, bool Pressed);
extern PACKAGE void __fastcall AHMDrawTransparentBitmap(int Method, Graphics::TCanvas* xCanvas, Graphics::TBitmap* bmp, int xStart, int yStart, int cTransparentColor);
extern PACKAGE void __fastcall AHMDrawDisabledText(Graphics::TFont* Font, Graphics::TCanvas* Canvas, const Types::TRect &TempRect, char * TempCaption, int Flags);
extern PACKAGE void __fastcall ShowEnhancedAbout(void);

}	/* namespace Ahmenhancedclass */
using namespace Ahmenhancedclass;
#pragma option pop	// -w-
#pragma option pop	// -Vx

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