paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-11-22 04:59:24 +01:00
Code Issues Packages Projects Releases Wiki Activity

* Split file according to Class; implemented dummys for all methods, so unit compiles.

Browse Source
This commit is contained in:
michael 1998-05-04 14:30:11 +00:00
parent eb6b7943a9
commit 39a62a2569
14 changed files with 2972 additions and 409 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

137
fcl/inc/bits.inc Normal file
View File

@ -0,0 +1,137 @@
{
$Id$
This file is part of the Free Component Library (FCL)
Copyright (c) 1998 by the Free Pascal development team
See the file COPYING.FPC, included in this distribution,
for details about the copyright.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
**********************************************************************}
{****************************************************************************}
{* TBits *}
{****************************************************************************}
procedure TBits.Error;
begin
{$ifdef NoExceptions}
;
{$else}
Raise(EBitsError);
{$endif}
end;
procedure TBits.SetSize(Value: Integer);
var
hp : pointer;
cvalue,csize : Integer;
begin
{ ajust value to n*8 }
cvalue:=Value;
if cvalue mod 8<>0 then
cvalue:=cvalue+(8-(cvalue mod 8));
{ store pointer to release it later }
hp:=FBits;
{ ajust size to n*8 }
csize:=FSize;
if csize mod 8<>0 then
csize:=csize+(8-(csize mod 8));
if FSize>0 then
begin
{ get new memory }
GetMem(FBits,cvalue div 8);
{ clear the whole array }
FillChar(FBits^,cvalue div 8,0);
{ copy old data }
Move(hp^,FBits^,csize div 8);
end
else
FBits:=nil;
if assigned(hp) then
FreeMem(hp,csize div 8);
FSize:=Value;
end;
procedure TBits.SetBit(Index: Integer; Value: Boolean);
type
pbyte = ^byte;
begin
if (Index>=FSize) or (Index<0) then
Error
else
begin
if Value then
pbyte(FBits)[Index div 8]:=pbyte(FBits)[Index div 8] or
(1 shl (Index mod 8))
else
pbyte(FBits)[Index div 8]:=pbyte(FBits)[Index div 8] and
not(1 shl (Index mod 8));
end;
end;
function TBits.GetBit(Index: Integer): Boolean;
type
pbyte = ^byte;
begin
if (Index>=FSize) or (Index<0) then
Error
else
GetBit:=(pbyte(FBits)[Index div 8] and (1 shl (Index mod 8)))<>0;
end;
destructor TBits.Destroy;
var
csize : Integer;
begin
{ ajust size to n*8 }
csize:=FSize;
if csize mod 8<>0 then
csize:=csize+(8-(csize mod 8));
if assigned(FBits) then
FreeMem(FBits,csize);
inherited Destroy;
end;
function TBits.OpenBit: Integer;
type
pbyte = ^byte;
var
i : Integer;
begin
for i:=0 to FSize-1 do
if (pbyte(FBits)[i div 8] and (1 shl (i mod 8)))=0 then
begin
OpenBit:=i;
exit;
end;
SetSize(FSize+1);
OpenBit:=FSize-1;
end;
{
$Log$
Revision 1.1 1998-05-04 14:30:11 michael
* Split file according to Class; implemented dummys for all methods, so unit compiles.
}

651
fcl/inc/classes.inc
View File

