home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1997 May / Pcwk0597.iso / borland / cb / setup / cbuilder / data.z / CLASSES.INT < prev    next >
Text File  |  1997-02-28  |  23KB  |  652 lines
  1.  
  2. {*******************************************************}
  3. {                                                       }
  4. {       Delphi Visual Component Library                 }
  5. {                                                       }
  6. {       Copyright (c) 1995-1997 Borland International   }
  7. {                                                       }
  8. {*******************************************************}
  9.  
  10. unit Classes;            // $Revision:   1.4  $
  11.  
  12. {$R-}
  13.  
  14. interface
  15.  
  16. uses SysUtils, Windows;
  17.  
  18. const
  19.  
  20. { Maximum TList size }
  21.  
  22.   MaxListSize = Maxint div 16;
  23.  
  24. { TStream seek origins }
  25.  
  26.   soFromBeginning = 0;
  27.   soFromCurrent = 1;
  28.   soFromEnd = 2;
  29.  
  30. { TFileStream create mode }
  31.  
  32.   fmCreate = $FFFF;
  33.  
  34. { TParser special tokens }
  35.  
  36.   toEOF     = Char(0);
  37.   toSymbol  = Char(1);
  38.   toString  = Char(2);
  39.   toInteger = Char(3);
  40.   toFloat   = Char(4);
  41.  
  42. type
  43.  
  44. { Text alignment types }
  45.  
  46.   TAlignment = (taLeftJustify, taRightJustify, taCenter);
  47.   TLeftRight = taLeftJustify..taRightJustify;
  48.  
  49. { Types used by standard events }
  50.  
  51.   TShiftState = set of (ssShift, ssAlt, ssCtrl,
  52.     ssLeft, ssRight, ssMiddle, ssDouble);
  53.  
  54.   THelpContext = -MaxLongint..MaxLongint;
  55.  
  56. { Standard events }
  57.  
  58.   TNotifyEvent = procedure(Sender: TObject) of object;
  59.   THelpEvent = function (Command: Word; Data: Longint;
  60.     var CallHelp: Boolean): Boolean of object;
  61.   TGetStrProc = procedure(const S: string) of object;
  62.  
  63. { Exception classes }
  64.  
  65.   EStreamError = class(Exception);
  66.   EFCreateError = class(EStreamError);
  67.   EFOpenError = class(EStreamError);
  68.   EFilerError = class(EStreamError);
  69.   EReadError = class(EFilerError);
  70.   EWriteError = class(EFilerError);
  71.   EClassNotFound = class(EFilerError);
  72.   EMethodNotFound = class(EFilerError);
  73.   EInvalidImage = class(EFilerError);
  74.   EResNotFound = class(Exception);
  75.   EListError = class(Exception);
  76.   EBitsError = class(Exception);
  77.   EStringListError = class(Exception);
  78.   EComponentError = class(Exception);
  79.   EParserError = class(Exception);
  80.  
  81. { Forward class declarations }
  82.  
  83.   TStream = class;
  84.   TFiler = class;
  85.   TReader = class;
  86.   TWriter = class;
  87.   TComponent = class;
  88.  
  89. { TList class }
  90.  
  91.   PPointerList = ^TPointerList;
  92.   TPointerList = array[0..MaxListSize - 1] of Pointer;
  93.   TListSortCompare = function (Item1, Item2: Pointer): Integer;
  94.  
  95.   TList = class(TObject)
  96.   protected
  97.     procedure Error; virtual;
  98.     function Get(Index: Integer): Pointer;
  99.     procedure Grow; virtual;
  100.     procedure Put(Index: Integer; Item: Pointer);
  101.     procedure SetCapacity(NewCapacity: Integer);
  102.     procedure SetCount(NewCount: Integer);
  103.   public
  104.     destructor Destroy; override;
  105.     function Add(Item: Pointer): Integer;
  106.     procedure Clear;
  107.     procedure Delete(Index: Integer);
  108.     procedure Exchange(Index1, Index2: Integer);
  109.     function Expand: TList;
  110.     function First: Pointer;
  111.     function IndexOf(Item: Pointer): Integer;
  112.     procedure Insert(Index: Integer; Item: Pointer);
  113.     function Last: Pointer;
  114.     procedure Move(CurIndex, NewIndex: Integer);
  115.     function Remove(Item: Pointer): Integer;
  116.     procedure Pack;
  117.     procedure Sort(Compare: TListSortCompare);
  118.     property Capacity: Integer;
  119.     property Count: Integer;
  120.     property Items[Index: Integer]: Pointer; default;
  121.     property List: PPointerList;
  122.   end;
  123.  
  124. { TBits class }
  125.  
  126.   TBits = class
  127.   public
  128.     destructor Destroy; override;
  129.     function OpenBit: Integer;
  130.     property Bits[Index: Integer]: Boolean; default;
  131.     property Size: Integer;
  132.   end;
  133.  
  134. { TPersistent abstract class }
  135.  
  136. {$M+}
  137.  
  138.   TPersistent = class(TObject)
  139.   protected
  140.     procedure AssignTo(Dest: TPersistent); virtual;
  141.     procedure DefineProperties(Filer: TFiler); virtual;
  142.   public
  143.     procedure Assign(Source: TPersistent); virtual;
  144.   end;
  145.  
  146. {$M-}
  147.  
  148. { TPersistent class reference type }
  149.  
  150.   TPersistentClass = class of TPersistent;
  151.  
  152. { TCollection class }
  153.  
  154.   TCollection = class;
  155.  
  156.   TCollectionItem = class(TPersistent)
  157.   protected
  158.     procedure Changed(AllItems: Boolean);
  159.     procedure SetIndex(Value: Integer); virtual;
  160.   public
  161.     constructor Create(Collection: TCollection); virtual;
  162.     destructor Destroy; override;
  163.     property Collection: TCollection;
  164.     property Index: Integer;
  165.   end;
  166.  
  167.   TCollectionItemClass = class of TCollectionItem;
  168.  
  169.   TCollection = class(TPersistent)
  170.   protected
  171.     procedure Changed;
  172.     function GetItem(Index: Integer): TCollectionItem;
  173.     procedure SetItem(Index: Integer; Value: TCollectionItem);
  174.     procedure Update(Item: TCollectionItem); virtual;
  175.   public
  176.     constructor Create(ItemClass: TCollectionItemClass);
  177.     destructor Destroy; override;
  178.     function Add: TCollectionItem;
  179.     procedure Assign(Source: TPersistent); override;
  180.     procedure BeginUpdate;
  181.     procedure Clear;
  182.     procedure EndUpdate;
  183.     property Count: Integer;
  184.     property Items[Index: Integer]: TCollectionItem;
  185.   end;
  186.  
  187. { TStrings class }
  188.  
  189.   TStrings = class(TPersistent)
  190.   protected
  191.     procedure DefineProperties(Filer: TFiler); override;
  192.     function Get(Index: Integer): string; virtual; abstract;
  193.     function GetCount: Integer; virtual; abstract;
  194.     function GetObject(Index: Integer): TObject; virtual;
  195.     function GetTextStr: string; virtual;
  196.     procedure Put(Index: Integer; const S: string); virtual;
  197.     procedure PutObject(Index: Integer; AObject: TObject); virtual;
  198.     procedure SetTextStr(const Value: string); virtual;
  199.     procedure SetUpdateState(Updating: Boolean); virtual;
  200.   public
  201.     function Add(const S: string): Integer; virtual;
  202.     function AddObject(const S: string; AObject: TObject): Integer; virtual;
  203.     procedure Append(const S: string);
  204.     procedure AddStrings(Strings: TStrings); virtual;
  205.     procedure Assign(Source: TPersistent); override;
  206.     procedure BeginUpdate;
  207.     procedure Clear; virtual; abstract;
  208.     procedure Delete(Index: Integer); virtual; abstract;
  209.     procedure EndUpdate;
  210.     function Equals(Strings: TStrings): Boolean;
  211.     procedure Exchange(Index1, Index2: Integer); virtual;
  212.     function GetText: PChar; virtual;
  213.     function IndexOf(const S: string): Integer; virtual;
  214.     function IndexOfName(const Name: string): Integer;
  215.     function IndexOfObject(AObject: TObject): Integer;
  216.     procedure Insert(Index: Integer; const S: string); virtual; abstract;
  217.     procedure InsertObject(Index: Integer; const S: string;
  218.       AObject: TObject);
  219.     procedure LoadFromFile(const FileName: string); virtual;
  220.     procedure LoadFromStream(Stream: TStream); virtual;
  221.     procedure Move(CurIndex, NewIndex: Integer); virtual;
  222.     procedure SaveToFile(const FileName: string); virtual;
  223.     procedure SaveToStream(Stream: TStream); virtual;
  224.     procedure SetText(Text: PChar); virtual;
  225.     property CommaText: string;
  226.     property Count: Integer;
  227.     property Names[Index: Integer]: string;
  228.     property Objects[Index: Integer]: TObject;
  229.     property Values[const Name: string]: string;
  230.     property Strings[Index: Integer]: string; default;
  231.     property Text: string;
  232.   end;
  233.  
  234. { TStringList class }
  235.  
  236.   TDuplicates = (dupIgnore, dupAccept, dupError);
  237.  
  238.   PStringItem = ^TStringItem;
  239.   TStringItem = record
  240.     FString: string;
  241.     FObject: TObject;
  242.   end;
  243.  
  244.   PStringItemList = ^TStringItemList;
  245.   TStringItemList = array[0..MaxListSize] of TStringItem;
  246.  
  247.   TStringList = class(TStrings)
  248.   protected
  249.     procedure Changed; virtual;
  250.     procedure Changing; virtual;
  251.     function Get(Index: Integer): string; override;
  252.     function GetCount: Integer; override;
  253.     function GetObject(Index: Integer): TObject; override;
  254.     procedure Put(Index: Integer; const S: string); override;
  255.     procedure PutObject(Index: Integer; AObject: TObject); override;
  256.     procedure SetUpdateState(Updating: Boolean); override;
  257.   public
  258.     destructor Destroy; override;
  259.     function Add(const S: string): Integer; override;
  260.     procedure Clear; override;
  261.     procedure Delete(Index: Integer); override;
  262.     procedure Exchange(Index1, Index2: Integer); override;
  263.     function Find(const S: string; var Index: Integer): Boolean; virtual;
  264.     function IndexOf(const S: string): Integer; override;
  265.     procedure Insert(Index: Integer; const S: string); override;
  266.     procedure Sort; virtual;
  267.     property Duplicates: TDuplicates;
  268.     property Sorted: Boolean;
  269.     property OnChange: TNotifyEvent;
  270.     property OnChanging: TNotifyEvent;
  271.   end;
  272.  
  273. { TStream abstract class }
  274.  
  275.   TStream = class(TObject)
  276.   public
  277.     function Read(var Buffer; Count: Longint): Longint; virtual; abstract;
  278.     function Write(const Buffer; Count: Longint): Longint; virtual; abstract;
  279.     function Seek(Offset: Longint; Origin: Word): Longint; virtual; abstract;
  280.     procedure ReadBuffer(var Buffer; Count: Longint);
  281.     procedure WriteBuffer(const Buffer; Count: Longint);
  282.     function CopyFrom(Source: TStream; Count: Longint): Longint;
  283.     function ReadComponent(Instance: TComponent): TComponent;
  284.     function ReadComponentRes(Instance: TComponent): TComponent;
  285.     procedure WriteComponent(Instance: TComponent);
  286.     procedure WriteComponentRes(const ResName: string; Instance: TComponent);
  287.     procedure WriteDescendent(Instance, Ancestor: TComponent);
  288.     procedure WriteDescendentRes(const ResName: string; Instance, Ancestor: TComponent);
  289.     procedure ReadResHeader;
  290.     property Position: Longint;
  291.     property Size: Longint;
  292.   end;
  293.  
  294. { THandleStream class }
  295.  
  296.   THandleStream = class(TStream)
  297.   public
  298.     constructor Create(AHandle: Integer);
  299.     function Read(var Buffer; Count: Longint): Longint; override;
  300.     function Write(const Buffer; Count: Longint): Longint; override;
  301.     function Seek(Offset: Longint; Origin: Word): Longint; override;
  302.     property Handle: Integer;
  303.   end;
  304.  
  305. { TFileStream class }
  306.  
  307.   TFileStream = class(THandleStream)
  308.   public
  309.     constructor Create(const FileName: string; Mode: Word);
  310.     destructor Destroy; override;
  311.   end;
  312.  
  313. { TCustomMemoryStream abstract class }
  314.  
  315.   TCustomMemoryStream = class(TStream)
  316.   protected
  317.     procedure SetPointer(Ptr: Pointer; Size: Longint);
  318.   public
  319.     function Read(var Buffer; Count: Longint): Longint; override;
  320.     function Seek(Offset: Longint; Origin: Word): Longint; override;
  321.     procedure SaveToStream(Stream: TStream);
  322.     procedure SaveToFile(const FileName: string);
  323.     property Memory: Pointer;
  324.   end;
  325.  
  326. { TMemoryStream }
  327.  
  328.   TMemoryStream = class(TCustomMemoryStream)
  329.   protected
  330.     function Realloc(var NewCapacity: Longint): Pointer; virtual;
  331.     property Capacity: Longint;
  332.   public
  333.     destructor Destroy; override;
  334.     procedure Clear;
  335.     procedure LoadFromStream(Stream: TStream);
  336.     procedure LoadFromFile(const FileName: string);
  337.     procedure SetSize(NewSize: Longint);
  338.     function Write(const Buffer; Count: Longint): Longint; override;
  339.   end;
  340.  
  341. { TResourceStream }
  342.  
  343.   TResourceStream = class(TCustomMemoryStream)
  344.   public
  345.     constructor Create(Instance: THandle; const ResName: string; ResType: PChar);
  346.     constructor CreateFromID(Instance: THandle; ResID: Integer; ResType: PChar);
  347.     destructor Destroy; override;
  348.     function Write(const Buffer; Count: Longint): Longint; override;
  349.   end;
  350.  
  351. { TFiler }
  352.  
  353.   TValueType = (vaNull, vaList, vaInt8, vaInt16, vaInt32, vaExtended,
  354.     vaString, vaIdent, vaFalse, vaTrue, vaBinary, vaSet, vaLString,
  355.     vaNil, vaCollection);
  356.  
  357.   TFilerFlag = (ffInherited, ffChildPos);
  358.   TFilerFlags = set of TFilerFlag;
  359.  
  360.   TReaderProc = procedure(Reader: TReader) of object;
  361.   TWriterProc = procedure(Writer: TWriter) of object;
  362.   TStreamProc = procedure(Stream: TStream) of object;
  363.  
  364.   TFiler = class(TObject)
  365.   public
  366.     constructor Create(Stream: TStream; BufSize: Integer);
  367.     destructor Destroy; override;
  368.     procedure DefineProperty(const Name: string;
  369.       ReadData: TReaderProc; WriteData: TWriterProc;
  370.       HasData: Boolean); virtual; abstract;
  371.     procedure DefineBinaryProperty(const Name: string;
  372.       ReadData, WriteData: TStreamProc;
  373.       HasData: Boolean); virtual; abstract;
  374.     procedure FlushBuffer; virtual; abstract;
  375.     property Root: TComponent;
  376.     property Ancestor: TPersistent;
  377.     property IgnoreChildren: Boolean;
  378.   end;
  379.  
  380. { TReader }
  381.  
  382.   TFindMethodEvent = procedure(Reader: TReader; const MethodName: string;
  383.     var Address: Pointer; var Error: Boolean) of object;
  384.   TSetNameEvent = procedure(Reader: TReader; Component: TComponent;
  385.     var Name: string) of object;
  386.   TReadComponentsProc = procedure(Component: TComponent) of object;
  387.   TReaderError = procedure(Reader: TReader; const Message: string; var Handled: Boolean) of object;
  388.  
  389.   TReader = class(TFiler)
  390.   protected
  391.     function Error(const Message: string): Boolean; virtual;
  392.     function FindMethod(Root: TComponent; const MethodName: string): Pointer; virtual;
  393.     function NextValue: TValueType;
  394.     procedure SetName(Component: TComponent; var Name: string); virtual;
  395.   public
  396.     destructor Destroy; override;
  397.     procedure BeginReferences;
  398.     procedure DefineProperty(const Name: string;
  399.       ReadData: TReaderProc; WriteData: TWriterProc;
  400.       HasData: Boolean); override;
  401.     procedure DefineBinaryProperty(const Name: string;
  402.       ReadData, WriteData: TStreamProc;
  403.       HasData: Boolean); override;
  404.     function EndOfList: Boolean;
  405.     procedure EndReferences;
  406.     procedure FixupReferences;
  407.     procedure FlushBuffer; override;
  408.     procedure Read(var Buf; Count: Longint);
  409.     function ReadBoolean: Boolean;
  410.     function ReadChar: Char;
  411.     function ReadComponent(Component: TComponent): TComponent;
  412.     procedure ReadComponents(AOwner, AParent: TComponent;
  413.       Proc: TReadComponentsProc);
  414.     function ReadFloat: Extended;
  415.     function ReadIdent: string;
  416.     function ReadInteger: Longint;
  417.     procedure ReadListBegin;
  418.     procedure ReadListEnd;
  419.     procedure ReadPrefix(var Flags: TFilerFlags; var AChildPos: Integer);
  420.     function ReadRootComponent(Root: TComponent): TComponent;
  421.     procedure ReadSignature;
  422.     function ReadStr: string;
  423.     function ReadString: string;
  424.     function ReadValue: TValueType;
  425.     property Owner: TComponent;
  426.     property Parent: TComponent;
  427.     property Position: Longint;
  428.     property OnError: TReaderError;
  429.     property OnFindMethod: TFindMethodEvent;
  430.     property OnSetName: TSetNameEvent;
  431.   end;
  432.  
  433. { TWriter }
  434.  
  435.   TWriter = class(TFiler)
  436.   public
  437.     destructor Destroy; override;
  438.     procedure DefineProperty(const Name: string;
  439.       ReadData: TReaderProc; WriteData: TWriterProc;
  440.       HasData: Boolean); override;
  441.     procedure DefineBinaryProperty(const Name: string;
  442.       ReadData, WriteData: TStreamProc;
  443.       HasData: Boolean); override;
  444.     procedure FlushBuffer; override;
  445.     procedure Write(const Buf; Count: Longint);
  446.     procedure WriteBoolean(Value: Boolean);
  447.     procedure WriteCollection(Value: TCollection);
  448.     procedure WriteComponent(Component: TComponent);
  449.     procedure WriteChar(Value: Char);
  450.     procedure WriteDescendent(Root: TComponent; AAncestor: TComponent);
  451.     procedure WriteFloat(Value: Extended);
  452.     procedure WriteIdent(const Ident: string);
  453.     procedure WriteInteger(Value: Longint);
  454.     procedure WriteListBegin;
  455.     procedure WriteListEnd;
  456.     procedure WriteRootComponent(Root: TComponent);
  457.     procedure WriteSignature;
  458.     procedure WriteStr(const Value: string);
  459.     procedure WriteString(const Value: string);
  460.     property Position: Longint;
  461.     property RootAncestor: TComponent;
  462.   end;
  463.  
  464. { TParser }
  465.  
  466.   TParser = class(TObject)
  467.   public
  468.     constructor Create(Stream: TStream);
  469.     destructor Destroy; override;
  470.     procedure CheckToken(T: Char);
  471.     procedure CheckTokenSymbol(const S: string);
  472.     procedure Error(Ident: Integer);
  473.     procedure ErrorFmt(Ident: Integer; const Args: array of const);
  474.     procedure ErrorStr(const Message: string);
  475.     procedure HexToBinary(Stream: TStream);
  476.     function NextToken: Char;
  477.     function SourcePos: Longint;
  478.     function TokenComponentIdent: String;
  479.     function TokenFloat: Extended;
  480.     function TokenInt: Longint;
  481.     function TokenString: string;
  482.     function TokenSymbolIs(const S: string): Boolean;
  483.     property SourceLine: Integer;
  484.     property Token: Char;
  485.   end;
  486.  
  487. { TThread }
  488.  
  489.   EThread = class(Exception);
  490.  
  491.   TThreadMethod = procedure of object;
  492.   TThreadPriority = (tpIdle, tpLowest, tpLower, tpNormal, tpHigher, tpHighest,
  493.     tpTimeCritical);
  494.  
  495.   TThread = class
  496.   protected
  497.     procedure DoTerminate; virtual;
  498.     procedure Execute; virtual; abstract;
  499.     procedure Synchronize(Method: TThreadMethod);
  500.     property ReturnValue: Integer;
  501.     property Terminated: Boolean;
  502.   public
  503.     constructor Create(CreateSuspended: Boolean);
  504.     destructor Destroy; override;
  505.     procedure Resume;
  506.     procedure Suspend;
  507.     procedure Terminate;
  508.     function WaitFor: Integer;
  509.     property FreeOnTerminate: Boolean;
  510.     property Handle: THandle;
  511.     property Priority: TT;
  512.     property Suspended: Boolean;
  513.     property T;
  514.     property OnTerminate: TNotifyEvent;
  515.   end;
  516.  
  517. { TComponent class }
  518.  
  519.   TOperation = (opInsert, opRemove);
  520.   TComponentState = set of (csLoading, csReading, csWriting, csDestroying,
  521.     csDesigning, csAncestor, csUpdating, csFixups);
  522.   TComponentStyle = set of (csInheritable, csCheckPropAvail);
  523.   TGetChildProc = procedure (Child: TComponent) of object;
  524.  
  525.   TComponentName = type string;
  526.  
  527.   TComponent = class(TPersistent)
  528.   protected
  529.     FComponentStyle: TComponentStyle;
  530.     procedure ChangeName(const NewName: TComponentName);
  531.     procedure DefineProperties(Filer: TFiler); override;
  532.     procedure GetChildren(Proc: TGetChildProc); dynamic;
  533.     function GetChildOwner: TComponent; dynamic;
  534.     function GetChildParent: TComponent; dynamic;
  535.     procedure Loaded; virtual;
  536.     procedure Notification(AComponent: TComponent;
  537.       Operation: TOperation); virtual;
  538.     procedure ReadState(Reader: TReader); virtual;
  539.     procedure SetAncestor(Value: Boolean);
  540.     procedure SetDesigning(Value: Boolean);
  541.     procedure SetName(const NewName: TComponentName); virtual;
  542.     procedure SetChildOrder(Child: TComponent; Order: Integer); dynamic;
  543.     procedure SetParentComponent(Value: TComponent); dynamic;
  544.     procedure Updating; dynamic;
  545.     procedure Updated; dynamic;
  546.     procedure ValidateRename(AComponent: TComponent;
  547.       const CurName, NewName: string); virtual;
  548.     procedure WriteState(Writer: TWriter); virtual;
  549.   public
  550.     constructor Create(AOwner: TComponent); virtual;
  551.     destructor Destroy; override;
  552.     procedure DestroyComponents;
  553.     procedure Destroying;
  554.     function FindComponent(const AName: string): TComponent;
  555.     function GetParentComponent: TComponent; dynamic;
  556.     function HasParent: Boolean; dynamic;
  557.     procedure FreeNotification(AComponent: TComponent);
  558.     procedure InsertComponent(AComponent: TComponent);
  559.     procedure RemoveComponent(AComponent: TComponent);
  560.     property Components[Index: Integer]: TComponent;
  561.     property ComponentCount: Integer;
  562.     property ComponentIndex: Integer;
  563.     property ComponentState: TComponentState;
  564.     property ComponentStyle: TComponentStyle;
  565.     property DesignInfo: Longint;
  566.     property Owner: TComponent;
  567.   published
  568.     property Name: TComponentName;
  569.     property Tag: Longint default 0;
  570.   end;
  571.  
  572. { TComponent class reference type }
  573.  
  574.   TComponentClass = class of TComponent;
  575.  
  576. { Component registration handlers }
  577.  
  578. const
  579.   RegisterComponentsProc: procedure(const Page: string;
  580.     ComponentClasses: array of TComponentClass) = nil;
  581.   RegisterNoIconProc: procedure(ComponentClasses: array of TComponentClass) = nil;
  582.  
  583. { Point and rectangle constructors }
  584.  
  585. function Point(AX, AY: Integer): TPoint;
  586. function SmallPoint(AX, AY: SmallInt): TSmallPoint;
  587. function Rect(ALeft, ATop, ARight, ABottom: Integer): TRect;
  588. function Bounds(ALeft, ATop, AWidth, AHeight: Integer): TRect;
  589.  
  590. { Class registration routines }
  591.  
  592. procedure RegisterClass(AClass: TPersistentClass);
  593. procedure RegisterClasses(AClasses: array of TPersistentClass);
  594. procedure RegisterClassAlias(AClass: TPersistentClass; const Alias: string);
  595. procedure UnRegisterClass(AClass: TPersistentClass);
  596. procedure UnRegisterClasses(AClasses: array of TPersistentClass);
  597. function FindClass(const ClassName: string): TPersistentClass;
  598. function GetClass(const ClassName: string): TPersistentClass;
  599.  
  600. { Component registration routines }
  601.  
  602. procedure RegisterComponents(const Page: string;
  603.   ComponentClasses: array of TComponentClass);
  604. procedure RegisterNoIcon(ComponentClasses: array of TComponentClass);
  605.  
  606. { Object filing routines }
  607.  
  608. type
  609.   TIdentToInt = function(const Ident: string; var Int: Longint): Boolean;
  610.   TIntToIdent = function(Int: Longint; var Ident: string): Boolean;
  611.   TFindGlobalComponent = function(const Name: string): TComponent;
  612.  
  613. var
  614.   MainThreadID: THandle;
  615.   FindGlobalComponent: TFindGlobalComponent;
  616.  
  617. procedure RegisterIntegerConsts(IntegerType: Pointer; IdentToInt: TIdentToInt;
  618.   IntToIdent: TIntToIdent);
  619. function InitInheritedComponent(Instance: TComponent; RootAncestor: TClass): Boolean;
  620. function InitComponentRes(const ResName: string; Instance: TComponent): Boolean;
  621. function ReadComponentRes(const ResName: string; Instance: TComponent): TComponent;
  622. function ReadComponentResFile(const FileName: string; Instance: TComponent): TComponent;
  623. procedure WriteComponentResFile(const FileName: string; Instance: TComponent);
  624.  
  625. procedure GlobalFixupReferences;
  626. procedure GetFixupReferenceNames(Root: TComponent; Names: TStrings);
  627. procedure GetFixupInstanceNames(Root: TComponent;
  628.   const ReferenceRootName: string; Names: TStrings);
  629. procedure RedirectFixupReferences(Root: TComponent; const OldRootName,
  630.   NewRootName: string);
  631. procedure RemoveFixupReferences(Root: TComponent; const RootName: string);
  632.  
  633. procedure BeginGlobalLoading;
  634. procedure NotifyGlobalLoading;
  635. procedure EndGlobalLoading;
  636.  
  637. function CollectionsEqual(C1, C2: TCollection): Boolean;
  638.  
  639. { Object conversion routines }
  640.  
  641. procedure ObjectBinaryToText(Input, Output: TStream);
  642. procedure ObjectTextToBinary(Input, Output: TStream);
  643.  
  644. procedure ObjectResourceToText(Input, Output: TStream);
  645. procedure ObjectTextToResource(Input, Output: TStream);
  646.  
  647. { Utility routines }
  648.  
  649. function LineStart(Buffer, BufPos: PChar): PChar;
  650.  
  651. implementation
  652.