Delphi does WDosX
=================
Anleitung zur Anpassung der Delphi 5.01 VCL Kern-Units an den WDosX 32bit
DOS-Extender

Versionsgeschichte
------------------
	10. Mai 2000: Originaldokument erstellt

Gliederung
	I. Voraussetzungen
	II. Vorbereitung
	III. Erstellung der Unit WDosSysUtils
	IV. Erstellung der Unit WDosClasses
	V. Erstellung der Unit WDosContnrs
	VI. Hinweise
	VII. Haftungsausschlu
	VIII. Kontakt mit dem Autor


I. Voraussetzungen
------------------
	1. Delphi 5 Professional oder Enterprise (Sourcecode der VCL
           ist erforderlich)
	2. Updatepack fr Delphi 5.01 (Professional oder Enterprise)
	3. Turbo Assembler 5 (TASM32.EXE ist erforderlich; verfgbar auf
           der Borland C++Builder 4 Professional+ CD)
	4. Die Datei LibWDos50.zip (verfgbar auf der DWP)
	5. Gesunder Menschenverstand

II. Vorbereitung
----------------
Fr die Erstellung der WDosX VCL Kern-Units empfiehlt es sich, folgende
Dateien in das Arbeitsverzeichnis $(DELPHI)\LibWDos zu kopieren:
	* WDosWinApi.pas,
	* WDosMessages.pas,
	* WDosCheck.pas,
	* WDosForms.pas (diese Dateien sind in der Zip-Datei LibWDos50.zip
          enthalten).

Weiterhin mssen folgende Dateien aus dem Verzeichnis $(DELPHI)\Source in das
Arbeitsverzeichnis kopiert werden:
	* Ffmt.asm,
	* Se.asm,
	* Classes.pas,
	* Consts.pas,
	* Contnrs.pas,
	* SysConst.pas,
	* SysUtils.pas und
	* TypInfo.pas.

Fr die erfolgreiche Assemblierung von Ffmt.obj mu der Turbo-Assembler
(TASM32.exe) im Suchpfad verfgbar sein.

III. Erstellung der Unit WDosSysUtils
-------------------------------------
Voraussetzung fr die Compilierung der Unit WDosSysUtils bildet das Vorliegen
der Datei Ffmt.obj, die leider nicht Bestandteil der Quellcode-Bibliothek von
Delphi ist. Sie kann aber mit Hilfe des Turbo-Assemblers (TASM32.exe) aus den
Dateien Ffmt.asm und Se.asm generiert werden. Dazu ist im Arbeitsverzeichnis
folgender Befehl einzugeben:

	C:\Programme\Borland\Delphi5\LibWDos>TASM32 FFMT.ASM

Als Ergebnis erhlt man die gesuchte Datei Ffmt.obj.
Nun folgt der schwierigere Teil der Arbeit. Starten Sie Delphi und ffnen Sie
die Unit SysConst.pas im oben genannten Arbeitsverzeichnis. Speichern Sie sie
anschlieend unter dem Namen WDosSysConst.pas neu ab. Fgen Sie anschlieend
den folgenden Copyright-Vermerk ein:

  --8<-------------------BEGIN-----------------------------

  {*******************************************************}
  {                                                       }
  {       Borland Delphi Runtime Library                  }
  {                                                       }
  {       Copyright (C) 1995,99 Inprise Corporation       }
  {                                                       }
  {       modified for Delphi 4, 5 WDosX DOS-Extender     }
  {       Copyright (c) 2000 by Immo Wache                }
  {       e-mail: immo.wache@t-online.de                  }
  {                                                       }
  {*******************************************************}


  unit WDosSysConst;

  --8<-------------------END-------------------------------


