/* --(FontDesigner)-------- File h0.c ----------- */

#include <exec/memory.h>
#include <intuition/intuition.h>
#include <intuition/intuitionbase.h>
#include <libraries/dos.h>
#include <graphics/gfxmacros.h>

#include "header.h"

/*-------------------- Externe Variablen aus main ------------------------*/

extern struct TextFont *tfuser,*tftopaz;
extern short *drawmem;
extern long XMatrix,YMatrix,BaseLine,Ascii;
extern ULONG *cmatrix;
extern struct FileInfoBlock *f_info;
extern struct RastPort *rast;
extern struct Image *oima,*mima;

/*---------------------- Daten  für GetFilename()  -----------------------*/
short fdat[][4]=
{
   { 10,16,48,28 },
   { 69,16,107,28 },
   { 128,16,166,28 },
   { 187,16,225,28 },
   { 248,16,302,28 },

   { 70,33,302,45 },
   { 10,50,272,152 },
   { 282,50,302,60 },
   { 282,142,302,153 },
   { 10,174,194,186 },

   { 10,191,64,203 },
   { 248,191,302,203 },
   { 264,174,302,186 },
   { 202,174,256,186 },
   { 10,157,128,169 },
   { 149,157,251,169 },
   { 272,157,302,169 },
   { 97,191,215,203 },
};

char *ftxt[]=
{
   "DF0:","DF1:","DF2:","DF3:","PARENT","DRAWER","","","","","  OK",
   "CANCEL","FAST","ASSIGN","FROM ASCII:","TO ASCII:","ALL",
   "IO Error: none",
};

short fpfeil[][7]=
{
   { 292,51,284,59,300,59,-2 },
   { 292,151,284,143,300,143,-2 },
};

struct StringInfo gf_info1,gf_info2;

struct Gadget gf_gad2=
{
   NULL,14,177,178,9,GADGHCOMP,NULL,STRGADGET,
   NULL,NULL,NULL,NULL,&gf_info2,1,NULL,
};
struct Gadget gf_gad1=
{
   &gf_gad2,74,36,228,9,GADGHCOMP,RELVERIFY,STRGADGET,
   NULL,NULL,NULL,NULL,&gf_info1,1,NULL,
};

char edrawer[100]="DF0:fonts";
char efname[100];
short FAscii=0,TAscii=255;

/*----------------------- Daten für SaveFont() --------------------------*/

unsigned long ublock1[]=
{
   0x3f3,0,1,0,0,0x35e,0x3e9,0x35e,0x70004e75,0,0,0x0c000000,
   0x001a0f80,0x00010000,0,0,0,0,0,0,0,0,0,0,0xc00,0x1a,0,
   0,0x0062000f,0x00060001,0,0x6e,0x66e0000,0x9f20000,0xbb40000
};
unsigned long ublock2[]=
{
   0,0x03ec0000,0x00060000,0x0,0x000e0000,0x00440000,0x005c0000,
   0x00620000,0x00660000,0x006a0000,0,0x03f20000,
};

short sdat[][4]=
{
   { 10,16,64,28 },
   { 74,16,300,28 },
   { 10,33,88,45 },
   { 88,33,190,45 },
   { 190,33,300,45 },
   { 10,50,112,62 },
   { 206,50,300,62 },
   { 10,67,64,79 },
   { 246,67,300,79 },
   { 120,67,190,79 },
};
char *stxt[]=
{
   "DRAWER","","HIGHT:","LOW CHAR:","HIGH CHAR:","PROPORTIONAL",
   "FIXED WIDTH","  OK","CANCEL","GET NAME",
};
struct StringInfo s_info;

struct Gadget s_gad=
{
   NULL,78,19,218,9,GADGHCOMP,NULL,STRGADGET,
   NULL,NULL,NULL,NULL,&s_info,1,NULL,
};
char fontbreit[256];

