workbench/system/FixFonts.c

   1 /*****************************************************************
   2  ** FixFonts                                                    **
   3  **                                                             **
   4  ** A recompile of the CBM fixfonts program                     **
   5  **                                                             **
   6  ** Version 40.2 vom 16.01.1999 © THOR-Software, Thomas Richter **
   7  ** Changes to compile with AROS - Henning Kiel, hkiel@aros.org **
   8  *****************************************************************/
   9
  10 #include <exec/types.h>
  11 #include <exec/memory.h>
  12
  13 #include <dos/dos.h>
  14 #include <dos/dosextens.h>
  15 #include <dos/dosasl.h>
  16 #include <dos/exall.h>
  17
  18 #include <diskfont/diskfont.h>
  19
  20 #ifdef __AROS__
  21 #include <aros/macros.h>
  22 #else
  23 #define AROS_ALIGN(x) x
  24 #endif
  25 #include <proto/exec.h>
  26 #include <proto/dos.h>
  27 #include <proto/diskfont.h>
  28
  29 #include <string.h>
  30
  31 #define MAXFONTLEN 25L
  32
  33
  34 char version[] = "$VER: FixFonts 40.2 (16.9.1999) (c) THOR";
  35
  36 int main()
  37 {
  38     struct ExAllControl       *exall;
  39     struct ExAllData          *ead;
  40     struct DevProc            *devproc=NULL;
  41     BPTR                       lock,
  42                                oldlock;
  43     BPTR                       file;
  44     struct FontContentsHeader *fhead;
  45     LONG                       size;
  46     ULONG                      fontflags;
  47     int                        len;
  48     long                       rc = 20;
  49     int                        more;
  50     char                       fullname[32];
  51     char                      *buffer;
  52     ULONG                      bufsize = 4096L;
  53
  54     if ((buffer=AllocMem(bufsize,MEMF_PUBLIC)))
  55     {
  56         if ((exall=AllocDosObject(DOS_EXALLCONTROL,TAG_DONE)))
  57         {
  58             /* Set return code to fine */
  59             rc=0;
  60
  61             do
  62             {
  63                 if ((devproc=GetDeviceProc("FONTS:",devproc)))
  64                 {
  65                     /* User abort? */
  66                     if (CheckSignal(SIGBREAKF_CTRL_C)) {
  67                     rc=ERROR_BREAK;
  68                     break;
  69                 }
  70
  71                 exall->eac_LastKey=0L;
  72                 if ((lock=DupLock(devproc->dvp_Lock)))
  73                 {
  74                     oldlock=CurrentDir(lock);
  75                     do
  76                     {
  77                         ead=(struct ExAllData *)buffer;
  78                         more=ExAll(lock,ead,bufsize,ED_TYPE,exall);
  79                         if (!more)
  80                         {
  81                             size=IoErr();
  82                             if (size!=ERROR_NO_MORE_ENTRIES) rc=size; /* break on an error */
  83                         }
  84                         else
  85                         {
  86                             /* if there are more entries and an error, abort */
  87                             if (rc) ExAllEnd(lock,ead,bufsize,ED_TYPE,exall);
  88                         }
  89
  90                         /* quit loop on error */
  91                         if (rc) break;
  92
  93                         if (exall->eac_Entries==0) continue; /* Ignore empty entries */
  94
  95                         do
  96                         {
  97                             if (ead->ed_Type>0)
  98                             {
  99                                 len=strlen(ead->ed_Name);
 100                                 if
 101                                 (
 102                                 len <= MAXFONTLEN
 103                                 && strncmp(ead->ed_Name, "TrueType", len) != 0
 104                                 )
 105                                 {
 106                                     /* check for user abort */
 107                                     if (CheckSignal(SIGBREAKF_CTRL_C))
 108                                     {
 109                                         rc=ERROR_BREAK;
 110                                         break;
 111                                     }
 112                                     /* Build name of the directory */
 113                                     strcpy(fullname,ead->ed_Name);
 114                                     strcpy(fullname+len,".font"); /* Add .font */
 115
 116                                     /* Build a contents header */
 117                                     fhead=NewFontContents(lock,fullname);
 118                                     if (fhead)
 119                                     {
 120                                     if (fhead->fch_NumEntries>0)
 121                                     {
 122                                     #ifdef __AROS__
 123                                     #if !AROS_BIG_ENDIAN
 124                                     WORD i;
 125
 126                                     for(i = 0; i < fhead->fch_NumEntries; i++)
 127                                     {
 128                                         if(fhead->fch_FileID == FCH_ID)
 129                                         {
 130                                             struct FontContents *fc;
 131
 132                                             fc = (struct FontContents *)(fhead + 1);
 133                                             fc += i;
 134
 135                                             fc->fc_YSize = AROS_WORD2BE(fc->fc_YSize);
 136                                         }
 137                                         else if
 138                                         (
 139                                                (fhead->fch_FileID == TFCH_ID)
 140                                             || (fhead->fch_FileID == OFCH_ID)
 141                                         )
 142                                         {
 143                                             struct TFontContents *tfc;
 144
 145                                             tfc = (struct TFontContents *)(fhead + 1);
 146                                             tfc += i;
 147
 148                                             if (tfc->tfc_TagCount)
 149                                             {
 150                                                 ULONG *tags;
 151                                                 WORD t;
 152
 153                                                 tags = (ULONG *)(&tfc->tfc_FileName[MAXFONTPATH-(tfc->tfc_TagCount*8)]);
 154                                                 for (t = 0; t < tfc->tfc_TagCount * 2 - 1; t++)
 155                                                 {
 156                                                     tags[t] = AROS_LONG2BE(tags[t]);
 157                                                 }
 158                                             }
 159                                             tfc->tfc_TagCount = AROS_WORD2BE(tfc->tfc_TagCount);
 160                                             tfc->tfc_YSize = AROS_WORD2BE(tfc->tfc_YSize);
 161                                         }
 162
 163                                     } /* for(i = 0; i < fhead->fch_NumEntries; i++) */
 164
 165                                     fhead->fch_FileID = AROS_WORD2BE(fhead->fch_FileID);
 166                                     fhead->fch_NumEntries = AROS_WORD2BE(fhead->fch_NumEntries);
 167
 168                                     #endif
 169                                     #endif
 170                                     file=Open(fullname,MODE_NEWFILE);
 171                                     if (file)
 172                                     {
 173                                         /* Find the size of the header. This is definitely a hack... */
 174                                         size=*((LONG *)((UBYTE *)fhead-AROS_ALIGN(sizeof(ULONG))))-sizeof(LONG); /* Ehem. This is AllocVec'd */
 175                                         rc=0;
 176                                         if (Write(file,fhead,size)<0) rc=IoErr();
 177                                         Close(file);
 178                                         /* Delete the file on failure, clear executeable otherwise */
 179                                         if (rc) DeleteFile(fullname);
 180                                         else    SetProtection(fullname,FIBF_EXECUTE);
 181                                     }
 182                                     else
 183                                     {
 184                                         rc=IoErr();
 185                                     }
 186                                     }
 187                                     else
 188                                     {
 189                                         DeleteFile(fullname); /* Remove empty fonts */
 190                                     }
 191                                     DisposeFontContents(fhead);          /* remove the fcheader */
 192                                     }
 193                                     else
 194                                     {
 195                                         /* FontContents allocation */
 196                                         size=IoErr();
 197                                         if (size==0) rc=ERROR_NO_FREE_STORE;
 198                                         else         rc=size;
 199                                     }
 200                                 } /* if name small enough */
 201                             } /* if type is directory */
 202
 203                             if (rc) break;
 204                             /* Abort on failure */
 205
 206                             ead=ead->ed_Next;
 207                         } while(ead); /* ExAll buffer loop */
 208                     } while(more); /* while more entries in exall-loop */
 209
 210                     /* restore the old directory */
 211                     UnLock(lock);
 212                     CurrentDir(oldlock);
 213                 }
 214                 else
 215                 {
 216                     rc=IoErr();
 217                 } /* If DupLock() */
 218
 219                 /* No more entries? */
 220                 if ((devproc->dvp_Flags & DVPF_ASSIGN)==0) break;
 221
 222                 }
 223                 else
 224                 {             /* GetDeviceProc worked */
 225                     rc=IoErr();
 226                     if (rc==ERROR_NO_MORE_ENTRIES) rc=0; /* Default fault is fine */
 227                     break;          /* loop abort */
 228                 }
 229             } while(rc==0); /* GetDeviceProc loop */
 230
 231             FreeDeviceProc(devproc);
 232             FreeDosObject(DOS_EXALLCONTROL,exall);
 233         }
 234         else
 235         {
 236             rc=ERROR_NO_FREE_STORE;
 237         }
 238
 239         /* Still no error? Rewrite font cache! */
 240         if (rc==0)
 241         {
 242             fontflags=AFF_DISK;
 243             while (rc==0)
 244             {
 245                 for (;;)
 246                 {
 247                     size=AvailFonts((STRPTR)buffer,bufsize,fontflags);
 248                     if (size>0)
 249                     {
 250                         FreeMem(buffer,bufsize);
 251                         bufsize+=size;
 252                         buffer=AllocMem(bufsize,MEMF_PUBLIC);
 253                         if (buffer==NULL)
 254                         {
 255                             rc=ERROR_NO_FREE_STORE;
 256                             break;
 257                         }
 258                     }
 259                     else if (size==0)
 260                     {
 261                         break;
 262                     }
 263                     else
 264                     {
 265                         rc=IoErr();
 266                         break;
 267                     } /* size switch */
 268                 } /* buffer enlarge loop */
 269
 270                 if (fontflags & AFF_TAGGED) break;
 271
 272                 fontflags |= AFF_TAGGED;        /* and now for the tagged stuff */
 273             }
 274         } /* FontCache rewrite */
 275
 276         FreeMem(buffer,bufsize);
 277     }
 278     else
 279     {
 280         rc=ERROR_NO_FREE_STORE;     /* buffer allocation */
 281     }
 282
 283     if (rc)
 284     {
 285         if (rc>64)
 286         {
 287             PrintFault(rc,"FixFonts failed");
 288
 289             if (rc==ERROR_BREAK) rc=0;
 290             else                 rc=10;
 291         }
 292     }
 293
 294     return rc;
 295 }