flexactions.hpp

来自「FlexGraphics是一套创建矢量图形的VCL组件」· HPP 代码 · 共 467 行 · 第 1/2 页

// CodeGear C++Builder
// Copyright (c) 1995, 2008 by CodeGear
// All rights reserved

// (DO NOT EDIT: machine generated header) 'Flexactions.pas' rev: 20.00

#ifndef FlexactionsHPP
#define FlexactionsHPP

#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 <Flexbase.hpp>	// Pascal unit
#include <Flexprops.hpp>	// Pascal unit
#include <Flexhistory.hpp>	// Pascal unit
#include <Flexpath.hpp>	// Pascal unit
#include <Flexutils.hpp>	// Pascal unit

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

namespace Flexactions
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TDocRectHistoryAction;
class PASCALIMPLEMENTATION TDocRectHistoryAction : public Flexprops::TIdHistoryAction
{
	typedef Flexprops::TIdHistoryAction inherited;
	
protected:
	Types::TRect FUndoDocRect;
	Types::TRect FRedoDocRect;
	bool FUndoExist;
	bool FRedoExist;
	__classmethod virtual bool __fastcall DoIsRecordable(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 Types::TPoint &Diff);
	__property Types::TRect UndoDocRect = {read=FUndoDocRect, write=FUndoDocRect};
	__property Types::TRect RedoDocRect = {read=FRedoDocRect, write=FRedoDocRect};
	__property bool UndoExist = {read=FUndoExist, write=FUndoExist, nodefault};
	__property bool RedoExist = {read=FRedoExist, write=FRedoExist, nodefault};
public:
	/* THistoryStreamAction.Destroy */ inline __fastcall virtual ~TDocRectHistoryAction(void) { }
	
public:
	/* THistoryAction.Create */ inline __fastcall virtual TDocRectHistoryAction(Flexhistory::THistory* AOwner, Flexhistory::THistoryGroup* AParent) : Flexprops::TIdHistoryAction(AOwner, AParent) { }
	
};


struct TPointsHistoryActionInfo
{
	
public:
	bool Exist;
	Types::TRect DocRect;
	Flexpath::TPointArray Points;
	Flexpath::TPointTypeArray Types;
};


class DELPHICLASS TPointsHistoryAction;
class PASCALIMPLEMENTATION TPointsHistoryAction : public Flexprops::TIdHistoryAction
{
	typedef Flexprops::TIdHistoryAction inherited;
	
protected:
	TPointsHistoryActionInfo FUndo;
	TPointsHistoryActionInfo FRedo;
	__classmethod virtual bool __fastcall DoIsRecordable(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 Types::TPoint &Diff);
	void __fastcall SetUndoSavedDocRect(Flexbase::TFlexControl* Control);
	__property TPointsHistoryActionInfo UndoInfo = {read=FUndo, write=FUndo};
	__property TPointsHistoryActionInfo RedoInfo = {read=FRedo, write=FRedo};
public:
	/* THistoryStreamAction.Destroy */ inline __fastcall virtual ~TPointsHistoryAction(void) { }
	
public:
	/* THistoryAction.Create */ inline __fastcall virtual TPointsHistoryAction(Flexhistory::THistory* AOwner, Flexhistory::THistoryGroup* AParent) : Flexprops::TIdHistoryAction(AOwner, AParent) { }
	
};


struct TOrderHistoryActionInfo
{
	
public:
	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:
	/* THistoryStreamAction.Destroy */ inline __fastcall virtual ~TOrderHistoryAction(void) { }
	
public:
	/* THistoryAction.Create */ inline __fastcall virtual TOrderHistoryAction(Flexhistory::THistory* AOwner, Flexhistory::THistoryGroup* AParent) : Flexprops::TIdHistoryAction(AOwner, AParent) { }
	
};


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


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:
	/* TGroupUngroupHistoryAction.Destroy */ inline __fastcall virtual ~TControlGroupHistoryAction(void) { }
	
public:
	/* THistoryAction.Create */ inline __fastcall virtual TControlGroupHistoryAction(Flexhistory::THistory* AOwner, Flexhistory::THistoryGroup* AParent) : TGroupUngroupHistoryAction(AOwner, AParent) { }
	
};


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:
	/* TGroupUngroupHistoryAction.Destroy */ inline __fastcall virtual ~TControlUngroupHistoryAction(void) { }
	
public:
	/* THistoryAction.Create */ inline __fastcall virtual TControlUngroupHistoryAction(Flexhistory::THistory* AOwner, Flexhistory::THistoryGroup* AParent) : TGroupUngroupHistoryAction(AOwner, AParent) { }
	
};


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:
	__classmethod TCustomControlHistoryAction* __fastcall RecordAction(Flexbase::TFlexControl* Source);
public:
	/* THistoryStreamAction.Destroy */ inline __fastcall virtual ~TCustomControlHistoryAction(void) { }
	
public:
	/* THistoryAction.Create */ inline __fastcall virtual TCustomControlHistoryAction(Flexhistory::THistory* AOwner, Flexhistory::THistoryGroup* AParent) : Flexprops::TIdHistoryAction(AOwner, AParent) { }
	
};


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;
	__classmethod virtual bool __fastcall DoIsRecordable(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:
	/* THistoryGroup.Create */ inline __fastcall virtual TCreateDestroyHistoryGroup(Flexhistory::THistory* AOwner, Flexhistory::THistoryGroup* AParent) : Flexhistory::THistoryGroup(AOwner, AParent) { }