flexlibs.hpp

FlexGraphics是一套创建矢量图形的VCL组件

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

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

#ifndef FlexlibsHPP
#define FlexlibsHPP

#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 <Classes.hpp>	// Pascal unit
#include <Controls.hpp>	// Pascal unit
#include <Sysutils.hpp>	// Pascal unit
#include <Graphics.hpp>	// Pascal unit
#include <Flexbase.hpp>	// Pascal unit
#include <Flexprops.hpp>	// Pascal unit
#include <Flexutils.hpp>	// Pascal unit

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

namespace Flexlibs
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TLibItemAnchorProp;
class PASCALIMPLEMENTATION TLibItemAnchorProp : public Flexprops::TCustomProp 
{
	typedef Flexprops::TCustomProp inherited;
	
private:
	Types::TPoint __fastcall GetAsPoint();
	void __fastcall SetAsPoint(const Types::TPoint &Value);
	void __fastcall SetEnabled(const bool Value);
	void __fastcall SetPosX(const int Value);
	void __fastcall SetPosY(const int Value);
	
protected:
	bool FEnabled;
	int FPosX;
	int FPosY;
	virtual AnsiString __fastcall GetDisplayValue();
	
public:
	__fastcall TLibItemAnchorProp(Flexprops::TPropList* AOwner, const AnsiString AName);
	__property Types::TPoint AsPoint = {read=GetAsPoint, write=SetAsPoint};
	
__published:
	__property bool Enabled = {read=FEnabled, write=SetEnabled, default=0};
	__property int PosX = {read=FPosX, write=SetPosX, default=0};
	__property int PosY = {read=FPosY, write=SetPosY, default=0};
public:
	#pragma option push -w-inl
	/* TCustomProp.Destroy */ inline __fastcall virtual ~TLibItemAnchorProp(void) { }
	#pragma option pop
	
};


class DELPHICLASS TFlexLibItem;
class PASCALIMPLEMENTATION TFlexLibItem : public Flexbase::TFlexControl 
{
	typedef Flexbase::TFlexControl inherited;
	
protected:
	TLibItemAnchorProp* FAnchorProp;
	virtual void __fastcall CreateProperties(void);
	virtual void __fastcall ControlCreate(void);
	
public:
	Flexbase::TFlexDragObject* __fastcall CreateDragObject(void);
	bool __fastcall MakeCopy(Flexbase::TFlexPanel* AFlex, int ALeft, int ATop);
	__property TLibItemAnchorProp* AnchorProp = {read=FAnchorProp};
public:
	#pragma option push -w-inl
	/* TFlexControl.Create */ inline __fastcall virtual TFlexLibItem(Flexbase::TFlexPanel* AOwner, Flexbase::TFlexControl* AParent, Flexbase::TFlexLayer* ALayer) : Flexbase::TFlexControl(AOwner, AParent, ALayer) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TFlexControl.Destroy */ inline __fastcall virtual ~TFlexLibItem(void) { }
	#pragma option pop
	
};


typedef TMetaClass* TFlexLibraryClass;

class DELPHICLASS TFlexLibrary;
class PASCALIMPLEMENTATION TFlexLibrary : public Flexbase::TFlexCustomScheme 
{
	typedef Flexbase::TFlexCustomScheme inherited;
	
public:
	TFlexLibItem* operator[](int Index) { return Controls[Index]; }
	
private:
	AnsiString FFilename;
	bool FModified;
	HIDESBASE TFlexLibItem* __fastcall GetByName(const AnsiString Name);
	TFlexLibItem* __fastcall GetLibItem(int Index);
	
protected:
	virtual void __fastcall CreateProperties(void);
	virtual void __fastcall ControlCreate(void);
	
public:
	virtual TFlexLibItem* __fastcall New(void);
	TFlexLibItem* __fastcall NewFromFlex(Flexbase::TFlexPanel* AFlex);
	virtual int __fastcall Add(Flexbase::TFlexControl* AControl);
	virtual void __fastcall Delete(int Index);
	virtual void __fastcall SaveToFiler(Flexutils::TFlexFiler* Filer, const AnsiString Indent);
	virtual void __fastcall LoadFromFiler(Flexutils::TFlexFiler* Filer);
	__property TFlexLibItem* Controls[int Index] = {read=GetLibItem/*, default*/};
	__property TFlexLibItem* ByName[AnsiString Name] = {read=GetByName};
	__property AnsiString LibFilename = {read=FFilename, write=FFilename};
	__property bool Modified = {read=FModified, write=FModified, nodefault};
public:
	#pragma option push -w-inl
	/* TFlexControl.Create */ inline __fastcall virtual TFlexLibrary(Flexbase::TFlexPanel* AOwner, Flexbase::TFlexControl* AParent, Flexbase::TFlexLayer* ALayer) : Flexbase::TFlexCustomScheme(AOwner, AParent, ALayer) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TFlexControl.Destroy */ inline __fastcall virtual ~TFlexLibrary(void) { }
	#pragma option pop
	
};