Die Clausel resourcestring mu nun in der Zeile 19 stehen. Gehen Sie
anschlieend in die Zeile 51 und nehmen hier folgende nderung vor:

  --8<-------------------BEGIN-----------------------------
  (*SException = 'Exception %s in Modul %s bei %p.'#$0A'%s%s';*)
    (**)
    SException = 'Exception %s in Modul %s bei %p.'#$0A#$0D'%s%s';
    (**)
  --8<-------------------END-------------------------------


Damit sind alle notwendigen nderungen an der Datei WDosSysConst.pas
durchgefhrt. Sie knnen Sie daher abspeichern.

Das Prinzip der nderungen sollte damit klar sein: Programmteile, die nicht fr
WDosX geeignet sind, werden mit den Kommentarzeichen (* und *) auskommentiert.
Zustzlich eingefgter Quelltext wird durch leere Kommentare (**) vor und
hinter dem eingefgten Text gekennzeichnet.

Nun knnen wir uns an die Erstellung der eigentlichen Unit dieses Kapitels
heranmachen. ffnen Sie dazu die Unit SysUtils.pas im oben genannten
Arbeitsverzeichnis. Speichern Sie sie nun unter dem Namen WDosSysUtils.pas ab.
Fgen Sie anschlieend folgenden Copyright-Vermerk ein:

  --8<-------------------BEGIN-----------------------------

  {*******************************************************}
  {                                                       }
  {       Borland Delphi Runtime Library                  }
  {       System Utilities Unit                           }
  {                                                       }
  {       Copyright (C) 1995,99 Inprise Corporation       }
  {                                                       }
  {       modified for Delphi 4, 5 WDosX DOS-Extender     }
  {       Copyright (c) 2000 by Immo Wache                }
  {       e-mail: immo.wache@t-online.de                  }
  {                                                       }
  {*******************************************************}



  unit WDosSysUtils;
  --8<-------------------END-------------------------------


Die uses-Clausel mu nun in der Zeile 23 stehen. ndern Sie diese wie folgt ab:

  --8<-------------------BEGIN-----------------------------
  uses (*Windows, SysConst*) (**)WDosWinApi, WDosSysConst(**);
  --8<-------------------END-------------------------------


Gehen Sie anschlieend zur Zeile 186 und fgen Sie einen Kommentarbeginn ein:

  --8<-------------------BEGIN-----------------------------
  (*
  { This is used by TLanguages }
  In der Zeile 217 endet der Kommentar:
      property Ext[Index: Integer]: string read GetExt;
    end;
  *)
  --8<-------------------END-------------------------------


Weiter geht es in der Zeile 491. Kommentieren Sie die Funktion Languages aus:

  --8<-------------------BEGIN-----------------------------
  (*
  function Languages: TLanguages;
  *)
  --8<-------------------END-------------------------------


In der Zeile 928 mu die Funktion ExpandUNCFileName  auskommentiert werden:

  --8<-------------------BEGIN-----------------------------
  (*
  function ExpandUNCFileName(const FileName: string): string;
  *)
  --8<-------------------END-------------------------------


In der Zeile 942 wird die Funktion ExtractShortPathName auskommentiert:

  --8<-------------------BEGIN-----------------------------
  (*
  function ExtractShortPathName(const FileName: string): string;
  *)
  --8<-------------------END-------------------------------


Gehen Sie nun zur Zeile 2161 und fgen Sie einen Kommentarbeginn ein:

  --8<-------------------BEGIN-----------------------------
  (*
  { Thread synchronization }
  In der Zeile 2197 endet der Kommentar:
      procedure EndWrite;
    end;
  *)
  --8<-------------------END-------------------------------


Weiter geht es im Implementierungsteil in der Zeile 2518. Ersetzen Sie die
Funktionen AnsiStrLower und AnsiStrUpper wie folgt:

  --8<-------------------BEGIN-----------------------------
  function AnsiStrLower(Str: PChar): PChar;
  begin
  (*
    CharLower(Str);
    Result := Str;
  *)
  (**)
    Result :=StrLower(Str);
  (**)
  end;

  function AnsiStrUpper(Str: PChar): PChar;
  begin
  (*
    CharUpper(Str);
    Result := Str;
  *)
  (**)
    Result :=StrUpper(Str);
  (**)
  end;
  --8<-------------------END-------------------------------


Weiter geht es in der Zeile 2895, sie mu wie folgt lauten:

  --8<-------------------BEGIN-----------------------------
  (*Windows*) WDosWinApi.FindClose(Handle);
  --8<-------------------END-------------------------------


Gleiches gilt fr die Zeilen 2993 und 3000. Hier mu ebenfalls der Bezug auf
die Windows-Unit gendert werden:

  --8<-------------------BEGIN-----------------------------
  (*Windows*) WDosWinApi.FindClose(F.FindHandle);
  ...
  Result := (*Windows*) WDosWinApi.DeleteFile(PChar(FileName));
  --8<-------------------END-------------------------------


Gehen Sie anschlieend zur Zeile 3124 und kommentieren Sie die Funktionen
GetUniversalName und ExpandUNCFileName aus (bis Zeile 3194):

  --8<-------------------BEGIN-----------------------------
  (*
  function GetUniversalName(const FileName: string): string;
  ...
      Result := GetUniversalName(Result);
  end;
  *)
  --8<-------------------END-------------------------------


Anschlieend strt uns die Funktion ExtractShortPathName. Kommentieren Sie sie
ebenfalls in Zeile 3253 bis 3261 aus:

  --8<-------------------BEGIN-----------------------------
  (*
  function ExtractShortPathName(const FileName: string): string;
  ...
      GetShortPathName(PChar(FileName), Buffer, SizeOf(Buffer)));
  end;
  *)
  --8<-------------------END-------------------------------


