imp_classes.pas

Delphi脚本控件

  RegisterProperty(TReader,
       'property Parent:TComponent read TReader_GetParent write TReader_PutParent;');
  RegisterMethod(TReader,
       'function TReader_GetPosition:Longint;',
       @TReader_GetPosition, Fake);
  RegisterMethod(TReader,
       'procedure TReader_PutPosition(const Value: Longint);',
       @TReader_PutPosition, Fake);
  RegisterProperty(TReader,
       'property Position:Longint read TReader_GetPosition write TReader_PutPosition;');
  RegisterMethod(TReader,
       'constructor Create(Stream: TStream; BufSize: Integer);',
       @TReader.Create);
  // End of class TReader
  // Begin of class TWriter
  RegisterClassType(TWriter, H);
  RegisterMethod(TWriter,
       'destructor Destroy; override;',
       @TWriter.Destroy);
  RegisterMethod(TWriter,
       'procedure DefineProperty(const Name: string;      ReadData: TReaderProc; WriteData: TWriterProc;      HasData: Boolean); override;',
       @TWriter.DefineProperty);
  RegisterMethod(TWriter,
       'procedure DefineBinaryProperty(const Name: string;      ReadData, WriteData: TStreamProc;      HasData: Boolean); override;',
       @TWriter.DefineBinaryProperty);
  RegisterMethod(TWriter,
       'procedure FlushBuffer; override;',
       @TWriter.FlushBuffer);
  RegisterMethod(TWriter,
       'procedure Write(const Buf; Count: Longint);',
       @TWriter.Write);
  RegisterMethod(TWriter,
       'procedure WriteBoolean(Value: Boolean);',
       @TWriter.WriteBoolean);
  RegisterMethod(TWriter,
       'procedure WriteCollection(Value: TCollection);',
       @TWriter.WriteCollection);
  RegisterMethod(TWriter,
       'procedure WriteComponent(Component: TComponent);',
       @TWriter.WriteComponent);
  RegisterMethod(TWriter,
       'procedure WriteChar(Value: Char);',
       @TWriter.WriteChar);
  RegisterMethod(TWriter,
       'procedure WriteDescendent(Root: TComponent; AAncestor: TComponent);',
       @TWriter.WriteDescendent);
  RegisterMethod(TWriter,
       'procedure WriteFloat(const Value: Extended);',
       @TWriter.WriteFloat);
  RegisterMethod(TWriter,
       'procedure WriteSingle(const Value: Single);',
       @TWriter.WriteSingle);
  RegisterMethod(TWriter,
       'procedure WriteCurrency(const Value: Currency);',
       @TWriter.WriteCurrency);
  RegisterMethod(TWriter,
       'procedure WriteDate(const Value: TDateTime);',
       @TWriter.WriteDate);
  RegisterMethod(TWriter,
       'procedure WriteIdent(const Ident: string);',
       @TWriter.WriteIdent);
  RegisterMethod(TWriter,
       'procedure WriteInteger(Value: Longint); overload;',
       @TWriter.WriteInteger);
  RegisterMethod(TWriter,
       'procedure WriteInteger(Value: Int64); overload;',
       @TWriter.WriteInteger);
  RegisterMethod(TWriter,
       'procedure WriteListBegin;',
       @TWriter.WriteListBegin);
  RegisterMethod(TWriter,
       'procedure WriteListEnd;',
       @TWriter.WriteListEnd);
  RegisterMethod(TWriter,
       'procedure WriteRootComponent(Root: TComponent);',
       @TWriter.WriteRootComponent);
  RegisterMethod(TWriter,
       'procedure WriteSignature;',
       @TWriter.WriteSignature);
  RegisterMethod(TWriter,
       'procedure WriteStr(const Value: string);',
       @TWriter.WriteStr);
  RegisterMethod(TWriter,
       'procedure WriteString(const Value: string);',
       @TWriter.WriteString);
  RegisterMethod(TWriter,
       'procedure WriteWideString(const Value: WideString);',
       @TWriter.WriteWideString);
  RegisterMethod(TWriter,
       'function TWriter_GetPosition:Longint;',
       @TWriter_GetPosition, Fake);
  RegisterMethod(TWriter,
       'procedure TWriter_PutPosition(const Value: Longint);',
       @TWriter_PutPosition, Fake);
  RegisterProperty(TWriter,
       'property Position:Longint read TWriter_GetPosition write TWriter_PutPosition;');
  RegisterMethod(TWriter,
       'function TWriter_GetRootAncestor:TComponent;',
       @TWriter_GetRootAncestor, Fake);
  RegisterMethod(TWriter,
       'procedure TWriter_PutRootAncestor(const Value: TComponent);',
       @TWriter_PutRootAncestor, Fake);
  RegisterProperty(TWriter,
       'property RootAncestor:TComponent read TWriter_GetRootAncestor write TWriter_PutRootAncestor;');
  RegisterMethod(TWriter,
       'constructor Create(Stream: TStream; BufSize: Integer);',
       @TWriter.Create);
  // End of class TWriter
  // Begin of class TParser
  RegisterClassType(TParser, H);
  RegisterMethod(TParser,
       'constructor Create(Stream: TStream);',
       @TParser.Create);
  RegisterMethod(TParser,
       'destructor Destroy; override;',
       @TParser.Destroy);
  RegisterMethod(TParser,
       'procedure CheckToken(T: Char);',
       @TParser.CheckToken);
  RegisterMethod(TParser,
       'procedure CheckTokenSymbol(const S: string);',
       @TParser.CheckTokenSymbol);
  RegisterMethod(TParser,
       'procedure Error(const Ident: string);',
       @TParser.Error);
  RegisterMethod(TParser,
       'procedure ErrorFmt(const Ident: string; const Args: array of const);',
       @TParser.ErrorFmt);
  RegisterMethod(TParser,
       'procedure ErrorStr(const Message: string);',
       @TParser.ErrorStr);
  RegisterMethod(TParser,
       'procedure HexToBinary(Stream: TStream);',
       @TParser.HexToBinary);
  RegisterMethod(TParser,
       'function NextToken: Char;',
       @TParser.NextToken);
  RegisterMethod(TParser,
       'function SourcePos: Longint;',
       @TParser.SourcePos);
  RegisterMethod(TParser,
       'function TokenComponentIdent: string;',
       @TParser.TokenComponentIdent);
  RegisterMethod(TParser,
       'function TokenFloat: Extended;',
       @TParser.TokenFloat);
  RegisterMethod(TParser,
       'function TokenInt: Int64;',
       @TParser.TokenInt);
  RegisterMethod(TParser,
       'function TokenString: string;',
       @TParser.TokenString);
  RegisterMethod(TParser,
       'function TokenWideString: WideString;',
       @TParser.TokenWideString);
  RegisterMethod(TParser,
       'function TokenSymbolIs(const S: string): Boolean;',
       @TParser.TokenSymbolIs);
  RegisterMethod(TParser,
       'function TParser_GetFloatType:Char;',
       @TParser_GetFloatType, Fake);
  RegisterProperty(TParser,
       'property FloatType:Char read TParser_GetFloatType;');
  RegisterMethod(TParser,
       'function TParser_GetSourceLine:Integer;',
       @TParser_GetSourceLine, Fake);
  RegisterProperty(TParser,
       'property SourceLine:Integer read TParser_GetSourceLine;');
  RegisterMethod(TParser,
       'function TParser_GetToken:Char;',
       @TParser_GetToken, Fake);
  RegisterProperty(TParser,
       'property Token:Char read TParser_GetToken;');
  // End of class TParser
  RegisterRTTIType(TypeInfo(TThreadPriority));
  // Begin of class TThread
  RegisterClassType(TThread, H);
  RegisterMethod(TThread,
       'constructor Create(CreateSuspended: Boolean);',
       @TThread.Create);
  RegisterMethod(TThread,
       'destructor Destroy; override;',
       @TThread.Destroy);
  RegisterMethod(TThread,
       'procedure Resume;',
       @TThread.Resume);
  RegisterMethod(TThread,
       'procedure Suspend;',
       @TThread.Suspend);
  RegisterMethod(TThread,
       'procedure Terminate;',
       @TThread.Terminate);
  RegisterMethod(TThread,
       'function WaitFor: LongWord;',
       @TThread.WaitFor);
  RegisterMethod(TThread,
       'function TThread_GetFreeOnTerminate:Boolean;',
       @TThread_GetFreeOnTerminate, Fake);
  RegisterMethod(TThread,
       'procedure TThread_PutFreeOnTerminate(const Value: Boolean);',
       @TThread_PutFreeOnTerminate, Fake);
  RegisterProperty(TThread,
       'property FreeOnTerminate:Boolean read TThread_GetFreeOnTerminate write TThread_PutFreeOnTerminate;');
  RegisterMethod(TThread,
       'function TThread_GetHandle:THandle;',
       @TThread_GetHandle, Fake);
  RegisterProperty(TThread,
       'property Handle:THandle read TThread_GetHandle;');
  RegisterMethod(TThread,
       'function TThread_GetPriority:TThreadPriority;',
       @TThread_GetPriority, Fake);
  RegisterMethod(TThread,
       'procedure TThread_PutPriority(const Value: TThreadPriority);',
       @TThread_PutPriority, Fake);
  RegisterProperty(TThread,
       'property Priority:TThreadPriority read TThread_GetPriority write TThread_PutPriority;');
  RegisterMethod(TThread,
       'function TThread_GetSuspended:Boolean;',
       @TThread_GetSuspended, Fake);
  RegisterMethod(TThread,
       'procedure TThread_PutSuspended(const Value: Boolean);',
       @TThread_PutSuspended, Fake);
  RegisterProperty(TThread,
       'property Suspended:Boolean read TThread_GetSuspended write TThread_PutSuspended;');
  RegisterMethod(TThread,
       'function TThread_GetThreadID:THandle;',
       @TThread_GetThreadID, Fake);
  RegisterProperty(TThread,
       'property ThreadID:THandle read TThread_GetThreadID;');
  // End of class TThread
  RegisterRTTIType(TypeInfo(TOperation));
  // Begin of class TComponent
  RegisterClassType(TComponent, H);
  RegisterMethod(TComponent,
       'constructor Create(AOwner: TComponent); virtual;',
       @TComponent.Create);
  RegisterMethod(TComponent,
       'destructor Destroy; override;',
       @TComponent.Destroy);
  RegisterMethod(TComponent,
       'procedure BeforeDestruction; override;',
       @TComponent.BeforeDestruction);
  RegisterMethod(TComponent,
       'procedure DestroyComponents;',
       @TComponent.DestroyComponents);
  RegisterMethod(TComponent,
       'procedure Destroying;',
       @TComponent.Destroying);
  RegisterMethod(TComponent,
       'function ExecuteAction(Action: TBasicAction): Boolean; dynamic;',
       @TComponent.ExecuteAction);
  RegisterMethod(TComponent,
       'function FindComponent(const AName: string): TComponent;',
       @TComponent.FindComponent);
  RegisterMethod(TComponent,
       'procedure FreeNotification(AComponent: TComponent);',
       @TComponent.FreeNotification);
  RegisterMethod(TComponent,
       'procedure RemoveFreeNotification(AComponent: TComponent);',
       @TComponent.RemoveFreeNotification);
  RegisterMethod(TComponent,
       'procedure FreeOnRelease;',
       @TComponent.FreeOnRelease);
  RegisterMethod(TComponent,
       'function GetParentComponent: TComponent; dynamic;',
       @TComponent.GetParentComponent);
  RegisterMethod(TComponent,
       'function GetNamePath: string; override;',
       @TComponent.GetNamePath);
  RegisterMethod(TComponent,
       'function HasParent: Boolean; dynamic;',
       @TComponent.HasParent);
  RegisterMethod(TComponent,
       'procedure InsertComponent(AComponent: TComponent);',
       @TComponent.InsertComponent);
  RegisterMethod(TComponent,
       'procedure RemoveComponent(AComponent: TComponent);',
       @TComponent.RemoveComponent);
  RegisterMethod(TComponent,
       'function SafeCallException(ExceptObject: TObject;      ExceptAddr: Pointer): HResult; override;',
       @TComponent.SafeCallException);
  RegisterMethod(TComponent,
       'function UpdateAction(Action: TBasicAction): Boolean; dynamic;',
       @TComponent.UpdateAction);
  RegisterMethod(TComponent,
       'function TComponent_GetComObject:IUnknown;',
       @TComponent_GetComObject, Fake);
  RegisterProperty(TComponent,
       'property ComObject:IUnknown read TComponent_GetComObject;');
  RegisterMethod(TComponent,
       'function TComponent_GetComponents(Index: Integer):TComponent;',
       @TComponent_GetComponents, Fake);
  RegisterProperty(TComponent,
       'property Components[Index: Integer]:TComponent read TComponent_GetComponents;');
  RegisterMethod(TComponent,
       'function TComponent_GetComponentCount:Integer;',
       @TComponent_GetComponentCount, Fake);
  RegisterProperty(TComponent,
       'property ComponentCount:Integer read TComponent_GetComponentCount;');
  RegisterMethod(TComponent,
       'function TComponent_GetComponentIndex:Integer;',
       @TComponent_GetComponentIndex, Fake);
  RegisterMethod(TComponent,
       'procedure TComponent_PutComponentIndex(const Value: Integer);',
       @TComponent_PutComponentIndex, Fake);
  RegisterProperty(TComponent,
       'property ComponentIndex:Integer read TComponent_GetComponentIndex write TComponent_PutComponentIndex;');
  RegisterMethod(TComponent,
       'function TComponent_GetComponentState:TComponentState;',
       @TComponent_GetComponentState, Fake);
  RegisterProperty(TComponent,
       'property ComponentState:TComponentState read TComponent_GetComponentState;');
  RegisterMethod(TComponent,
       'function TComponent_GetComponentStyle:TComponentStyle;',
       @TComponent_GetComponentStyle, Fake);
  RegisterProperty(TComponent,
       'property ComponentStyle:TComponentStyle read TComponent_GetComponentStyle;');
  RegisterMethod(TComponent,
       'function TComponent_GetDesignInfo:Longint;',
       @TComponent_GetDesignInfo, Fake);
  RegisterMethod(TComponent,
       'procedure TComponent_PutDesignInfo(const Value: Longint);',
       @TComponent_PutDesignInfo, Fake);
  RegisterProperty(TComponent,
       'property DesignInfo:Longint read TComponent_GetDesignInfo write TComponent_PutDesignInfo;');
  RegisterMethod(TComponent,
       'function TComponent_GetOwner:TComponent;',
       @TComponent_GetOwner, Fake);
  RegisterProperty(TComponent,
       'property Owner:TComponent read TComponent_GetOwner;');
  RegisterMethod(TComponent,
       'function TComponent_GetVCLComObject:Pointer;',
       @TComponent_GetVCLComObject, Fake);
  RegisterMethod(TComponent,
       'procedure TComponent_PutVCLComObject(const Value: Pointer);',
       @TComponent_PutVCLComObject, Fake);
  RegisterProperty(TComponent,
       'property VCLComObject:Pointer read TComponent_GetVCLComObject write TComponent_PutVCLComObject;');
  // End of class TComponent
  // Begin of class TBasicActionLink
  RegisterClassType(TBasicActionLink, H);
  RegisterMethod(TBasicActionLink,
       'constructor Create(AClient: TObject); virtual;',
       @TBasicActionLink.Create);
  RegisterMethod(TBasicActionLink,
       'destructor Destroy; override;',
       @TBasicActionLink.Destroy);
  RegisterMethod(TBasicActionLink,
       'function Execute: Boolean;