barmenus.hpp

Virtual CD Sample driver

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

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

#ifndef BarMenusHPP
#define BarMenusHPP

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

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

namespace Barmenus
{
//-- type declarations -------------------------------------------------------
#pragma option push -b-
enum TVertAlignment { vaTop, vaBottom, vaMiddle };
#pragma option pop

#pragma option push -b-
enum THorzAlignment { haLeft, haRight, haCenter };
#pragma option pop

#pragma option push -b-
enum TDrawStyle { dsNormal, dsTile, dsStretch };
#pragma option pop

#pragma option push -b-
enum TGradientStyle { gsHorizontal, gsVertical, gsDiagonalLeftRight, gsDiagonalRightLeft };
#pragma option pop

#pragma option push -b-
enum TBarPart { bpGradient, bpPicture, bpBackPicture, bpCaption };
#pragma option pop

typedef Set<TBarPart, bpGradient, bpCaption>  TBarParts;

#pragma option push -b-
enum TSide { sLeft, sRight };
#pragma option pop

#pragma option push -b-
enum TDirection { dDownToUp, dUpToDown };
#pragma option pop

#pragma option push -b-
enum TSeparatorStyle { ssNormal, ssShortLine, ssCaption };
#pragma option pop

#pragma option push -b-
enum TBcMenuStyle { msAuto, msStandard, msWindowsXP };
#pragma option pop

typedef Byte TOpacity;

typedef Graphics::TBitmap TBcPicture;
;

typedef void __fastcall (__closure *TOnBeforeDrawBarEvent)(System::TObject* Sender, Graphics::TCanvas* 
	ACanvas, const Windows::TRect &ARect, bool &DefaultDraw);

typedef void __fastcall (__closure *TOnAfterDrawBarEvent)(System::TObject* Sender, Graphics::TCanvas* 
	ACanvas, const Windows::TRect &ARect);

typedef void __fastcall (__closure *TOnDrawMenuItemEvent)(System::TObject* Sender, Menus::TMenuItem* 
	AMenuItem, Graphics::TCanvas* ACanvas, const Windows::TRect &ARect, Windows::TOwnerDrawState State, 
	bool ABarVisible, bool &DefaultDraw);

typedef void __fastcall (__closure *TOnMeasureMenuItemEvent)(System::TObject* Sender, Menus::TMenuItem* 
	AMenuItem, Graphics::TCanvas* ACanvas, int &Width, int &Height, bool ABarVisible, bool &DefaultMeasure
	);

typedef void __fastcall (__closure *TOnAdvancedBeforeDrawBarEvent)(System::TObject* Sender, Graphics::TCanvas* 
	ACanvas, const Windows::TRect &ARect, TBarParts &DrawParts);

__interface IBarMenusIntf;
typedef System::DelphiInterface<IBarMenusIntf> _di_IBarMenusIntf;
class DELPHICLASS TBcBar;
class DELPHICLASS TBcSeparators;
class DELPHICLASS TBcBarProtected;
__interface IBarMenusIntf  : public IUnknown 
{
	
public:
	virtual void __fastcall UpdateItems(void) = 0 ;
	virtual void __fastcall FlushDoubleBuffer(void) = 0 ;
	virtual TBcMenuStyle __fastcall UseMenuStyle(void) = 0 ;
	virtual Menus::TMenu* __fastcall GetSelf(void) = 0 ;
	virtual TBcBar* __fastcall GetBar(void) = 0 ;
	virtual TBcSeparators* __fastcall GetSeparators(void) = 0 ;
	virtual TBcBarProtected* __fastcall GetBarProtected(void) = 0 ;
	virtual void __fastcall SetMenuWindowHandle(unsigned Handle) = 0 ;
	virtual TOpacity __fastcall GetOpacity(void) = 0 ;
	virtual void __fastcall SetOpacity(const TOpacity Value) = 0 ;
	virtual bool __fastcall GetFlat(void) = 0 ;
	virtual void __fastcall SetFlat(const bool Value) = 0 ;
	virtual Graphics::TFont* __fastcall GetMenuFont(void) = 0 ;
	virtual void __fastcall SetMenuFont(const Graphics::TFont* Value) = 0 ;
	virtual TBcMenuStyle __fastcall GetMenuStyle(void) = 0 ;
	virtual void __fastcall SetMenuStyle(const TBcMenuStyle Value) = 0 ;
	virtual bool __fastcall GetUseSystemFont(void) = 0 ;
	virtual void __fastcall SetUseSystemFont(const bool Value) = 0 ;
	virtual TOnBeforeDrawBarEvent __fastcall GetOnBeforeDrawBar(void) = 0 ;
	virtual void __fastcall SetOnBeforeDrawBar(const TOnBeforeDrawBarEvent Value) = 0 ;
	virtual TOnAdvancedBeforeDrawBarEvent __fastcall GetOnAdvancedBeforeDrawBar(void) = 0 ;
	virtual void __fastcall SetOnAdvancedBeforeDrawBar(const TOnAdvancedBeforeDrawBarEvent Value) = 0 ;
		
	virtual TOnAfterDrawBarEvent __fastcall GetOnAfterDrawBar(void) = 0 ;
	virtual void __fastcall SetOnAfterDrawBar(const TOnAfterDrawBarEvent Value) = 0 ;
	virtual TOnMeasureMenuItemEvent __fastcall GetOnMeasureMenuItem(void) = 0 ;
	virtual void __fastcall SetOnMeasureMenuItem(const TOnMeasureMenuItemEvent Value) = 0 ;
	virtual Bcdrawmodule::TBcBarMenusDrawModule* __fastcall GetDrawModule(void) = 0 ;
	virtual void __fastcall SetDrawModule(const Bcdrawmodule::TBcBarMenusDrawModule* Value) = 0 ;
	__property TBcBarProtected* BarProtected = {read=GetBarProtected};
	__property Menus::TMenu* Self = {read=GetSelf};
	__property TBcBar* Bar = {read=GetBar};
	__property TBcSeparators* Separators = {read=GetSeparators};
	__property TOpacity Opacity = {read=GetOpacity, write=SetOpacity};
	__property bool Flat = {read=GetFlat, write=SetFlat};
	__property Graphics::TFont* MenuFont = {read=GetMenuFont, write=SetMenuFont};
	__property bool UseSystemFont = {read=GetUseSystemFont, write=SetUseSystemFont};
	__property TBcMenuStyle MenuStyle = {read=GetMenuStyle, write=SetMenuStyle};
	__property Bcdrawmodule::TBcBarMenusDrawModule* DrawModule = {read=GetDrawModule, write=SetDrawModule
		};
	__property TOnBeforeDrawBarEvent OnBeforeDrawBar = {read=GetOnBeforeDrawBar, write=SetOnBeforeDrawBar
		};
	__property TOnAdvancedBeforeDrawBarEvent OnAdvancedBeforeDrawBar = {read=GetOnAdvancedBeforeDrawBar
		, write=SetOnAdvancedBeforeDrawBar};
	__property TOnAfterDrawBarEvent OnAfterDrawBar = {read=GetOnAfterDrawBar, write=SetOnAfterDrawBar};
		
	__property TOnMeasureMenuItemEvent OnMeasureMenuItem = {read=GetOnMeasureMenuItem, write=SetOnMeasureMenuItem
		};
};

class PASCALIMPLEMENTATION TBcBarProtected : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	Menus::TMenu* FOwner;
	int FPopupHeight;
	Graphics::TBitmap* FBarDoubleBuffer;
	bool FDrawn;
	bool FUpdatePopupHeight;
	Graphics::TBitmap* __fastcall GetBarDoubleBuffer(void);
	void __fastcall SetBarDoubleBuffer(const Graphics::TBitmap* Value);
	void __fastcall SetUpdatePopupHeight(const bool Value);
	void __fastcall SetPopupHeight(const int Value);
	
protected:
	void __fastcall FreeBarDoubleBuffer(void);
	__property Graphics::TBitmap* BarDoubleBuffer = {read=GetBarDoubleBuffer, write=SetBarDoubleBuffer}
		;
	__property bool UpdatePopupHeight = {read=FUpdatePopupHeight, write=SetUpdatePopupHeight, nodefault
		};
	__property int PopupHeight = {read=FPopupHeight, nodefault};
	__property bool Drawn = {read=FDrawn, write=FDrawn, nodefault};
	
public:
	__fastcall virtual TBcBarProtected(Menus::TMenu* AOwner);
	__fastcall virtual ~TBcBarProtected(void);
	__property Menus::TMenu* Owner = {read=FOwner};
};


