workbench/libs/diskfont/af_fontdescr_io.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Functions for readin .font files
   6     Lang: English.
   7 */
   8
   9 /****************************************************************************************/
  10
  11 #include <diskfont/diskfonttag.h>
  12 #include <aros/macros.h>
  13
  14 #include <proto/dos.h>
  15 #include <proto/utility.h>
  16 #include <proto/arossupport.h>
  17 #include <string.h>
  18 #include "diskfont_intern.h"
  19
  20 #include <aros/debug.h>
  21
  22 /****************************************************************************************/
  23
  24 /******************/
  25 /* ReadFontDescr  */
  26 /******************/
  27
  28 /****************************************************************************************/
  29
  30 struct FontDescrHeader *ReadFontDescr(CONST_STRPTR filename, struct DiskfontBase_intern *DiskfontBase)
  31 {
  32     struct FontDescrHeader  *fdh = 0;
  33     struct TTextAttr        *tattr;
  34     BPTR                     fh;
  35     UWORD                    aword, numentries, numtags;
  36     UWORD                   *availsizes = NULL;
  37     UWORD                    numoutlineentries = 0;
  38     UBYTE                    strbuf[MAXFONTPATH + 1];
  39
  40     D(bug("ReadFontDescr(filename=%s\n", filename));
  41
  42     /* Allocate the FontDescrHeader */
  43     if (!(fh = Open(filename, MODE_OLDFILE)))
  44         goto failure;
  45
  46     if (!(fdh = AllocMem(sizeof (struct FontDescrHeader), MEMF_ANY | MEMF_CLEAR)) )
  47         goto failure;
  48
  49     /* First read the file id (FCH_ID or TFCH_ID) */
  50     if (!ReadWord( &DFB(DiskfontBase)->dsh, &aword, (void *)fh ))
  51         goto failure;
  52
  53     /* Check that this is a .font file */
  54
  55     if ( (aword != FCH_ID) && (aword != TFCH_ID) && (aword != OFCH_ID) )
  56     {
  57         D(bug("ReadFontDescr: unsupported file id\n"));
  58         goto failure;
  59     }
  60
  61     fdh->ContentsID = aword;
  62
  63     fdh->Tagged = ((aword == TFCH_ID) || (aword == OFCH_ID));
  64
  65      /* Read number of (T)FontContents structs in the file */
  66     if (!ReadWord( &DFB(DiskfontBase)->dsh, &numentries , (void *)fh ))
  67     {
  68         D(bug("ReadFontDescr: error reading numentries\n"));
  69         goto failure;
  70     }
  71
  72     fdh->NumEntries = numentries;
  73
  74     if (fdh->ContentsID == OFCH_ID)
  75     {
  76         fdh->OTagList = OTAG_GetFile(filename, DiskfontBase);
  77         if (fdh->OTagList)
  78         {
  79             availsizes = (UWORD *)GetTagData(OT_AvailSizes, (IPTR) NULL, fdh->OTagList->tags);
  80             if (availsizes)
  81             {
  82                 /* OT_AvailSizes points to an UWORD array, where the first UWORD
  83                    is the number of entries, and the following <numentry> UWORD's
  84                    are the sizes */
  85
  86                 numoutlineentries = AROS_BE2WORD(*availsizes);
  87                 availsizes++;
  88
  89             }
  90         }
  91         else
  92         {
  93             D(bug("ReadFontDescr: No OTagList for outlined font\n"));
  94
  95             #warning "stegerg: CHECKME!! Prevent OTAG_ functions from being called on NULL/non existing otag / taglist"
  96             fdh->ContentsID = TFCH_ID;
  97         }
  98     }
  99
 100     if (!(numentries + numoutlineentries)) goto failure;
 101
 102     /* Allocate mem for array of TTextAttrs */
 103     fdh->TAttrArray = AllocVec((fdh->NumEntries + numoutlineentries) * sizeof(struct TTextAttr), MEMF_ANY|MEMF_CLEAR);
 104     if (!fdh->TAttrArray) goto failure;
 105
 106     tattr = fdh->TAttrArray;
 107
 108     while (numentries--)
 109     {
 110
 111         /* Read the fontname */
 112
 113         STRPTR  strptr;
 114         UWORD   len = 0; /* Length of fontname in file including null-termination */
 115
 116         strptr = strbuf;
 117
 118         do
 119         {
 120             if (!ReadByte( &DFB(DiskfontBase)->dsh, strptr, (void *)fh))
 121                 goto failure;
 122
 123             len ++;
 124         }
 125         while (*strptr ++);
 126
 127         /* We set tattr->tta_Name to the real font name, for
 128            example FONTS:helvetica/15 */
 129
 130         if (!(tattr->tta_Name = AllocVec(len + 1, MEMF_ANY)))
 131             goto failure;
 132
 133         strcpy(tattr->tta_Name, strbuf);
 134
 135         D(bug("ReadFontDescr: tta_Name \"%s\"\n", tattr->tta_Name));
 136
 137         /* Seek to the end of the fontnamebuffer ( - 2 if tagged) */
 138         Flush(fh);
 139         Seek
 140         (
 141             fh,
 142             MAXFONTPATH - ( len + (fdh->Tagged ? 2 : 0) ),
 143             OFFSET_CURRENT
 144         );
 145
 146
 147         /* Do special stuff for files with tags in them */
 148         if (fdh->Tagged)
 149         {
 150
 151             /* Next thing up is the tagcount */
 152             if (!ReadWord(&DFB(DiskfontBase)->dsh, &numtags, (void *)fh))
 153                 goto failure;
 154
 155
 156             if (numtags)
 157             {
 158                 /* Seek back and read the tags. Note, that the TAG_DONE
 159                    tagitem "goes over" the numtags, ie. it's ti_Data will
 160                    contain the numtags in the lower WORD:
 161
 162                              TAGLIST start
 163                             /
 164                    00000000 80000008 00370000 80000001
 165                    003F003F 80000002 00640064 00000000
 166                    00000004 00378022          \TAG_DONE
 167                        |||| ||||||||
 168                    TagCount ||||||Flags
 169                             ||||||
 170                             ||||Style
 171                             ||||
 172                             YSize
 173                 */
 174
 175                 Flush(fh);
 176                 Seek
 177                 (
 178                     fh,
 179                     -(numtags * 8), /*  sizeof (struct TagItem) = 8 */
 180                     OFFSET_CURRENT
 181                 );
 182
 183                 if (!(tattr->tta_Tags = ReadTags(fh, numtags, DFB(DiskfontBase) )))
 184                     goto failure;
 185
 186             } /* if (numtags) */
 187             else
 188                 tattr->tta_Tags = NULL;
 189
 190         } /* if (fdh->Tagged) */
 191         else
 192             tattr->tta_Tags = NULL;
 193
 194         D(bug("ReadFontDescr: font \"%s\" tags %p\n", tattr->tta_Name, tattr->tta_Tags));
 195
 196         /* Read the rest of the info */
 197         if (!ReadWord( &DFB(DiskfontBase)->dsh, &(tattr->tta_YSize), (void *)fh ))
 198             goto failure;
 199
 200         if (!ReadByte(&DFB(DiskfontBase)->dsh, &(tattr->tta_Style), (void *)fh ))
 201             goto failure;
 202
 203         if (!ReadByte( &DFB(DiskfontBase)->dsh, &(tattr->tta_Flags), (void *)fh ))
 204             goto failure;
 205
 206         tattr ++;
 207
 208     } /* while (numentries--) */
 209
 210     Close(fh); fh = 0;
 211
 212     if (numoutlineentries)
 213     {
 214         UBYTE flags = OTAG_GetFontFlags(fdh->OTagList, DiskfontBase);
 215         UBYTE style = OTAG_GetFontStyle(fdh->OTagList, DiskfontBase);
 216
 217         while(numoutlineentries--)
 218         {
 219             UWORD size;
 220             UWORD i;
 221             BOOL  exists = FALSE;
 222
 223             size = AROS_BE2WORD(*availsizes);
 224             availsizes++;
 225
 226             /* Check if this size already exists as bitmap
 227                font. If it does, then ignore it */
 228
 229             for(i = 0; i < fdh->NumEntries; i++)
 230             {
 231                 if (fdh->TAttrArray[i].tta_YSize == size)
 232                 {
 233                     exists = TRUE;
 234                     break;
 235                 }
 236             }
 237
 238             if (exists) continue;
 239
 240             /* NumEntries contains the total number of entries, ie.
 241                bitmap fonts and outline fonts included. NumOutlineEntries
 242                tells how many among these (at the end of the array) are
 243                outline fonts */
 244
 245             fdh->NumEntries++;
 246             fdh->NumOutlineEntries++;
 247
 248             tattr->tta_Name  = fdh->OTagList->filename;
 249             tattr->tta_YSize = size;
 250             tattr->tta_Flags = flags;
 251             tattr->tta_Style = style;
 252             tattr->tta_Tags  = NULL;
 253
 254             D(bug("ReadFontDescr: font \"%s\" tags %p\n", tattr->tta_Name, tattr->tta_Tags));
 255
 256             tattr++;
 257         } /* while(numoutlineentries--) */
 258
 259     } /* if (numoutlineentries) */
 260
 261     ReturnPtr ("ReadFontDescr", struct FontDescrHeader *, fdh);
 262
 263 failure:
 264     /* Free all allocated memory */
 265
 266     if (fh) Close(fh);
 267
 268     if (fdh)
 269         FreeFontDescr(fdh, DFB(DiskfontBase) );
 270
 271     ReturnPtr ("ReadFontDescr", struct FontDescrHeader*, FALSE);
 272
 273 }
 274
 275 /****************************************************************************************/
 276
 277 /******************/
 278 /* FreeFontDescr  */
 279 /******************/
 280
 281 /****************************************************************************************/
 282
 283 VOID FreeFontDescr(struct FontDescrHeader *fdh, struct DiskfontBase_intern *DiskfontBase)
 284 {
 285     struct TTextAttr *tattr;
 286
 287     UWORD numentries;
 288
 289     D(bug("FreeFontDescr(fdh=%p\n", fdh));
 290
 291     if (fdh)
 292     {
 293         tattr       = fdh->TAttrArray;
 294         numentries  = fdh->NumEntries - fdh->NumOutlineEntries;
 295
 296         if (tattr)
 297         {
 298             /* Go through the whole array of bitmap font entries
 299                freeing strings and tags. Outline font entries
 300                always have the tta_Name pointing to the otag file
 301                and must not get the tta_Name freed. They also have
 302                tta_Tags always being NULL. Therefore the loop below
 303                goes only through the bitmap font entries */
 304
 305             while(numentries--)
 306             {
 307                 if (tattr->tta_Name)
 308                     FreeVec(tattr->tta_Name);
 309
 310                 if (tattr->tta_Tags)
 311                     FreeVec(tattr->tta_Tags);
 312
 313                 tattr ++;
 314             }
 315
 316             FreeVec(fdh->TAttrArray);
 317         }
 318
 319         if (fdh->OTagList) OTAG_KillFile(fdh->OTagList, DiskfontBase);
 320
 321         FreeMem(fdh, sizeof (struct FontDescrHeader));
 322     }
 323
 324     ReturnVoid("FreeFontDescr");
 325 }
 326
 327 /****************************************************************************************/