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