{ ************************************************************************** }
{ OBJDOS.PAS                     Version 3.0                     (c) Mr Vain }
{                                15.07.92                                    }
{                                                                            }
{ ObjectDOS ist eine Standard-Unit zur Verwendung von Graphischen Bedien-    }
{ elementen fuer den Textmodus.                                              }
{ ************************************************************************** }
UNIT OBJDOS;

INTERFACE

USES
  CRT, DOS, OBJIO;

CONST
  left=0;
  center=1;
  right=2;

  horizontal=10;
  vertical=11;

TYPE
  { PEventRec=^TEventRec;
  TEventRec=RECORD
    EvCode: WORD;
    EvTime: LONGINT;
  END;

  PTextList=^TTextList;
  TTextList=RECORD
    Nr        : WORD;
    TextLine  : STRING;
    prev, next: PTextList;
  END;  (* TTextList *) }

  PView=^TView;
  TView=OBJECT
    PRIVATE
      X, Y, Width, Height   : BYTE;
      BackGrdCol, ForeGrdCol: BYTE;
      FillChar              : CHAR;
    PUBLIC
      CONSTRUCTOR Init(vx, vy, vw, vh,
                       vbg, vfg: BYTE;
                       vfc: CHAR);
      PROCEDURE   Draw;  VIRTUAL;
      DESTRUCTOR  Done;  VIRTUAL;
  END;  (* Obj TView *)

  PControl=^TControl;
  TControl=OBJECT(TView)
    PRIVATE
      Activate: BOOLEAN;
      MausPtr : PMaus;
    PUBLIC
      CONSTRUCTOR Init(vx, vy, vw, vh,
                       vbg, vfg: BYTE;
                       vfc: CHAR;
                       vact: BOOLEAN;
                       vmp: PMaus);
      PROCEDURE   Draw;  VIRTUAL;
      FUNCTION    IsOnMove: BOOLEAN;   VIRTUAL;
      FUNCTION    IsOnClick: BOOLEAN;  VIRTUAL;
      PROCEDURE   SetActive(IsActive: BOOLEAN);  VIRTUAL;
      DESTRUCTOR  Done;  VIRTUAL;
  END;  (* Obj TControl(TView) *)

  PDesktop=^TDesktop;
  TDesktop=OBJECT(TControl)
    PRIVATE
      blink: BOOLEAN;
    PRIVATE
      PROCEDURE   BlinkON;
      PROCEDURE   BlinkOFF;
    PUBLIC
      CONSTRUCTOR Init(vbg, vfg: BYTE;
                       vch: CHAR; vbl: BOOLEAN;
                       vmp: PMaus);
      PROCEDURE   SetDesktopColor(bc, fc: BYTE);
      PROCEDURE   Draw;  VIRTUAL;
      DESTRUCTOR  Done;  VIRTUAL;
  END;  (* Obj TDesktop(TControl) *)

  PStatusLine=^TStatusLine;
  TStatusLine=OBJECT(TControl)
    PRIVATE
      StatusLineText: STRING;
    PUBLIC
      CONSTRUCTOR Init(vbg, vfg: BYTE;
                       vtxt: STRING;
                       vmp: PMaus);
      PROCEDURE   ClrStatusLine;
      PROCEDURE   SetStatusLineColor(bc, fc: BYTE);
      PROCEDURE   ShowDate(vx, vy: BYTE);
      PROCEDURE   ShowTime(vx, vy: BYTE);
      PROCEDURE   WriteText(vtxt: STRING; vjust: BYTE);
      PROCEDURE   WriteTextAt(vx: BYTE; vtxt: STRING);
      PROCEDURE   Draw;  VIRTUAL;
      DESTRUCTOR  Done;  VIRTUAL;
  END;  (* Obj TStatusLine(TControl) *)

  PWindow=^TWindow;
  TWindow=OBJECT(TControl)
    PRIVATE
      Title                   : STRING;
      TitleForeGrdCol         : BYTE;
      TitleBackGrdCol         : BYTE;
      Left, Top, Right, Bottom: BYTE;
    PUBLIC
      CONSTRUCTOR Init(vx, vy, vw, vh: BYTE;
                       vt: STRING;
                       vact: BOOLEAN;
                       vmp: PMaus);
      PROCEDURE   Draw;  VIRTUAL;
      PROCEDURE   SetActive(IsActive: BOOLEAN);  VIRTUAL;
      PROCEDURE   SetWindowColor(bc, fc: BYTE);
      PROCEDURE   SetWindowTitleColor(bc, fc: BYTE);
      PROCEDURE   WriteText(lin, col, just: BYTE; zeile: STRING);  VIRTUAL;
      DESTRUCTOR  Done;  VIRTUAL;
  END;  (* Obj TWindow(TControl) *)
  {
  PSchaltflaeche=^TSchaltflaeche;
  TSchaltflaeche=OBJECT(TView)
    caption            : STRING;
    CONSTRUCTOR Init(vx, vy, vw, vh, vbg, vfg: BYTE; vcap: STRING; vmp: PMaus);
    PROCEDURE Draw; VIRTUAL;
    FUNCTION MouseDown(EvVar, Code: WORD): BOOLEAN; VIRTUAL;
    DESTRUCTOR Done; VIRTUAL;
  END;  (* TSchaltflaeche *)

  PEdit=^TEdit;
  TEdit=OBJECT(TView)
    caption         : STRING;
    CONSTRUCTOR Init(vx, vy, vw, vbg, vfg: BYTE; vcap: STRING; vmp: PMaus);
    PROCEDURE Draw; VIRTUAL;
    FUNCTION ReadText(vorgabe: STRING; stellen, wo: BYTE): STRING; VIRTUAL;
    DESTRUCTOR Done; VIRTUAL;
  END;  (* TEdit *)

  PPanel=^TPanel;
  TPanel=OBJECT(TView)
    relief             : BYTE;
    caption            : STRING;
    CONSTRUCTOR Init(vx, vy, vw, vh, vbg, vfg, vrel: BYTE; vcap: STRING; vmp: PMaus);
    PROCEDURE Draw; VIRTUAL;
    DESTRUCTOR Done; VIRTUAL;
  END;  (* TPanel *)

  PProgressBar=^TProgressBar;
  TProgressBar=OBJECT(TView)
    frmcol, textcol    : BYTE;
    rangemin, rangemax : REAL;
    CONSTRUCTOR Init(vx, vy, vw, vh, vbg, vfg, vr, vt: BYTE;
                     vrgmin, vrgmax: REAL; vmp: PMaus);
    PROCEDURE Draw; VIRTUAL;
    PROCEDURE DrawBar(percent: REAL); VIRTUAL;
    DESTRUCTOR Done; VIRTUAL;
  END;  (* TProgressBar *)

  PLabel=^TLabel;
  TLabel=OBJECT(TView)
    caption: STRING;
    CONSTRUCTOR Init(vx, vy, vbg, vfg: BYTE; vcap: STRING; vmp: PMaus);
    PROCEDURE Draw; VIRTUAL;
    DESTRUCTOR Done; VIRTUAL;
  END;  (* TLabel *)

  PCheckBox=^TCheckBox;
  TCheckBox=OBJECT(TView)
    caption     : STRING;
    active      : BOOLEAN;
    keycode     : WORD;
    HLkey, HLcol: BYTE;
    CONSTRUCTOR Init(vx, vy, vbg, vfg, vhlc: BYTE; vcap: STRING;
                     vact: BOOLEAN; vmp: PMaus);
    PROCEDURE Draw; VIRTUAL;
    PROCEDURE Check(EvKey: WORD); VIRTUAL;
    DESTRUCTOR Done; VIRTUAL;
  END;  (* TCheckBox *)

  PMemo=^TMemo;
  TMemo=OBJECT(TView)
    HeadPtr, Current: PTextList;
    NrOfLines       : WORD;
    minLine, maxLine: WORD;
    CONSTRUCTOR Init(vx, vy, vw, vh, vbg, vfg: BYTE; vmp: PMaus);
    PROCEDURE Draw; VIRTUAL;
    PROCEDURE AddLine(zeile: STRING); VIRTUAL;
    PROCEDURE PrintList; VIRTUAL;
    PROCEDURE DeleteLine; VIRTUAL;
    PROCEDURE DeleteList; VIRTUAL;
    PROCEDURE ScrollList(EvVar: WORD); VIRTUAL;
    DESTRUCTOR Done; VIRTUAL;
  END;  (* TMemo *)

  PScrollBar=^TScrollBar;
  TScrollBar=OBJECT(TView)
    min, max, position, interval: REAL;
    sbKind                      : BYTE;
    CONSTRUCTOR Init(vx, vy, vw, vbg, vfg, vkind: BYTE; vmp: PMaus;
                     vmin, vmax, vpos, vint: REAL);
    PROCEDURE Draw; VIRTUAL;
    PROCEDURE Change(EvVar: WORD); VIRTUAL;
    DESTRUCTOR Done; VIRTUAL;
  END;  (* TScrollBar *)

  PGroupBox=^TGroupBox;
  TGroupBox=OBJECT(TView)
    caption: STRING;
    CONSTRUCTOR Init(vx, vy, vw, vh, vbg, vfg: BYTE; vcap: STRING; vmp: PMaus);
    PROCEDURE Draw; VIRTUAL;
    DESTRUCTOR Done; VIRTUAL;
  END;  (* TGroupBox *)

  PSubMenuList=^TSubMenuList;
  TSubMenuList=RECORD
    SubItemName: STRING;
    ItemNr     : BYTE;
    posx, posy : BYTE;
    Next       : PSubMenuList;
  END;  (* TSubMenuList *)

  PMenuList=^TMenuList;
  TMenuList=RECORD
    ItemName    : STRING;
    ItemNr      : BYTE;
    cmCode      : WORD;
    HLkey, HLcol: BYTE;
    SubItemPtr  : PSubMenuList;
    posx, posy  : BYTE;
    SubItems    : BYTE;
    Next        : PMenuList;
  END;  (* TMenuList *)

  PMainMenu=^TMainMenu;
  TMainMenu=OBJECT(TView)
    MaxItem    : BYTE;
    MaxSubItem : BYTE;
    CurrentMain: BYTE;
    CurrentSub : BYTE;
    Items      : PMenuList;
    hlightcol  : BYTE;
    menuHLcol  : BYTE;
    BackgrdBox : PBox;
    CONSTRUCTOR Init(vx, vy, vw, vbg, vfg, vhl, vmhlc: BYTE; vmp: PMaus);
    FUNCTION NewMenu(Name: STRING; cd: WORD; SubPtr: PSubMenuList; NextPtr: PMenuList): PMenuList; VIRTUAL;
    FUNCTION NewSubMenu(Name: STRING; NextPtr: PSubMenuList): PSubMenuList; VIRTUAL;
    FUNCTION GetMenuItem(nr: BYTE): PMenuList; VIRTUAL;
    FUNCTION GetSubMenuItem(nr: BYTE): PSubMenuList; VIRTUAL;
    FUNCTION MouseDown(EvVar, Code: WORD): BOOLEAN; VIRTUAL;
    FUNCTION Change(EV: WORD): BYTE; VIRTUAL;
    PROCEDURE Create; VIRTUAL;
    PROCEDURE DeleteMenu; VIRTUAL;
    PROCEDURE Draw; VIRTUAL;
    DESTRUCTOR Done; VIRTUAL;
  END;  (* TMainMenu *)
}
  PComponent=^TComponent;
  TComponent=RECORD
    Element   : PControl;
    Index     : BYTE;
    Prev, Next: PComponent;
  END;  (* Rec TComponent *)

  PCompList=^TCompList;
  TCompList=OBJECT
    PRIVATE
      Head, Tail: PComponent;
      CompIndex : BYTE;
      MausPtr   : PMaus;
    PRIVATE
      PROCEDURE   DeleteList;
      FUNCTION    FindComp(Node: PControl): PComponent;
      FUNCTION    GetCompIndex(Node: PComponent): BYTE;
      FUNCTION    GetNumberOfComp: BYTE;
      PROCEDURE   InsertAfterHead(Node: PComponent);
    PUBLIC
      CONSTRUCTOR Init(vmp: PMaus);
      PROCEDURE   DeleteComp(Node: PControl);
      PROCEDURE   InsertComp(Node: PControl);
      FUNCTION    CheckOnClick: PControl;
      PROCEDURE   Draw;
      DESTRUCTOR  Done;
  END;  (* Obj TCompList *)