class DELPHICLASS TBcGradientBar;
class PASCALIMPLEMENTATION TBcGradientBar : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	Menus::TMenu* FOwner;
	Graphics::TColor FBorder;
	TGradientStyle FGradientStyle;
	Graphics::TColor __fastcall GetGradientColor(const int Index);
	void __fastcall SetGradientColor(const int Index, const Graphics::TColor Value);
	void __fastcall SetGradientStyle(const TGradientStyle Value);
	
protected:
	Graphics::TColor FGradientStart;
	Graphics::TColor FGradientEnd;
	
public:
	__fastcall virtual TBcGradientBar(Menus::TMenu* AOwner);
	__fastcall virtual ~TBcGradientBar(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	__property Menus::TMenu* Owner = {read=FOwner};
	__property Graphics::TColor GradientStart = {read=GetGradientColor, write=SetGradientColor, index=0
		, default=14204335};
	__property Graphics::TColor GradientEnd = {read=GetGradientColor, write=SetGradientColor, index=1, 
		default=0};
	__property Graphics::TColor Border = {read=FBorder, write=FBorder, default=536870911};
	__property TGradientStyle GradientStyle = {read=FGradientStyle, write=SetGradientStyle, default=1};
		
};


class DELPHICLASS TBcBarBackPicture;
class DELPHICLASS TBcBarPicture;
class PASCALIMPLEMENTATION TBcBarPicture : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	Menus::TMenu* FOwner;
	bool FTransparent;
	Graphics::TBitmap* FPicture;
	int FOffsetX;
	int FOffsetY;
	TVertAlignment FVertAlignment;
	THorzAlignment FHorzAlignment;
	bool FVisible;
	