/*h0.1----------------------- Diskfont laden ----------------------------*/
BYTE LoadDiskFont()
{
struct TextAttr txtatr;
BYTE erfolg,hmem[100];
long i;
double atof();
static BYTE count=0;

   if(count==0)
   {
      strcpy(efname,"");
      strcpy(edrawer,"DF0:fonts");
      count++;
   }
   erfolg=GetFilename(edrawer,efname);
   if(erfolg < 0) return(erfolg);

   strcpy(hmem,edrawer);
   strcpy(edrawer+strlen(edrawer),".font");
   txtatr.ta_Name=edrawer;
   txtatr.ta_YSize=(UWORD)atof(efname);
   txtatr.ta_Style=0;
   txtatr.ta_Flags=0;
   tfuser=OpenDiskFont(&txtatr);
   i=0;
   if(tfuser==0)
   {
      tfuser=tftopaz;
      i=-1;
   }

   edrawer[strlen(edrawer)-5]=0;
   return(i);
}
/*h0.2----------------------- Filename Holen ----------------------------*/
BYTE GetFilename(drawer,filename)
char filename[],drawer[];
{
ULONG flags=WINDOWDRAG|WINDOWCLOSE|WINDOWDEPTH|SMART_REFRESH|
            ACTIVATE;
ULONG iflags=MOUSEBUTTONS|CLOSEWINDOW|GADGETUP|GADGETDOWN|DISKINSERTED;
struct Window *wn;
struct RastPort *rp;
BYTE i,offs=3,*names,*point,flag,mode=0;
short mox,moy;
ULONG class;
USHORT code;
short fzahl,start=1,nr,aktdrive=0;
short DirScroll();

   wn=Make_Window(20,10,320,209,"GET FILENAME",flags,iflags,0);
   if(wn==0) return(-3);
   names=AllocMem(1024,MEMF_CLEAR);
   if(names==0) return(-3);
   rp=wn->RPort;
   SetAPen(rp,1);RectFill(rp,0,11,320,209);
   Box(rp,2,12,317,207,0,JAM1);

   for(i=0;i<=17;i++)
   {
      SetAPen(rp,0);
      RectFill(rp,fdat[i][0],fdat[i][1],fdat[i][2],fdat[i][3]);
      Box(rp,fdat[i][0],fdat[i][1],fdat[i][2],fdat[i][3],2,JAM1);
      Box(rp,fdat[i][0]-1,fdat[i][1],fdat[i][2]+1,fdat[i][3],2,JAM1);
      if(i==5)
      {
         offs=-57;SetAPen(rp,0);
         RectFill(rp,10,33,64,45);
      }
      else offs=3;
      Text_out(rp,fdat[i][0]+offs,fdat[i][1]+3,3,0,JAM2,ftxt[i],0);
   }
   FDrawPolygon(rp,fpfeil[0],3,JAM2);
   FDrawPolygon(rp,fpfeil[1],3,JAM2);

   gf_info1.Buffer=drawer;gf_info2.Buffer=filename;
   gf_info1.UndoBuffer=NULL;gf_info2.UndoBuffer=NULL;
   gf_info1.MaxChars=100;gf_info2.MaxChars=100;
   AddGadget(wn,&gf_gad1,-1);AddGadget(wn,&gf_gad2,-1);
   RefreshGadgets(&gf_gad1,wn,NULL);
   fzahl=GetDir(names,drawer,mode);
   DirOut(rp,names,start,fzahl);
   FOREVER
   {
      while (ExaIntui(wn,&class,&code))
      {
         mox=wn->MouseX;moy=wn->MouseY;

         switch (class)
         {
            case CLOSEWINDOW:
               flag=-2;
            ende:
               FreeMem(names,1024);
               RemoveGadget(wn,&gf_gad1);RemoveGadget(wn,&gf_gad2);
               CloseWindow(wn);
               return(flag);

            case DISKINSERTED:
               strcpy(drawer,ftxt[aktdrive]);
               strcpy(&drawer[4],"fonts");
               Assign(drawer);

            case GADGETUP: case GADGETDOWN:
               RefreshGadgets(&gf_gad1,wn,NULL);
               fzahl=GetDir(names,drawer,mode);
               start=1;
               DirOut(rp,names,start,fzahl);
               break;
            case MOUSEBUTTONS:
               if(code != SELECTDOWN)break;
               i=Prurec(mox,moy,fdat,0,16);
               if(i<0)break;
               if(i!=6 && i<14)Invert(rp,fdat[i]);
               switch(i)
               {
                  case 0: case 1: case 2: case 3: case 4: case 12:
                     if(i!=4 && i!=12)
                     {
                        aktdrive=i;
                        strcpy(drawer,ftxt[i]);
                        strcpy(&drawer[4],"fonts");
                        Assign(drawer);
                     }
                     else
                     {
                        if(i==4)
                          Parent(drawer);
                     }
                     if(i==12)mode=1;
                     fzahl=GetDir(names,drawer,mode);
                     mode=0;
                     start=1;
                     DirOut(rp,names,start,fzahl);
                     Invert(rp,fdat[i]);
                     break;
                  case 6:
                     nr=(moy-52)/10+start;
                     if(nr>=fzahl)break;
                     i=52+(nr-start)*10;
                     SetDrMd(rp,COMPLEMENT);
                     RectFill(rp,11,i,271,i+7);
                     Delay(5);RectFill(rp,11,i,271,i+7);
                     point=names;
                     for(i=1;i<=nr-1;i++)
                     {
                        point++;
                        point+=strlen(point)+1;
                     }
                     moy=*point;point++;
                     if(moy==1)
                     {
                        if(drawer[strlen(drawer)-1] != ':')
                           strcpy(drawer+strlen(drawer),"/\0");
                        strcpy(drawer+strlen(drawer),point);
                        fzahl=GetDir(names,drawer,mode);
                        start=1;
                        DirOut(rp,names,start,fzahl);
                     }
                     else strcpy(filename,point);
                     break;
                  case 7: case 8:
                     start=DirScroll(wn,names,start,fzahl,i);
                     Invert(rp,fdat[i]);
                     break;
                  case 10: case 11:
                     if(i==10) flag=0;
                     else flag=-2;
                     Delay(5);Invert(rp,fdat[i]);
                     goto ende;
                  case 13:
                     ModifyIDCMP(wn,wn->IDCMPFlags&(~DISKINSERTED));
                     Assign(drawer);
                     ModifyIDCMP(wn,wn->IDCMPFlags|DISKINSERTED);
                     Invert(rp,fdat[i]);
                     break;
                  case 14:
                     SetAPen(rp,3);SetDrMd(rp,JAM2);
                     FAscii=(short)input_zahl(wn,fdat[14][0]+91,
                                              fdat[14][1]+3,3,"");
                     if(FAscii<0 || FAscii>TAscii)FAscii=0;
                     break;
                  case 15:
                     SetAPen(rp,3);SetDrMd(rp,JAM2);
                     TAscii=(short)input_zahl(wn,fdat[15][0]+75,
                                                 fdat[15][1]+3,3,"");
                     if(TAscii>255 || TAscii<FAscii)TAscii=255;
                     break;
                  case 16:
                     Invert(rp,fdat[i]);
                     FAscii=0;TAscii=255;
                     Delay(5);
                     Invert(rp,fdat[16]);
                     break;
               }
               RefreshGadgets(&gf_gad1,wn,NULL);
         }
         ErrOut(rp);
      }
   }
}
/*--- Unterfunktion zu h0.2 ---*/
short DirScroll(wn,names,start,fzahl,mode)
struct Window *wn;
char *names;
short start,fzahl,mode;
{
ULONG class;
USHORT code;

   Delay(10);
   FOREVER
   {
      switch (mode)
      {

         case 7:
            if(start>1)
            {
               start--;
               DirOut(wn->RPort,names,start,fzahl);
            }
            break;
         case 8:
            if(start<(fzahl-10))
            {
               start++;
               DirOut(wn->RPort,names,start,fzahl);
            }
            break;
      }
      if(ExaIntui(wn,&class,&code))break;
   }
   return(start);
}

