imp_classes.pas

Delphi脚本控件

  // Begin of class TCollectionItem
  RegisterClassType(TCollectionItem, H);
  RegisterMethod(TCollectionItem,
       'constructor Create(Collection: TCollection); virtual;',
       @TCollectionItem.Create);
  RegisterMethod(TCollectionItem,
       'destructor Destroy; override;',
       @TCollectionItem.Destroy);
  RegisterMethod(TCollectionItem,
       'function GetNamePath: string; override;',
       @TCollectionItem.GetNamePath);
  RegisterMethod(TCollectionItem,
       'function TCollectionItem_GetCollection:TCollection;',
       @TCollectionItem_GetCollection, Fake);
  RegisterMethod(TCollectionItem,
       'procedure TCollectionItem_PutCollection(const Value: TCollection);',
       @TCollectionItem_PutCollection, Fake);
  RegisterProperty(TCollectionItem,
       'property Collection:TCollection read TCollectionItem_GetCollection write TCollectionItem_PutCollection;');
  RegisterMethod(TCollectionItem,
       'function TCollectionItem_GetID:Integer;',
       @TCollectionItem_GetID, Fake);
  RegisterProperty(TCollectionItem,
       'property ID:Integer read TCollectionItem_GetID;');
  RegisterMethod(TCollectionItem,
       'function TCollectionItem_GetIndex:Integer;',
       @TCollectionItem_GetIndex, Fake);
  RegisterMethod(TCollectionItem,
       'procedure TCollectionItem_PutIndex(const Value: Integer);',
       @TCollectionItem_PutIndex, Fake);
  RegisterProperty(TCollectionItem,
       'property Index:Integer read TCollectionItem_GetIndex write TCollectionItem_PutIndex;');
  RegisterMethod(TCollectionItem,
       'function TCollectionItem_GetDisplayName:String;',
       @TCollectionItem_GetDisplayName, Fake);
  RegisterMethod(TCollectionItem,
       'procedure TCollectionItem_PutDisplayName(const Value: String);',
       @TCollectionItem_PutDisplayName, Fake);
  RegisterProperty(TCollectionItem,
       'property DisplayName:String read TCollectionItem_GetDisplayName write TCollectionItem_PutDisplayName;');
  // End of class TCollectionItem
  // Begin of class TCollection
  RegisterClassType(TCollection, H);
  RegisterMethod(TCollection,
       'constructor Create(ItemClass: TCollectionItemClass);',
       @TCollection.Create);
  RegisterMethod(TCollection,
       'destructor Destroy; override;',
       @TCollection.Destroy);
  RegisterMethod(TCollection,
       'function Add: TCollectionItem;',
       @TCollection.Add);
  RegisterMethod(TCollection,
       'procedure Assign(Source: TPersistent); override;',
       @TCollection.Assign);
  RegisterMethod(TCollection,
       'procedure BeginUpdate; virtual;',
       @TCollection.BeginUpdate);
  RegisterMethod(TCollection,
       'procedure Clear;',
       @TCollection.Clear);
  RegisterMethod(TCollection,
       'procedure Delete(Index: Integer);',
       @TCollection.Delete);
  RegisterMethod(TCollection,
       'procedure EndUpdate; virtual;',
       @TCollection.EndUpdate);
  RegisterMethod(TCollection,
       'function FindItemID(ID: Integer): TCollectionItem;',
       @TCollection.FindItemID);
  RegisterMethod(TCollection,
       'function GetNamePath: string; override;',
       @TCollection.GetNamePath);
  RegisterMethod(TCollection,
       'function Insert(Index: Integer): TCollectionItem;',
       @TCollection.Insert);
  RegisterMethod(TCollection,
       'function TCollection_GetCount:Integer;',
       @TCollection_GetCount, Fake);
  RegisterProperty(TCollection,
       'property Count:Integer read TCollection_GetCount;');
  RegisterMethod(TCollection,
       'function TCollection_GetItemClass:TCollectionItemClass;',
       @TCollection_GetItemClass, Fake);
  RegisterProperty(TCollection,
       'property ItemClass:TCollectionItemClass read TCollection_GetItemClass;');
  RegisterMethod(TCollection,
       'function TCollection_GetItems(Index: Integer):TCollectionItem;',
       @TCollection_GetItems, Fake);
  RegisterMethod(TCollection,
       'procedure TCollection_PutItems(Index: Integer;const Value: TCollectionItem);',
       @TCollection_PutItems, Fake);
  RegisterProperty(TCollection,
       'property Items[Index: Integer]:TCollectionItem read TCollection_GetItems write TCollection_PutItems;');
  // End of class TCollection
  // Begin of class TOwnedCollection
  RegisterClassType(TOwnedCollection, H);
  RegisterMethod(TOwnedCollection,
       'constructor Create(AOwner: TPersistent; ItemClass: TCollectionItemClass);',
       @TOwnedCollection.Create);
  // End of class TOwnedCollection
  // Begin of class TStrings
  RegisterClassType(TStrings, H);
  RegisterMethod(TStrings,
       'destructor Destroy; override;',
       @TStrings.Destroy);
  RegisterMethod(TStrings,
       'function Add(const S: string): Integer; virtual;',
       @TStrings.Add);
  RegisterMethod(TStrings,
       'function AddObject(const S: string; AObject: TObject): Integer; virtual;',
       @TStrings.AddObject);
  RegisterMethod(TStrings,
       'procedure Append(const S: string);',
       @TStrings.Append);
  RegisterMethod(TStrings,
       'procedure AddStrings(Strings: TStrings); virtual;',
       @TStrings.AddStrings);
  RegisterMethod(TStrings,
       'procedure Assign(Source: TPersistent); override;',
       @TStrings.Assign);
  RegisterMethod(TStrings,
       'procedure BeginUpdate;',
       @TStrings.BeginUpdate);
  RegisterMethod(TStrings,
       'procedure EndUpdate;',
       @TStrings.EndUpdate);
  RegisterMethod(TStrings,
       'function Equals(Strings: TStrings): Boolean;',
       @TStrings.Equals);
  RegisterMethod(TStrings,
       'procedure Exchange(Index1, Index2: Integer); virtual;',
       @TStrings.Exchange);
  RegisterMethod(TStrings,
       'function GetText: PChar; virtual;',
       @TStrings.GetText);
  RegisterMethod(TStrings,
       'function IndexOf(const S: string): Integer; virtual;',
       @TStrings.IndexOf);
  RegisterMethod(TStrings,
       'function IndexOfName(const Name: string): Integer;',
       @TStrings.IndexOfName);
  RegisterMethod(TStrings,
       'function IndexOfObject(AObject: TObject): Integer;',
       @TStrings.IndexOfObject);
  RegisterMethod(TStrings,
       'procedure InsertObject(Index: Integer; const S: string;      AObject: TObject);',
       @TStrings.InsertObject);
  RegisterMethod(TStrings,
       'procedure LoadFromFile(const FileName: string); virtual;',
       @TStrings.LoadFromFile);
  RegisterMethod(TStrings,
       'procedure LoadFromStream(Stream: TStream); virtual;',
       @TStrings.LoadFromStream);
  RegisterMethod(TStrings,
       'procedure Move(CurIndex, NewIndex: Integer); virtual;',
       @TStrings.Move);
  RegisterMethod(TStrings,
       'procedure SaveToFile(const FileName: string); virtual;',
       @TStrings.SaveToFile);
  RegisterMethod(TStrings,
       'procedure SaveToStream(Stream: TStream); virtual;',
       @TStrings.SaveToStream);
  RegisterMethod(TStrings,
       'procedure SetText(Text: PChar); virtual;',
       @TStrings.SetText);
  RegisterMethod(TStrings,
       'function TStrings_GetCapacity:Integer;',
       @TStrings_GetCapacity, Fake);
  RegisterMethod(TStrings,
       'procedure TStrings_PutCapacity(const Value: Integer);',
       @TStrings_PutCapacity, Fake);
  RegisterProperty(TStrings,
       'property Capacity:Integer read TStrings_GetCapacity write TStrings_PutCapacity;');
  RegisterMethod(TStrings,
       'function TStrings_GetCommaText:String;',
       @TStrings_GetCommaText, Fake);
  RegisterMethod(TStrings,
       'procedure TStrings_PutCommaText(const Value: String);',
       @TStrings_PutCommaText, Fake);
  RegisterProperty(TStrings,
       'property CommaText:String read TStrings_GetCommaText write TStrings_PutCommaText;');
  RegisterMethod(TStrings,
       'function TStrings_GetCount:Integer;',
       @TStrings_GetCount, Fake);
  RegisterProperty(TStrings,
       'property Count:Integer read TStrings_GetCount;');

  {$IFDEF Delphi6_UP}
  RegisterMethod(TStrings,
       'function TStrings_ReadDelimiter:Char;',
       @TStrings_ReadDelimiter, Fake);
  RegisterMethod(TStrings,
       'procedure TStrings_WriteDelimiter(const Value: Char);',
       @TStrings_WriteDelimiter, Fake);
  RegisterProperty(TStrings,
       'property Delimiter:Char read TStrings_ReadDelimiter write TStrings_WriteDelimiter;');
  RegisterMethod(TStrings,
       'function TStrings_ReadDelimitedText:String;',
       @TStrings_ReadDelimitedText, Fake);
  RegisterMethod(TStrings,
       'procedure TStrings_WriteDelimitedText(const Value: String);',
       @TStrings_WriteDelimitedText, Fake);
  RegisterProperty(TStrings,
       'property DelimitedText:String read TStrings_ReadDelimitedText write TStrings_WriteDelimitedText;');
  RegisterMethod(TStrings,
       'function TStrings_ReadQuoteChar:Char;',
       @TStrings_ReadQuoteChar, Fake);
  RegisterMethod(TStrings,
       'procedure TStrings_WriteQuoteChar(const Value: Char);',
       @TStrings_WriteQuoteChar, Fake);
  RegisterProperty(TStrings,
       'property QuoteChar:Char read TStrings_ReadQuoteChar write TStrings_WriteQuoteChar;');
  {$ENDIF}

  RegisterMethod(TStrings,
       'function TStrings_GetNames(Index: Integer):String;',
       @TStrings_GetNames, Fake);
  RegisterProperty(TStrings,
       'property Names[Index: Integer]:String read TStrings_GetNames;');
  RegisterMethod(TStrings,
       'function TStrings_GetObjects(Index: Integer):TObject;',
       @TStrings_GetObjects, Fake);
  RegisterMethod(TStrings,
       'procedure TStrings_PutObjects(Index: Integer;const Value: TObject);',
       @TStrings_PutObjects, Fake);
  RegisterProperty(TStrings,
       'property Objects[Index: Integer]:TObject read TStrings_GetObjects write TStrings_PutObjects;');
  RegisterMethod(TStrings,
       'function TStrings_GetValues(const Name: string):String;',
       @TStrings_GetValues, Fake);
  RegisterMethod(TStrings,
       'procedure TStrings_PutValues(const Name: string;const Value: String);',
       @TStrings_PutValues, Fake);
  RegisterProperty(TStrings,
       'property Values[const Name: string]:String read TStrings_GetValues write TStrings_PutValues;');
  RegisterMethod(TStrings,
       'function TStrings_GetStrings(Index: Integer):String;',
       @TStrings_GetStrings, Fake);
  RegisterMethod(TStrings,
       'procedure TStrings_PutStrings(Index: Integer;const Value: String);',
       @TStrings_PutStrings, Fake);
  RegisterProperty(TStrings,
       'property Strings[Index: Integer]:String read TStrings_GetStrings write TStrings_PutStrings;default;');
  RegisterMethod(TStrings,
       'function TStrings_GetText:String;',
       @TStrings_GetText, Fake);
  RegisterMethod(TStrings,
       'procedure TStrings_PutText(const Value: String);',
       @TStrings_PutText, Fake);
  RegisterProperty(TStrings,
       'property Text:String read TStrings_GetText write TStrings_PutText;');
  RegisterMethod(TStrings,
       'function TStrings_GetStringsAdapter:IStringsAdapter;',
       @TStrings_GetStringsAdapter, Fake);
  RegisterMethod(TStrings,
       'procedure TStrings_PutStringsAdapter(const Value: IStringsAdapter);',
       @TStrings_PutStringsAdapter, Fake);
  RegisterProperty(TStrings,
       'property StringsAdapter:IStringsAdapter read TStrings_GetStringsAdapter write TStrings_PutStringsAdapter;');
  RegisterMethod(TStrings,
       'constructor Create;',
       @TStrings.Create);
  // End of class TStrings
  // Begin of class TStringList
  RegisterClassType(TStringList, H);
  RegisterMethod(TStringList,
       'destructor Destroy; override;',
       @TStringList.Destroy);
  RegisterMethod(TStringList,
       'function Add(const S: string): Integer; override;',
       @TStringList.Add);
  RegisterMethod(TStringList,
       'procedure Clear; override;',
       @TStringList.Clear);
  RegisterMethod(TStringList,
       'procedure Delete(Index: Integer); override;',
       @TStringList.Delete);
  RegisterMethod(TStringList,
       'procedure Exchange(Index1, Index2: Integer); override;',
       @TStringList.Exchange);
  RegisterMethod(TStringList,
       'function Find(const S: string; var Index: Integer): Boolean; virtual;',
       @TStringList.Find);
  RegisterMethod(TStringList,
       'function IndexOf(const S: string): Integer; override;',
       @TStringList.IndexOf);
  RegisterMethod(TStringList,
       'procedure Insert(Index: Integer; const S: string); override;',
       @TStringList.Insert);
  RegisterMethod(TStringList,
       'procedure Sort; virtual;',
       @TStringList.Sort);
  RegisterMethod(TStringList,
       'procedure CustomSort(Compare: TStringListSortCompare); virtual;',
       @TStringList.CustomSort);
  RegisterMethod(TStringList,
       'function TStringList_GetDuplicates:TDuplicates;',
       @TStringList_GetDuplicates, Fake);
  RegisterMethod(TStringList,
       'procedure TStringList_PutDuplicates(const Value: TDuplicates);',
       @TStringList_PutDuplicates, Fake);
  RegisterProperty(TStringList,
       'property Duplicates:TDuplicates read TStringList_GetDuplicates write TStringList_PutDuplicates;');
  RegisterMethod(TStringList,
       'function TStringList_GetSorted:Boolean;',
       @TStringList_GetSorted, Fake);
  RegisterMethod(TStringList,
       'procedure TStringList_PutSorted(const Value: Boolean);',
       @TStringList_PutSorted, Fake);
  RegisterProperty(TStringList,
       'property Sorted:Boolean read TStringList_GetSorted write TStringList_PutSorted;');
  RegisterMethod(TStringList,
       'constructor Create;',
       @TStringList.Create);
  // End of class TStringList
  // Begin of class TStream
  RegisterClassType(TStream, H);
  RegisterMethod(TStream,
       'procedure ReadBuffer(var Buffer; Count: Longint);',
       @TStream.ReadBuffer);
  RegisterMethod(TStream,
       'procedure WriteBuffer(const Buffer; Count: Longint);',
       @TStream.WriteBuffer);
  RegisterMethod(TStream,
       'function CopyFrom(Source: TStream; Count: Longint): Longint;',
       @TStream.CopyFrom);
  RegisterMethod(TStream,
       'function ReadComponent(Instance: TComponent): TComponent;',
       @TStream.ReadComponent);
  RegisterMethod(TStream,
       'function ReadComponentRes(Instance: TComponent): TComponent;',
       @TStream.ReadComponentRes);
  RegisterMethod(TStream,
       'procedure WriteComponent(Instance: TComponent);',
       @TStream.WriteComponent);
  RegisterMethod(TStream,
       'procedure WriteComponentRes(const ResName: string; Instance: TComponent);',
       @TStream.WriteComponentRes);
  RegisterMethod(TStream,
       'procedure WriteDescendent(Instance, Ancestor: TComponent);',
       @TStream.WriteDescendent);
  RegisterMethod(TStream,
       'procedure WriteDescendentRes(const ResName: string; Instance, Ancestor: TComponent);',
       @TStream.WriteDescendentRes);
  RegisterMethod(TStream,
       'procedure WriteResourceHeader(const ResName: string; out FixupInfo: Integer);',
       @TStream.WriteResourceHeader);
  RegisterMethod(TStream,
       'procedure FixupResourceHeader(FixupInfo: Integer);',