protected:
	Graphics::TBitmap* __fastcall GetPicture(void);
	void __fastcall SetPicture(Graphics::TBitmap* Value);
	void __fastcall SetTransparent(bool Value);
	bool __fastcall GetTransparent(void);
	
public:
	__fastcall virtual TBcBarPicture(Menus::TMenu* AOwner);
	__fastcall virtual ~TBcBarPicture(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	void __fastcall CalcPicturePosition(int &X, int &Y);
	__property Menus::TMenu* Owner = {read=FOwner};
	
__published:
	__property bool Transparent = {read=GetTransparent, write=SetTransparent, default=1};
	__property Graphics::TBitmap* Picture = {read=GetPicture, write=SetPicture};
	__property int OffsetX = {read=FOffsetX, write=FOffsetX, default=0};
	__property int OffsetY = {read=FOffsetY, write=FOffsetY, default=0};
	__property TVertAlignment VertAlignment = {read=FVertAlignment, write=FVertAlignment, default=1};
	__property THorzAlignment HorzAlignment = {read=FHorzAlignment, write=FHorzAlignment, default=2};
	__property bool Visible = {read=FVisible, write=FVisible, default=1};
};


class PASCALIMPLEMENTATION TBcBarBackPicture : public TBcBarPicture 
{
	typedef TBcBarPicture inherited;
	
private:
	TDrawStyle FDrawStyle;
	
public:
	__fastcall virtual TBcBarBackPicture(Menus::TMenu* AOwner);
	__fastcall virtual ~TBcBarBackPicture(void);
	
__published:
	__property TDrawStyle DrawStyle = {read=FDrawStyle, write=FDrawStyle, default=0};
	__property VertAlignment ;
	__property HorzAlignment ;
};


class DELPHICLASS TBcBarCaption;