/*h0.3--------------------- Direktory laden ------------------------------*/
short GetDir(namen,dirname,mode)
BYTE mode;
char *namen,*dirname;
{
struct FileLock *lockp;
register short anz;
short flag;
char *point=namen;

   if((lockp=Lock(dirname,ACCESS_READ))==0)
      return(-1);
   if(Examine(lockp,f_info)==0)return(-1);
   if(f_info->fib_DirEntryType<0) return(-1);

   flag=FastDir(0,dirname,point,anz);
   if(flag>0 && mode==0)
   {
      SortDir(point,flag);
      return(flag);
   }

   while(ExNext(lockp,f_info)==-1)
   {
      if(f_info->fib_DirEntryType<0)
         *namen=0;
      else
         *namen=1;
      namen++;
      strcpy(namen,f_info->fib_FileName);
      namen+=(strlen(f_info->fib_FileName)+1);
      anz++;
   }
   UnLock(lockp);
   if(IoErr()==ERROR_NO_MORE_ENTRIES)
   {
      if(mode==1) FastDir(1,dirname,point,anz);
      SortDir(point,anz);
      return(anz);
   }
   else return(-1);
}
/*h0.4------------------- Direktory ausgeben ----------------------------*/
void DirOut(rp,names,start,max)
char *names;
struct RastPort *rp;
short start,max;
{
short xa=13,ya=52,i,anz=max-start;
char farbe;


   SetAPen(rp,0);SetDrMd(rp,JAM1);
   RectFill(rp,11,51,271,151);
   for(i=1;i<=start-1;i++)
   {
      names++;
      names+=strlen(names)+1;
   }
   if(anz>10)anz=10;
   for(i=1;i<=anz;i++,ya+=10)
   {
      farbe=2;
      if(*names==1)
         farbe=3;
      names++;
      Text_out(rp,xa,ya,farbe,0,JAM2,names,0);
      names+=strlen(names)+1;
   }
}
/*h0.5------------------- Io Fehler ausgeben --------------------------*/
void ErrOut(rp)
struct RastPort *rp;
{
long err;
char htxt[15];

