flexactions.hpp

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

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

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

#ifndef FlexActionsHPP
#define FlexActionsHPP

#pragma delphiheader begin
#pragma option push -w-
#pragma option push -Vx
#include <FlexUtils.hpp>	// Pascal unit
#include <FlexPath.hpp>	// Pascal unit
#include <FlexHistory.hpp>	// Pascal unit
#include <FlexProps.hpp>	// Pascal unit
#include <FlexBase.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 Flexactions
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TDocRectHistoryAction;
class PASCALIMPLEMENTATION TDocRectHistoryAction : public Flexprops::TIdHistoryAction 
{
	typedef Flexprops::TIdHistoryAction inherited;
	
protected:
	Windows::TRect FUndoDocRect;
	Windows::TRect FRedoDocRect;
	bool FUndoExist;
	bool FRedoExist;
	#pragma option push -w-inl
	/* virtual class method */ virtual bool __fastcall DoIsRecordable(System::TObject* Source, Flexhistory::THistoryGroup* 
		Parent) { return DoIsRecordable(__classid(TDocRectHistoryAction), Source, Parent); }
	#pragma option pop
	/*         class method */ static bool __fastcall DoIsRecordable(TMetaClass* vmt, System::TObject* 
		Source, Flexhistory::THistoryGroup* Parent);
	virtual void __fastcall DoRecordAction(System::TObject* Source);
	virtual void __fastcall DoUndo(System::TObject* Source);
	virtual void __fastcall DoRedo(System::TObject* Source);
	
public:
	void __fastcall OffsetUndo(const Windows::TPoint &Diff);
	__property Windows::TRect UndoDocRect = {read=FUndoDocRect, write=FUndoDocRect};
	__property Windows::TRect RedoDocRect = {read=FRedoDocRect, write=FRedoDocRect};
	__property bool UndoExist = {read=FUndoExist, write=FUndoExist, nodefault};
	__property bool RedoExist = {read=FRedoExist, write=FRedoExist, nodefault};
public:
	#pragma option push -w-inl
	/* THistoryStreamAction.Destroy */ inline __fastcall virtual ~TDocRectHistoryAction(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* THistoryAction.Create */ inline __fastcall virtual TDocRectHistoryAction(Flexhistory::THistory* 
		AOwner, Flexhistory::THistoryGroup* AParent) : Flexprops::TIdHistoryAction(AOwner, AParent) { }
	#pragma option pop
	
};


struct TPointsHistoryActionInfo
{
	bool Exist;
	Windows::TRect DocRect;
	DynamicArray<Windows::TPoint >  Points;
	DynamicArray<Flexpath::TPointType >  Types;
} ;

class DELPHICLASS TPointsHistoryAction;
class PASCALIMPLEMENTATION TPointsHistoryAction : public Flexprops::TIdHistoryAction 
{
	typedef Flexprops::TIdHistoryAction inherited;
	
protected:
	TPointsHistoryActionInfo FUndo;
	TPointsHistoryActionInfo FRedo;
	#pragma option push -w-inl
	/* virtual class method */ virtual bool __fastcall DoIsRecordable(System::TObject* Source, Flexhistory::THistoryGroup* 
		Parent) { return DoIsRecordable(__classid(TPointsHistoryAction), Source, Parent); }
	#pragma option pop
	/*         class method */ static bool __fastcall DoIsRecordable(TMetaClass* vmt, System::TObject* 
		Source, Flexhistory::THistoryGroup* Parent);
	void __fastcall Save(TPointsHistoryActionInfo &Info, Flexbase::TFlexControl* Control);
	void __fastcall Restore(TPointsHistoryActionInfo &Info, Flexbase::TFlexControl* Control);
	virtual void __fastcall DoRecordAction(System::TObject* Source);
	virtual void __fastcall DoUndo(System::TObject* Source);
	virtual void __fastcall DoRedo(System::TObject* Source);
	
public:
	void __fastcall OffsetUndo(const Windows::TPoint &Diff);
	void __fastcall SetUndoSavedDocRect(Flexbase::TFlexControl* Control);
	__property TPointsHistoryActionInfo UndoInfo = {read=FUndo, write=FUndo};
	__property TPointsHistoryActionInfo RedoInfo = {read=FRedo, write=FRedo};
public:
	#pragma option push -w-inl
	/* THistoryStreamAction.Destroy */ inline __fastcall virtual ~TPointsHistoryAction(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* THistoryAction.Create */ inline __fastcall virtual TPointsHistoryAction(Flexhistory::THistory* AOwner
		, Flexhistory::THistoryGroup* AParent) : Flexprops::TIdHistoryAction(AOwner, AParent) { }
	#pragma option pop
	
};


struct TOrderHistoryActionInfo
{
	bool Exist;
	int Index;
	unsigned ParentId;
	unsigned LayerId;
} ;

class DELPHICLASS TOrderHistoryAction;
class PASCALIMPLEMENTATION TOrderHistoryAction : public Flexprops::TIdHistoryAction 
{
	typedef Flexprops::TIdHistoryAction inherited;
	
protected:
	TOrderHistoryActionInfo FUndo;
	TOrderHistoryActionInfo FRedo;
	void __fastcall Save(TOrderHistoryActionInfo &Info, Flexbase::TFlexControl* Control);
	void __fastcall Restore(TOrderHistoryActionInfo &Info, Flexbase::TFlexControl* Control, int CurIndex
		);
	virtual void __fastcall DoRecordAction(System::TObject* Source);
	virtual void __fastcall DoUndo(System::TObject* Source);
	virtual void __fastcall DoRedo(System::TObject* Source);
	
public:
	__property TOrderHistoryActionInfo UndoInfo = {read=FUndo};
	__property TOrderHistoryActionInfo RedoInfo = {read=FRedo};
public:
	#pragma option push -w-inl
	/* THistoryStreamAction.Destroy */ inline __fastcall virtual ~TOrderHistoryAction(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* THistoryAction.Create */ inline __fastcall virtual TOrderHistoryAction(Flexhistory::THistory* AOwner
		, Flexhistory::THistoryGroup* AParent) : Flexprops::TIdHistoryAction(AOwner, AParent) { }
	#pragma option pop
	
};


class DELPHICLASS TGroupUngroupHistoryAction;
class PASCALIMPLEMENTATION TGroupUngroupHistoryAction : public Flexprops::TIdHistoryAction 
{
	typedef Flexprops::TIdHistoryAction inherited;
	
protected:
	Flexbase::TFlexPanel* FSourcePanel;
	TMetaClass*FGroupClass;
	Classes::TList* FSelected;
	void __fastcall SelectControls(void);
	void __fastcall Save(Flexbase::TFlexGroup* Source);
	
public:
	__fastcall virtual ~TGroupUngroupHistoryAction(void);
public:
	#pragma option push -w-inl
	/* THistoryAction.Create */ inline __fastcall virtual TGroupUngroupHistoryAction(Flexhistory::THistory* 
		AOwner, Flexhistory::THistoryGroup* AParent) : Flexprops::TIdHistoryAction(AOwner, AParent) { }
	#pragma option pop
	
};


class DELPHICLASS TControlGroupHistoryAction;
class PASCALIMPLEMENTATION TControlGroupHistoryAction : public TGroupUngroupHistoryAction 
{
	typedef TGroupUngroupHistoryAction inherited;
	
protected:
	virtual void __fastcall DoUndo(System::TObject* Source);
	virtual void __fastcall DoRedo(System::TObject* Source);
	virtual void __fastcall DoRecordAction(System::TObject* Source);
public:
	#pragma option push -w-inl
	/* TGroupUngroupHistoryAction.Destroy */ inline __fastcall virtual ~TControlGroupHistoryAction(void
		) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* THistoryAction.Create */ inline __fastcall virtual TControlGroupHistoryAction(Flexhistory::THistory* 
		AOwner, Flexhistory::THistoryGroup* AParent) : TGroupUngroupHistoryAction(AOwner, AParent) { }
	#pragma option pop
	
};


class DELPHICLASS TControlUngroupHistoryAction;
class PASCALIMPLEMENTATION TControlUngroupHistoryAction : public TGroupUngroupHistoryAction 
{
	typedef TGroupUngroupHistoryAction inherited;
	
protected:
	virtual void __fastcall DoUndo(System::TObject* Source);
	virtual void __fastcall DoRedo(System::TObject* Source);
	virtual void __fastcall DoRecordAction(System::TObject* Source);
public:
	#pragma option push -w-inl
	/* TGroupUngroupHistoryAction.Destroy */ inline __fastcall virtual ~TControlUngroupHistoryAction(void
		) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* THistoryAction.Create */ inline __fastcall virtual TControlUngroupHistoryAction(Flexhistory::THistory* 
		AOwner, Flexhistory::THistoryGroup* AParent) : TGroupUngroupHistoryAction(AOwner, AParent) { }
	#pragma option pop
	
};


class DELPHICLASS TCustomControlHistoryAction;
class PASCALIMPLEMENTATION TCustomControlHistoryAction : public Flexprops::TIdHistoryAction 
{
	typedef Flexprops::TIdHistoryAction inherited;
	
protected:
	virtual bool __fastcall ProcessSource(Classes::TStream* Stream, System::TObject* Source, bool DoLoad
		);
	
public:
	/*         class method */ static TCustomControlHistoryAction* __fastcall RecordAction(TMetaClass* vmt
		, Flexbase::TFlexControl* Source);
public:
	#pragma option push -w-inl
	/* THistoryStreamAction.Destroy */ inline __fastcall virtual ~TCustomControlHistoryAction(void) { }
		
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* THistoryAction.Create */ inline __fastcall virtual TCustomControlHistoryAction(Flexhistory::THistory* 
		AOwner, Flexhistory::THistoryGroup* AParent) : Flexprops::TIdHistoryAction(AOwner, AParent) { }
	#pragma option pop
	
};


class DELPHICLASS TCreateDestroyHistoryGroup;
class PASCALIMPLEMENTATION TCreateDestroyHistoryGroup : public Flexhistory::THistoryGroup 
{
	typedef Flexhistory::THistoryGroup inherited;
	
protected:
	Classes::TMemoryStream* FStream;
	Flexbase::TFlexPanel* FSourcePanel;
	unsigned FSourceId;
	unsigned FParentId;
	int FParentIndex;
	#pragma option push -w-inl
	/* virtual class method */ virtual bool __fastcall DoIsRecordable(System::TObject* Source, Flexhistory::THistoryGroup* 
		Parent) { return DoIsRecordable(__classid(TCreateDestroyHistoryGroup), Source, Parent); }
	#pragma option pop
	/*         class method */ static bool __fastcall DoIsRecordable(TMetaClass* vmt, System::TObject* 
		Source, Flexhistory::THistoryGroup* Parent);
	void __fastcall SaveSource(System::TObject* Source);
	bool __fastcall ProcessSource(Flexbase::TFlexControl* Source, bool DoLoad);
	
public:
	__property Flexbase::TFlexPanel* SourcePanel = {read=FSourcePanel, write=FSourcePanel};
	__property unsigned SourceId = {read=FSourceId, write=FSourceId, nodefault};
	__property unsigned ParentId = {read=FParentId, write=FParentId, nodefault};
	__property int ParentIndex = {read=FParentIndex, write=FParentIndex, nodefault};
	__property Classes::TMemoryStream* Stream = {read=FStream};
public:
	#pragma option push -w-inl
	/* THistoryGroup.Create */ inline __fastcall virtual TCreateDestroyHistoryGroup(Flexhistory::THistory* 
		AOwner, Flexhistory::THistoryGroup* AParent) : Flexhistory::THistoryGroup(AOwner, AParent) { }
	#pragma option pop
	#pragma option push -w-inl
	/* THistoryGroup.Destroy */ inline __fastcall virtual ~TCreateDestroyHistoryGroup(void) { }
	#pragma option pop
	
};


class DELPHICLASS TControlCreateHistoryGroup;
class PASCALIMPLEMENTATION TControlCreateHistoryGroup : public TCreateDestroyHistoryGroup 
{
	typedef TCreateDestroyHistoryGroup inherited;
	
protected:
	virtual void __fastcall DoUndo(System::TObject* Source);