rm_system.hpp

这是一个功能强大

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

// (DO NOT EDIT: machine generated header) 'Rm_system.pas' rev: 11.00

#ifndef Rm_systemHPP
#define Rm_systemHPP

#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 <Sysutils.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <Messages.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Graphics.hpp>	// Pascal unit
#include <Forms.hpp>	// Pascal unit
#include <Rm_jvinterpreter.hpp>	// Pascal unit
#include <Rm_jvinterpreterfm.hpp>	// Pascal unit
#include <Variants.hpp>	// Pascal unit

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

namespace Rm_system
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TRMNamedItem;
class PASCALIMPLEMENTATION TRMNamedItem : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
protected:
	AnsiString FName;
	virtual void __fastcall OnChange(System::TObject* Sender);
	virtual void __fastcall SetDisplayName(const AnsiString Value);
	virtual AnsiString __fastcall GetDisplayName();
	__property AnsiString Name = {read=FName, write=FName};
	
public:
	virtual void __fastcall Assign(Classes::TPersistent* Source);
public:
	#pragma option push -w-inl
	/* TCollectionItem.Create */ inline __fastcall virtual TRMNamedItem(Classes::TCollection* Collection) : Classes::TCollectionItem(Collection) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TCollectionItem.Destroy */ inline __fastcall virtual ~TRMNamedItem(void) { }
	#pragma option pop
	
};


typedef TMetaClass* TRMNamedItemClass;

typedef void __fastcall (__closure *TUpdateCollectionEvent)(System::TObject* Sender, Classes::TCollectionItem* Item);

class DELPHICLASS TRMCustomNamedItems;
class PASCALIMPLEMENTATION TRMCustomNamedItems : public Classes::TCollection 
{
	typedef Classes::TCollection inherited;
	
private:
	Classes::TPersistent* FOwner;
	Classes::TNotifyEvent FOnChange;
	TUpdateCollectionEvent FOnUpdate;
	HIDESBASE TRMNamedItem* __fastcall GetItem(int Index);
	AnsiString __fastcall GetName(int Index);
	void __fastcall SetName(int Index, AnsiString Value);
	
protected:
	void __fastcall FreeNotificationProc(System::TObject* Instance);
	virtual void __fastcall Update(Classes::TCollectionItem* Item);
	
public:
	__fastcall virtual TRMCustomNamedItems(Classes::TPersistent* AOwner, TMetaClass* ItemClass);
	__fastcall virtual ~TRMCustomNamedItems(void);
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	int __fastcall IndexOfName(const AnsiString Name);
	int __fastcall IndexOf(TRMNamedItem* Item)/* overload */;
	int __fastcall IndexOf(const AnsiString Name)/* overload */;
	__property TRMNamedItem* Items[int index] = {read=GetItem};
	__property AnsiString Name[int Index] = {read=GetName, write=SetName};
	__property Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
	__property TUpdateCollectionEvent OnUpdate = {read=FOnUpdate, write=FOnUpdate};
};


class DELPHICLASS TRMNamedItems;
class PASCALIMPLEMENTATION TRMNamedItems : public TRMCustomNamedItems 
{
	typedef TRMCustomNamedItems inherited;
	
public:
	virtual void __fastcall LoadFromFile(const AnsiString FileName);
	virtual void __fastcall LoadFromStream(Classes::TStream* Stream);
	virtual void __fastcall SaveToStream(Classes::TStream* Stream);
	virtual void __fastcall SaveToFile(const AnsiString FileName);
public:
	#pragma option push -w-inl
	/* TRMCustomNamedItems.Create */ inline __fastcall virtual TRMNamedItems(Classes::TPersistent* AOwner, TMetaClass* ItemClass) : TRMCustomNamedItems(AOwner, ItemClass) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TRMCustomNamedItems.Destroy */ inline __fastcall virtual ~TRMNamedItems(void) { }
	#pragma option pop
	
};


class DELPHICLASS TRMVariableItem;
class PASCALIMPLEMENTATION TRMVariableItem : public TRMNamedItem 
{
	typedef TRMNamedItem inherited;
	
private:
	Variant FValue;
	bool FIsExpression;
	
public:
	__fastcall virtual TRMVariableItem(Classes::TCollection* Collection);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property Name ;
	__property Variant Value = {read=FValue, write=FValue};
	__property bool IsExpression = {read=FIsExpression, write=FIsExpression, nodefault};
public:
	#pragma option push -w-inl
	/* TCollectionItem.Destroy */ inline __fastcall virtual ~TRMVariableItem(void) { }
	#pragma option pop
	
};