VAR
  CompList: PCompList;

IMPLEMENTATION

CONSTRUCTOR TCompList.Init(vmp: PMaus);
BEGIN
  Head:=NIL;  Tail:=NIL;
  CompIndex:=0;
  MausPtr:=vmp;
END;

PROCEDURE TCompList.DeleteComp(Node: PControl);
VAR
  hilf, Vor, Nach: PComponent;
BEGIN
  hilf:=FindComp(Node);

  IF (hilf=NIL) THEN EXIT;

  Vor:=hilf^.Prev;
  Nach:=hilf^.Next;

  IF (Vor=NIL) THEN BEGIN
    Nach^.Prev:=NIL;
    Head:=Nach;
  END  (* IF *)
  ELSE Nach^.Prev:=hilf^.Prev;

  IF (Nach=NIL) THEN BEGIN
    Vor^.Next:=NIL;
    Tail:=Vor;
  END  (* IF *)
  ELSE Vor^.Next:=hilf^.Next;

  DISPOSE(hilf);
  DEC(CompIndex,1);
END;

FUNCTION TCompList.FindComp(Node: PControl): PComponent;
VAR
  hilf: PComponent;
BEGIN
  hilf:=Head;
  WHILE (NOT(hilf=NIL) AND NOT(hilf^.Element=Node)) DO hilf:=hilf^.Next;
  FindComp:=hilf;
END;

FUNCTION TCompList.GetNumberOfComp: BYTE;
BEGIN
  GetNumberOfComp:=CompIndex;
END;

PROCEDURE TCompList.DeleteList;
VAR
  hilf: PComponent;
BEGIN
  WHILE NOT(Head=NIL) DO BEGIN
    hilf:=Head;
    Head:=Head^.next;
    DISPOSE(hilf);
  END;  (* WHILE *)
  Tail:=NIL;
  CompIndex:=0;
END;

FUNCTION TCompList.GetCompIndex(Node: PComponent): BYTE;
BEGIN
  { GetCompIndex:=FindComp(Node)^.Index; }
  GetCompIndex:=Node^.Index;
END;

PROCEDURE TCompList.InsertComp(Node: PControl);
VAR
  hilf: PComponent;
BEGIN
  INC(CompIndex,1);
  NEW(hilf);
  hilf^.Element:=Node;
  hilf^.Index:=CompIndex;
  IF (Head=NIL) THEN BEGIN
    hilf^.Next:=NIL;
    hilf^.Prev:=NIL;
    Head:=hilf;
    Tail:=Head;
  END  (* IF *)
  ELSE IF ((Head=Tail) AND NOT(Head=NIL)) THEN BEGIN
    hilf^.Next:=Tail;
    hilf^.Prev:=NIL;
    Tail^.Prev:=hilf;
    Head:=hilf;
  END (* ELSE IF *)
  ELSE BEGIN
    hilf^.Next:=Head;
    hilf^.Prev:=NIL;
    Head^.Prev:=hilf;
    Head:=hilf;
  END;  (* ELSE *)
END;

FUNCTION TCompList.CheckOnClick: PControl;
VAR
  hilf: PComponent;
BEGIN
  hilf:=Head;

  WHILE NOT(hilf=NIL) DO BEGIN
    IF (hilf^.Element^.IsOnClick) THEN BEGIN
      CheckOnClick:=hilf^.Element;
      IF NOT(TypeOf(hilf^.Element^)=TypeOf(TDesktop)) THEN
        InsertAfterHead(hilf);
      EXIT;
    END  (* IF *)
    ELSE hilf:=hilf^.Next;
  END;  (* WHILE NOT(hilf) *)

  CheckOnClick:=NIL
END;

PROCEDURE TCompList.InsertAfterHead(Node: PComponent);
VAR
  hilf, rett, Current: PComponent;
BEGIN
  rett:=Node;
  DeleteComp(Node^.Element);
  { InsertComp(rett^.Element); }

  Current:=Head^.Next;
  NEW(hilf);
  hilf^.Element:=rett^.Element;
  hilf^.Index:=rett^.Index;

  Current^.Prev:=hilf;
  hilf^.Next:=Current;
  hilf^.Prev:=Head;
  Head^.Next:=hilf;