class DELPHICLASS TFlexLibraryWithIDs;
class PASCALIMPLEMENTATION TFlexLibraryWithIDs : public TFlexLibrary 
{
	typedef TFlexLibrary inherited;
	
protected:
	virtual void __fastcall CreateProperties(void);
	
public:
	virtual int __fastcall Add(Flexbase::TFlexControl* AControl);
public:
	#pragma option push -w-inl
	/* TFlexControl.Create */ inline __fastcall virtual TFlexLibraryWithIDs(Flexbase::TFlexPanel* AOwner, Flexbase::TFlexControl* AParent, Flexbase::TFlexLayer* ALayer) : TFlexLibrary(AOwner, AParent, ALayer) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TFlexControl.Destroy */ inline __fastcall virtual ~TFlexLibraryWithIDs(void) { }
	#pragma option pop
	
};


class DELPHICLASS TFlexLibraries;
class PASCALIMPLEMENTATION TFlexLibraries : public System::TObject 
{
	typedef System::TObject inherited;
	
public:
	TFlexLibrary* operator[](int Index) { return Items[Index]; }
	
private:
	Flexbase::TFlexPanel* FFlex;
	Flexbase::TFlexPanel* FDragSource;
	Classes::TNotifyEvent FOnChange;
	int __fastcall GetCount(void);
	TFlexLibrary* __fastcall GetItem(int Index);
	
protected:
	virtual void __fastcall DoOnChange(void);
	__property Flexbase::TFlexPanel* DragSource = {read=FDragSource};
	
public:
	__fastcall TFlexLibraries(void);
	__fastcall virtual ~TFlexLibraries(void);
	virtual TFlexLibrary* __fastcall New(const AnsiString Filename, TMetaClass* LibClass = 0x0);
	int __fastcall IndexOf(TFlexLibrary* ALibrary);
	void __fastcall Remove(TFlexLibrary* ALibrary);
	bool __fastcall SaveLibrary(TFlexLibrary* ALibrary);
	bool __fastcall LoadLibrary(TFlexLibrary* ALibrary);
	__property Flexbase::TFlexPanel* Flex = {read=FFlex};
	__property int Count = {read=GetCount, nodefault};
	__property TFlexLibrary* Items[int Index] = {read=GetItem/*, default*/};
	__property Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
};


typedef TMetaClass* TFlexSingleLibraryClass;

class DELPHICLASS TFlexSingleLibrary;
class DELPHICLASS TFlexSingleLibraries;
class PASCALIMPLEMENTATION TFlexSingleLibraries : public System::TObject 
{
	typedef System::TObject inherited;
	
public:
	TFlexSingleLibrary* operator[](int Index) { return Items[Index]; }
	
private:
	int __fastcall GetCount(void);
	TFlexSingleLibrary* __fastcall GetLibrary(int Index);
	
protected:
	Classes::TList* FList;
	unsigned FMaxId;
	int __fastcall InternalAdd(TFlexSingleLibrary* Item);
	void __fastcall InternalDelete(int Index);
	
public:
	__fastcall TFlexSingleLibraries(void);
	__fastcall virtual ~TFlexSingleLibraries(void);
	void __fastcall Clear(void);
	virtual TFlexSingleLibrary* __fastcall New(TMetaClass* AClass = 0x0, TMetaClass* LibClass = 0x0);
	void __fastcall Delete(int Index);
	int __fastcall IndexOf(TFlexSingleLibrary* Item);
	int __fastcall FindByName(const AnsiString FlexPanelName);
	__property int Count = {read=GetCount, nodefault};
	__property TFlexSingleLibrary* Items[int Index] = {read=GetLibrary/*, default*/};
};


class PASCALIMPLEMENTATION TFlexSingleLibrary : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	TFlexSingleLibraries* FOwner;
	Classes::TNotifyEvent FOnChange;
	
protected:
	unsigned FId;
	Flexbase::TFlexPanel* FFlex;
	TFlexLibrary* FLibrary;
	Flexbase::TFlexPanel* FDragSource;
	virtual void __fastcall DoOnChange(void);
	__property Flexbase::TFlexPanel* Flex = {read=FFlex};
	__property Flexbase::TFlexPanel* DragSource = {read=FDragSource};
	
public:
	__fastcall virtual TFlexSingleLibrary(TFlexSingleLibraries* AOwner, TMetaClass* LibClass);
	__fastcall virtual ~TFlexSingleLibrary(void);
	bool __fastcall SaveLibrary(void);
	bool __fastcall LoadLibrary(void);
	__property TFlexSingleLibraries* Owner = {read=FOwner};
	__property unsigned Id = {read=FId, nodefault};
	__property Flexbase::TFlexPanel* FlexPanel = {read=FFlex};
	__property TFlexLibrary* FlexLibrary = {read=FLibrary};
	__property Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
};


//-- var, const, procedure ---------------------------------------------------
extern PACKAGE TFlexLibraries* FlexLibraries;

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

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