   err=IoErr();
   if(err<103 || err>231)
      strcpy(htxt,ftxt[17]);
   else
      sprintf(htxt,"IO Error:  %3.0f",(float)err);

   Text_out(rp,fdat[17][0]+3,fdat[17][1]+3,3,0,JAM2,htxt,14);
   sprintf(htxt,"%3.0f",(float)FAscii);
   Text_out(rp,fdat[14][0]+91,fdat[14][1]+3,3,0,JAM2,htxt,0);
   sprintf(htxt,"%3.0f",(float)TAscii);
   Text_out(rp,fdat[15][0]+75,fdat[15][1]+3,3,0,JAM2,htxt,0);
}
/*h0.6-------------- Fast Directory lesen oder erzeugen -----------------*/
short FastDir(mode,drawer,nam,anz)
char mode,*drawer,*nam;
short anz;
{
ULONG datei;
char dateiname[80],text[10],*point=nam;
short bytes=0,i;

   strcpy(dateiname,drawer);
   if(drawer[strlen(drawer)-1]==':')
      strcpy(text,"fd.fdir");
   else
      strcpy(text,"/fd.fdir");

   strcpy(dateiname+strlen(dateiname),text);

   switch(mode)
   {
      case 0:
         datei=Open(dateiname,MODE_OLDFILE);
         if(datei==0)return(-1);
         if(Read(datei,&anz,2)!=2) goto abbruch;
         Read(datei,nam,1024);
         break;

      case 1:
         for(i=1;i<=anz-1;i++)
         {
            point++;
            bytes+=strlen(point)+2;
            point+=strlen(point)+1;
         }
         datei=Open(dateiname,MODE_NEWFILE);
         if(datei==0)return(-1);
         if(Write(datei,&anz,2)!=2) goto abbruch;
         if(Write(datei,nam,bytes)!=bytes) goto abbruch;
         break;
   }
   Close(datei);
   return(anz);

abbruch:
   Close(datei);
   return(-1);
}
/*h0.7---------------- Textfont auf Diskette schreiben -------------------*/
void SaveFont()
{
ULONG flags=ACTIVATE|WINDOWCLOSE|WINDOWDRAG;
ULONG iflags=MOUSEBUTTONS|CLOSEWINDOW;
ULONG class;
USHORT code;
long i,help=Ascii;
struct Window *wn;
struct RastPort *rp;
short mox,moy,lochar=32,hichar=255;
BYTE proflag=1;
void zahl_out();

   wn=Make_Window(50,20,318,90,"SAVE FONT",flags,iflags,0);
   if(wn==0)return();
   rp=wn->RPort;
   SetAPen(rp,1);RectFill(rp,0,11,318,90);
   Box(rp,2,12,315,88,0,JAM1);

   for(i=0;i<=9;i++)
   {
      SetAPen(rp,0);
      RectFill(rp,sdat[i][0],sdat[i][1],sdat[i][2],sdat[i][3]);
      Box(rp,sdat[i][0],sdat[i][1],sdat[i][2],sdat[i][3],2,JAM1);
      Text_out(rp,sdat[i][0]+3,sdat[i][1]+3,3,0,JAM2,stxt[i],0);
   }
   s_info.Buffer=edrawer;
   s_info.UndoBuffer=NULL;
   s_info.MaxChars=100;
   AddGadget(wn,&s_gad,-1);
   RefreshGadgets(&s_gad,wn,NULL);
   zahl_out(rp,lochar,hichar);
   Invert(rp,sdat[5]);

   FOREVER
   {
      while (ExaIntui(wn,&class,&code))
      {
         mox=wn->MouseX;moy=wn->MouseY;

         switch(class)
         {
            case CLOSEWINDOW:
            ende:
               RemoveGadget(wn,&s_gad);
               CloseWindow(wn);
               return();

            case MOUSEBUTTONS:
               if(code != SELECTDOWN)break;
               i=Prurec(mox,moy,sdat,2,9);
               if(i<0)break;
               SetAPen(rp,1);
               switch(i)
               {
                  case 2:
                     YMatrix=(long)input_zahl(wn,61,36,2,"");
                     if(YMatrix<0 || YMatrix>50) YMatrix=8;
                     break;
                  case 3:
                     lochar=(short)input_zahl(wn,163,36,3,"");
                     if(lochar>hichar || lochar<0) lochar=32;
                     break;
                  case 4:
                     hichar=(short)input_zahl(wn,273,36,3,"");
                     if(hichar<lochar || hichar>255) hichar=255;
                     break;
                  case 5:
                     if(proflag==1)break;
                     proflag=1;
                     Invert(rp,sdat[5]);Invert(rp,sdat[6]);
                     break;
                  case 6:
                     if(proflag==0)break;
                     proflag=0;
                     Invert(rp,sdat[5]);Invert(rp,sdat[6]);
                     break;
                 case 7: case 8:
                     Invert(rp,sdat[i]);
                     if(i==7)
                     {
                        if(MakeFont(proflag,lochar,hichar)<0)
                           Shure(2);
                     }
                     Ascii=help;AsciiOut();
                     Delay(5);
                     goto ende;
                     break;
                 case 9:
                  Invert(rp,sdat[i]);
                  GetFilename(edrawer,efname);
                  YMatrix=(long)atoi(efname);
                  Invert(rp,sdat[i]);
                  break;
            }
            RefreshGadgets(&s_gad,wn,NULL);
            zahl_out(rp,lochar,hichar);
         }
      }
   }
}
/*---- Unterfunktion zu h0.7 ------*/
void zahl_out(rp,lochar,hichar)
struct RastPort *rp;
short lochar,hichar;
{
char htext[10];

   sprintf(htext,"%2.0f",(float)YMatrix);
   Text_out(rp,61,36,1,0,JAM2,htext,0);
   sprintf(htext,"%3.0f",(float)lochar);
   Text_out(rp,163,36,1,0,JAM2,htext,0);
   sprintf(htext,"%3.0f",(float)hichar);
   Text_out(rp,273,36,1,0,JAM2,htext,0);
}
/*h0.8----------------- Font berechnen und schreiben -------------------------*/
BYTE MakeFont(pflag,lochar,hichar)
BYTE pflag;
short lochar,hichar;
{
ULONG datei;
BYTE mode,hmem[100],*nam;
short modulo=0,anz=hichar-lochar+1,i,anz1,h1;
USHORT *point=&ublock1[5];
void WriteLine(),WriteCharLoc(),WriteSpace(),WriteKern();

   mode=PruConf(edrawer,YMatrix);
   if(WriteFont(mode,edrawer,YMatrix)<0)return(-1);

   sprintf(hmem,"%s/%1.0f",edrawer,(float)YMatrix);
   Shure(8);
   for(i=lochar;i<=hichar;i++)
   {
      Ascii=i;AsciiOut();
      fontbreit[i]=Breit(pflag,i);
      modulo+=fontbreit[i];
   }
   modulo/=8;modulo+=(4-modulo%4);
   h1=0x6e+modulo*YMatrix;
   anz1=modulo*YMatrix+anz*8+8;
   point++;
   *point=(anz1+112)/4;point+=4;
   *point=(anz1+112)/4;point=&ublock1[27];
   *point=anz1;point++;
   *point=YMatrix;point++;
   *point=98;
   point++;
   *point=(USHORT)XMatrix;point++;
   *point=(USHORT)BaseLine;point+=3;
   *point=256*lochar+hichar;point+=3;
   *point=modulo;point+=2;
   *point=h1;point+=2;
   *point=h1+anz*4+4;point+=2;
   *point=h1+(anz*4+4)+(anz*2+2);

   point=drawmem;
   Shure(8);
   datei=Open(hmem,MODE_NEWFILE);
   if(datei==0)return(-1);
   Shure(9);
   if(Write(datei,ublock1,142)!=142) goto abbruch;

   /* ---- CharData schreiben -----*/
   for(i=0;i<=YMatrix-1;i++)
   {
      BltClear(point,modulo,1);
      WriteLine(i,lochar,hichar);
      if(Write(datei,point,modulo)!=modulo) goto abbruch;
   }
   /* ---- CharLoc schreiben -----*/

   WriteCharLoc(lochar,hichar);
   if(Write(datei,point,anz*4+4)!=anz*4+4) goto abbruch;

   /* ---- CharSpace schreiben ----*/

   WriteSpace(lochar,hichar);
   if(Write(datei,point,anz*2+2)!=anz*2+2) goto abbruch;

   /* ---- CharKern schreiben -----*/

   WriteKern(lochar,hichar);
   if(Write(datei,point,anz*2+2)!=anz*2+2) goto abbruch;

   if(Write(datei,ublock2,46)!=46) goto abbruch;
   Close(datei);
   Shure(9);
   /* ---- Fast Direktory erzeugen -----*/
   if(mode != 0)
   {
      sprintf(hmem,"%s/fd.fdir",edrawer);
      DeleteFile(hmem);
   }
   if(mode==2)
   {
      nam=AllocMem(1024,MEMF_CLEAR);
      if(nam != 0)
      {
         strcpy(hmem,edrawer);
         Parent(hmem);
         sprintf(hmem,"%s/fd.fdir",hmem);
         datei=Open(hmem,MODE_OLDFILE);
         if(datei != 0)
         {
            Close(datei);
            Shure(10);
            Parent(hmem);
            GetDir(nam,hmem,1);
            Shure(10);
         }
         FreeMem(nam,1024);
      }
   }
   return(0);
abbruch:
   Shure(9);
   Close(datei);
   return(-1);
}
/*--- Unterfunktionen zu h0.8-----*/
void WriteLine(i,lochar,hichar)
short i,lochar,hichar;
{
register short j,k;
register ULONG *adr;
register long count=0;
long *point=drawmem;

   for(j=lochar;j<=hichar;j++)
   {
      adr=cmatrix+100*j+2*i;
      for(k=0;k<=fontbreit[j]-1;k++,count++)
      {
         if(TestBit(adr,k))
            SetBit(point,count);
         else
            ClrBit(point,count);
      }
   }
}
/*-------------------------------*/
void WriteCharLoc(lochar,hichar)
short lochar,hichar;
{
register short *point=drawmem,offs=0,i;

   for(i=lochar;i<=hichar;i++)
   {
      Ascii=i;AsciiOut();
      *point=offs;point++;
      *point=fontbreit[i];point++;
      offs+=fontbreit[i];
   }
   *point=0;point++;*point=0;
}
/*-----------------------------*/
void WriteKern(lochar,hichar)
short lochar,hichar;
{
register short *point=drawmem,i;

   for(i=lochar;i<=hichar;i++)
   {
      Ascii=i;AsciiOut();
      *point=1;
      point++;
   }
   *point=0;
}
/*----------------------------*/
void WriteSpace(lochar,hichar)
short lochar,hichar;
{
register short *point=drawmem,i;

   for(i=lochar;i<=hichar;i++)
   {
      Ascii=i;AsciiOut();
      if(fontbreit[i]==0)
         *point=XMatrix;
      else
         *point=fontbreit[i]+1;
      point++;
   }
   *point=0;
}
/*h0.9--------------- Ermittelt die Breite eines Zeichens ----------------*/
short Breit(pflag,ascii)
BYTE pflag;
short ascii;
{
ULONG *adr=cmatrix+100*ascii;
long i,j,flag=0;

   if(pflag==0)return(XMatrix);

   for(i=XMatrix-1;i>=0;i--)
   {
      for(j=0;j<=YMatrix;j++)
      {
         if(TestBit(adr,j*64+i))
            flag=1;
      }
   if(flag==1)break;
   }
   if(flag==0)return(0);
   return(i+1);
}
/*h0.10--------------- Prüft ob Diskfont vorhanden -----------------------*/
BYTE PruConf(drawer,high)
char drawer[];
short high;
{
ULONG datei;
char hmem[100],h;
struct FileLock *lock;

   sprintf(hmem,"%s/%1.0f",drawer,(float)high);
   datei=Open(hmem,MODE_OLDFILE);
   if( datei != 0) { Close(datei);return(0); }

   lock=Lock(drawer,ACCESS_READ);
   if(lock != 0) h=1;
   else
   {
      lock=CreateDir(drawer);
      h=2;
   }
   UnLock(lock);
   return(h);
}
/*h0.11----------------Erzeugt den File xxxx.font ------------------------*/
BYTE WriteFont(mode,drawer,high)
BYTE mode;
char drawer[];
short high;
{
char puffer[264],filename[100];
long help;
short i;
ULONG datei;


   if(mode==0)return(0);
   if (datei==0) {Shure(11);
                  return(-1);}
   for(i=0;i<=263;i++) puffer[i]=0;
   puffer[0]=0x0f;puffer[3]=1;puffer[263]=0x62;puffer[261]=high;

   for(i=strlen(drawer);i>=0;i--)
   {
      if(drawer[i]=='/' || drawer[i]==':')
         break;
   }
   sprintf(filename,"%s.font",drawer);
   sprintf(&puffer[4],"%s/%1.0f",&drawer[i+1],(float)high);
   switch(mode)
   {
      case 1:
         datei=Open(filename,MODE_OLDFILE);
         if(datei==0)return(-1);
         if(Read(datei,&help,4)!=4) goto abbruch;
         help++;
         Seek(datei,0,OFFSET_BEGINNING);
         if(Write(datei,&help,4)!=4) goto abbruch;
         Seek(datei,0,OFFSET_END);
         if(Write(datei,&puffer[4],260)!=260)goto abbruch;
         break;

      case 2:
         datei=Open(filename,MODE_NEWFILE);
         if(datei==0) {shure(11);
                       return(-1);}
         if(Write(datei,puffer,264)!=264) goto abbruch;
         break;
   }
   Shure(11);
   Close(datei);
   return(0);

abbruch:
   Shure(11);
   Close(datei);
   return(-1);
}
/*h0.12--------- Ermittelt übergeordnetes Verzeichnis ------------------*/
void Parent(name)
char *name;
{
register short i,flag;

   for(i=strlen(name);i>=0;i--)
   {
      if(name[i]=='/') { flag=0;break; }
      if(name[i]==':') { flag=1;break; }
   }
   if(flag==1)i++;
   name[i]=0;
}
/*h0.13----------- Zeichnet kleines Image --------------------*/
void DrawLittle(mode,x,y,adr)
BYTE mode;
short x,y;
register ULONG *adr;
{
register ULONG *adr1=drawmem;
register short i;

   for(i=0;i<=99;*adr1=*adr,adr++,adr1++,i++);
   oima->ImageData=mima->ImageData=drawmem;

   if(mode==0)
      DrawImage(rast,oima,x,y);
   else
      DrawImage(rast,mima,x,y);
}
/*-----------------------------------------------------------------------*/