END;

PROCEDURE TCompList.Draw;
VAR
  hilf: PComponent;
BEGIN
  hilf:=Tail;
  WHILE NOT(hilf=NIL) DO BEGIN
    hilf^.Element^.Draw;
    hilf:=hilf^.Prev;
  END;  (* WHILE *)
  IF NOT(MausPtr=NIL) THEN BEGIN
    MausPtr^.SwOff;
    UpdateScreen;
    MausPtr^.SwOn;
  END;  (* IF NOT(MausPtr)=NIL *)
END;

DESTRUCTOR TCompList.Done;
BEGIN
  DeleteList;
END;

CONSTRUCTOR TView.Init(vx, vy, vw, vh, vbg, vfg: BYTE;
                      vfc: CHAR);
BEGIN
  X:=vx;  Y:=vy;  Width:=vw;  Height:=vh;
  BackGrdCol:=vbg;  ForeGrdCol:=vfg;  FillChar:=vfc;
END;

PROCEDURE TView.Draw;
BEGIN
  DrawBox(X,Y,X-1+Width,Y-1+Height,BackGrdCol*16+ForeGrdCol,FillChar);
END;

DESTRUCTOR TView.Done;
BEGIN  END;

CONSTRUCTOR TControl.Init(vx, vy, vw, vh, vbg, vfg: BYTE;
                          vfc: CHAR;
                          vact: BOOLEAN;
                          vmp: PMaus);
BEGIN
  Inherited Init(vx,vy,vw,vh,vbg,vfg,vfc);
  Activate:=vact;
  MausPtr:=vmp;
END;

PROCEDURE TControl.Draw;
BEGIN
  Inherited Draw;
END;

FUNCTION TControl.IsOnMove: BOOLEAN;
BEGIN
  IF ((MausPtr^.GetPosX > X-1) AND (MausPtr^.GetPosX < X+Width) AND
      (MausPtr^.GetPosY > Y-1) AND (MausPtr^.GetPosY < Y+Height)) THEN IsOnMove:=TRUE
  ELSE IsOnMove:=FALSE;
END;

FUNCTION TControl.IsOnClick: BOOLEAN;
BEGIN
  IF (IsOnMove AND MausPtr^.GetLastKeyLeft AND MausPtr^.GetKeyRelease)
  THEN IsOnClick:=TRUE
  ELSE IsOnClick:=FALSE;
END;

PROCEDURE TControl.SetActive(IsActive: BOOLEAN);
BEGIN
  Activate:=IsActive;
END;

DESTRUCTOR TControl.Done;
BEGIN
  Inherited Done;
END;

CONSTRUCTOR TDesktop.Init(vbg, vfg: BYTE; vch: CHAR; vbl: BOOLEAN; vmp: PMaus);
BEGIN
  Inherited Init(1,1,80,25,vbg,vfg,vch,FALSE,vmp);
  blink:=vbl;
  IF (blink=FALSE) THEN BlinkOFF ELSE BlinkON;
  Cursor(FALSE);
  { Inherited Draw; }   (* Nur den Contructor des Vorfahren aufrufen!! *)
  { Self.Draw; }        (* Hier NICHT die Draw-Methode aufrufen *)
END;

PROCEDURE TDesktop.BlinkOFF;
ASSEMBLER;     (* Assembler als reserviertes Word fuer ganze Prozedur *)
ASM            (* statt BEGIN halt ASM                                *)
  MOV AH, $10;
  MOV AL, $03;
  MOV BL, $00; (* Hexwert 0 im BL-Register stellt das Blinken ab *)
  INT $10;     (* Videointerrupt=10, Dollarzeichen=Hexzahl       *)
END;

PROCEDURE TDesktop.BlinkON;
ASSEMBLER;
ASM
  MOV AH, $10;
  MOV AL, $03;
  MOV BL, $01; (* Hexwert 1 im BL-Register stellt das Blinken an *)
  INT $10;     (* Videointerrupt=10, Dollarzeichen=Hexzahl       *)
END;

PROCEDURE TDesktop.SetDesktopColor(bc, fc: BYTE);
BEGIN
  BackGrdCol:=bc;  ForeGrdCol:=fc;
  { Self.Draw; }
END;

PROCEDURE TDesktop.Draw;
BEGIN
  Inherited Draw;  (* WICHTIG!! Draw-Methode des Vorfahren aufrufen!! *)
END;

DESTRUCTOR TDesktop.Done;
BEGIN
  Inherited Done;
  IF (blink=FALSE) THEN BlinkON;
  Cursor(TRUE);
  TEXTATTR:=7;  CLRSCR;
END;

CONSTRUCTOR TStatusLine.Init(vbg, vfg: BYTE; vtxt: STRING; vmp: PMaus);
BEGIN
  Inherited Init(1,25,80,1,vbg,vfg,' ',TRUE,vmp);
  StatusLineText:=vtxt;
END;

PROCEDURE TStatusLine.ClrStatusLine;
VAR
  ii   : BYTE;
  blank: STRING;
BEGIN
  blank:='';
  FOR ii:=X TO X+Width-1 DO blank:=blank+' ';
  DrawText(X,Y,BackGrdCol*16+ForeGrdCol,blank);
END;

PROCEDURE TStatusLine.SetStatusLineColor(bc, fc: BYTE);
BEGIN
  BackGrdCol:=bc;  ForeGrdCol:=fc;
  { Self.Draw; }
END;

PROCEDURE TStatusLine.ShowDate(vx, vy: BYTE);
BEGIN
END;

PROCEDURE TStatusLine.ShowTime(vx, vy: BYTE);
VAR
  Hour, Minute, Second, Sec100: WORD;
BEGIN
  GetTime(Hour,Minute,Second,Sec100);
  DrawText(vx,vy,BackGrdCol*16+ForeGrdCol,Int2Str(Hour,2)+':'+Int2Str(Minute,2)+':'+Int2Str(Second,2));
END;

PROCEDURE TStatusLine.WriteText(vtxt: STRING; vjust: BYTE);
VAR
  x_pos: BYTE;
BEGIN
  StatusLineText:=vtxt;
  ClrStatusLine;
  CASE vjust OF left  : x_pos:=X;
                center: x_pos:=X+(Width DIV 2)-(Length(StatusLineText) DIV 2);
                right : x_pos:=(X+Width-2)-Length(StatusLineText);
  END;  (* CASE *)
  DrawText(x_pos,Y,BackGrdCol*16+ForeGrdCol,StatusLineText);
END;

PROCEDURE TStatusLine.WriteTextAt(vx: BYTE; vtxt: STRING);
BEGIN
  StatusLineText:=vtxt;
  ClrStatusLine;
  DrawText(vx,Y,BackGrdCol*16+ForeGrdCol,StatusLineText);
END;

PROCEDURE TStatusLine.Draw;
BEGIN
  Inherited Draw;  (* WICHTIG!! Draw-Methode des Vorfahren aufrufen!! *)
  ClrStatusLine;
  DrawText(X,Y,BackGrdCol*16+ForeGrdCol,StatusLineText);
END;

DESTRUCTOR TStatusLine.Done;
BEGIN
  Inherited Done;
END;

CONSTRUCTOR TWindow.Init(vx, vy, vw, vh: BYTE;
                         vt: STRING;
                         vact: BOOLEAN;
                         vmp: PMaus);
BEGIN
  Inherited Init(vx,vy,vw,vh,7,0,' ',vact,vmp);
  title:=vt;  IF NOT(title='') THEN title:=' '+title+' ';
  TitleForeGrdCol:=15;
  TitleBackGrdCol:=1;
  Left:=vx;  Top:=vy;  Right:=Left+Width-1;  Bottom:=Top+Height-1;
END;

PROCEDURE TWindow.Draw;
VAR
  ii, fc1, fc2: BYTE;
  tc1, tc2    : BYTE;
  linie       : STRING;