In der Zeile 6073 mu der DebugHook auf 1 gesetzt werden, damit Delphi die
Laufzeit-Exceptions auch selbst behandelt und keinen externen Debugger aufruft:

  --8<-------------------BEGIN-----------------------------
    AbstractErrorProc := @AbstractErrorHandler;
    (**)
    DebugHook := 1; { forces Delphi5 exe to handle exceptions him self }
    (**)
  end;
  --8<-------------------END-------------------------------


Zur Abwechslung etwas Musik, die Prozedur Beep mu gendert werden:

  --8<-------------------BEGIN-----------------------------
  procedure Beep;
  begin
  (*
    MessageBeep(0);
  *)
    Write(#07);
  end;
  --8<-------------------END-------------------------------


Nun geht es in der Zeile 6378 weiter; die Prozedur InitSysLocale mu etwas
modifiziert werden. Zunchst der var-Abschnitt:

  --8<-------------------BEGIN-----------------------------
  procedure InitSysLocale;
  var
    DefaultLCID: LCID;
    DefaultLangID: LANGID;
  (*
    AnsiCPInfo: TCPInfo;
    I: Integer;
    J: Byte;
  *)
  --8<-------------------END-------------------------------


Anschlieend noch etwas in der Implementierung ab Zeile 6401 auskommentieren:

  --8<-------------------BEGIN-----------------------------
    SysLocale.FarEast := GetSystemMetrics(SM_DBCSENABLED) <> 0;
  (*
    if not SysLocale.FarEast then Exit;

    GetCPInfo(CP_ACP, AnsiCPInfo);
    with AnsiCPInfo do
    begin
      I := 0;
      while (I < MAX_LEADBYTES) and ((LeadByte[I] or LeadByte[I+1]) <> 0) do
      begin
        for J := LeadByte[I] to LeadByte[I+1] do
          Include(LeadBytes, Char(J));
        Inc(I,2);
      end;
    end;
  *)
  end;
  --8<-------------------END-------------------------------


In der Zeile 6664 ist mal wieder ein Windows-Bezug zu entfernen:

  --8<-------------------BEGIN-----------------------------
  SetString(Result, ModName, (*Windows*) WDosWinApi.GetModuleFileName(Module,
      ModName, SizeOf(ModName)));
  --8<-------------------END-------------------------------


Auf der Zeile 7077 das selbe Problem:

  --8<-------------------BEGIN-----------------------------
  Kernel := GetModuleHandle((*Windows*) WDosWinApi.Kernel32);
  --8<-------------------END-------------------------------


Gleich anschlieend in Zeile 7084 beginnt die Implementierung des nicht
verwendbaren TMultiReadExclusiveWriteSynchronizer. Also auskommentieren:

  --8<-------------------BEGIN-----------------------------
  (*
  { TMultiReadExclusiveWriteSynchronizer }
  --8<-------------------END-------------------------------


und zwar bis Zeile 7241:

  --8<-------------------BEGIN-----------------------------
      if (InterlockedDecrement(FCount) = 0) or WriterIsOnlyReader then
        SetEvent(FReadExit);     // release next writer
    end;
  end;
  *)
  --8<-------------------END-------------------------------


Weiter geht's in Zeile 7267 mit der Klasse TLanguages:

  --8<-------------------BEGIN-----------------------------
  (*
  { TLanguages }
  Diese endet in Zeile 7395:
    Result := FLanguages;
  end;
  *)
  --8<-------------------END-------------------------------


Nun noch schnell ein paar Modifikationen an SafeLoadLibrary ab Zeile 7399:

  --8<-------------------BEGIN-----------------------------
  function SafeLoadLibrary(const Filename: string; ErrorMode: UINT): HMODULE;
  var
  (*
    OldMode: UINT;
  *)
    FPUControlWord: Word;
  begin
  (*
    OldMode := SetErrorMode(ErrorMode);
  *)
    try
      asm
      end;
      try
        Result := LoadLibrary(PChar(Filename));
      finally
      end;
    finally
  (*
      SetErrorMode(OldMode);
  *)
    end;
  end;
  --8<-------------------END-------------------------------


Und als krnendes Finale ab Zeile 7433 den finalization-Abschnitt leicht
modifizieren:

  --8<-------------------BEGIN-----------------------------
  finalization
  (*
    FreeAndNil(FLanguages);
  *)
    FreeTerminateProcs;
    DoneExceptions;
  --8<-------------------END-------------------------------


Herzlichen Glckwunsch. Damit sind Sie stolzer Besitzer des Quellcodes von
WDosSysUtils. Zum Test sollten Sie jetzt eine kleine Konsolen-Applikation
schreiben, die die Unit WDosSysUtils verwendet. Diese wird nun (hoffentlich)
fehlerfrei bersetzt.
Damit knnen wir nun zum zweiten Teil des Abends bergehen, die Unit
WDosClasses.

IV. Erstellung der Unit WDosClasses
-----------------------------------
ffnen Sie die Unit Consts.pas im oben genannten Arbeitsverzeichnis.
Speichern Sie sie anschlieend unter dem Namen WDosConsts.pas neu ab.
Fgen Sie anschlieend den folgenden Copyright-Vermerk ein:

  --8<-------------------BEGIN-----------------------------

  {*******************************************************}
  {                                                       }
  {       Borland Delphi Visual Component Library         }
  {                                                       }
  {       Copyright (c) 1995,99 Inprise Corporation       }
  {                                                       }
  {       modified for Delphi 4, 5 WDosX DOS-Extender     }
  {       Copyright (c) 2000 by Immo Wache                }
  {       e-mail: immo.wache@t-online.de                  }
  {                                                       }
  {*******************************************************}


  unit WDosConsts;
  --8<-------------------END-------------------------------


Damit sind bereits alle notwendigen nderungen an der Datei WDosSysConst.pas
durchgefhrt. Sie knnen Sie daher abspeichern.

Weiter geht's mit der Unit TypInfo.pas. ffnen Sie diese unter Delphi und
speichern Sie sie anschlieend unter dem Namen WDosTypInfo.pas wieder ab.
Fgen Sie anschlieend den folgenden Copyright-Vermerk ein:

  --8<-------------------BEGIN-----------------------------

  {*******************************************************}
  {                                                       }
  {       Borland Delphi Visual Component Library         }
  {                                                       }
  {       Copyright (c) 1995,99 Inprise Corporation       }
  {                                                       }
  {       modified for Delphi 4, 5 WDosX DOS-Extender     }
  {       Copyright (c) 2000 by Immo Wache                }
  {       e-mail: immo.wache@t-online.de                  }
  {                                                       }
  {*******************************************************}


  unit WDosTypInfo;
  --8<-------------------END-------------------------------


Die uses-Clausel mu nun in der Zeile 21 stehen. ndern Sie diese wie folgt ab:

  --8<-------------------BEGIN-----------------------------
  uses (*SysUtils*) (**)WDosSysUtils(**);
  --8<-------------------END-------------------------------


Gehen Sie anschlieend zur Zeile 268 und ndern Sie die uses-Clausel im
implementation-Abschnitt wie folgt:

  --8<-------------------BEGIN-----------------------------
  uses
    (*Consts*) WDosConsts;
  --8<-------------------END-------------------------------


Damit sind auch hier alle notwendigen Modifikationen durchgefhrt.
Speichern Sie die Unit ab und ffnen Sie anschlieend die Haupt-Unit dieses
Abschnitts, also Classes.pas. Speichern Sie diese anschlieend unter dem Namen
WDosClasses.pas wieder ab. Geben sie anschlieend den folgenden
Copyright-Vermerk ein:

  --8<-------------------BEGIN-----------------------------

  {*******************************************************}
  {                                                       }
  {       Borland Delphi Visual Component Library         }
  {                                                       }
  {       Copyright (c) 1995,99 Inprise Corporation       }
  {                                                       }
  {       modified for Delphi 4, 5 WDosX DOS-Extender     }
  {       Copyright (c) 2000 by Immo Wache                }
  {       e-mail: immo.wache@t-online.de                  }
  {                                                       }
  {*******************************************************}


  unit WDosClasses;
  --8<-------------------END-------------------------------


Damit steht nun die erste uses-Clausel in der Zeile 25.
ndern Sie diese wie folgt:

  --8<-------------------BEGIN-----------------------------
  uses (*SysUtils, Windows, ActiveX*) (**)WDosSysUtils, WDosWinApi(**);
  --8<-------------------END-------------------------------


Wie sie daraus erkennen knnen, steht unter WDosX leider keine
ActiveX-Untersttzung zur Verfgung.

Weiter geht es in der Zeile 621. Die Klasse TStreamAdapter ist leider nicht
verwendbar:

  --8<-------------------BEGIN-----------------------------
  (*
  { TStreamAdapter }
  { Implements OLE IStream on VCL TStream }
  --8<-------------------END-------------------------------


Der auskommentierte Abschnitt endet in Zeile 655:

  --8<-------------------BEGIN-----------------------------
      property StreamOwnership: TStreamOwnership read FOwnership write FOwnership;
    end;
  *)
  --8<-------------------END-------------------------------


In der Zeile 912 geht es mit der Klasse TThread weiter. Auch diese mu leider
auskommentiert werden:

  --8<-------------------BEGIN-----------------------------
  (*
  { TThread }

    EThread = class(Exception);
  --8<-------------------END-------------------------------


Der Deklarationsteil von TThread endet in Zeile 957:

  --8<-------------------BEGIN-----------------------------
      property OnTerminate: TNotifyEvent read FOnTerminate write FOnTerminate;
    end;
  *)
  --8<-------------------END-------------------------------


Weiterhin strt in der Zeile 1177 die globale Variable GlobalNameSpace:

  --8<-------------------BEGIN-----------------------------
  (*
  var
    GlobalNameSpace: TMultiReadExclusiveWriteSynchronizer;
  *)
  --8<-------------------END-------------------------------

In der Zeile 1210 mu zustzlich die Funktion ReadInheritedComponentResFiles
eingefgt werden. Diese dient im Zusammenhang mit der Unit WDosForms dazu,
die Ressourcendateien der Formulare (*.dfm) des Projekts in die entstechenden
TForm-Objekte einzulesen.

  --8<-------------------BEGIN-----------------------------
  procedure WriteComponentResFile(const FileName: string; Instance: TComponent);
  (**)
  procedure ReadInheritedComponentResFiles(Instance: TComponent;
      RootAncestor: TClass);
  (**)
  --8<-------------------END-------------------------------


Die uses-Clausel im implementation-Abschnitt (Zeile 1265) mu wie folgt
gendert werden:

  --8<-------------------BEGIN-----------------------------
  uses (*Consts, TypInfo*) (**)WDosConsts, WDosTypInfo(**);
  --8<-------------------END-------------------------------


Smtliche Bezge auf GlobalNameSpace mssen auskommentiert werden. Die
entsprechenden Zeilen finden sich bei 1646 und 1659.
Folgender Quelltextauszug demonstriert die Vorgehensweise:

  --8<-------------------BEGIN-----------------------------
  (*
    GlobalNameSpace.BeginWrite;
  *)
  ...
    finally
  (*
      GlobalNameSpace.EndWrite;
  *)
    end;
  --8<-------------------END-------------------------------


In Zeile 1717 erfolgt im Anschlu an die Funktion WriteComponentResFile die
Implementierung der zustzlichen Funktion ReadInheritedComponentResFiles wie
folgt:

  --8<-------------------BEGIN-----------------------------
  (**)
  procedure ReadInheritedComponentResFiles(Instance: TComponent;
      RootAncestor: TClass);

    function InitComponent(ClassType: TClass): Boolean;
    var
      pTd: PTypeData;
      FileName: string;
    begin
      Result := False;
      if (ClassType = TComponent) or (ClassType = RootAncestor) then Exit;
      Result := InitComponent(ClassType.ClassParent);

      pTd := GetTypeData(ClassType.ClassInfo);
      FileName := pTd^.UnitName + '.dfm';
      try
        Instance := ReadComponentResFile(FileName, Instance);
      except
        raise EResNotFound.CreateFmt(SResNotFound, [FileName]);
      end;
    end;

  var
    LocalizeLoading: Boolean;
  begin
    LocalizeLoading := (Instance.ComponentState * [csInline, csLoading]) = [];
    if LocalizeLoading then BeginGlobalLoading;  // push new loadlist onto stack
    try
      InitComponent(Instance.ClassType);
      if LocalizeLoading then NotifyGlobalLoading;  // call Loaded
    finally
      if LocalizeLoading then EndGlobalLoading;  // pop loadlist off stack
    end;
  end;
  (**)
  --8<-------------------END-------------------------------


Ab Zeile 4146, 4196, 5091 und 5139 mssen wieder die Bezge auf GlobalNameSpace 
auskommentiert werden.


Zur Abwechslung wird ab Zeile 7307 die Implementierung von TTread
auskommentiert:

  --8<-------------------BEGIN-----------------------------
  (*
  { Thread management routines }
  ...
      ExceptionRecord: PExceptionRecord;
    end;
  *)

  var
    ThreadLock: TRTLCriticalSection;
  (*
    ThreadWindow: HWND;
  ...
  --8<-------------------END-------------------------------


Hier ist zu beachten, da die Variable ThreadLock nicht auskommentiert werden
darf. TThread endet in der Zeile 7547:

  --8<-------------------BEGIN-----------------------------
    GetExitCodeThread(H, Result);
  end;
  *)
  --8<-------------------END-------------------------------


Die Implementation von TStreamAdapter beginnt ab Zeile 8201:

  --8<-------------------BEGIN-----------------------------
  (*
  { TStreamAdapter }
  --8<-------------------END-------------------------------


und endet in der Zeile 8386 mit:

  --8<-------------------BEGIN-----------------------------
    Result := E_NOTIMPL;
  end;
  *)
  --8<-------------------END-------------------------------


Der vorletzte Streich erfolgt im initialization-Abschnitt in Zeile 8410 mit:

  --8<-------------------BEGIN-----------------------------
    AddModuleUnloadProc(ModuleUnload);
  (*
    GlobalNameSpace := TMultiReadExclusiveWriteSynchronizer.Create;
  *)
    ClassList := TThreadList.Create;
  --8<-------------------END-------------------------------


Und den krnenden Abschlu bildet der finalization-Abschnitt in Zeile 8420
und 8430 mit:

  --8<-------------------BEGIN-----------------------------
  finalization
    UnRegisterModuleClasses(HInstance);
  (*
    GlobalNameSpace.BeginWrite;
  *)
    FreeIntConstList;
  ...
    GlobalLists.Free;
  (*
    FreeThreadWindow;
    GlobalNameSpace.Free;
    GlobalNameSpace := nil;
  *)
    RemoveModuleUnloadProc(ModuleUnload);
  --8<-------------------END-------------------------------


Noch einmal Herzlichen Glckwunsch, wenn Sie es bis hier geschafft haben.
Damit sind Sie nun auch stolzer Besitzer des Quellcodes von WDosClasses.pas.
Zum Test sollten Sie auch hier eine kleine Konsolen-Applikation schreiben,
die die Unit WDosClasses verwendet. Diese wird nun (hoffentlich) fehlerfrei
bersetzt.

V. Erstellung der Unit WDosContnrs
----------------------------------
Da wir gerade dabei sind, empfiehlt es sich, auch die Unit Contnrs.pas fr
WDosX anzupassen. Diese Unit ist recht ntzlich fr den Umgang mit Objekt-
und Komponentenlisten und wird darber hinaus fr die Komponente
TwdxApplicationEvents bentigt. Die Anpassung ist im Vergleich zu WDosSysUtils
und WDosClasses ganz einfach.
ffnen Sie die Datei Contnrs.pas unter Delphi und speichern Sie sie
anschlieend unter dem Namen WDosCntnrs.pas wieder ab. Fgen Sie anschlieend
den folgenden Copyright-Vermerk ein:

  --8<-------------------BEGIN-----------------------------
  {*******************************************************}
  {                                                       }
  {       Borland Delphi Visual Component Library         }
  {                                                       }
  {       Copyright (c) 1995,99 Inprise Corporation       }
  {                                                       }
  {       modified for Delphi 4, 5 WDosX DOS-Extender     }
  {       Copyright (c) 2000 by Immo Wache                }
  {       e-mail: immo.wache@t-online.de                  }
  {                                                       }
  {*******************************************************}

  unit WDosContnrs;
  --8<-------------------END-------------------------------


Die uses-Clausel mu nun in den Zeilen 17 und 18 stehen. ndern Sie diese wie
folgt ab:

  --8<-------------------BEGIN-----------------------------
  uses
    (*SysUtils, Classes*) (**)WDosSysUtils, WDosClasses(**);
  --8<-------------------END-------------------------------


So, das war schon alles. Damit ist die Erstellung der WDosX VCL Kern-Units
abgeschlossen. Weitere Hinweise zur Anwendung von WDoxX mit Delhi finden sich
im folgenden Abschnitt.

VI. Hinweise
------------
Nhere Informationen zur Anwendung von WDosX zusammen mit Delphi finden Sie
auf meiner Home-Page unter
	http://home.t-online.de/home/immo.wache/dwp/

WDosX von Michael Tippach ist unter folgender Adresse verfgbar:
	http://www.wuschel.demon.co.uk/

VII. Haftungsausschlu
----------------------
Wie blich erfolgt die Verwendung von WDosX mit Delphi auf eigenes Risiko.
Der Autor bernimmt keinerlei Haftung fr Schden die durch die Anwendung
dieser Software entstehen. Weiterhin ist zu bercksichtigen, dass Delphi
ursprnglich nicht fr die hier dargestellte Verwendung unter DOS vorgesehen
ist.

VIII. Kontakt mit dem Autor
---------------------------

	Immo Wache
	Willem-Barents-Str. 5
	D-10106 Rostock
	Germany

	e-mail:	immo.wache@t-online.de
	www:	http://home.t-online.de/home/immo.wache/dwp/