@ -12,504 +12,353 @@
**********************************************************************}
{****************************************************************************}
{* TBits *}
{****************************************************************************}
{**********************************************************************
* Class implementations are in separate files. *
**********************************************************************}
procedure TBits.Error;
{ TBits implementation }
{$i bits.inc}
begin
{$ifdef NoExceptions}
;
{$else}
Raise(EBitsError);
{$endif}
end;
{ TReader implementation }
{$i reader.inc}
procedure TBits.SetSize(Value: Integer);
{ TWriter implementation }
{$i writer.inc}
var
hp : pointer;
cvalue,csize : Integer;
{ TFiler implementation }
{$i filer.inc}
begin
{ ajust value to n*8 }
cvalue:=Value;
if cvalue mod 8<>0 then
cvalue:=cvalue+(8-(cvalue mod 8));
{ All streams implementations: }
{ Tstreams THandleStream TFileStream TResourcseStreams TStringStream }
{ TCustomMemoryStream TMemoryStream }
{$i streams.inc}
{ store pointer to release it later }
hp:=FBits;
{ TParser implementation}
{$i parser.inc}
{ ajust size to n*8 }
csize:=FSize;
if csize mod 8<>0 then
csize:=csize+(8-(csize mod 8));
{ TCollection and TCollectionItem implementations }
{$i collect.inc}
if FSize>0 then
begin
{ get new memory }
GetMem(FBits,cvalue div 8);
{ clear the whole array }
FillChar(FBits^,cvalue div 8,0);
{ copy old data }
Move(hp^,FBits^,csize div 8);
end
else
FBits:=nil;
{ TList and TThreadList implementations }
{$i lists.inc}
if assigned(hp) then
FreeMem(hp,csize div 8);
{ TStrings and TStringList implementations }
{$i strings.inc}
FSize:=Value;
end;
{ TThread implementation }
{$i thread.inc}
procedure TBits.SetBit(Index: Integer; Value: Boolean);
{ TPersistent implementation }
{$i persist.inc }
type
pbyte = ^byte;
{ TComponent implementation }
{$i compon.inc}
begin
if (Index>=FSize) or (Index<0) then
Error
else
begin
if Value then
pbyte(FBits)[Index div 8]:=pbyte(FBits)[Index div 8] or
(1 shl (Index mod 8))
else
pbyte(FBits)[Index div 8]:=pbyte(FBits)[Index div 8] and
not(1 shl (Index mod 8));
end;
end;
{**********************************************************************
* Miscellaneous procedures and functions *
**********************************************************************}
function TBits.GetBit(Index: Integer): Boolean;
{ Point and rectangle constructors }
type
pbyte = ^byte;
function Point(AX, AY: Integer): TPoint;
begin
if (Index>=FSize) or (Index<0) then
Error
else
GetBit:=(pbyte(FBits)[Index div 8] and (1 shl (Index mod 8)))<>0;
end;
begin
end;
destructor TBits.Destroy;
var
csize : Integer;
function SmallPoint(AX, AY: SmallInt): TSmallPoint;
begin
{ ajust size to n*8 }
csize:=FSize;
if csize mod 8<>0 then
csize:=csize+(8-(csize mod 8));
if assigned(FBits) then
FreeMem(FBits,csize);
inherited Destroy;
end;
begin
end;
function TBits.OpenBit: Integer;
type
pbyte = ^byte;
function Rect(ALeft, ATop, ARight, ABottom: Integer): TRect;
var
i : Integer;
begin
end;
begin
for i:=0 to FSize-1 do
if (pbyte(FBits)[i div 8] and (1 shl (i mod 8)))=0 then
begin
OpenBit:=i;
exit;
end;
SetSize(FSize+1);
OpenBit:=FSize-1;
end;
{****************************************************************************}
{* TStream *}
{****************************************************************************}
function TStream.GetPosition: Longint;
begin
GetPosition:=Seek(0,soFromCurrent);
end;
procedure TStream.SetPosition(Pos: Longint);
begin
Seek(soFromBeginning,Pos);
end;
function TStream.GetSize: Longint;
var
p : longint;
begin
p:=GetPosition;
GetSize:=Seek(soFromEnd,0);
Seek(soFromBeginning,p);
end;
procedure TStream.SetSize(NewSize: Longint);
begin
SetPosition(NewSize);
end;
procedure TStream.ReadBuffer(var Buffer; Count: Longint);
begin
if Read(Buffer,Count)<Count then
{$ifdef NoExceptions}
;
{$else}
Raise(EReadError);
{$endif}
end;
procedure TStream.WriteBuffer(const Buffer; Count: Longint);
begin
if Write(Buffer,Count)<Count then
{$ifdef NoExceptions}
;
{$else}
Raise(EWriteError);
{$endif}
end;
function TStream.CopyFrom(Source: TStream; Count: Longint): Longint;
var
i : longint;
buffer : array[0..1023] of byte;
begin
CopyFrom:=0;
while Count>0 do
begin
if (Count>sizeof(buffer)) then
i:=sizeof(Buffer)
else
i:=Count;
i:=Source.Read(buffer,i);
i:=Write(buffer,i);
dec(count,i);
CopyFrom:=CopyFrom+i;
if i=0 then
exit;
end;
end;
function TStream.ReadComponent(Instance: TComponent): TComponent;
var
Reader : TReader;
begin
Reader.Create(Self,1024);
if assigned(Instance) then
ReadComponent:=Reader.ReadRootComponent(Instance)
else
begin
{!!!!!}
end;
Reader.Destroy;
end;
function TStream.ReadComponentRes(Instance: TComponent): TComponent;
begin
{!!!!!}
end;
procedure TStream.WriteComponent(Instance: TComponent);
var
Writer : TWriter;
begin
Writer.Create(Self,1024);
Writer.WriteRootComponent(Instance);
Writer.Destroy;
end;
procedure TStream.WriteComponentRes(const ResName: string; Instance: TComponent);
var
startpos,s : longint;
begin
(*
{$ifdef Win16Res}
{ Numeric resource type }
WriteByte($ff);
{ Application defined data }
WriteWord($0a);
{ write the name as asciiz }
WriteData(ResName[1],length(ResName));
WriteByte(0);
{ Movable, Pure and Discardable }
WriteWord($1030);
{ size isn't known yet }
WriteDWord(0);
startpos:=GetPosition;
WriteComponent(Instance);
{ calculate size }
s:=GetPosition-startpos;
{ back patch size }
SetPosition(startpos-4);
WriteDWord(s);
{$endif Win16Res}
*)
end;
procedure TStream.WriteDescendent(Instance, Ancestor: TComponent);
begin
{!!!!!}
end;
procedure TStream.WriteDescendentRes(const ResName: string; Instance, Ancestor: TComponent);
begin
{!!!!!}
end;
procedure TStream.ReadResHeader;
begin
{$ifdef Win16Res}
try
{ application specific resource ? }
if ReadByte<>$ff then
raise EInvalidImage;
if ReadWord<>$000a then
raise EInvalidImage;
{ read name }
while ReadByte<>0 do
;
{ check the access specifier }
if ReadWord<>$1030 then
raise EInvalidImage;
{ ignore the size }
ReadDWord;
except
{/////
on EInvalidImage do
raise;
else
raise(EInvalidImage);
}
end;
{$endif Win16Res}
end;
function TStream.ReadByte : Byte;
var
b : Byte;
begin
ReadBuffer(b,1);
ReadByte:=b;
end;
function TStream.ReadWord : Word;
var
w : Word;
begin
ReadBuffer(w,2);
ReadWord:=w;
end;
function TStream.ReadDWord : Cardinal;
var
d : Cardinal;
begin
ReadBuffer(d,4);
ReadDWord:=d;
end;
procedure TStream.WriteByte(b : Byte);
begin
WriteBuffer(b,1);
end;
procedure TStream.WriteWord(w : Word);
begin
WriteBuffer(w,2);
end;
procedure TStream.WriteDWord(d : Cardinal);
begin
WriteBuffer(d,4);
end;
{****************************************************************************}
{* TList *}
{****************************************************************************}
{ TList = class(TObject)
private
FList: PPointerList;
FCount: Integer;
FCapacity: Integer;
}
function TList.Get(Index: Integer): Pointer;
function Bounds(ALeft, ATop, AWidth, AHeight: Integer): TRect;
begin
end;
procedure TList.Grow;
{ Class registration routines }
procedure RegisterClass(AClass: TPersistentClass);
begin
end;
procedure RegisterClasses(AClasses: array of TPersistentClass);
begin
end;
procedure RegisterClassAlias(AClass: TPersistentClass; const Alias: string);
begin
end;
procedure UnRegisterClass(AClass: TPersistentClass);
begin
end;
procedure UnRegisterClasses(AClasses: array of TPersistentClass);
begin
end;
procedure UnRegisterModuleClasses(Module: HMODULE);
begin
end;
function FindClass(const ClassName: string): TPersistentClass;
begin
end;
function GetClass(const ClassName: string): TPersistentClass;
begin
end;
procedure TList.Put(Index: Integer; Item: Pointer);
{ Component registration routines }
procedure RegisterComponents(const Page: string;
ComponentClasses: array of TComponentClass);
begin
end;
procedure RegisterNoIcon(ComponentClasses: array of TComponentClass);
begin
end;
procedure RegisterNonActiveX(ComponentClasses: array of TComponentClass;
AxRegType: TActiveXRegType);
begin
end;
procedure TList.SetCapacity(NewCapacity: Integer);
{ Object filing routines }
procedure RegisterIntegerConsts(IntegerType: Pointer; IdentToInt: TIdentToInt;
IntToIdent: TIntToIdent);
begin
end;
function IdentToInt(const Ident: string; var Int: Longint; const Map: array of TIdentMapEntry): Boolean;
begin
end;
function IntToIdent(Int: Longint; var Ident: string; const Map: array of TIdentMapEntry): Boolean;
begin
end;
function InitInheritedComponent(Instance: TComponent; RootAncestor: TClass): Boolean;
begin
end;
function InitComponentRes(const ResName: string; Instance: TComponent): Boolean;
begin
end;
function ReadComponentRes(const ResName: string; Instance: TComponent): TComponent;
begin
end;
function ReadComponentResEx(HInstance: THandle; const ResName: string): TComponent;
begin
end;
function ReadComponentResFile(const FileName: string; Instance: TComponent): TComponent;
begin
end;
procedure WriteComponentResFile(const FileName: string; Instance: TComponent);
begin
end;
procedure TList.SetCount(NewCount: Integer);
procedure GlobalFixupReferences;
begin
end;
procedure GetFixupReferenceNames(Root: TComponent; Names: TStrings);
begin
end;
procedure GetFixupInstanceNames(Root: TComponent;
const ReferenceRootName: string; Names: TStrings);
begin
end;
procedure RedirectFixupReferences(Root: TComponent; const OldRootName,
NewRootName: string);
begin
end;
procedure RemoveFixupReferences(Root: TComponent; const RootName: string);
begin
end;
procedure RemoveFixups(Instance: TPersistent);
begin
end;
destructor TList.Destroy;
procedure BeginGlobalLoading;
begin
Clear;
inherited Destroy;
end;
Function TList.Add(Item: Pointer): Integer;
procedure NotifyGlobalLoading;
begin
Self.Insert (Count,Item);
end;
Procedure TList.Clear;
procedure EndGlobalLoading;
begin
end;
Procedure TList.Delete(Index: Integer);
begin
end;
class procedure Error(const Msg: string; Data: Integer);
begin
end;
procedure TList.Exchange(Index1, Index2: Integer);
function CollectionsEqual(C1, C2: TCollection): Boolean;
begin
end;
function TList.Expand: TList;
{ Object conversion routines }
procedure ObjectBinaryToText(Input, Output: TStream);
begin
end;
function TList.First: Pointer;
procedure ObjectTextToBinary(Input, Output: TStream);
begin
end;
procedure ObjectResourceToText(Input, Output: TStream);
begin
end;
procedure ObjectTextToResource(Input, Output: TStream);
begin
end;
function TList.IndexOf(Item: Pointer): Integer;
{ Utility routines }
function LineStart(Buffer, BufPos: PChar): PChar;
begin
end;
procedure TList.Insert(Index: Integer; Item: Pointer);
begin
end;
function TList.Last: Pointer;
begin
end;
procedure TList.Move(CurIndex, NewIndex: Integer);
begin
end;
function TList.Remove(Item: Pointer): Integer;
begin
end;
procedure TList.Pack;
begin
end;
procedure TList.Sort(Compare: TListSortCompare);
begin
end;
{
$Log$
Revision 1.1 1998-05-04 12:16:01 florian
Revision 1.2 1998-05-04 14:30:11 michael
* Split file according to Class; implemented dummys for all methods, so unit compiles.
Revision 1.9 1998/05/04 12:16:01 florian
+ Initial revisions after making a new directory structure
Revision 1.8 1998/05/04 11:20:13 florian
+ Write* and Read* methods to TStream added
* small problems solved
Revision 1.7 1998/05/04 09:39:51 michael
+ Started implementation of TList
Revision 1.6 1998/05/01 22:17:19 florian
+ TBits implemented
+ TStream partial implemented
Revision 1.5 1998/05/01 17:53:12 florian
* now it compiles with FPC
Revision 1.4 1998/04/28 11:47:00 florian
* more adaptions to FPC
Revision 1.3 1998/04/27 12:55:57 florian
+ uses objpas added
Revision 1.2 1998/04/27 09:09:49 michael
+ Added log at the end
}
{
$Log$
Revision 1.2 1998-05-04 14:30:11 michael
* Split file according to Class; implemented dummys for all methods, so unit compiles.
Revision 1.1 1998/05/04 12:16:01 florian
+ Initial revisions after making a new directory structure
}

19
fcl/inc/classesh.inc
View File

@ -237,7 +237,7 @@ type
procedure SetIndex(Value: Integer); virtual;
procedure SetDisplayName(const Value: string); virtual;
public
constructor Create(Collection: TCollection); virtual;
constructor Create(ACollection: TCollection); virtual;
destructor Destroy; override;
property Collection: TCollection read FCollection write SetCollection;
property ID: Integer read FID;
@ -271,7 +271,7 @@ type
procedure Update(Item: TCollectionItem); virtual;
property PropName: string read GetPropName write FPropName;
public
constructor Create(ItemClass: TCollectionItemClass);
constructor Create(AItemClass: TCollectionItemClass);
destructor Destroy; override;
function Add: TCollectionItem;
procedure Assign(Source: TPersistent); override;
@ -330,13 +330,13 @@ type
function Add(const S: string): Integer; virtual;
function AddObject(const S: string; AObject: TObject): Integer; virtual;
procedure Append(const S: string);
procedure AddStrings(Strings: TStrings); virtual;
procedure AddStrings(TheStrings: TStrings); virtual;
procedure Assign(Source: TPersistent); override;
procedure BeginUpdate;
procedure Clear; virtual; abstract;
procedure Delete(Index: Integer); virtual; abstract;
procedure EndUpdate;
function Equals(Strings: TStrings): Boolean;
function Equals(TheStrings: TStrings): Boolean;
procedure Exchange(Index1, Index2: Integer); virtual;
function GetText: PChar; virtual;
function IndexOf(const S: string): Integer; virtual;
@ -350,7 +350,7 @@ type
procedure Move(CurIndex, NewIndex: Integer); virtual;
procedure SaveToFile(const FileName: string); virtual;
procedure SaveToStream(Stream: TStream); virtual;
procedure SetText(Text: PChar); virtual;
procedure SetText(TheText: PChar); virtual;
property Capacity: Integer read GetCapacity write SetCapacity;
property CommaText: string read GetCommaText write SetCommaText;
property Count: Integer read GetCount;
@ -864,7 +864,7 @@ type
FDesignInfo: Longint;
FVCLComObject: Pointer;
FComponentState: TComponentState;
function GetComObject: IUnknown;
// function GetComObject: IUnknown;
function GetComponent(AIndex: Integer): TComponent;
function GetComponentCount: Integer;
function GetComponentIndex: Integer;
@ -927,7 +927,7 @@ type
procedure RemoveComponent(AComponent: TComponent);
function SafeCallException(ExceptObject: TObject;
ExceptAddr: Pointer): Integer; override;
property ComObject: IUnknown read GetComObject;
// property ComObject: IUnknown read GetComObject;
property Components[Index: Integer]: TComponent read GetComponent;
property ComponentCount: Integer read GetComponentCount;
property ComponentIndex: Integer read GetComponentIndex write SetComponentIndex;
@ -1043,7 +1043,10 @@ function LineStart(Buffer, BufPos: PChar): PChar;
{
$Log$
Revision 1.1 1998-05-04 12:16:01 florian
Revision 1.2 1998-05-04 14:30:11 michael
* Split file according to Class; implemented dummys for all methods, so unit compiles.
Revision 1.1 1998/05/04 12:16:01 florian
+ Initial revisions after making a new directory structure
}

238
fcl/inc/collect.inc Normal file
View File

@ -0,0 +1,238 @@
{
$Id$
This file is part of the Free Component Library (FCL)
Copyright (c) 1998 by the Free Pascal development team
See the file COPYING.FPC, included in this distribution,
for details about the copyright.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
**********************************************************************}
{****************************************************************************}
{* TCollectionItem *}
{****************************************************************************}
function TCollectionItem.GetIndex: Integer;
begin
end;
procedure TCollectionItem.SetCollection(Value: TCollection);
begin
end;
procedure TCollectionItem.Changed(AllItems: Boolean);
begin
end;
function TCollectionItem.GetNamePath: string;
begin
end;
function TCollectionItem.GetOwner: TPersistent;
begin
end;
function TCollectionItem.GetDisplayName: string;
begin
end;
procedure TCollectionItem.SetIndex(Value: Integer);
begin
end;
procedure TCollectionItem.SetDisplayName(const Value: string);
begin
end;
constructor TCollectionItem.Create(ACollection: TCollection);
begin
end;
destructor TCollectionItem.Destroy;
begin
end;
{****************************************************************************}
{* TCollection *}
{****************************************************************************}
function TCollection.GetCount: Integer;
begin
end;
function TCollection.GetPropName: string;
begin
end;
procedure TCollection.InsertItem(Item: TCollectionItem);
begin
end;
procedure TCollection.RemoveItem(Item: TCollectionItem);
begin
end;
function TCollection.GetAttrCount: Integer;
begin
end;
function TCollection.GetAttr(Index: Integer): string;
begin
end;
function TCollection.GetItemAttr(Index, ItemIndex: Integer): string;
begin
end;
function TCollection.GetNamePath: string;
begin
end;
procedure TCollection.Changed;
begin
end;
function TCollection.GetItem(Index: Integer): TCollectionItem;
begin
end;
procedure TCollection.SetItem(Index: Integer; Value: TCollectionItem);
begin
end;
procedure TCollection.SetItemName(Item: TCollectionItem);
begin
end;
procedure TCollection.Update(Item: TCollectionItem);
begin
end;
constructor TCollection.Create(AItemClass: TCollectionItemClass);
begin
end;
destructor TCollection.Destroy;
begin
end;
function TCollection.Add: TCollectionItem;
begin
end;
procedure TCollection.Assign(Source: TPersistent);
begin
end;
procedure TCollection.BeginUpdate;
begin
end;
procedure TCollection.Clear;
begin
end;
procedure TCollection.EndUpdate;
begin
end;
function TCollection.FindItemID(ID: Integer): TCollectionItem;
begin
end;
{
$Log$
Revision 1.1 1998-05-04 14:30:11 michael
* Split file according to Class; implemented dummys for all methods, so unit compiles.
}

297
fcl/inc/compon.inc Normal file
View File

@ -0,0 +1,297 @@
{
$Id$
This file is part of the Free Component Library (FCL)
Copyright (c) 1998 by the Free Pascal development team
See the file COPYING.FPC, included in this distribution,
for details about the copyright.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
**********************************************************************}
{****************************************************************************}
{* TComponent *}
{****************************************************************************}
Function TComponent.GetComponent(AIndex: Integer): TComponent;
begin
end;
Function TComponent.GetComponentCount: Integer;
begin
end;
Function TComponent.GetComponentIndex: Integer;
begin
end;
Procedure TComponent.Insert(AComponent: TComponent);
begin
end;
Procedure TComponent.ReadLeft(Reader: TReader);
begin
end;
Procedure TComponent.ReadTop(Reader: TReader);
begin
end;
Procedure TComponent.Remove(AComponent: TComponent);
begin
end;
Procedure TComponent.SetComponentIndex(Value: Integer);
begin
end;
Procedure TComponent.SetReference(Enable: Boolean);
begin
end;
Procedure TComponent.WriteLeft(Writer: TWriter);
begin
end;
Procedure TComponent.WriteTop(Writer: TWriter);
begin
end;
Procedure TComponent.ChangeName(const NewName: TComponentName);
begin
end;
Procedure TComponent.DefineProperties(Filer: TFiler);
begin
end;
Procedure TComponent.GetChildren(Proc: TGetChildProc; Root: TComponent);
begin
end;
Function TComponent.GetChildOwner: TComponent;
begin
end;
Function TComponent.GetChildParent: TComponent;
begin
end;
Function TComponent.GetNamePath: string;
begin
end;
Function TComponent.GetOwner: TPersistent;
begin
end;
Procedure TComponent.Loaded;
begin
end;
Procedure TComponent.Notification(AComponent: TComponent;
Operation: TOperation);
begin
end;
Procedure TComponent.ReadState(Reader: TReader);
begin
end;
Procedure TComponent.SetAncestor(Value: Boolean);
begin
end;
Procedure TComponent.SetDesigning(Value: Boolean);
begin
end;
Procedure TComponent.SetName(const NewName: TComponentName);
begin
end;
Procedure TComponent.SetChildOrder(Child: TComponent; Order: Integer);
begin
end;
Procedure TComponent.SetParentComponent(Value: TComponent);
begin
end;
Procedure TComponent.Updating;
begin
end;
Procedure TComponent.Updated;
begin
end;
class Procedure TComponent.UpdateRegistry(Register: Boolean; const ClassID, ProgID: string);
begin
end;
Procedure TComponent.ValidateRename(AComponent: TComponent;
const CurName, NewName: string);
begin
end;
Procedure TComponent.ValidateContainer(AComponent: TComponent);
begin
end;
Procedure TComponent.ValidateInsert(AComponent: TComponent);
begin
end;
Procedure TComponent.WriteState(Writer: TWriter);
begin
end;
Constructor TComponent.Create(AOwner: TComponent);
begin
end;
Destructor TComponent.Destroy;
begin
end;
Procedure TComponent.DestroyComponents;
begin
end;
Procedure TComponent.Destroying;
begin
end;
Function TComponent.FindComponent(const AName: string): TComponent;
begin
end;
Procedure TComponent.FreeNotification(AComponent: TComponent);
begin
end;
Procedure TComponent.FreeOnRelease;
begin
end;
Function TComponent.GetParentComponent: TComponent;
begin
end;
Function TComponent.HasParent: Boolean;
begin
end;
Procedure TComponent.InsertComponent(AComponent: TComponent);
begin
end;
Procedure TComponent.RemoveComponent(AComponent: TComponent);
begin
end;
Function TComponent.SafeCallException(ExceptObject: TObject;
ExceptAddr: Pointer): Integer;
begin
end;
{
$Log$
Revision 1.1 1998-05-04 14:30:11 michael
* Split file according to Class; implemented dummys for all methods, so unit compiles.
}

32
fcl/inc/filer.inc Normal file
View File

@ -0,0 +1,32 @@
{
$Id$
This file is part of the Free Component Library (FCL)
Copyright (c) 1998 by the Free Pascal development team
See the file COPYING.FPC, included in this distribution,
for details about the copyright.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
**********************************************************************}
{ *********************************************************************
* TFiler *
*********************************************************************}
Constructor TFiler.Create(Stream: TStream; BufSize: Integer);
begin
end;
Destructor TFiler.Destroy;
begin
end;{
$Log$
Revision 1.1 1998-05-04 14:30:11 michael
* Split file according to Class; implemented dummys for all methods, so unit compiles.
}

217
fcl/inc/lists.inc Normal file
View File

@ -0,0 +1,217 @@
{
$Id$
This file is part of the Free Component Library (FCL)
Copyright (c) 1998 by the Free Pascal development team
See the file COPYING.FPC, included in this distribution,
for details about the copyright.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
**********************************************************************}
{****************************************************************************}
{* TList *}
{****************************************************************************}
{ TList = class(TObject)
private
FList: PPointerList;
FCount: Integer;
FCapacity: Integer;
}
function TList.Get(Index: Integer): Pointer;
begin
end;
procedure TList.Grow;
begin
end;
procedure TList.Put(Index: Integer; Item: Pointer);
begin
end;
procedure TList.SetCapacity(NewCapacity: Integer);
begin
end;
procedure TList.SetCount(NewCount: Integer);
begin
end;
destructor TList.Destroy;
begin
Clear;
inherited Destroy;
end;
Function TList.Add(Item: Pointer): Integer;
begin
// Self.Insert (Count,Item);
end;
Procedure TList.Clear;
begin
end;
Procedure TList.Delete(Index: Integer);
begin
end;
class procedure TList.Error(const Msg: string; Data: Integer);
begin
end;
procedure TList.Exchange(Index1, Index2: Integer);
begin
end;
function TList.Expand: TList;
begin
end;
function TList.First: Pointer;
begin
end;
function TList.IndexOf(Item: Pointer): Integer;
begin
end;
procedure TList.Insert(Index: Integer; Item: Pointer);
begin
end;
function TList.Last: Pointer;
begin
end;
procedure TList.Move(CurIndex, NewIndex: Integer);
begin
end;
function TList.Remove(Item: Pointer): Integer;
begin
end;
procedure TList.Pack;
begin
end;
procedure TList.Sort(Compare: TListSortCompare);
begin
end;
{****************************************************************************}
{* TThreadList *}
{****************************************************************************}
constructor TThreadList.Create;
begin
end;
destructor TThreadList.Destroy;
begin
end;
procedure TThreadList.Add(Item: Pointer);
begin
end;
procedure TThreadList.Clear;
begin
end;
function TThreadList.LockList: TList;
begin
end;
procedure TThreadList.Remove(Item: Pointer);
begin
end;
procedure TThreadList.UnlockList;
begin
end;
{
$Log$
Revision 1.1 1998-05-04 14:30:12 michael
* Split file according to Class; implemented dummys for all methods, so unit compiles.
}

124
fcl/inc/parser.inc Normal file
View File

@ -0,0 +1,124 @@
{
$Id$
This file is part of the Free Component Library (FCL)
Copyright (c) 1998 by the Free Pascal development team
See the file COPYING.FPC, included in this distribution,
for details about the copyright.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
**********************************************************************}
{****************************************************************************}
{* TParser *}
{****************************************************************************}
Procedure TParser.ReadBuffer;
begin
end;
Procedure TParser.SkipBlanks;
begin
end;
constructor TParser.Create(Stream: TStream);
begin
end;
destructor TParser.Destroy;
begin
end;
Procedure TParser.CheckToken(T: Char);
begin
end;
Procedure TParser.CheckTokenSymbol(const S: string);
begin
end;
Procedure TParser.Error(const Ident: string);
begin
end;
{!!!!!!
Procedure TParser.ErrorFmt(const Ident: string; const Args: array of const);
begin
end;
!!!!!!}
Procedure TParser.ErrorStr(const Message: string);
begin
end;
Procedure TParser.HexToBinary(Stream: TStream);
begin
end;
Function TParser.NextToken: Char;
begin
end;
Function TParser.SourcePos: Longint;
begin
end;
Function TParser.TokenComponentIdent: String;
begin
end;
Function TParser.TokenFloat: Extended;
begin
end;
Function TParser.TokenInt: Longint;
begin
end;
Function TParser.TokenString: string;
begin
end;
Function TParser.TokenSymbolIs(const S: string): Boolean;
begin
end;
{
$Log$
Revision 1.1 1998-05-04 14:30:12 michael
* Split file according to Class; implemented dummys for all methods, so unit compiles.
}

63
fcl/inc/persist.inc Normal file
View File

@ -0,0 +1,63 @@
{
$Id$
This file is part of the Free Component Library (FCL)
Copyright (c) 1998 by the Free Pascal development team
See the file COPYING.FPC, included in this distribution,
for details about the copyright.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
**********************************************************************}
{****************************************************************************}
{* TPersistent *}
{****************************************************************************}
procedure TPersistent.AssignError(Source: TPersistent);
begin
end;
procedure TPersistent.AssignTo(Dest: TPersistent);
begin
end;
procedure TPersistent.DefineProperties(Filer: TFiler);
begin
end;
function TPersistent.GetOwner: TPersistent;
begin
end;
destructor TPersistent.Destroy;
begin
end;
procedure TPersistent.Assign(Source: TPersistent);
begin
end;
function TPersistent.GetNamePath: string;
begin
end;
{
$Log$
Revision 1.1 1998-05-04 14:30:12 michael
* Split file according to Class; implemented dummys for all methods, so unit compiles.
}

362
fcl/inc/reader.inc Normal file
View File

@ -0,0 +1,362 @@
{
$Id$
This file is part of the Free Component Library (FCL)
Copyright (c) 1998 by the Free Pascal development team
See the file COPYING.FPC, included in this distribution,
for details about the copyright.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
**********************************************************************}
{****************************************************************************}
{* TREADER *}
{****************************************************************************}
Procedure TReader.CheckValue(Value: TValueType);
begin
end;
Procedure TReader.DoFixupReferences;
begin
end;
Procedure TReader.FreeFixups;
begin
end;
Function TReader.GetPosition: Longint;
begin
end;
Procedure TReader.PropertyError;
begin
end;
Procedure TReader.ReadBuffer;
begin
end;
Procedure TReader.ReadData(Instance: TComponent);
begin
end;
Procedure TReader.ReadDataInner(Instance: TComponent);
begin
end;
Procedure TReader.ReadProperty(AInstance: TPersistent);
begin
end;
Procedure TReader.ReadPropValue(Instance: TPersistent; PropInfo: Pointer);
begin
end;
Function TReader.ReadSet(SetType: Pointer): Integer;
begin
end;
Procedure TReader.SetPosition(Value: Longint);
begin
end;
Procedure TReader.SkipSetBody;
begin
end;
Procedure TReader.SkipValue;
begin
end;
Procedure TReader.SkipProperty;
begin
end;
Procedure TReader.SkipComponent(SkipHeader: Boolean);
begin
end;
Function TReader.Error(const Message: string): Boolean;
begin
end;
Function TReader.FindMethod(Root: TComponent; const MethodName: string): Pointer;
begin
end;
Procedure TReader.SetName(Component: TComponent; var Name: string);
begin
end;
Procedure TReader.ReferenceName(var Name: string);
begin
end;
Function TReader.FindAncestorComponent(const Name: string;
ComponentClass: TPersistentClass): TComponent;
begin
end;
destructor TReader.Destroy;
begin
end;
Procedure TReader.BeginReferences;
begin
end;
Procedure TReader.DefineProperty(const Name: string;
rd : TReaderProc; wd : TWriterProc;
HasData: Boolean);
begin
end;
Procedure TReader.DefineBinaryProperty(const Name: string;
rd, wd: TStreamProc;
HasData: Boolean);
begin
end;
Function TReader.EndOfList: Boolean;
begin
end;
Procedure TReader.EndReferences;
begin
end;
Procedure TReader.FixupReferences;
begin
end;
Procedure TReader.FlushBuffer;
begin
end;
Function TReader.NextValue: TValueType;
begin
end;
Procedure TReader.Read(var Buf; Count: Longint);
begin
end;
Function TReader.ReadBoolean: Boolean;
begin
end;
Function TReader.ReadChar: Char;
begin
end;
Procedure TReader.ReadCollection(Collection: TCollection);
begin
end;
Function TReader.ReadComponent(Component: TComponent): TComponent;
begin
end;
Procedure TReader.ReadComponents(AOwner, AParent: TComponent;
Proc: TReadComponentsProc);
begin
end;
Function TReader.ReadFloat: Extended;
begin
end;
Function TReader.ReadIdent: string;
begin
end;
Function TReader.ReadInteger: Longint;
begin
end;
Procedure TReader.ReadListBegin;
begin
end;
Procedure TReader.ReadListEnd;
begin
end;
Procedure TReader.ReadPrefix(var Flags: TFilerFlags; var AChildPos: Integer);
begin
end;
Function TReader.ReadRootComponent(Root: TComponent): TComponent;
begin
end;
Procedure TReader.ReadSignature;
begin
end;
Function TReader.ReadStr: string;
begin
end;
Function TReader.ReadString: string;
begin
end;
Function TReader.ReadValue: TValueType;
begin
end;
Procedure TReader.CopyValue(Writer: TWriter); {!!!}
begin
end;
{
$Log$
Revision 1.1 1998-05-04 14:30:12 michael
* Split file according to Class; implemented dummys for all methods, so unit compiles.
}

472
fcl/inc/streams.inc Normal file
View File

@ -0,0 +1,472 @@
{
$Id$
This file is part of the Free Component Library (FCL)
Copyright (c) 1998 by the Free Pascal development team
See the file COPYING.FPC, included in this distribution,
for details about the copyright.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
**********************************************************************}
{****************************************************************************}
{* TStream *}
{****************************************************************************}
function TStream.GetPosition: Longint;
begin
GetPosition:=Seek(0,soFromCurrent);
end;
procedure TStream.SetPosition(Pos: Longint);
begin
Seek(soFromBeginning,Pos);
end;
function TStream.GetSize: Longint;
var
p : longint;
begin
p:=GetPosition;
GetSize:=Seek(soFromEnd,0);
Seek(soFromBeginning,p);
end;
procedure TStream.SetSize(NewSize: Longint);
begin
SetPosition(NewSize);
end;
procedure TStream.ReadBuffer(var Buffer; Count: Longint);
begin
if Read(Buffer,Count)<Count then
{$ifdef NoExceptions}
;
{$else}
Raise(EReadError);
{$endif}
end;
procedure TStream.WriteBuffer(const Buffer; Count: Longint);
begin
if Write(Buffer,Count)<Count then
{$ifdef NoExceptions}
;
{$else}
Raise(EWriteError);
{$endif}
end;
function TStream.CopyFrom(Source: TStream; Count: Longint): Longint;
var
i : longint;
buffer : array[0..1023] of byte;
begin
CopyFrom:=0;
while Count>0 do
begin
if (Count>sizeof(buffer)) then
i:=sizeof(Buffer)
else
i:=Count;
i:=Source.Read(buffer,i);
i:=Write(buffer,i);
dec(count,i);
CopyFrom:=CopyFrom+i;
if i=0 then
exit;
end;
end;
function TStream.ReadComponent(Instance: TComponent): TComponent;
var
Reader : TReader;
begin
Reader.Create(Self,1024);
if assigned(Instance) then
ReadComponent:=Reader.ReadRootComponent(Instance)
else
begin
{!!!!!}
end;
Reader.Destroy;
end;
function TStream.ReadComponentRes(Instance: TComponent): TComponent;
begin
{!!!!!}
end;
procedure TStream.WriteComponent(Instance: TComponent);
var
Writer : TWriter;
begin
Writer.Create(Self,1024);
Writer.WriteRootComponent(Instance);
Writer.Destroy;
end;
procedure TStream.WriteComponentRes(const ResName: string; Instance: TComponent);
var
startpos,s : longint;
begin
(*
{$ifdef Win16Res}
{ Numeric resource type }
WriteByte($ff);
{ Application defined data }
WriteWord($0a);
{ write the name as asciiz }
WriteData(ResName[1],length(ResName));
WriteByte(0);
{ Movable, Pure and Discardable }
WriteWord($1030);
{ size isn't known yet }
WriteDWord(0);
startpos:=GetPosition;
WriteComponent(Instance);
{ calculate size }
s:=GetPosition-startpos;
{ back patch size }
SetPosition(startpos-4);
WriteDWord(s);
{$endif Win16Res}
*)
end;
procedure TStream.WriteDescendent(Instance, Ancestor: TComponent);
begin
{!!!!!}
end;
procedure TStream.WriteDescendentRes(const ResName: string; Instance, Ancestor: TComponent);
begin
{!!!!!}
end;
procedure TStream.ReadResHeader;
begin
{$ifdef Win16Res}
try
{ application specific resource ? }
if ReadByte<>$ff then
raise EInvalidImage;
if ReadWord<>$000a then
raise EInvalidImage;
{ read name }
while ReadByte<>0 do
;
{ check the access specifier }
if ReadWord<>$1030 then
raise EInvalidImage;
{ ignore the size }
ReadDWord;
except
{/////
on EInvalidImage do
raise;
else
raise(EInvalidImage);
}
end;
{$endif Win16Res}
end;
function TStream.ReadByte : Byte;
var
b : Byte;
begin
ReadBuffer(b,1);
ReadByte:=b;
end;
function TStream.ReadWord : Word;
var
w : Word;
begin
ReadBuffer(w,2);
ReadWord:=w;
end;
function TStream.ReadDWord : Cardinal;
var
d : Cardinal;
begin
ReadBuffer(d,4);
ReadDWord:=d;
end;
procedure TStream.WriteByte(b : Byte);
begin
WriteBuffer(b,1);
end;
procedure TStream.WriteWord(w : Word);
begin
WriteBuffer(w,2);
end;
procedure TStream.WriteDWord(d : Cardinal);
begin
WriteBuffer(d,4);
end;
{****************************************************************************}
{* THandleStream *}
{****************************************************************************}
Procedure THandleStream.SetSize(NewSize: Longint);
begin
end;
Constructor THandleStream.Create(AHandle: Integer);
begin
end;
function THandleStream.Read(var Buffer; Count: Longint): Longint;
begin
end;
function THandleStream.Write(const Buffer; Count: Longint): Longint;
begin
end;
function THandleStream.Seek(Offset: Longint; Origin: Word): Longint;
begin
end;
{****************************************************************************}
{* TFileStream *}
{****************************************************************************}
constructor TFileStream.Create(const FileName: string; Mode: Word);
begin
end;
destructor TFileStream.Destroy;
begin
end;
{****************************************************************************}
{* TCustomMemoryStream *}
{****************************************************************************}
procedure TCustomMemoryStream.SetPointer(Ptr: Pointer; Size: Longint);
begin
end;
function TCustomMemoryStream.Read(var Buffer; Count: Longint): Longint;
begin
end;
function TCustomMemoryStream.Seek(Offset: Longint; Origin: Word): Longint;
begin
end;
procedure TCustomMemoryStream.SaveToStream(Stream: TStream);
begin
end;
procedure TCustomMemoryStream.SaveToFile(const FileName: string);
begin
end;
{****************************************************************************}
{* TMemoryStream *}
{****************************************************************************}
procedure TMemoryStream.SetCapacity(NewCapacity: Longint);
begin
end;
function TMemoryStream.Realloc(var NewCapacity: Longint): Pointer;
begin
end;
destructor TMemoryStream.Destroy;
begin
end;
procedure TMemoryStream.Clear;
begin
end;
procedure TMemoryStream.LoadFromStream(Stream: TStream);
begin
end;
procedure TMemoryStream.LoadFromFile(const FileName: string);
begin
end;
procedure TMemoryStream.SetSize(NewSize: Longint);
begin
end;
function TMemoryStream.Write(const Buffer; Count: Longint): Longint;
begin
end;
{****************************************************************************}
{* TStringStream *}
{****************************************************************************}
procedure TStringStream.SetSize(NewSize: Longint);
begin
end;
constructor TStringStream.Create(const AString: string);
begin
end;
function TStringStream.Read(var Buffer; Count: Longint): Longint;
begin
end;
function TStringStream.ReadString(Count: Longint): string;
begin
end;
function TStringStream.Seek(Offset: Longint; Origin: Word): Longint;
begin
end;
function TStringStream.Write(const Buffer; Count: Longint): Longint;
begin
end;
procedure TStringStream.WriteString(const AString: string);
begin
end;
{****************************************************************************}
{* TResourceStream *}
{****************************************************************************}
procedure TResourceStream.Initialize(Instance: THandle; Name, ResType: PChar);
begin
end;
constructor TResourceStream.Create(Instance: THandle; const ResName: string; ResType: PChar);
begin
end;
constructor TResourceStream.CreateFromID(Instance: THandle; ResID: Integer; ResType: PChar);
begin
end;
destructor TResourceStream.Destroy;
begin
end;
function TResourceStream.Write(const Buffer; Count: Longint): Longint;
begin
end;
{
$Log$
Revision 1.1 1998-05-04 14:30:12 michael
* Split file according to Class; implemented dummys for all methods, so unit compiles.
}

468
fcl/inc/strings.inc Normal file
View File

@ -0,0 +1,468 @@
{
$Id$
This file is part of the Free Component Library (FCL)
Copyright (c) 1998 by the Free Pascal development team
See the file COPYING.FPC, included in this distribution,
for details about the copyright.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
**********************************************************************}
{****************************************************************************}
{* TStrings *}
{****************************************************************************}
function TStrings.GetCommaText: string;
begin
end;
function TStrings.GetName(Index: Integer): string;
begin
end;
Function TStrings.GetValue(const Name: string): string;
begin
end;
Procedure TStrings.ReadData(Reader: TReader);
begin
end;
Procedure TStrings.SetCommaText(const Value: string);
begin
end;
Procedure TStrings.SetStringsAdapter(const Value: IStringsAdapter);
begin
end;
Procedure TStrings.SetValue(const Name, Value: string);
begin
end;
Procedure TStrings.WriteData(Writer: TWriter);
begin
end;
Procedure TStrings.DefineProperties(Filer: TFiler);
begin
end;
Procedure TStrings.Error(const Msg: string; Data: Integer);
begin
end;
Function TStrings.GetCapacity: Integer;
begin
end;
Function TStrings.GetObject(Index: Integer): TObject;
begin
end;
Function TStrings.GetTextStr: string;
begin
end;
Procedure TStrings.Put(Index: Integer; const S: string);
begin
end;
Procedure TStrings.PutObject(Index: Integer; AObject: TObject);
begin
end;
Procedure TStrings.SetCapacity(NewCapacity: Integer);
begin
end;
Procedure TStrings.SetTextStr(const Value: string);
begin
end;
Procedure TStrings.SetUpdateState(Updating: Boolean);
begin
end;
destructor TSTrings.Destroy;
begin
end;
Function TStrings.Add(const S: string): Integer;
begin
end;
Function TStrings.AddObject(const S: string; AObject: TObject): Integer;
begin
end;
Procedure TStrings.Append(const S: string);
begin
end;
Procedure TStrings.AddStrings(TheStrings: TStrings);
begin
end;
Procedure TStrings.Assign(Source: TPersistent);
begin
end;
Procedure TStrings.BeginUpdate;
begin
end;
Procedure TStrings.EndUpdate;
begin
end;
Function TStrings.Equals(TheStrings: TStrings): Boolean;
begin
end;
Procedure TStrings.Exchange(Index1, Index2: Integer);
begin
end;
Function TStrings.GetText: PChar;
begin
end;
Function TStrings.IndexOf(const S: string): Integer;
begin
end;
Function TStrings.IndexOfName(const Name: string): Integer;
begin
end;
Function TStrings.IndexOfObject(AObject: TObject): Integer;
begin
end;
Procedure TStrings.InsertObject(Index: Integer; const S: string;
AObject: TObject);
begin
end;
Procedure TStrings.LoadFromFile(const FileName: string);
begin
end;
Procedure TStrings.LoadFromStream(Stream: TStream);
begin
end;
Procedure TStrings.Move(CurIndex, NewIndex: Integer);
begin
end;
Procedure TStrings.SaveToFile(const FileName: string);
begin
end;
Procedure TStrings.SaveToStream(Stream: TStream);
begin
end;
Procedure TStrings.SetText(TheText: PChar);
begin
end;
{****************************************************************************}
{* TStringList *}
{****************************************************************************}
Procedure TStringList.ExchangeItems(Index1, Index2: Integer);
begin
end;
Procedure TStringList.Grow;
begin
end;
Procedure TStringList.QuickSort(L, R: Integer);
begin
end;
Procedure TStringList.InsertItem(Index: Integer; const S: string);
begin
end;
Procedure TStringList.SetSorted(Value: Boolean);
begin
end;
Procedure TStringList.Changed;
begin
end;
Procedure TStringList.Changing;
begin
end;
Function TStringList.Get(Index: Integer): string;
begin
end;
Function TStringList.GetCapacity: Integer;
begin
end;
Function TStringList.GetCount: Integer;
begin
end;
Function TStringList.GetObject(Index: Integer): TObject;
begin
end;
Procedure TStringList.Put(Index: Integer; const S: string);
begin
end;
Procedure TStringList.PutObject(Index: Integer; AObject: TObject);
begin
end;
Procedure TStringList.SetCapacity(NewCapacity: Integer);
begin
end;
Procedure TStringList.SetUpdateState(Updating: Boolean);
begin
end;
destructor TStringList.Destroy;
begin
end;
Function TStringList.Add(const S: string): Integer;
begin
end;
Procedure TStringList.Clear;
begin
end;
Procedure TStringList.Delete(Index: Integer);
begin
end;
Procedure TStringList.Exchange(Index1, Index2: Integer);
begin
end;
Function TStringList.Find(const S: string; var Index: Integer): Boolean;
begin
end;
Function TStringList.IndexOf(const S: string): Integer;
begin
end;
Procedure TStringList.Insert(Index: Integer; const S: string);
begin
end;
Procedure TStringList.Sort;
begin
end;
{
$Log$
Revision 1.1 1998-05-04 14:30:12 michael
* Split file according to Class; implemented dummys for all methods, so unit compiles.
}

96
fcl/inc/thread.inc Normal file
View File

@ -0,0 +1,96 @@
{
$Id$
This file is part of the Free Component Library (FCL)
Copyright (c) 1998 by the Free Pascal development team
See the file COPYING.FPC, included in this distribution,
for details about the copyright.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
**********************************************************************}
{****************************************************************************}
{* TThread *}
{****************************************************************************}
procedure TThread.CallOnTerminate;
begin
end;
function TThread.GetPriority: TThreadPriority;
begin
end;
procedure TThread.SetPriority(Value: TThreadPriority);
begin
end;
procedure TThread.SetSuspended(Value: Boolean);
begin
end;
procedure TThread.DoTerminate;
begin
end;
procedure TThread.Synchronize(Method: TThreadMethod);
begin
end;
constructor TThread.Create(CreateSuspended: Boolean);
begin
end;
destructor TThread.Destroy;
begin
end;
procedure TThread.Resume;
begin
end;
procedure TThread.Suspend;
begin
end;
procedure TThread.Terminate;
begin
end;
function TThread.WaitFor: Integer;
begin
end;
{
$Log$
Revision 1.1 1998-05-04 14:30:12 michael
* Split file according to Class; implemented dummys for all methods, so unit compiles.
}

205
fcl/inc/writer.inc Normal file
View File

@ -0,0 +1,205 @@
{
$Id$
This file is part of the Free Component Library (FCL)
Copyright (c) 1998 by the Free Pascal development team
See the file COPYING.FPC, included in this distribution,
for details about the copyright.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
**********************************************************************}
{****************************************************************************}
{* TWriter *}
{****************************************************************************}
Procedure TWriter.AddAncestor(Component: TComponent);
begin
end;
function TWriter.GetPosition: Longint;
begin
end;
Procedure TWriter.SetPosition(Value: Longint);
begin
end;
Procedure TWriter.WriteBuffer;
begin
end;
Procedure TWriter.WriteData(Instance: TComponent);
begin
end;
Procedure TWriter.WriteProperty(Instance: TPersistent; PropInfo: Pointer);
begin
end;
Procedure TWriter.WriteProperties(Instance: TPersistent);
begin
end;
Procedure TWriter.WritePropName(const PropName: string);
begin
end;
Procedure TWriter.WriteBinary(wd : TStreamProc);
begin
end;
Procedure TWriter.WritePrefix(Flags: TFilerFlags; AChildPos: Integer);
begin
end;
Procedure TWriter.WriteValue(Value: TValueType);
begin
end;
Destructor TWriter.Destroy;
begin
end;
Procedure TWriter.DefineProperty(const Name: string;
rd : TReaderProc; wd : TWriterProc;
HasData: Boolean);
begin
end;
Procedure TWriter.DefineBinaryProperty(const Name: string;
rd, wd: TStreamProc;
HasData: Boolean);
begin
end;
Procedure TWriter.FlushBuffer;
begin
end;
Procedure TWriter.Write(const Buf; Count: Longint);
begin
end;
Procedure TWriter.WriteBoolean(Value: Boolean);
begin
end;
Procedure TWriter.WriteCollection(Value: TCollection);
begin
end;
Procedure TWriter.WriteComponent(Component: TComponent);
begin
end;
Procedure TWriter.WriteChar(Value: Char);
begin
end;
Procedure TWriter.WriteDescendent(Root: TComponent; AAncestor: TComponent);
begin
end;
Procedure TWriter.WriteFloat(Value: Extended);
begin
end;
Procedure TWriter.WriteIdent(const Ident: string);
begin
end;
Procedure TWriter.WriteInteger(Value: Longint);
begin
end;
Procedure TWriter.WriteListBegin;
begin
end;
Procedure TWriter.WriteListEnd;
begin
end;
Procedure TWriter.WriteRootComponent(Root: TComponent);
begin
end;
Procedure TWriter.WriteSignature;
begin
end;
Procedure TWriter.WriteStr(const Value: string);
begin
end;
Procedure TWriter.WriteString(const Value: string);
begin
end;
{
$Log$
Revision 1.1 1998-05-04 14:30:12 michael
* Split file according to Class; implemented dummys for all methods, so unit compiles.
}