BEGIN
  Inherited Draw;

  linie:='';
  IF (BackGrdCol=0)  THEN fc2:=8 ELSE fc2:=0;
  IF (BackGrdCol=15) THEN fc1:=7 ELSE fc1:=15;
  IF (Activate) THEN BEGIN
    tc1:=TitleBackGrdCol;
    tc2:=TitleForeGrdCol;
  END  (* IF *)
  ELSE BEGIN
    tc1:=8;  tc2:=7;
  END;  (* ELSE *)

  FOR ii:=X TO X+Width-1 DO
    DrawText(ii,Y,tc1*16+tc2,' ');
  DrawText(X+(Width-LENGTH(title)) DIV 2,Y,tc1*16+tc2,title);

  { aus den kleinen Titelleistenschaltern eigene TControls machen... }
  DrawText(X+1,Y,7*16,'[ð]');
  DrawText(X+Width-7,Y,7*16,'[?]['+CHR(18)+']');

  FOR ii:=X+1 TO X+Width-2 DO linie:=linie+'Ä';
  DrawText(X,Y+1,BackGrdCol*16+fc1,'Ú'+linie);
  DrawText(X+Width-1,Y+1,BackGrdCol*16+fc2,'¿');
  FOR ii:=Y+2 TO Y+Height-2 DO BEGIN
    DrawText(X,ii,BackGrdCol*16+fc1,'³');
    DrawText(X+Width-1,ii,BackGrdCol*16+fc2,'³');
  END; (* FOR *)
  DrawText(X,Y+Height-1,BackGrdCol*16+fc1,'À');
  DrawText(X+1,Y+Height-1,BackGrdCol*16+fc2,linie+'Ù');
  IF ((Y+Height-1)<24) THEN HShadow(X+2,Y+Height,Width);
  IF ((X+Width-1) <80) THEN VShadow(X+Width,Y+1,Height-1);
  IF ((X+Width-1) <79) THEN VShadow(X+Width+1,Y+1,Height-1);
END;

PROCEDURE TWindow.SetActive(IsActive: BOOLEAN);
BEGIN
  Activate:=IsActive;
  { IF NOT(Activate) THEN BEGIN
    TitleForeGrdCol:=7;  TitleBackGrdCol:=8;
  END;  (* IF *) }
  { Self.Draw; }
END;

PROCEDURE TWindow.SetWindowColor(bc, fc: BYTE);
BEGIN
  BackGrdCol:=bc;  ForeGrdCol:=fc;
  { Self.Draw; }
END;

PROCEDURE TWindow.SetWindowTitleColor(bc, fc: BYTE);
BEGIN
  TitleBackGrdCol:=bc;  TitleForeGrdCol:=fc;
  { Self.Draw; }
END;

PROCEDURE TWindow.WriteText(lin, col, just: BYTE; zeile: STRING);
BEGIN
END;

DESTRUCTOR TWindow.Done;
BEGIN
  Inherited Done;