class DELPHICLASS TRMVariables;
class PASCALIMPLEMENTATION TRMVariables : public TRMNamedItems 
{
	typedef TRMNamedItems inherited;
	
public:
	Variant operator[](AnsiString Name) { return Variable[Name]; }
	
private:
	HIDESBASE TRMVariableItem* __fastcall GetItem(int Index);
	Variant __fastcall GetVariable(const AnsiString Name);
	Variant __fastcall GetValue(int Index);
	void __fastcall SetVariable(const AnsiString Name, const Variant &Value);
	void __fastcall SetStringVariable(const AnsiString aName, const Variant &aValue);
	void __fastcall SetValue(int Index, const Variant &Value);
	
public:
	__fastcall virtual TRMVariables(Classes::TPersistent* AOwner)/* overload */;
	HIDESBASE int __fastcall Add(const AnsiString aName, const Variant &aValue)/* overload */;
	void __fastcall AddCategory(const AnsiString Name);
	HIDESBASE void __fastcall Delete(int Index);
	void __fastcall DeleteByName(const AnsiString AName);
	HIDESBASE void __fastcall Insert(int Index, const AnsiString aName, const Variant &aValue)/* overload */;
	__property Variant Variable[AnsiString Name] = {read=GetVariable, write=SetVariable/*, default*/};
	__property Variant Value[int Index] = {read=GetValue, write=SetValue};
	__property Variant AsString[AnsiString Name] = {read=GetVariable, write=SetStringVariable};
	__property TRMVariableItem* Items[int index] = {read=GetItem};
public:
	#pragma option push -w-inl
	/* TRMCustomNamedItems.Destroy */ inline __fastcall virtual ~TRMVariables(void) { }
	#pragma option pop
	
};


class DELPHICLASS TRMPersistentCompAdapter;
class PASCALIMPLEMENTATION TRMPersistentCompAdapter : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
protected:
	System::TObject* FComp;
	
public:
	__fastcall virtual TRMPersistentCompAdapter(System::TObject* aComp);
	__fastcall virtual ~TRMPersistentCompAdapter(void);
public:
	#pragma option push -w-inl
	/* TComponent.Create */ inline __fastcall virtual TRMPersistentCompAdapter(Classes::TComponent* AOwner) : Classes::TComponent(AOwner) { }
	#pragma option pop
	
};


class DELPHICLASS TRMPersistent;
class PASCALIMPLEMENTATION TRMPersistent : public Classes::TInterfacedPersistent 
{
	typedef Classes::TInterfacedPersistent inherited;
	
private:
	TRMVariables* __fastcall GetEventPropVars(void);
	
protected:
	TRMVariables* FEventPropVars;
	AnsiString FName;
	System::_di_IInterface FComAdapter;
	void __fastcall LoadEventInfo(Classes::TStream* aStream);
	void __fastcall SaveEventInfo(Classes::TStream* aStream);
	void __fastcall SetObjectEvent(Classes::TList* aEventList, Rm_jvinterpreter::TJvInterpreterProgram* aEngine);
	virtual void __fastcall SetName(const AnsiString Value);
	virtual bool __fastcall GetPropValue(System::TObject* aObject, AnsiString aPropName, Variant &aValue, Variant * Args, const int Args_Size);
	virtual bool __fastcall SetPropValue(System::TObject* aObject, AnsiString aPropName, const Variant &aValue);
	System::_di_IInterface __fastcall GetComAdapter();
	void __fastcall SetComAdapter(const System::_di_IInterface Value);
	
public:
	__fastcall virtual TRMPersistent(void);
	__fastcall virtual ~TRMPersistent(void);
	__property TRMVariables* EventPropVars = {read=GetEventPropVars};
	__property AnsiString Name = {read=FName, write=SetName};
	__property System::_di_IInterface ComAdapter = {read=GetComAdapter, write=SetComAdapter};
};


