{$ if not def AP_TOOLTYPE_H}

{Enthält alles, was it Tooltypes und Workbench usw. zu tun hat}
 
CONST 
      AP_TOOLTYPE_H = 0;

VAR  dobj      : p_DiskObject;


PROCEDURE OPENTT;
VAR     ownarg    : p_WBarg;
        WBMsg     : p_WBStartup;
        owndir    : BPTR;
        success   : BOOLEAN;
        name      : STRING[200];
        dir       : STRING[108];

 BEGIN
  dobj:=NIL;
  IF fromwb THEN                       
   BEGIN
    WBmsg:=p_wbstartup(StartupMessage);  
    ownarg:=p_wbarg(wbmsg^.sm_arglist);  
    name:=ownarg^.wa_name;               
    owndir:=ownarg^.wa_lock;             
    i:=namefromlock(owndir,^dir,108);    
    IF dir[length(dir)]<>':'             
       THEN dir:=dir+'/';                
    name:=dir+name;                      
   END
   ELSE success:=GetProgramname(^name,200);  
   dobj:=GetDiskObject(name);                
 END;

PROCEDURE CLOSETT;
 BEGIN
  IF dobj<>NIL THEN BEGIN FreeDiskObject(dobj); dobj:=NIL; END;
 END;

FUNCTION Holett(davor:STR,VAR ergebnis:STRING):BOOLEAN;
 { Holt das, was beim Tooltype hinter dem '=' steht 
   davor: das was vor dem '=' steht 
   ergebnis: das was hinter dem '=' steht die
   Funktion gibt True zurück, wenn alles geklappt hat.}

  BEGIN
    holett:=FALSE;
   IF dobj<>NIL THEN
   BEGIN
    ergebnis:= FindToolType(dobj^.do_ToolTypes,davor); 
    IF ergebnis<>'' THEN holett:=TRUE;
   END
  END;

FUNCTION Holettint(davor:STR,VAR ergebnis:INTEGER):BOOLEAN;
 { Wie holett, nur daß das Ergebnis vom Typ integer ist }
 VAR hilf:INTEGER;
     s:STRING

  BEGIN
   holettint:=FALSE;
   IF dobj<>NIL THEN
   BEGIN
    s:= FindToolType(dobj^.do_ToolTypes,davor); 
    IF s<>'' THEN
    BEGIN
      VAL(s,ergebnis,hilf); 
      IF (hilf=0) THEN holettint:=TRUE
      ELSE ergebnis:=0;              { zur Sicherheit}
    END;
   END
  END;

FUNCTION GetWBArgs:BOOLEAN;
 {FROM PackMANs ZMORE OR?}
 VAR WBMsg   :p_WBStartup;
     help    :INTEGER;STATIC;
     helpstr :STRING;STATIC;
 BEGIN
  helpstr:='';
  WBMsg:=StartupMessage;
  IF WBmsg^.sm_numargs<2 THEN 
   BEGIN
    getwbargs:=FALSE;
   END
  ELSE
   BEGIN
    pfad:='';
    datei:='';
    help:=Namefromlock(wbmsg^.sm_arglist^[2].wa_lock,^helpstr,256);
    IF (helpstr[length(Helpstr)])<>':'
     THEN datei:=ConCat(helpstr,'/',WBmsg^.sm_Arglist^[2].wa_name)
     ELSE datei:=ConCat(helpstr,WBmsg^.sm_Arglist^[2].wa_name);
    getWBArgs:=TRUE;
   END;
 END;

FUNCTION holeeigenname:STRING256;
 
VAR success   : boolean;
    name      : string256;
    dir       : string[108];
    WBMsg     : p_WBStartup;
    owndir    : BPTR;
    i         : integer;
    ownarg    : p_WBarg; { Das erste Argument ist das Programm selbst,
                           deswegen benötigen wir kein array of wbarg}


BEGIN
 IF fromwb THEN                        { Start von Workbench ?             }
 BEGIN
  WBmsg:=p_wbstartup(StartupMessage);  { Startupmessage holen              }
  ownarg:=p_wbarg(wbmsg^.sm_arglist);  { Argumente holen                   }
  name:=ownarg^.wa_name;               { Dateinamen holen                  }
  owndir:=ownarg^.wa_lock;             { Lock auf Verzeichnisnamen holen   }
  i:=NameFromLock(owndir,^dir,108);    { Verzeichnisnamen als String holen }
  IF dir[length(dir)]<>':'             { schauen ob ein : an letzter       }
     THEN dir:=dir+'/';                { Stelle, wenn nicht ein / anhängen }
  name:=dir+name;                      { Pfad und Dateinamen zusammenfügen }
 END
 ELSE                                  { Start vom CLI                     }
  success:=GetProgramname(^name,256);  { Programmname aus CLI besorgen     }
  holeeigenname:=name;
END;
  
 
{$endif}