END;
{
CONSTRUCTOR TSchaltflaeche.Init(vx, vy, vw, vh, vbg, vfg: BYTE; vcap: STRING; vmp: PMaus);
BEGIN
  caption:=vcap;
  TView.Init(vx,vy,vw,vh,vbg,vfg,vmp);
  TSchaltflaeche.Draw;
END;

PROCEDURE TSchaltflaeche.Draw;
BEGIN
  MouseOFF;
  TView.Draw;
  DrawText(x+(width-LENGTH(caption)) DIV 2,y+(height DIV 2),backgrd*16+foregrd,caption);
  MouseON;
END;

FUNCTION TSchaltflaeche.MouseDown(EvVar, Code: WORD): BOOLEAN;
VAR
  rettbg, rettfg: BYTE;
BEGIN
  MouseDown:=FALSE;
  IF (EvVar=Code) AND (MausPtr<>NIL) THEN
    IF ((MausPtr^.x>x-1) AND (MausPtr^.x<x+width) AND
       (MausPtr^.y>y-1) AND (MausPtr^.y<y+height)) THEN BEGIN
      MouseDown:=TRUE;
      rettbg:=backgrd;  rettfg:=foregrd;
      backgrd:=rettfg;  foregrd:=rettbg;  TSchaltflaeche.Draw;  DELAY(200);
      backgrd:=rettbg;  foregrd:=rettfg;  TSchaltflaeche.Draw;
    END;  (* IF *)
END;

DESTRUCTOR TSchaltflaeche.Done;
BEGIN
  TView.Done;
END;

CONSTRUCTOR TEdit.Init(vx, vy, vw, vbg, vfg: BYTE; vcap: STRING; vmp: PMaus);
BEGIN
  caption:=vcap;
  TView.Init(vx,vy,vw,1,vbg,vfg,vmp);
  TEdit.Draw;
END;

PROCEDURE TEdit.Draw;
VAR
  ii    : BYTE;
  balken: STRING;
BEGIN
  MouseOFF;
  TView.Draw;
  DrawText(x+1,y,backgrd*16+foregrd,caption);
  MouseON;
END;

FUNCTION TEdit.ReadText(vorgabe: STRING; stellen, wo: BYTE): STRING;
VAR
  laenge : BYTE;
  curspos: BYTE;
  key    : CHAR;
  balken : STRING;
  ii     : BYTE;
BEGIN
  balken:='';  FOR ii:=2 TO width-1 DO balken:=balken+' ';
  laenge:=LENGTH(vorgabe);  caption:=vorgabe;
  curspos:=laenge+1;

  MouseOFF;
  Cursor(TRUE);
  DrawText(x+1,y,backgrd*16+foregrd,balken);
  DrawText(x+1,y,backgrd*16+foregrd,caption);
  GOTOXY(x+curspos,y);
  MouseON;

  REPEAT
    key:=READKEY;

    CASE key OF #32..#126: IF (laenge<stellen) THEN BEGIN
                             IF (key=',') THEN key:='.';
                             INSERT(key,caption,curspos);
                             INC(curspos,1);
                           END;  (* IF *)
                #8:  IF (curspos>1) THEN BEGIN
                       DELETE(caption,curspos-1,1);
                       DEC(curspos,1);
                     END;  (* IF *)
                #27: BEGIN
                       caption:=vorgabe;
                       curspos:=LENGTH(caption)+1;
                     END;
                #0:  BEGIN
                       key:=READKEY;
                       CASE key OF #75: IF (curspos>1) THEN DEC(curspos,1);
                                   #77: IF (curspos<laenge+1) THEN INC(curspos,1);
                                   #71: curspos:=1;
                                   #79: curspos:=laenge+1;
                                   #83: IF (laenge>0) AND (curspos<laenge+1) THEN
                                          DELETE(caption,curspos,1);
                       END;  (* CASE *)
                     END;
    END;  (* CASE *)

    laenge:=LENGTH(caption);

    MouseOFF;
    DrawText(x+1,y,backgrd*16+foregrd,balken);
    DrawText(x+1,y,backgrd*16+foregrd,caption);
    GOTOXY(x+curspos,y);
    MouseON;

  UNTIL (key=#13);

  ReadText:=caption;
  Cursor(FALSE);
END;

DESTRUCTOR TEdit.Done;
BEGIN
  TView.Done;
END;

CONSTRUCTOR TPanel.Init(vx, vy, vw, vh, vbg, vfg, vrel: BYTE; vcap: STRING; vmp: PMaus);
VAR
  ii: WORD;
BEGIN
  caption:=vcap;  relief:=vrel;
  TView.Init(vx,vy,vw,vh,vbg,vfg,vmp);
  TPanel.Draw;
END;

PROCEDURE TPanel.Draw;
VAR
  linecol1, linecol2: BYTE;
  linienst          : STRING;
  ii, hilfcol       : BYTE;
BEGIN
  MouseOFF;
  TView.Draw;
  CASE backgrd OF 0:     BEGIN  linecol1:=7; linecol2:=8;  END;
                  1..7:  BEGIN  linecol1:=backgrd+8; linecol2:=0;  END;
                  8:     BEGIN  linecol1:=7; linecol2:=0;  END;
                  9..14: BEGIN  linecol1:=15; linecol2:=0;  END;
                  15:    BEGIN  linecol1:=7; linecol2:=0;  END;
  END;  (* CASE *)
  IF (relief=1) THEN BEGIN
    hilfcol:=linecol2;  linecol2:=linecol1;  linecol1:=hilfcol;
  END;  (* IF *)
  linienst:='';
  FOR ii:=2 TO width-1 DO linienst:=linienst+'Ä';
  DrawText(x,y,backgrd*16+linecol1,'Ú'+linienst);
  DrawText(x-1+width,y,backgrd*16+linecol2,'¿');
  IF (height>2) THEN
    FOR ii:=y+1 TO y-2+height DO BEGIN
      DrawText(x,ii,backgrd*16+linecol1,'³');
      DrawText(x-1+width,ii,backgrd*16+linecol2,'³');
    END;  (* FOR *)
  DrawText(x,y-1+height,backgrd*16+linecol1,'À');
  DrawText(x+1,y-1+height,backgrd*16+linecol2,linienst+'Ù');
  DrawText(x+(width-LENGTH(caption)) DIV 2,y+(height DIV 2),backgrd*16+foregrd,caption);
  MouseON;
END;

DESTRUCTOR TPanel.Done;
BEGIN
  TView.Done;
END;

CONSTRUCTOR TProgressBar.Init(vx, vy, vw, vh, vbg, vfg, vr, vt: BYTE;
                              vrgmin, vrgmax: REAL; vmp: PMaus);
VAR
  ii: WORD;
BEGIN
  frmcol:=vr;  textcol:=vt;
  rangemin:=vrgmin;  rangemax:=vrgmax;
  TView.Init(vx,vy,vw,vh,vbg,vfg,vmp);
  TProgressBar.Draw;
END;

PROCEDURE TProgressBar.Draw;
VAR
  linie: STRING;
  ii   : WORD;
BEGIN
  linie:='';
  FOR ii:=2 TO width-1 DO linie:=linie+'Ä';

  MouseOFF;
  TView.Draw;
  DrawText(x,y,backgrd*16+frmcol,'Ú'+linie+'¿');
  IF (height>2) THEN
    FOR ii:=y+1 TO y-2+height DO BEGIN
      DrawText(x,ii,backgrd*16+frmcol,'³');
      DrawText(x-1+width,ii,backgrd*16+frmcol,'³');
    END;
  DrawText(x,y-1+height,backgrd*16+frmcol,'À'+linie+'Ù');
  MouseON;
END;

PROCEDURE TProgressBar.DrawBar(percent: REAL);
VAR
  balken: STRING;
  ii    : WORD;
  px, py: BYTE;
  proz  : STRING;
BEGIN
  IF (percent<rangemin) THEN percent:=rangemin;
  IF (percent>rangemax) THEN percent:=rangemax;
  percent:=((percent-rangemin)/(rangemax-rangemin));
  balken:='';  proz:='';  ii:=0;
  WHILE (ii<percent*(width-2)) DO BEGIN
    balken:=balken+' ';
    INC(ii,1);
  END;
  MouseOFF;
  IF (height>2) THEN
    FOR ii:=y+1 TO y-2+height DO DrawText(x+1,ii,foregrd*16+textcol,balken);
  px:=x+(width DIV 2)-2;  py:=y+(height DIV 2);
  proz:=REAL2STR(percent*100,3,0)+'%';
  FOR ii:=1 TO LENGTH(proz) DO BEGIN
    MEM[ScreenBuf:(px-2+ii)*2+(py-1)*160]:=ORD(proz[ii]);
    MEM[ScreenBuf:(px-2+ii)*2+(py-1)*160+1]:=(MEM[ScreenBuf:(px-2+ii)*2+(py-1)*160+1] DIV 16)*16+textcol;
  END;
  MouseON;
END;

DESTRUCTOR TProgressBar.Done;
BEGIN
  TView.Done;
END;

CONSTRUCTOR TLabel.Init(vx, vy, vbg, vfg: BYTE; vcap: STRING; vmp: PMaus);
BEGIN
  caption:=vcap;
  TView.Init(vx,vy,LENGTH(caption),1,vbg,vfg,vmp);
END;

PROCEDURE TLabel.Draw;
BEGIN
  MouseOFF;
  DrawText(x,y,backgrd*16+foregrd,caption);
  MouseON;
END;

DESTRUCTOR TLabel.Done;
BEGIN
  TView.Done;
END;

CONSTRUCTOR TCheckBox.Init(vx, vy, vbg, vfg, vhlc: BYTE; vcap: STRING;
                           vact: BOOLEAN; vmp: PMaus);
VAR
  ii: BYTE;
BEGIN
  caption:=vcap;  active:=vact;  HLkey:=1;  HLcol:=vhlc;
  ii:=0;
  WHILE (ii<LENGTH(caption)) DO BEGIN
    INC(ii,1);
    IF (caption[ii]='~') AND (caption[ii+2]='~') THEN HLkey:=ii;
  END;
  ii:=0;
  WHILE (ii<LENGTH(caption)) DO BEGIN
    INC(ii,1);
    IF (caption[ii]='~') THEN DELETE(caption,ii,1);
  END;
  keycode:=ORD(DOWNCASE(caption[HLkey]));
  TView.Init(vx,vy,LENGTH(caption)+4,1,vbg,vfg,vmp);
  TCheckBox.Draw;
END;

PROCEDURE TCheckBox.Draw;
VAR
  cr: STRING[1];
BEGIN
  IF (active=TRUE) THEN cr:='x' ELSE cr:=' ';
  MouseOFF;
  DrawText(x,y,backgrd*16+foregrd,'['+cr+'] '+caption);
  DrawText(x+3+HLkey,y,backgrd*16+HLcol,caption[HLkey]);
  MouseON;
END;

PROCEDURE TCheckBox.Check(EvKey: WORD);
BEGIN
  IF (MausPtr<>NIL) THEN
    IF (MausPtr^.x>x-1) AND (MausPtr^.x<x+width) AND
       (MausPtr^.y=y) AND (EvKey=2001) THEN BEGIN
      active:=NOT active;
      TCheckBox.Draw;
    END;  (* IF *)

  CASE EvKey OF 65..90: EvKey:=EvKey+32;
  END;  (* CASE *)

  IF (EvKey=keycode) THEN BEGIN
    active:=NOT active;
    TCheckBox.Draw;
  END;  (* IF *)
END;

DESTRUCTOR TCheckBox.Done;
BEGIN
  TView.Done;
END;

CONSTRUCTOR TMemo.Init(vx, vy, vw, vh, vbg, vfg: BYTE; vmp: PMaus);
BEGIN
  HeadPtr:=NIL;  Current:=NIL;
  NrOfLines:=0;  minLine:=1;  maxLine:=vh;
  TView.Init(vx,vy,vw,vh,vbg,vfg,vmp);
END;

PROCEDURE TMemo.Draw;
VAR
  ii: BYTE;
BEGIN
  MouseOFF;
  TView.Draw;
  FOR ii:=y TO y-1+height DO DrawText(x-1+width,ii,7,'±');
  DrawText(x-1+width,y,7,#30);
  DrawText(x-1+width,y-1+height,7,#31);
  TMemo.PrintList;
  MouseON;
END;

PROCEDURE TMemo.AddLine(zeile: STRING);
VAR
  HelpPtr      : PTextList;
  laenge, zaehl: BYTE;
BEGIN
  laenge:=LENGTH(zeile);
  zaehl:=1;
  REPEAT
    INC(NrOfLines,1);
    NEW(HelpPtr);
    HelpPtr^.Nr:=NrOfLines;
    HelpPtr^.TextLine:=COPY(zeile,zaehl,width-1);
    HelpPtr^.next:=NIL;
    HelpPtr^.prev:=NIL;
    IF (HeadPtr=NIL) THEN BEGIN
      Current:=HelpPtr;
      HeadPtr:=Current;
    END  (* IF *)
    ELSE BEGIN
      Current^.next:=HelpPtr;
      HelpPtr^.prev:=Current;
      Current:=Current^.next;
    END;  (* ELSE *)
    INC(zaehl,width-1);
  UNTIL (zaehl>laenge);
  TMemo.PrintList;
END;

PROCEDURE TMemo.PrintList;
VAR
  HelpPtr: PTextList;
  ii, jj : WORD;
  blank  : STRING;
BEGIN
  HelpPtr:=HeadPtr;  ii:=0;
  blank:='';  FOR jj:=x TO x-2+width DO blank:=blank+' ';
  MouseOFF;
  FOR jj:=y TO y-1+height DO DrawText(x,jj,backgrd*16+foregrd,blank);

  IF (HelpPtr<>NIL) THEN BEGIN
    WHILE (HelpPtr<>NIL) AND (ii<height) DO BEGIN
      INC(ii,1);
      DrawText(x,y-1+ii,backgrd*16+foregrd,HelpPtr^.TextLine);
      HelpPtr:=HelpPtr^.next;
    END;  (* WHILE *)
  END;  (* IF *)

  MouseON;
END;

PROCEDURE TMemo.DeleteLine;
VAR
  HelpPtr: PTextList;
BEGIN
  HelpPtr:=Current;
  IF (HeadPtr<>NIL) THEN BEGIN
    IF (HeadPtr=Current) THEN TMemo.DeleteList
    ELSE BEGIN
      IF (maxLine=NrOfLines) AND (maxLine>height) AND (minLine>1) THEN BEGIN
        DEC(maxLine,1);  minLine:=maxLine-height+1;
      END;  (* IF *)
      DEC(NrOfLines,1);
      Current:=Current^.prev;
      Current^.next:=NIL;
      DISPOSE(HelpPtr);
    END;  (* ELSE *)
    TMemo.PrintList;
  END;  (* IF *)
END;

PROCEDURE TMemo.DeleteList;
VAR
  HelpPtr: PTextList;
BEGIN
  IF (HeadPtr<>NIL) THEN BEGIN
    WHILE (HeadPtr<>NIL) DO BEGIN
      NrOfLines:=0;
      minLine:=1;  maxLine:=height;
      HelpPtr:=HeadPtr;
      HeadPtr:=HeadPtr^.next;
      DISPOSE(HelpPtr);
    END;  (* WHILE *)
    TMemo.PrintList;
  END;  (* IF *)
END;

PROCEDURE TMemo.ScrollList(EvVar: WORD);
VAR
  HelpPtr  : PTextList;
  startline: WORD;
  blank    : STRING;
  ii       : BYTE;
BEGIN
  blank:='';  FOR ii:=x TO x-2+width DO blank:=blank+' ';

  IF (NrOfLines>height) THEN BEGIN

    IF (EvVar=2001) AND (MausPtr<>NIL) THEN BEGIN
      IF (MausPtr^.x=x-1+width) AND (MausPtr^.y=y) THEN EvVar:=1072;
      IF (MausPtr^.x=x-1+width) AND (MausPtr^.y=y-1+height) THEN EvVar:=1080;
    END;  (* IF *)

    CASE EvVar OF 1072: IF (minLine>1) THEN BEGIN
                          DEC(minLine,1);
                          maxLine:=minLine+height-1;
                        END;  (* IF *)
                  1080: IF (maxLine<NrOfLines) THEN BEGIN
                          INC(maxLine,1);
                          minLine:=maxLine-height+1;
                        END;  (* IF *)
                  1071: BEGIN
                          minLine:=1;  maxLine:=minLine+height-1;
                        END;
                  1079: BEGIN
                          maxLine:=NrOfLines;  minLine:=maxLine-height+1;
                        END;
    END;  (* CASE *)

    HelpPtr:=HeadPtr;
    WHILE (HelpPtr^.Nr<minLine) DO HelpPtr:=HelpPtr^.next;

    ii:=0;
    MouseOFF;
    WHILE (HelpPtr^.Nr<=maxLine) AND (HelpPtr<>NIL) DO BEGIN
      DrawText(x,y+ii,backgrd*16+foregrd,blank);
      DrawText(x,y+ii,backgrd*16+foregrd,HelpPtr^.TextLine);
      HelpPtr:=HelpPtr^.next;
      INC(ii,1);
    END;  (* WHILE *)
    MouseON;
  END;  (* IF *)
END;

DESTRUCTOR TMemo.Done;
BEGIN
  TMemo.DeleteList;
  TView.Done;
END;

CONSTRUCTOR TScrollBar.Init(vx, vy, vw, vbg, vfg, vkind: BYTE; vmp: PMaus;
                            vmin, vmax, vpos, vint: REAL);
BEGIN
  min:=vmin;  max:=vmax;  position:=vpos;  interval:=ABS(vint);
  sbkind:=vkind;
  IF (position<min) THEN position:=min;
  IF (position>max) THEN position:=max;
  IF (vw<3) THEN vw:=3;
  IF (sbkind=vertical) THEN TView.Init(vx,vy,1,vw,vbg,vfg,vmp)
  ELSE TView.Init(vx,vy,vw,1,vbg,vfg,vmp);
END;

PROCEDURE TScrollBar.Draw;
VAR
  ii: BYTE;
BEGIN
  MouseOFF;
  TView.Draw;
  IF (sbKind=vertical) THEN BEGIN
    DrawText(x,y,backgrd*16+foregrd,#30);
    DrawText(x,y+height-1,backgrd*16+foregrd,#31);
    FOR ii:=y+1 TO y+height-2 DO DrawText(x,ii,backgrd*16+foregrd,'±');
    DrawText(x,y+1+ROUND(((position-min)/(max-min))*(height-3)),backgrd*16+foregrd,'þ');
  END  (* IF *)
  ELSE BEGIN
    DrawText(x,y,backgrd*16+foregrd,#17);
    DrawText(x+width-1,y,backgrd*16+foregrd,#16);
    FOR ii:=x+1 TO x+width-2 DO DrawText(ii,y,backgrd*16+foregrd,'±');
    DrawText(x+1+ROUND(((position-min)/(max-min))*(width-3)),y,backgrd*16+foregrd,'þ');
  END;  (* ELSE *)
  MouseON;
END;

PROCEDURE TScrollBar.Change(EvVar: WORD);
BEGIN
  IF (sbKind=vertical) THEN BEGIN
    IF (MausPtr<>NIL) AND (EvVar=2001) AND (MausPtr^.x=x) THEN BEGIN
      IF (MausPtr^.y=y) THEN EvVar:=1072;
      IF (MausPtr^.y=y+height-1) THEN EvVar:=1080;
    END;  (* IF *)
    MouseOFF;
    DrawText(x,y+1+ROUND(((position-min)/(max-min))*(height-3)),backgrd*16+foregrd,'±');
    CASE EvVar OF 1072: IF (position>min) THEN position:=position-interval;
                  1080: IF (position<max) THEN position:=position+interval;
                  1071: position:=min;
                  1079: position:=max;
    END;  (* CASE *)
    IF (position<min) THEN position:=min;
    IF (position>max) THEN position:=max;
    DrawText(x,y+1+ROUND(((position-min)/(max-min))*(height-3)),backgrd*16+foregrd,'þ');
    MouseON;
  END  (* IF *)
  ELSE BEGIN
    IF (MausPtr<>NIL) AND (EvVar=2001) AND (MausPtr^.y=y) THEN BEGIN
      IF (MausPtr^.x=x) THEN EvVar:=1075;
      IF (MausPtr^.x=x+width-1) THEN EvVar:=1077;
    END;  (* IF *)
    MouseOFF;
    DrawText(x+1+ROUND(((position-min)/(max-min))*(width-3)),y,backgrd*16+foregrd,'±');
    CASE EvVar OF 1075: IF (position>min) THEN position:=position-interval;
                  1077: IF (position<max) THEN position:=position+interval;
                  1071: position:=min;
                  1079: position:=max;
    END;  (* CASE *)
    IF (position<min) THEN position:=min;
    IF (position>max) THEN position:=max;
    DrawText(x+1+ROUND(((position-min)/(max-min))*(width-3)),y,backgrd*16+foregrd,'þ');
    MouseON;
  END;  (* ELSE *)
END;

DESTRUCTOR TScrollBar.Done;
BEGIN
  TView.Done;
END;

CONSTRUCTOR TGroupBox.Init(vx, vy, vw, vh, vbg, vfg: BYTE; vcap: STRING; vmp: PMaus);
BEGIN
  caption:=vcap;
  TView.Init(vx,vy,vw,vh,vbg,vfg,vmp);
END;

PROCEDURE TGroupBox.Draw;
VAR
  linecol: BYTE;
  linest : STRING;
  ii     : BYTE;
BEGIN
  linest:='';  FOR ii:=x+1 TO x+width-2 DO linest:=linest+'Ä';
  MouseOFF;
  TView.Draw;
  CASE backgrd OF 1,4,5,8,9:        linecol:=7;
                  0,2,3,6,7,10..15: linecol:=8;
  END;  (* CASE *)
  DrawText(x,y,backgrd*16+linecol,'Ú'+linest+'¿');
  FOR ii:=y+1 TO y+height-2 DO BEGIN
    DrawText(x,ii,backgrd*16+linecol,'³');  DrawText(x+width-1,ii,backgrd*16+linecol,'³');
  END;  (* FOR *)
  DrawText(x,y+height-1,backgrd*16+linecol,'À'+linest+'Ù');
  IF (caption<>'') THEN DrawText(x+1,y,backgrd*16+foregrd,' '+caption+' ');
  MouseON;
END;

DESTRUCTOR TGroupBox.Done;
BEGIN
  TView.Done;
END;

CONSTRUCTOR TMainMenu.Init(vx, vy, vw, vbg, vfg, vhl, vmhlc: BYTE; vmp: PMaus);
BEGIN
  hlightcol:=vhl;
  menuHLcol:=vmhlc;
  Items:=NIL;
  MaxItem:=0;  MaxSubItem:=0;
  CurrentMain:=1;  CurrentSub:=1;
  TView.Init(vx,vy,vw,1,vbg,vfg,vmp);
END;

FUNCTION TMainMenu.NewMenu(Name: STRING; cd: WORD;
                           SubPtr: PSubMenuList; NextPtr: PMenuList): PMenuList;
VAR
  HelpPtr: PMenuList;
BEGIN
  NEW(HelpPtr);
  HelpPtr^.ItemName:=Name;
  HelpPtr^.cmCode:=cd;
  HelpPtr^.SubItemPtr:=SubPtr;
  HelpPtr^.Next:=NextPtr;
  NewMenu:=HelpPtr;
END;

FUNCTION TMainMenu.NewSubMenu(Name: STRING; NextPtr: PSubMenuList): PSubMenuList;
VAR
  HelpPtr: PSubMenuList;
BEGIN
  NEW(HelpPtr);
  HelpPtr^.SubItemName:=Name;
  HelpPtr^.ItemNr:=0;
  HelpPtr^.Next:=NextPtr;
  NewSubMenu:=HelpPtr;
END;

FUNCTION TMainMenu.GetMenuItem(nr: BYTE): PMenuList;
VAR
  ii     : BYTE;
  ItemPtr: PMenuList;
BEGIN
  ItemPtr:=Items;
  ii:=1;
  WHILE (ii<nr) DO BEGIN
    INC(ii,1);
    ItemPtr:=ItemPtr^.Next;
  END;  (* WHILE *)
  GetMenuItem:=ItemPtr;
END;

FUNCTION TMainMenu.GetSubMenuItem(nr: BYTE): PSubMenuList;
VAR
  ii     : BYTE;
  startnr: BYTE;
  PMain  : PMenuList;
  PSub   : PSubMenuList;
BEGIN
  PMain:=Items;
  PSub:=PMain^.SubItemPtr;

  WHILE ((nr<>PSub^.ItemNr) AND (PMain<>NIL)) DO BEGIN
    PSub:=PMain^.SubItemPtr;
    WHILE ((PSub^.ItemNr<>nr) AND (PSub<>NIL)) DO BEGIN
      PSub:=PSub^.Next;
    END;
    PMain:=PMain^.Next;
  END;  (* WHILE *)

  GetSubMenuItem:=PSub;
END;

FUNCTION TMainMenu.MouseDown(EvVar, Code: WORD): BOOLEAN;
BEGIN
  MouseDown:=FALSE;
  IF (EvVar=Code) AND (MausPtr<>NIL) THEN
    IF ((MausPtr^.x>x-1) AND (MausPtr^.x<x+width) AND (MausPtr^.y=y)) THEN BEGIN
      MouseDown:=TRUE;
    END;  (* IF *)
END;

FUNCTION TMainMenu.Change(EV: WORD): BYTE;
VAR
  Main        : PMenuList;
  Sub         : PSubMenuList;
  leavemenu   : BOOLEAN;
  ii          : BYTE;
  Rett        : PMenuList;
  chflag      : BOOLEAN;

  FUNCTION GetMaxWidth(VAR S: PSubMenuList): BYTE;
  VAR
    hp     : PSubMenuList;
    iw, len: BYTE;
  BEGIN
    hp:=S;
    iw:=0;
    WHILE (hp<>NIL) DO BEGIN
      len:=LENGTH(hp^.SubItemName);
      IF (iw<len) THEN iw:=len;
      hp:=hp^.Next;
    END;
    GetMaxWidth:=iw;
  END;

  PROCEDURE SubMenuBar(bx, by, bc, bw: BYTE);
  VAR
    blk: STRING;
    kk : BYTE;
  BEGIN
    blk:='';  FOR kk:=1 TO bw DO blk:=blk+' ';
    DrawText(bx,by,bc,blk);
  END;

  PROCEDURE SubFrame(VAR M: PMenuList; SubNr: BYTE);
  VAR
    Hilf        : PSubMenuList;
    box_w, box_h: BYTE;
    box_x, box_y: BYTE;
    cc          : BYTE;
    ll          : STRING;
  BEGIN
    box_w:=GetMaxWidth(M^.SubItemPtr)+4;
    box_h:=M^.SubItems+2;
    box_x:=M^.posx;
    box_y:=M^.posy+1;

    BackgrdBox^.RestoreBackGround;
    BackgrdBox^.x:=box_x;  BackgrdBox^.y:=box_y;
    BackgrdBox^.width:=box_w;  BackgrdBox^.height:=box_h;
    BackgrdBox^.SaveBackGround;
    BackgrdBox^.Draw;
    ll:='';  FOR cc:=2 TO box_w-1 DO ll:=ll+'Ä';
    DrawText(box_x,box_y,backgrd*16+foregrd,'Ú'+ll+'¿');
    FOR cc:=box_y+1 TO box_y+box_h-2 DO BEGIN
      DrawText(box_x,cc,backgrd*16+foregrd,'³');
      DrawText(box_x+box_w-1,cc,backgrd*16+foregrd,'³');
    END;  (* FOR *)
    DrawText(box_x,box_y+box_h-1,backgrd*16+foregrd,'À'+ll+'Ù');

    Hilf:=M^.SubItemPtr;
    cc:=1;
    WHILE (Hilf<>NIL) DO BEGIN
      DrawText(box_x+2,box_y+cc,backgrd*16+foregrd,Hilf^.SubItemName);
      Hilf:=Hilf^.Next;  INC(cc,1);
    END;  (* WHILE *)

    Hilf:=GetSubMenuItem(SubNr);
    SubMenuBar(Hilf^.posx,Hilf^.posy,hlightcol,box_w-2);
    DrawText(Hilf^.posx+1,Hilf^.posy,hlightcol,Hilf^.SubItemName);
  END;

BEGIN
  leavemenu:=FALSE;

  IF (TMainmenu.MouseDown(EV,2001)=TRUE) THEN BEGIN
    Main:=Items;
    WHILE ((Main^.posx+LENGTH(Main^.ItemName)<MausPtr^.x) AND (Main^.Next<>NIL)) DO BEGIN
      Main:=Main^.Next;
    END;  (* WHILE *)
    CurrentMain:=Main^.ItemNr;
  END  (* IF *)
  ELSE IF (EV=1068) THEN Main:=GetMenuItem(CurrentMain)
  ELSE BEGIN
    ii:=1;
    Main:=Items;
    WHILE ((Main^.cmCode<>EV) AND (Main<>NIL)) DO BEGIN
      INC(ii,1);
      Main:=Main^.Next;
    END;  (* WHILE *)
    IF (Main=NIL) THEN leavemenu:=TRUE
    ELSE BEGIN
      CurrentMain:=ii;
      Main:=GetMenuItem(CurrentMain);
    END;  (* ELSE *)
  END;

  IF (Main<>NIL) THEN BEGIN
    Sub:=Main^.SubItemPtr;
    CurrentSub:=Sub^.ItemNr;

    MouseOFF;
    DrawText(Main^.posx-1,Main^.posy,hlightcol,' '+Main^.ItemName+' ');
    BackgrdBox^.Init(Main^.posx,Main^.posy+1,GetMaxWidth(Main^.SubItemPtr)+4,Main^.SubItems+2,
                     backgrd,foregrd,MausPtr);
    SubFrame(Main,CurrentSub);

    MouseON;
  END;  (* IF *)

  chflag:=FALSE;

  WHILE (leavemenu=FALSE) DO BEGIN

    GetEvent(Event);
    MouseOFF;
    Rett:=Main;

    CASE Event^.EvCode OF 1075: BEGIN

                                  IF (CurrentMain=1) THEN CurrentMain:=MaxItem
                                  ELSE DEC(CurrentMain,1);

                                  Main:=GetMenuItem(CurrentMain);
                                  Sub:=Main^.SubItemPtr;
                                  CurrentSub:=Sub^.ItemNr;

                                  chflag:=TRUE;
                                END;
                          1077: BEGIN

                                  IF (CurrentMain=MaxItem) THEN CurrentMain:=1
                                  ELSE INC(CurrentMain,1);

                                  Main:=GetMenuItem(CurrentMain);
                                  Sub:=Main^.SubItemPtr;
                                  CurrentSub:=Sub^.ItemNr;

                                  chflag:=TRUE;
                                END;
                          1072: BEGIN

                                  IF (CurrentSub=Main^.SubItemPtr^.ItemNr) THEN
                                    CurrentSub:=Main^.SubItemPtr^.ItemNr+Main^.SubItems-1
                                  ELSE DEC(CurrentSub,1);

                                  Sub:=GetSubMenuItem(CurrentSub);

                                  chflag:=TRUE;
                                END;
                          1080: BEGIN

                                  IF (CurrentSub=Main^.SubItemPtr^.ItemNr+Main^.SubItems-1) THEN
                                    CurrentSub:=Main^.SubItemPtr^.ItemNr
                                  ELSE INC(CurrentSub,1);

                                  Sub:=GetSubMenuItem(CurrentSub);

                                  chflag:=TRUE;
                                END;
                          2001: IF (TMainMenu.MouseDown(2001,2001)=TRUE) THEN BEGIN
                                  Main:=Items;
                                  WHILE ((Main^.posx+LENGTH(Main^.ItemName)<MausPtr^.x) AND
                                        (Main^.Next<>NIL)) DO Main:=Main^.Next;
                                  CurrentMain:=Main^.ItemNr;
                                  Sub:=Main^.SubItemPtr;
                                  CurrentSub:=Sub^.ItemNr;
                                  chflag:=TRUE;
                                END  (* IF *)
                                ELSE IF (MausPtr^.y>y+1) AND (MausPtr^.y<y+Main^.SubItems+2) AND
                                        (MausPtr^.x>Main^.SubItemPtr^.posx-1) AND
                                        (MausPtr^.x<Main^.SubItemPtr^.posx+GetMaxWidth(Main^.SubItemPtr)+2) THEN BEGIN
                                  Sub:=Main^.SubItemPtr;
                                  WHILE (Sub^.posy<>MausPtr^.y) DO Sub:=Sub^.Next;
                                  CurrentSub:=Sub^.ItemNr;
                                  leavemenu:=TRUE;
                                END;  (* ELSE IF *)
                          13, 27: leavemenu:=TRUE;
                          2002:   IF (MausPtr<>NIL) THEN leavemenu:=TRUE;
    END;  (* CASE *)

    Main:=Items;
    WHILE ((Main^.cmCode<>Event^.EvCode) AND (Main<>NIL)) DO Main:=Main^.Next;
    IF (Main=NIL) THEN Main:=GetMenuItem(CurrentMain)
    ELSE BEGIN
      CurrentMain:=Main^.ItemNr;
      Sub:=Main^.SubItemPtr;
      CurrentSub:=Sub^.ItemNr;
      chflag:=TRUE;
    END;  (* ELSE *)

    IF (chflag=TRUE) THEN BEGIN
      DrawText(Rett^.posx-1,Rett^.posy,backgrd*16+foregrd,' '+Rett^.ItemName+' ');
      DrawText(Rett^.posx-1+Rett^.HLkey,Rett^.posy,backgrd*16+Rett^.HLcol,Rett^.ItemName[Rett^.HLkey]);
      DrawText(Main^.posx-1,Main^.posy,hlightcol,' '+Main^.ItemName+' ');
      SubFrame(Main,CurrentSub);
      chflag:=FALSE;
    END;  (* IF *)

    MouseON;

  END;  (* WHILE *)

  IF (Main=NIL) THEN Change:=0
  ELSE BEGIN
    MouseOFF;
    DrawText(Main^.posx-1,Main^.posy,backgrd*16+foregrd,' '+Main^.ItemName+' ');
    DrawText(Main^.posx-1+Main^.HLkey,Main^.posy,backgrd*16+Main^.HLcol,Main^.ItemName[Main^.HLkey]);
    BackgrdBox^.RestoreBackGround;
    MouseON;
    IF ((Event^.EvCode=13) OR (Event^.EvCode=2001)) THEN
      Change:=CurrentSub
    ELSE Change:=0;
  END;  (* ELSE *)
END;

PROCEDURE TMainMenu.Create;
VAR
  M         : PMenuList;
  S         : PSubMenuList;
  nr, px, py: BYTE;
  itemlaenge: BYTE;
  pysub     : BYTE;
  ii        : BYTE;
BEGIN
  nr:=0;  px:=x+1;  py:=y;
  M:=Items;
  S:=M^.SubItemPtr;

  WHILE (M<>NIL) DO BEGIN

    INC(MaxItem,1);
    M^.HLkey:=1;  M^.HLcol:=menuHLcol;
    ii:=0;
    WHILE (ii<LENGTH(M^.ItemName)) DO BEGIN
      INC(ii,1);
      IF (M^.ItemName[ii]='~') AND (M^.ItemName[ii+2]='~') THEN M^.HLkey:=ii;
    END;  (* WHILE *)
    ii:=0;
    WHILE (ii<LENGTH(M^.ItemName)) DO BEGIN
      INC(ii,1);
      IF (M^.ItemName[ii]='~') THEN DELETE(M^.ItemName,ii,1);
    END;  (* WHILE *)

    M^.posx:=px;  M^.posy:=py;  itemlaenge:=LENGTH(M^.ItemName);  M^.ItemNr:=MaxItem;

    pysub:=0;
    WHILE (S<>NIL) DO BEGIN
      INC(nr,1);
      INC(pysub,1);
      S^.ItemNr:=nr;
      S^.posx:=px+1;
      S^.posy:=py+pysub+1;
      S:=S^.Next;
    END;  (* WHILE *)

    M^.SubItems:=pysub;
    M:=M^.Next;
    S:=M^.SubItemPtr;

    INC(px,itemlaenge+2);

  END;  (* WHILE *)

  MaxSubItem:=nr;
  CurrentMain:=1;
  CurrentSub:=1;
  TMainMenu.Draw;
  NEW(BackgrdBox);
END;

PROCEDURE TMainMenu.DeleteMenu;
VAR
  HelpPtr      : PMenuList;
  SMPtr, SMHelp: PSubMenuList;
BEGIN
  HelpPtr:=Items;
  WHILE (HelpPtr<>NIL) DO BEGIN
    SMPtr:=HelpPtr^.SubItemPtr;
    SMHelp:=SMPtr;
    WHILE (SMPtr<>NIL) DO BEGIN
      SMPtr:=SMPtr^.Next;
      DISPOSE(SMHelp);
      SMHelp:=SMPtr;
    END;  (* WHILE *)
    Items:=Items^.Next;
    DISPOSE(HelpPtr);
    HelpPtr:=Items;
  END;  (* WHILE *)
  MaxItem:=0;
  MaxSubItem:=0;
  CurrentMain:=0;
  CurrentSub:=0;
  DISPOSE(BackgrdBox);
END;

PROCEDURE TMainMenu.Draw;
VAR
  M: PMenuList;
BEGIN
  M:=Items;
  MouseOFF;
  TBox.Draw;

  WHILE (M<>NIL) DO BEGIN
    DrawText(M^.posx,M^.posy,backgrd*16+foregrd,M^.ItemName);
    DrawText(M^.posx-1+M^.HLkey,M^.posy,backgrd*16+M^.HLcol,M^.ItemName[M^.HLkey]);
    M:=M^.Next;
  END;  (* WHILE *)

  MouseON;
END;

DESTRUCTOR TMainMenu.Done;
BEGIN
  TMainMenu.DeleteMenu;
  TBox.Done;
END;
}
END.