class DELPHICLASS TRMComponent;
class PASCALIMPLEMENTATION TRMComponent : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	System::_di_IInterface __fastcall GetComAdapter();
	void __fastcall SetComAdapter(const System::_di_IInterface Value);
	TRMVariables* __fastcall GetEventPropVars(void);
	
protected:
	TRMVariables* FEventPropVars;
	System::_di_IInterface FComAdapter;
	virtual bool __fastcall GetPropValue(System::TObject* aObject, AnsiString aPropName, Variant &aValue, Variant * Args, const int Args_Size);
	virtual bool __fastcall SetPropValue(System::TObject* aObject, AnsiString aPropName, const Variant &aValue);
	
public:
	__fastcall virtual ~TRMComponent(void);
	__property TRMVariables* EventPropVars = {read=GetEventPropVars};
	__property System::_di_IInterface ComAdapter = {read=GetComAdapter, write=SetComAdapter};
public:
	#pragma option push -w-inl
	/* TComponent.Create */ inline __fastcall virtual TRMComponent(Classes::TComponent* AOwner) : Classes::TComponent(AOwner) { }
	#pragma option pop
	
};


class DELPHICLASS TRMEventItem;
class PASCALIMPLEMENTATION TRMEventItem : public TRMNamedItem 
{
	typedef TRMNamedItem inherited;
	
private:
	AnsiString FObjectName;
	AnsiString FEventValueName;
	AnsiString FEventPropName;
	Classes::TPersistent* FInstance;
	
__published:
	__property Classes::TPersistent* Instance = {read=FInstance, write=FInstance};
	__property AnsiString ObjectName = {read=FObjectName, write=FObjectName};
	__property AnsiString EventPropName = {read=FEventPropName, write=FEventPropName};
	__property AnsiString EventValueName = {read=FEventValueName, write=FEventValueName};
public:
	#pragma option push -w-inl
	/* TCollectionItem.Create */ inline __fastcall virtual TRMEventItem(Classes::TCollection* Collection) : TRMNamedItem(Collection) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TCollectionItem.Destroy */ inline __fastcall virtual ~TRMEventItem(void) { }
	#pragma option pop
	
};


class DELPHICLASS TRMCustomEventItems;
class PASCALIMPLEMENTATION TRMCustomEventItems : public TRMNamedItems 
{
	typedef TRMNamedItems inherited;
	
private:
	HIDESBASE TRMEventItem* __fastcall GetItem(int index);
	
public:
	__fastcall virtual TRMCustomEventItems(Classes::TComponent* AOwner)/* overload */;
	__property TRMEventItem* Items[int index] = {read=GetItem};
public:
	#pragma option push -w-inl
	/* TRMCustomNamedItems.Destroy */ inline __fastcall virtual ~TRMCustomEventItems(void) { }
	#pragma option pop
	
};


class DELPHICLASS TRMEventPropVars;
class PASCALIMPLEMENTATION TRMEventPropVars : public TRMCustomEventItems 
{
	typedef TRMCustomEventItems inherited;
	
private:
	Classes::TComponent* FParentReport;
	
protected:
	void __fastcall CheckParentReport(void);
	
public:
	__fastcall virtual TRMEventPropVars(Classes::TComponent* aReport)/* overload */;
	int __fastcall IndexOfEvent(AnsiString aObjectName, AnsiString aEventPropName)/* overload */;
	int __fastcall IndexOfEvent(Classes::TPersistent* AInstance, AnsiString aEventPropName)/* overload */;
	AnsiString __fastcall GetEventPropVar(Classes::TPersistent* AInstance, AnsiString APropName);
	int __fastcall SetEventPropVar(Classes::TPersistent* AInstance, AnsiString APropName, AnsiString AProcName);
	bool __fastcall DeleteEventProp(Classes::TPersistent* AInstance, AnsiString APropName);
	void __fastcall RenameEventProc(AnsiString aOldProcName, AnsiString aNewProcName);
	bool __fastcall DeleteAllEventByObjName(AnsiString aComponentName)/* overload */;
public:
	#pragma option push -w-inl
	/* TRMCustomNamedItems.Destroy */ inline __fastcall virtual ~TRMEventPropVars(void) { }
	#pragma option pop
	
};


//-- var, const, procedure ---------------------------------------------------

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

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