workbench/libs/diskfont/diskfontfunc.c

   1 /*
   2     Copyright © 1995-2010, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Hook for handling fonts in FONTS:
   6     Lang: English.
   7 */
   8
   9 /****************************************************************************************/
  10
  11 #include <exec/initializers.h>
  12 #include <dos/dosextens.h>
  13 #include <proto/dos.h>
  14 #include <proto/graphics.h>
  15 #include <proto/arossupport.h>
  16 //#include <proto/alib.h>
  17 #include <string.h>
  18
  19 #include "diskfont_intern.h"
  20
  21 /****************************************************************************************/
  22
  23 #include <aros/debug.h>
  24
  25 /****************************************************************************************/
  26
  27 struct DirEntry;
  28
  29 struct FileEntry
  30 {
  31     struct MinNode          Node;
  32     struct DirEntry        *DirEntry;
  33     STRPTR                  FileName;
  34     struct DateStamp        FileChanged;
  35     UWORD                   ContentsID;
  36     UBYTE                   SupportedStyles;
  37     UBYTE                   FontStyle;
  38     ULONG                   Numentries;
  39     struct TTextAttr       *Attrs;
  40 };
  41
  42 struct DirEntry
  43 {
  44     struct MinNode         Node;
  45     BPTR                   DirLock;
  46     struct DateStamp       DirChanged;
  47     struct MinList         FileList;
  48 };
  49
  50 struct DF_FontsData /*DiskFontData */
  51 {
  52 #ifdef PROGDIRFONTSDIR
  53     struct DirEntry       *ProgdirDirEntry;
  54 #endif
  55     struct DirEntry       *CurrentDirEntry;
  56     struct FileEntry      *CurrentFileEntry, *PrevFileEntry;
  57     UWORD                  AttrsIndex;
  58     struct FileEntry      *RememberFileEntry;
  59     UWORD                  RememberIndex;
  60 };
  61
  62 struct DF_FileData
  63 {
  64     struct FontDescrHeader *FDH;
  65     STRPTR                  FilePart;
  66     STRPTR                  OrigName;
  67     struct TTextAttr       *LastAttr;
  68     UWORD                   AttrsIndex;
  69     UWORD                   RememberIndex;
  70     struct TTextAttr        ExtraAttr;
  71 };
  72
  73 typedef enum {DF_FONTSDATA, DF_FILEDATA} DF_DataType;
  74
  75 struct DF_Data
  76 {
  77     DF_DataType       Type;
  78     struct TTextAttr *ReqAttr;
  79     union
  80     {
  81         struct DF_FontsData FontsData;
  82         struct DF_FileData  FileData;
  83     } u;
  84 };
  85
  86
  87 /****************************************************************************************/
  88
  89 /*****************/
  90 /* ReadFileEntry */
  91 /*****************/
  92
  93 /****************************************************************************************/
  94
  95 STATIC struct FileEntry *ReadFileEntry(struct ExAllData *ead, struct DiskfontBase_intern *DiskfontBase)
  96 {
  97     struct FontDescrHeader *fdh;
  98     struct FileEntry       *retval = NULL;
  99     ULONG                   size, strsize, tagcount;
 100     int                     i;
 101     struct TagItem         *tagitems;
 102     STRPTR                  filename;
 103
 104     D(bug("ReadFileEntry: ead: 0x%lx\n", ead));
 105     D(bug("ReadFileEntry: name=\"%s\"\n", ead->ed_Name));
 106
 107     fdh = ReadFontDescr(ead->ed_Name, DiskfontBase);
 108     if (fdh == NULL)
 109     {
 110         D(bug("ReadFileEntry: error in ReadFontDescr\n"));
 111         return NULL;
 112     }
 113
 114     strsize = strlen(ead->ed_Name) + 1;
 115     size = sizeof(struct FileEntry) + strsize + fdh->NumEntries * sizeof(struct TTextAttr);
 116     if (fdh->ContentsID == OFCH_ID) /* Reserve extra Attr for outline fonts */
 117          size += sizeof(struct TTextAttr);
 118
 119     for (i = 0; i < fdh->NumEntries; i++)
 120         if (fdh->TAttrArray[i].tta_Tags != NULL)
 121             size += NumTags(fdh->TAttrArray[i].tta_Tags, DiskfontBase) * sizeof(struct TagItem);
 122
 123     retval = AllocVec(size, MEMF_ANY|MEMF_CLEAR);
 124     if (retval == NULL)
 125     {
 126         D(bug("ReadFileEntry: Could not allocate memory\n"));
 127         FreeFontDescr(fdh, DiskfontBase);
 128         ReturnPtr("ReadFileEntry", struct FileEntry *, NULL);
 129     }
 130
 131     filename = (STRPTR)(retval + 1);
 132     strcpy(filename, ead->ed_Name);
 133     retval->FileName = filename;
 134     retval->FileChanged = *(struct DateStamp *)&ead->ed_Days;
 135
 136     retval->Numentries = fdh->NumEntries;
 137     retval->ContentsID = fdh->ContentsID;
 138     retval->Attrs = (struct TTextAttr *)(filename + strsize);
 139     memcpy(retval->Attrs, fdh->TAttrArray, fdh->NumEntries * sizeof(struct TTextAttr));
 140     if (retval->ContentsID == OFCH_ID)
 141     {
 142          int ind = retval->Numentries;
 143
 144          retval->Numentries++;
 145          retval->SupportedStyles = OTAG_GetSupportedStyles(fdh->OTagList, DiskfontBase);
 146          retval->FontStyle = OTAG_GetFontStyle(fdh->OTagList, DiskfontBase);
 147          retval->Attrs[ind].tta_Name = filename;
 148          retval->Attrs[ind].tta_Flags = OTAG_GetFontFlags(fdh->OTagList, DiskfontBase);
 149     }
 150
 151     tagitems = (struct TagItem *)(retval->Attrs + retval->Numentries);
 152
 153     for (i = 0; i < fdh->NumEntries; i++)
 154     {
 155         retval->Attrs[i].tta_Name = retval->FileName;
 156
 157         if (fdh->TAttrArray[i].tta_Tags != NULL)
 158         {
 159             tagcount = NumTags(fdh->TAttrArray[i].tta_Tags, DiskfontBase);
 160             CopyTagItems(tagitems, fdh->TAttrArray[i].tta_Tags, DiskfontBase);
 161             retval->Attrs[i].tta_Tags = tagitems;
 162             tagitems += tagcount;
 163         }
 164         else
 165             retval->Attrs[i].tta_Tags = NULL;
 166     }
 167
 168     FreeFontDescr(fdh, DiskfontBase);
 169
 170     ReturnPtr("ReadFileEntry", struct FileEntry *, retval);
 171 }
 172
 173 /****************************************************************************************/
 174
 175 /*****************/
 176 /* FreeFileEntry */
 177 /*****************/
 178
 179 /****************************************************************************************/
 180
 181 STATIC VOID FreeFileEntry(struct FileEntry *feptr, struct DiskfontBase_intern *DiskfontBase)
 182 {
 183     FreeVec(feptr);
 184 }
 185
 186 /****************************************************************************************/
 187
 188 /****************/
 189 /* FreeFileList */
 190 /****************/
 191
 192 /****************************************************************************************/
 193
 194 STATIC VOID FreeFileList(struct MinList *filelist, struct DiskfontBase_intern *DiskfontBase)
 195 {
 196     struct FileEntry *feptr, *nextfeptr;
 197
 198     D(bug("FreeFileList(filelist=%p)\n", filelist));
 199
 200     ForeachNodeSafe(filelist, feptr, nextfeptr)
 201     {
 202         REMOVE(feptr);
 203         FreeFileEntry(feptr, DiskfontBase);
 204     }
 205
 206     ReturnVoid("FreeFileList");
 207 }
 208
 209 /****************************************************************************************/
 210
 211 /****************/
 212 /* GetFileList  */
 213 /****************/
 214
 215 /****************************************************************************************/
 216
 217 /* Build the list of .font file names using Examine() */
 218 STATIC BOOL GetFileList(struct DirEntry *direntry, struct DiskfontBase_intern *DiskfontBase)
 219 {
 220     struct MinList       newlist;
 221     struct FileEntry    *fe, *nextfe;
 222     BOOL                 retval = TRUE, more;
 223     struct ExAllControl *eac;
 224     struct ExAllData    *ead, *eadit;
 225
 226     D(bug("GetFileList(direntry=%p)\n", direntry));
 227
 228     NEWLIST(&newlist);
 229
 230     eac = AllocDosObject(DOS_EXALLCONTROL, NULL);
 231     eac->eac_LastKey = 0;
 232     ead = (struct ExAllData *)AllocMem(1024, MEMF_ANY);
 233
 234     do
 235     {
 236         more = ExAll(direntry->DirLock, ead, 1024, ED_DATE, eac);
 237         if ((!more) && (IoErr() != ERROR_NO_MORE_ENTRIES))
 238             retval = FALSE;
 239         else if (eac->eac_Entries == 0)
 240             continue;
 241         else
 242         {
 243             for (eadit = ead; eadit != NULL; eadit = eadit->ed_Next)
 244             {
 245                 ULONG namelen = strlen(eadit->ed_Name);
 246
 247                 D(bug("GetFileList: Scanning file: %s\n", eadit->ed_Name));
 248
 249                 /* Maybe this can be done in a hook function passed in eac */
 250                 if (namelen < 5 || strncmp(eadit->ed_Name+namelen-5, ".font", 5) != 0)
 251                 {
 252                     D(bug("GetFileList: wrong suffix: %s\n", eadit->ed_Name+namelen-5));
 253                     continue;
 254                 }
 255
 256                 /* Is a FileEntry for this file already in the list */
 257                 for (fe = (struct FileEntry *)GetHead(&direntry->FileList);
 258                      fe != NULL;
 259                      fe = (struct FileEntry *)GetSucc(fe))
 260                 {
 261                     if (strcmp(eadit->ed_Name, fe->FileName) == 0)
 262                         break;
 263                 }
 264
 265                 if (fe == NULL)
 266                 {
 267                     D(bug("GetFileList: Filename not yet in memory\n"));
 268
 269                     fe = ReadFileEntry(eadit, DiskfontBase);
 270                     if (fe != NULL)
 271                     {
 272                         fe->DirEntry = direntry;
 273
 274                         D(bug("GetFileList: Add to list: 0x%lx\n", fe));
 275                         ADDTAIL(&newlist, fe);
 276                     }
 277                 }
 278                 else
 279                 {
 280                     struct DateStamp ds;
 281                     REMOVE(fe);
 282
 283                     ds.ds_Days = eadit->ed_Days;
 284                     ds.ds_Minute = eadit->ed_Mins;
 285                     ds.ds_Tick = eadit->ed_Ticks;
 286
 287                     D(bug("GetFileList: Found filename already in memory\n"));
 288
 289                     if (CompareDates(&ds, &fe->FileChanged) == 0)
 290                     {
 291                         D(bug("GetFileList: File's date not changed: Add to list 0x%lx\n", fe));
 292                         ADDTAIL(&newlist, fe);
 293                     }
 294                     else
 295                     {
 296                         D(bug("GetFileList: Date changed rereading information\n"));
 297
 298                         FreeFileEntry(fe, DiskfontBase);
 299
 300                         fe = ReadFileEntry(eadit, DiskfontBase);
 301                         if (fe == NULL)
 302                         {
 303                             D(bug("GetFileList: Reading information failed\n"));
 304                             retval = FALSE;
 305                             break;
 306                         }
 307                         else
 308                         {
 309                             fe->DirEntry = direntry;
 310                             D(bug("GetFileList: Reading OK, add to list: 0x%lx\n", fe));
 311                             ADDTAIL(&newlist, fe);
 312                         }
 313                     }
 314                 }
 315             } /* for (eadit = ... */
 316         }
 317     } while (more && retval);
 318
 319     FreeDosObject(DOS_EXALLCONTROL, eac);
 320     FreeMem(ead, 1024);
 321
 322     if (!retval)
 323     {
 324         D(bug("GetFileList: Not OK freeing FileList\n"));
 325         FreeFileList(&newlist, DiskfontBase);
 326     }
 327     else
 328     {
 329         /* Remove FileEntries that are still in memory but not anymore
 330          * on disk */
 331         FreeFileList(&direntry->FileList, DiskfontBase);
 332
 333         ForeachNodeSafe(&newlist, fe, nextfe)
 334         {
 335             REMOVE(fe);
 336             ADDTAIL(&direntry->FileList, fe);
 337             D(bug("GetFileList: Adding fe=%p\n", fe));
 338         }
 339     }
 340
 341     ReturnBool ("GetFileList", retval);
 342 }
 343
 344 /****************************************************************************************/
 345
 346 /*********************/
 347 /* StreamOutFileList */
 348 /*********************/
 349
 350 /****************************************************************************************/
 351
 352 STATIC BOOL StreamOutFileList(struct MinList *filelist, BPTR fh, struct DiskfontBase_intern *DiskfontBase)
 353 {
 354     struct FileEntry *fe;
 355     ULONG i;
 356     BOOL ok = TRUE;
 357
 358     ForeachNode(filelist, fe)
 359     {
 360         D(bug("StreamOutFileList: Writing file %s\n", fe->FileName));
 361         ok = ok && WriteString(&DiskfontBase->dsh, fe->FileName, fh);
 362         D(bug("StreamOutFileList: Write days: %d minute: %d, tick: %d\n",
 363               fe->FileChanged.ds_Days, fe->FileChanged.ds_Minute,
 364               fe->FileChanged.ds_Tick));
 365         ok = ok && WriteLong(&DiskfontBase->dsh, fe->FileChanged.ds_Days, fh);
 366         ok = ok && WriteLong(&DiskfontBase->dsh, fe->FileChanged.ds_Minute, fh);
 367         ok = ok && WriteLong(&DiskfontBase->dsh, fe->FileChanged.ds_Tick, fh);
 368         ok = ok && WriteWord(&DiskfontBase->dsh, fe->ContentsID, fh);
 369         ok = ok && WriteByte(&DiskfontBase->dsh, fe->SupportedStyles, fh);
 370         ok = ok && WriteByte(&DiskfontBase->dsh, fe->FontStyle, fh);
 371         D(bug("StreamOutFileList: Write numentries=%d\n", fe->Numentries));
 372         ok = ok && WriteLong(&DiskfontBase->dsh, fe->Numentries, fh);
 373
 374         for (i=0; ok && i<fe->Numentries; i++)
 375         {
 376             ok = ok && WriteWord(&DiskfontBase->dsh, fe->Attrs[i].tta_YSize, fh);
 377             ok = ok && WriteByte(&DiskfontBase->dsh, fe->Attrs[i].tta_Style, fh);
 378             ok = ok && WriteByte(&DiskfontBase->dsh, fe->Attrs[i].tta_Flags, fh);
 379             ok = ok && WriteTagsNum(fh, fe->Attrs[i].tta_Tags, DiskfontBase);
 380         }
 381     }
 382     ok = ok && WriteString(&DiskfontBase->dsh, "", fh);
 383
 384     return ok;
 385 }
 386
 387 /****************************************************************************************/
 388
 389 /********************/
 390 /* StreamInFileList */
 391 /********************/
 392
 393 /****************************************************************************************/
 394
 395 STATIC BOOL StreamInFileList(struct DirEntry *direntry, BPTR fh, struct DiskfontBase_intern *DiskfontBase)
 396 {
 397     struct FileEntry *fe, fe2;
 398     ULONG i, numtags, totnumtags;
 399     BOOL ok = TRUE;
 400     struct TTextAttr *attrs;
 401     struct TagItem *tagptr;
 402
 403     for (ok = ReadString(&DiskfontBase->dsh, &fe2.FileName, fh);
 404          ok && strlen(fe2.FileName)>0;
 405          ok = ok && ReadString(&DiskfontBase->dsh, &fe2.FileName, fh))
 406     {
 407         D(bug("StreamInFileList: reading data for \"%s\"\n", fe2.FileName));
 408
 409         ok = ok && ReadLong(&DiskfontBase->dsh, &fe2.FileChanged.ds_Days, fh);
 410         ok = ok && ReadLong(&DiskfontBase->dsh, &fe2.FileChanged.ds_Minute, fh);
 411         ok = ok && ReadLong(&DiskfontBase->dsh, &fe2.FileChanged.ds_Tick, fh);
 412         D(bug("StreamInFileList: read days: %d minute: %d tick: %d\n",
 413               fe2.FileChanged.ds_Days, fe2.FileChanged.ds_Minute,
 414               fe2.FileChanged.ds_Tick));
 415         ok = ok && ReadWord(&DiskfontBase->dsh, &fe2.ContentsID, fh);
 416         ok = ok && ReadByte(&DiskfontBase->dsh, &fe2.SupportedStyles, fh);
 417         ok = ok && ReadByte(&DiskfontBase->dsh, &fe2.FontStyle, fh);
 418         ok = ok && ReadLong(&DiskfontBase->dsh, &fe2.Numentries, fh);
 419
 420         if (ok)
 421         {
 422             attrs = AllocVec(fe2.Numentries * sizeof(struct TTextAttr), MEMF_ANY|MEMF_CLEAR);
 423
 424             ok = ok && attrs != NULL;
 425
 426             if (ok)
 427                 for (i = 0; i < fe2.Numentries; i++)
 428                     attrs[i].tta_Tags = NULL;
 429
 430             for (i = 0, totnumtags = 0; ok && i < fe2.Numentries; i++)
 431             {
 432                 ok = ok && ReadWord(&DiskfontBase->dsh, &attrs[i].tta_YSize, fh);
 433                 ok = ok && ReadByte(&DiskfontBase->dsh, &attrs[i].tta_Style, fh);
 434                 ok = ok && ReadByte(&DiskfontBase->dsh, &attrs[i].tta_Flags, fh);
 435                 if (ok)
 436                 {
 437                     attrs[i].tta_Tags = ReadTagsNum(fh, &numtags, DiskfontBase);
 438                     D(bug("StreamInFileList: read tags %p\n", attrs[i].tta_Tags));
 439                     totnumtags += numtags;
 440                     ok = ok && numtags > 0;
 441                 }
 442             }
 443             D(bug("StreamInFileList: totnumtags == %u\n", totnumtags));
 444
 445             if (ok)
 446             {
 447                 ULONG size = sizeof(struct FileEntry) +
 448                     strlen(fe2.FileName)+1 +
 449                     fe2.Numentries * sizeof(struct TTextAttr) +
 450                     totnumtags * sizeof(struct TagItem);
 451
 452                 fe = (struct FileEntry *)AllocVec(size, MEMF_ANY);
 453                 ok = ok && fe != NULL;
 454             }
 455             if (ok)
 456             {
 457                 fe->DirEntry = direntry;
 458                 fe->FileName = (STRPTR)(fe+1);
 459                 strcpy(fe->FileName, fe2.FileName);
 460                 fe->FileChanged = fe2.FileChanged;
 461                 fe->ContentsID = fe2.ContentsID;
 462                 fe->SupportedStyles = fe2.SupportedStyles;
 463                 fe->FontStyle = fe2.FontStyle;
 464                 fe->Numentries = fe2.Numentries;
 465                 fe->Attrs = (struct TTextAttr *)(fe->FileName + strlen(fe2.FileName)+1);
 466
 467                 tagptr = (struct TagItem *)(fe->Attrs + fe2.Numentries);
 468                 for (i = 0; i < fe2.Numentries; i++)
 469                 {
 470                     fe->Attrs[i].tta_Name = fe->FileName;
 471                     fe->Attrs[i].tta_YSize = attrs[i].tta_YSize;
 472                     fe->Attrs[i].tta_Style = attrs[i].tta_Style;
 473                     fe->Attrs[i].tta_Flags = attrs[i].tta_Flags;
 474                     numtags = CopyTagItems(tagptr, attrs[i].tta_Tags, DiskfontBase);
 475                     fe->Attrs[i].tta_Tags = tagptr;
 476                     tagptr += numtags;
 477                 }
 478                 ADDTAIL(&direntry->FileList, fe);
 479             }
 480
 481             if (attrs != NULL)
 482             {
 483                 for (i = 0; i < fe2.Numentries; i++)
 484                     if (attrs[i].tta_Tags != NULL)
 485                     {
 486                         D(bug("StreamInFileList: freeing tags %p\n", attrs[i].tta_Tags));
 487                         FreeVec(attrs[i].tta_Tags);
 488                     }
 489                 FreeVec(attrs);
 490             }
 491         }
 492
 493         FreeVec(fe2.FileName);
 494     }
 495     if (ok)
 496     {
 497         D(bug("StreamInFileList: FileName empty\n"));
 498         FreeVec(fe2.FileName);
 499     }
 500     else
 501     {
 502         D(bug("StreamInFileList: Error reading chachefile\n"));
 503         FreeFileList(&direntry->FileList, DiskfontBase);
 504     }
 505
 506     return ok;
 507 }
 508
 509 /****************************************************************************************/
 510
 511 /****************/
 512 /* FreeDirEntry */
 513 /****************/
 514
 515 /****************************************************************************************/
 516
 517 STATIC VOID FreeDirEntry(struct DirEntry *direntry, struct DiskfontBase_intern *DiskfontBase)
 518 {
 519     if (direntry!=NULL)
 520     {
 521         FreeFileList(&direntry->FileList, DiskfontBase);
 522         UnLock(direntry->DirLock);
 523         FreeVec(direntry);
 524     }
 525 }
 526
 527 /****************************************************************************************/
 528
 529 /****************/
 530 /* ReadDirEntry */
 531 /****************/
 532
 533 /****************************************************************************************/
 534
 535 STATIC struct DirEntry *ReadDirEntry(BPTR dirlock, struct DirEntry *direntry, struct DiskfontBase_intern *DiskfontBase)
 536 {
 537     struct Process *Self;
 538     APTR oldwinptr;
 539     struct FileInfoBlock *fib;
 540     BPTR olddir;
 541     BPTR fh;
 542
 543     D(bug("ReadDirEntry(dirlock=0x%lx, direntry=0x%lx)\n", dirlock, direntry));
 544
 545     Self               = (struct Process *) FindTask(NULL);
 546     oldwinptr          = Self->pr_WindowPtr;
 547     Self->pr_WindowPtr = (APTR) -1;
 548
 549     fib = AllocDosObject(DOS_FIB, NULL);
 550     if (fib == NULL)
 551     {
 552         D(bug("ReadDirEntry: Could not allocate DosObject\n"));
 553         Self->pr_WindowPtr = oldwinptr;
 554         ReturnPtr("ReadDirEntry", struct DirEntry *, NULL);
 555     }
 556     Examine(dirlock, fib);
 557     Self->pr_WindowPtr = oldwinptr;
 558
 559     olddir = CurrentDir(dirlock);
 560
 561     if (direntry == NULL)
 562     {
 563         direntry = AllocVec(sizeof(struct DirEntry), MEMF_ANY | MEMF_CLEAR);
 564         if (direntry==NULL)
 565         {
 566             D(bug("ReadDirEntry: Could not allocate DirEntry\n"));
 567             FreeDosObject(DOS_FIB, fib);
 568             CurrentDir(olddir);
 569             ReturnPtr("ReadDirEntry", struct DirEntry *, NULL);
 570         }
 571         else
 572             D(bug("ReadDirEntry: allocated direntry = 0x%lx\n", direntry));
 573
 574         direntry->DirLock  = dirlock;
 575         NEWLIST(&direntry->FileList);
 576
 577         /* Try to read the direntry from the file */
 578         fh = Open(CACHE_FILE, MODE_OLDFILE);
 579         if (fh != NULL)
 580         {
 581             BOOL ok;
 582
 583             ok = ReadLong(&DiskfontBase->dsh, &direntry->DirChanged.ds_Days, fh);
 584             ok = ok && ReadLong(&DiskfontBase->dsh, &direntry->DirChanged.ds_Minute, fh);
 585             ok = ok && ReadLong(&DiskfontBase->dsh, &direntry->DirChanged.ds_Tick, fh);
 586
 587             if (ok)
 588                 ok = StreamInFileList(direntry, fh, DiskfontBase);
 589
 590             Close(fh);
 591
 592 #warning CHECKME
 593 #if 0
 594             /* This part is disabled because in emul_handler on UNIX the date
 595              * of a parent directory is changed only when a file is added or
 596              * removed from the directory
 597              */
 598
 599             /* If dates are the same return the direntry as is */
 600             if (ok && CompareDates(&direntry->DirChanged, &fib->fib_Date) == 0)
 601             {
 602                 D(bug("ReadDirEntry: date in cache not changed\n"));
 603                 FreeDosObject(DOS_FIB, fib);
 604                 Self->pr_WindowPtr = oldwinptr;
 605                 CurrentDir(olddir);
 606                 ReturnPtr("ReadDirEntry", struct DirEntry *, direntry);
 607             }
 608 #endif
 609         }
 610     }
 611     else
 612     {
 613         CurrentDir(direntry->DirLock);
 614         UnLock(dirlock);
 615         if (CompareDates(&direntry->DirChanged, &fib->fib_Date) == 0)
 616         {
 617             D(bug("ReadDirEntry: direntry 0x%lx not changed\n", direntry));
 618             FreeDosObject(DOS_FIB, fib);
 619             Self->pr_WindowPtr = oldwinptr;
 620             CurrentDir(olddir);
 621             ReturnPtr("ReadDirEntry", struct DirEntry *, direntry);
 622         }
 623     }
 624
 625     direntry->DirChanged = fib->fib_Date;
 626
 627     if (!GetFileList(direntry, DiskfontBase))
 628     {
 629         D(bug("ReadDirEntry: Error reading FileList\n"));
 630         FreeDosObject(DOS_FIB, fib);
 631         CurrentDir(olddir);
 632         UnLock(direntry->DirLock);
 633         FreeVec(direntry);
 634         Self->pr_WindowPtr = oldwinptr;
 635         ReturnPtr("ReadDirEntry", struct DirEntry *, NULL);
 636     }
 637
 638     /* If everything went OK Write the cache file */
 639     fh = Open(CACHE_FILE, MODE_NEWFILE);
 640     if (fh != NULL)
 641     {
 642         BOOL ok;
 643
 644         ok = WriteLong(&DiskfontBase->dsh, fib->fib_Date.ds_Days, fh);
 645         ok = ok && WriteLong(&DiskfontBase->dsh, fib->fib_Date.ds_Minute, fh);
 646         ok = ok && WriteLong(&DiskfontBase->dsh, fib->fib_Date.ds_Tick, fh);
 647
 648         if (ok)
 649             ok = StreamOutFileList(&direntry->FileList, fh, DiskfontBase);
 650
 651         Close(fh);
 652
 653         if (ok)
 654         {
 655             Examine(direntry->DirLock, fib);
 656             direntry->DirChanged = fib->fib_Date;
 657             fh = Open(CACHE_FILE, MODE_OLDFILE);
 658             if (fh != NULL)
 659             {
 660                 Seek(fh, 0, OFFSET_BEGINNING);
 661                 ok = WriteLong(&DiskfontBase->dsh, fib->fib_Date.ds_Days, fh);
 662                 ok = ok && WriteLong(&DiskfontBase->dsh, fib->fib_Date.ds_Minute, fh);
 663                 ok = ok && WriteLong(&DiskfontBase->dsh, fib->fib_Date.ds_Tick, fh);
 664                 Close(fh);
 665             }
 666         }
 667
 668         if (!ok)
 669             DeleteFile(CACHE_FILE);
 670     }
 671
 672     FreeDosObject(DOS_FIB, fib);
 673     CurrentDir(olddir);
 674     Self->pr_WindowPtr = oldwinptr;
 675
 676     ReturnPtr("ReadDirEntry", struct DirEntry *, direntry);
 677 }
 678
 679 /****************************************************************************************/
 680
 681 /****************/
 682 /* FreeResouces */
 683 /****************/
 684
 685 /****************************************************************************************/
 686
 687 STATIC VOID FreeResources(struct DF_Data *df_data, struct DiskfontBase_intern *DiskfontBase)
 688 {
 689     D(bug("FreeResources(df_data=%p)\n", df_data));
 690
 691     ReleaseSemaphore(&DiskfontBase->fontssemaphore);
 692
 693     switch (df_data->Type)
 694     {
 695     case DF_FONTSDATA:
 696 #ifdef PROGDIRFONTSDIR
 697         FreeDirEntry(df_data->u.FontsData.ProgdirDirEntry, DiskfontBase);
 698 #endif
 699         break;
 700
 701     case DF_FILEDATA:
 702         if (df_data->u.FileData.FDH != NULL)
 703             FreeFontDescr(df_data->u.FileData.FDH, DiskfontBase);
 704         break;
 705     }
 706
 707     FreeMem(df_data, sizeof (struct DF_Data));
 708
 709     ReturnVoid("FreeResources");
 710 }
 711
 712 /****************************************************************************************/
 713
 714 /****************************/
 715 /* CleanUpFontsDirEntryList */
 716 /****************************/
 717
 718 /****************************************************************************************/
 719
 720 VOID CleanUpFontsDirEntryList(struct DiskfontBase_intern *DiskfontBase)
 721 {
 722     struct DirEntry *direntry, *direntry2;
 723
 724     ForeachNodeSafe(&DiskfontBase->fontsdirentrylist, direntry, direntry2)
 725         FreeDirEntry(direntry, DiskfontBase);
 726
 727     ReturnVoid("CleanUpFontsDirEntryList");
 728 }
 729
 730 /****************************************************************************************/
 731
 732 /******************/
 733 /* AllocResources */
 734 /******************/
 735
 736 /****************************************************************************************/
 737
 738 STATIC struct DF_Data *AllocResources(struct TTextAttr *reqattr, struct DiskfontBase_intern *DiskfontBase)
 739 {
 740     struct DF_Data *df_data;
 741
 742     D(bug("AllocResources(void)\n"));
 743
 744     ObtainSemaphore(&DiskfontBase->fontssemaphore);
 745
 746     /* Allocate user data */
 747     if ((df_data = AllocMem( sizeof (struct DF_Data), MEMF_ANY | MEMF_CLEAR)))
 748     {
 749         df_data->ReqAttr = reqattr;
 750
 751         if (reqattr==NULL || FilePart(reqattr->tta_Name)==reqattr->tta_Name)
 752         {
 753             struct DevProc *dp = NULL;
 754             struct MinList newdirlist;
 755             struct DirEntry *direntry, *direntry2;
 756
 757             df_data->Type = DF_FONTSDATA;
 758
 759 #ifdef PROGDIRFONTSDIR
 760             do
 761             {
 762                 struct Process *Self;
 763                 APTR oldwinptr;
 764                 BPTR lock;
 765
 766                 df_data->u.FontsData.ProgdirDirEntry = NULL;
 767
 768                 if (!GetProgramDir())
 769                     break;
 770
 771                 Self               = (struct Process *) FindTask(NULL);
 772                 oldwinptr          = Self->pr_WindowPtr;
 773                 Self->pr_WindowPtr = (APTR) -1;
 774                 lock               = Lock(PROGDIRFONTSDIR, ACCESS_READ);
 775                 Self->pr_WindowPtr = oldwinptr;
 776
 777                 D(bug("AllocResources: PROGDIR:Fonts DirLock = 0x%lx\n", lock));
 778
 779                 if (!lock)
 780                     break;
 781
 782                 df_data->u.FontsData.ProgdirDirEntry = ReadDirEntry(lock, NULL, DiskfontBase);
 783                 D(bug("AllocResources: PROGDIR:Fonts direntry 0x%lx\n", df_data->u.FontsData.ProgdirDirEntry));
 784             } while (0);
 785 #endif
 786
 787             NEWLIST(&newdirlist);
 788             while((dp = GetDeviceProc(FONTSDIR, dp))!=NULL)
 789             {
 790                 BPTR lock;
 791
 792                 D(bug("AllocResources: FONTS: lock = 0x%lx\n", dp->dvp_Lock));
 793
 794                 lock = DupLock(dp->dvp_Lock);
 795                 if (lock==NULL)
 796                 {
 797                     D(bug("AllocResources: Could not duplicate lock\n"));
 798                     continue;
 799                 }
 800
 801                 /* See if direntry is already in memory */
 802                 for (direntry = (struct DirEntry *)GetHead(&DiskfontBase->fontsdirentrylist);
 803                      direntry != NULL;
 804                      direntry = (struct DirEntry *)GetSucc(direntry))
 805                 {
 806                     if (SameLock(direntry->DirLock, lock) == LOCK_SAME)
 807                     {
 808                         REMOVE(direntry);
 809                         break;
 810                     }
 811                 }
 812
 813                 /* Read or update fonts information in this directory */
 814                 direntry = ReadDirEntry(lock, direntry, DiskfontBase);
 815                 if (direntry!=NULL)
 816                 {
 817                     D(bug("AllocResources: addtail direntry 0x%lx\n", direntry));
 818                     D(bug("AllocResources: first FileEntry: %p\n", GetHead(&direntry->FileList)));
 819                     ADDTAIL(&newdirlist, direntry);
 820                 }
 821                 else
 822                     D(bug("AllocResources: Error reading DirEntry\n"));
 823             }
 824
 825             /* Clean up directory lists that are in memory but not in the
 826              * FONTS: assign anymore */
 827             ForeachNodeSafe(&DiskfontBase->fontsdirentrylist, direntry, direntry2)
 828             {
 829                 REMOVE(direntry);
 830                 FreeDirEntry(direntry, DiskfontBase);
 831             }
 832
 833             ForeachNodeSafe(&newdirlist, direntry, direntry2)
 834             {
 835                 REMOVE(direntry);
 836                 ADDTAIL(&DiskfontBase->fontsdirentrylist, direntry);
 837             }
 838
 839             FreeDeviceProc(dp);
 840         }
 841         else
 842         {
 843             struct FontDescrHeader *fdh;
 844
 845             df_data->Type = DF_FILEDATA;
 846             fdh = ReadFontDescr(reqattr->tta_Name, DiskfontBase);
 847             df_data->u.FileData.FDH = fdh;
 848
 849             if (fdh != NULL)
 850             {
 851                 if (fdh->ContentsID==OFCH_ID)
 852                 {
 853                     UBYTE SupportedStyles = OTAG_GetSupportedStyles(fdh->OTagList, DiskfontBase);
 854
 855                     df_data->u.FileData.ExtraAttr.tta_Name = reqattr->tta_Name;
 856                     df_data->u.FileData.ExtraAttr.tta_YSize = reqattr->tta_YSize;
 857                     df_data->u.FileData.ExtraAttr.tta_Style = OTAG_GetFontStyle(fdh->OTagList, DiskfontBase);
 858                     df_data->u.FileData.ExtraAttr.tta_Flags = OTAG_GetFontFlags(fdh->OTagList, DiskfontBase);
 859
 860                     df_data->u.FileData.ExtraAttr.tta_Tags = NULL;
 861                     if (reqattr->tta_Style & FSF_TAGGED)
 862                     {
 863                         df_data->u.FileData.ExtraAttr.tta_Style |= FSF_TAGGED;
 864                         df_data->u.FileData.ExtraAttr.tta_Tags = reqattr->tta_Tags;
 865                     }
 866
 867                     if ((reqattr->tta_Style & FSF_BOLD)
 868                         && !(df_data->u.FileData.ExtraAttr.tta_Style & FSF_BOLD)
 869                         && (SupportedStyles & FSF_BOLD))
 870                     {
 871                         df_data->u.FileData.ExtraAttr.tta_Style |= FSF_BOLD;
 872                     }
 873
 874                     if ((reqattr->tta_Style & FSF_ITALIC)
 875                         && !(df_data->u.FileData.ExtraAttr.tta_Style & FSF_ITALIC)
 876                         && (SupportedStyles & FSF_ITALIC))
 877                     {
 878                         df_data->u.FileData.ExtraAttr.tta_Style |= FSF_ITALIC;
 879                     }
 880                 }
 881             }
 882         }
 883     }
 884
 885     ReturnPtr("AllocResources", struct DF_Data *, df_data);
 886 }
 887
 888 /****************************************************************************************/
 889
 890 /*******************/
 891 /* DF_IteratorInit */
 892 /*******************/
 893
 894 /****************************************************************************************/
 895
 896 APTR DF_IteratorInit(struct TTextAttr *reqattr, struct DiskfontBase_intern *DiskfontBase)
 897 {
 898     struct DF_Data *df_data;
 899
 900     D(bug("DF_IteratorInit(reqattr=0x%lx)\n", reqattr));
 901
 902     df_data = AllocResources(reqattr, DiskfontBase);
 903     if (df_data == NULL)
 904     {
 905         D(bug("DF_IteratorInit: Error executing Allocresources\n"));
 906         ReturnPtr("DF_IteratorInit", APTR, NULL);
 907     }
 908
 909     switch (df_data->Type)
 910     {
 911     case DF_FONTSDATA:
 912         df_data->u.FontsData.CurrentDirEntry = NULL;
 913         df_data->u.FontsData.CurrentFileEntry = NULL;
 914
 915 #ifdef PROGDIRFONTSDIR
 916         if (df_data->u.FontsData.ProgdirDirEntry != NULL)
 917         {
 918             D(bug("DF_IteratorInit: ProgdirDirEntry found\n"));
 919             df_data->u.FontsData.CurrentDirEntry = df_data->u.FontsData.ProgdirDirEntry;
 920             df_data->u.FontsData.CurrentFileEntry = (struct FileEntry *)GetHead(&df_data->u.FontsData.ProgdirDirEntry->FileList);
 921         }
 922         else
 923             D(bug("DF_IteratorInit: No ProgdirEntry found\n"));
 924 #endif
 925         if (df_data->u.FontsData.CurrentDirEntry == NULL || df_data->u.FontsData.CurrentFileEntry == NULL)
 926         {
 927             df_data->u.FontsData.CurrentDirEntry = (struct DirEntry *)GetHead(&DiskfontBase->fontsdirentrylist);
 928             if (df_data->u.FontsData.CurrentDirEntry != NULL)
 929                 df_data->u.FontsData.CurrentFileEntry = (struct FileEntry *)GetHead(&df_data->u.FontsData.CurrentDirEntry->FileList);
 930         }
 931
 932         D(bug("DF_IteratorInit: CurrentDirEntry: %p CurrentFileEntry: %p\n",
 933               df_data->u.FontsData.CurrentDirEntry, df_data->u.FontsData.CurrentFileEntry));
 934
 935         /* If DirEntry was empty search for one that is not empty */
 936         while (df_data->u.FontsData.CurrentDirEntry != NULL && df_data->u.FontsData.CurrentFileEntry == NULL)
 937         {
 938             df_data->u.FontsData.CurrentDirEntry = (struct DirEntry *)GetSucc(df_data->u.FontsData.CurrentDirEntry);
 939             if (df_data->u.FontsData.CurrentDirEntry != NULL)
 940                 df_data->u.FontsData.CurrentFileEntry = (struct FileEntry *)GetHead(&df_data->u.FontsData.CurrentDirEntry->FileList);
 941
 942             D(bug("DF_IteratorInit: CurrentDirEntry: %p CurrentFileEntry: %p\n",
 943                   df_data->u.FontsData.CurrentDirEntry, df_data->u.FontsData.CurrentFileEntry));
 944         }
 945         df_data->u.FontsData.AttrsIndex = 0;
 946
 947         break;
 948
 949     case DF_FILEDATA:
 950         df_data->u.FileData.AttrsIndex = 0;
 951         df_data->u.FileData.FilePart = FilePart(df_data->ReqAttr->tta_Name);
 952         df_data->u.FileData.LastAttr = NULL;
 953         break;
 954     }
 955
 956     ReturnPtr("DF_IteratorInit", APTR, df_data);
 957 }
 958
 959 /****************************************************************************************/
 960
 961 /**********************/
 962 /* DF_IteratorGetNext */
 963 /**********************/
 964
 965 /****************************************************************************************/
 966
 967 struct TTextAttr *DF_IteratorGetNext(APTR iterator, struct DiskfontBase_intern *DiskfontBase)
 968 {
 969     struct TTextAttr *retval = NULL;
 970     struct DF_Data *df_data = (struct DF_Data *)iterator;
 971
 972     D(bug("DF_IteratorGetNext(iterator=0x%lx)\n", iterator));
 973
 974     if (df_data==NULL)
 975         ReturnPtr("DF_IteratorGetNext", struct TTextAttr *, NULL);
 976
 977     switch (df_data->Type)
 978     {
 979     case DF_FONTSDATA:
 980         if (df_data->u.FontsData.CurrentDirEntry==NULL)
 981             ReturnPtr("DF_IteratorGetNext", struct TTextAttr *, NULL);
 982
 983         retval = df_data->u.FontsData.CurrentFileEntry->Attrs + df_data->u.FontsData.AttrsIndex;
 984         D(bug("DF_IteratorGetNext:\n"
 985               "  ContentsID: 0x%x == 0x%x\n"
 986               "  ReqAttr: %p\n"
 987               "  AttrIndex: %d, Numentries: %d\n",
 988               df_data->u.FontsData.CurrentFileEntry->ContentsID, OFCH_ID,
 989               df_data->ReqAttr,
 990               df_data->u.FontsData.AttrsIndex, df_data->u.FontsData.CurrentFileEntry->Numentries));
 991
 992         if (df_data->u.FontsData.CurrentFileEntry->ContentsID == OFCH_ID
 993             && df_data->ReqAttr != NULL
 994             && df_data->u.FontsData.AttrsIndex == df_data->u.FontsData.CurrentFileEntry->Numentries-1)
 995         {
 996             D(bug("DF_IteratorGetNext: Setting last outline element\n"));
 997
 998             /* The last attr for a outline font is filled with values matching
 999              * as close as possible the reqattr */
1000             retval->tta_YSize = df_data->ReqAttr->tta_YSize;
1001             retval->tta_Style = df_data->u.FontsData.CurrentFileEntry->FontStyle;
1002
1003             retval->tta_Tags  = NULL;
1004
1005             if (df_data->ReqAttr->tta_Style & FSF_TAGGED)
1006             {
1007                 retval->tta_Style |= FSF_TAGGED;
1008                 retval->tta_Tags  = df_data->ReqAttr->tta_Tags;
1009             }
1010
1011             if ((df_data->ReqAttr->tta_Style & FSF_BOLD)
1012                 && !(retval->tta_Style & FSF_BOLD)
1013                 && (df_data->u.FontsData.CurrentFileEntry->SupportedStyles & FSF_BOLD))
1014             {
1015                 retval->tta_Style |= FSF_BOLD;
1016             }
1017
1018             if ((df_data->ReqAttr->tta_Style & FSF_ITALIC)
1019                 && !(retval->tta_Style & FSF_ITALIC)
1020                 && (df_data->u.FontsData.CurrentFileEntry->SupportedStyles & FSF_ITALIC))
1021             {
1022                 retval->tta_Style |= FSF_ITALIC;
1023             }
1024         }
1025
1026         /* Let the iterator point to the next attr */
1027         if ((df_data->u.FontsData.AttrsIndex == df_data->u.FontsData.CurrentFileEntry->Numentries-1)
1028             || (df_data->u.FontsData.CurrentFileEntry->ContentsID == OFCH_ID
1029                 && df_data->ReqAttr==NULL &&
1030                 df_data->u.FontsData.AttrsIndex == df_data->u.FontsData.CurrentFileEntry->Numentries-2
1031                )
1032            )
1033         {
1034             df_data->u.FontsData.PrevFileEntry = df_data->u.FontsData.CurrentFileEntry;
1035             df_data->u.FontsData.CurrentFileEntry = (struct FileEntry *)GetSucc(df_data->u.FontsData.CurrentFileEntry);
1036             df_data->u.FontsData.AttrsIndex = 0;
1037             if (df_data->u.FontsData.CurrentFileEntry == NULL)
1038             {
1039                 while (df_data->u.FontsData.CurrentDirEntry != NULL && df_data->u.FontsData.CurrentFileEntry == NULL)
1040                 {
1041 #ifdef PROGDIRFONTSDIR
1042                     if (df_data->u.FontsData.CurrentDirEntry == df_data->u.FontsData.ProgdirDirEntry)
1043                         df_data->u.FontsData.CurrentDirEntry = (struct DirEntry *)GetHead(&DiskfontBase->fontsdirentrylist);
1044                     else
1045                         df_data->u.FontsData.CurrentDirEntry = (struct DirEntry *)GetSucc(df_data->u.FontsData.CurrentDirEntry);
1046 #else
1047                     df_data->u.FontsData.CurrentDirEntry = (struct DirEntry *)GetSucc(df_data->u.FontsData.CurrentDirEntry);
1048 #endif
1049                     if (df_data->u.FontsData.CurrentDirEntry != NULL)
1050                         df_data->u.FontsData.CurrentFileEntry = (struct FileEntry *)GetHead(&df_data->u.FontsData.CurrentDirEntry->FileList);
1051                 }
1052             }
1053
1054         }
1055         else
1056             df_data->u.FontsData.AttrsIndex++;
1057         break;
1058
1059     case DF_FILEDATA:
1060         if (df_data->u.FileData.LastAttr != NULL)
1061         {
1062             df_data->u.FileData.LastAttr->tta_Name = df_data->u.FileData.OrigName;
1063             df_data->u.FileData.LastAttr = NULL;
1064         }
1065
1066         /* Do not return the best-match attribute if it is not an outline font! */
1067
1068         if (df_data->u.FileData.FDH==NULL
1069             || df_data->u.FileData.AttrsIndex > df_data->u.FileData.FDH->NumEntries
1070             || (df_data->u.FileData.FDH->ContentsID != OFCH_ID &&
1071                 df_data->u.FileData.AttrsIndex == df_data->u.FileData.FDH->NumEntries))
1072
1073             ReturnPtr("DF_IteratorGetNext", struct TTextAttr *, NULL);
1074
1075         /* Get the TextAttr the iterator is pointing to
1076          * If it points to the element after the last element return
1077          * the Extra Attr that matches the outline font as close as possible
1078          */
1079         if (df_data->u.FileData.AttrsIndex == df_data->u.FileData.FDH->NumEntries)
1080             retval = &df_data->u.FileData.ExtraAttr;
1081         else
1082         {
1083             retval = &df_data->u.FileData.FDH->TAttrArray[df_data->u.FileData.AttrsIndex];
1084             df_data->u.FileData.OrigName = retval->tta_Name;
1085             retval->tta_Name = df_data->u.FileData.FilePart;
1086             df_data->u.FileData.LastAttr = retval;
1087         }
1088
1089         /* Let the iterator point to the next element.
1090          */
1091         df_data->u.FileData.AttrsIndex++;
1092
1093         break;
1094     }
1095
1096     ReturnPtr("DF_IteratorGetNext", struct TTextAttr *, retval);
1097 }
1098
1099 /****************************************************************************************/
1100
1101 /***********************/
1102 /* DF_IteratorRemember */
1103 /***********************/
1104
1105 /****************************************************************************************/
1106
1107 VOID DF_IteratorRemember(APTR iterator, struct DiskfontBase_intern *DiskfontBase)
1108 {
1109     struct DF_Data *df_data = (struct DF_Data *)iterator;
1110
1111     D(bug("DF_IteratorRemember(iterator=0x%lx)\n", iterator));
1112
1113     switch (df_data->Type)
1114     {
1115     case DF_FONTSDATA:
1116         if (df_data->u.FontsData.AttrsIndex > 0)
1117         {
1118             df_data->u.FontsData.RememberIndex = df_data->u.FontsData.AttrsIndex-1;
1119             df_data->u.FontsData.RememberFileEntry = df_data->u.FontsData.CurrentFileEntry;
1120         }
1121         else
1122         {
1123             df_data->u.FontsData.RememberFileEntry = df_data->u.FontsData.PrevFileEntry;
1124             df_data->u.FontsData.RememberIndex = df_data->u.FontsData.RememberFileEntry->Numentries-1;
1125             if (df_data->u.FontsData.RememberFileEntry->ContentsID == OFCH_ID
1126                 && df_data->ReqAttr == NULL
1127                )
1128             {
1129                 df_data->u.FontsData.RememberIndex--;
1130             }
1131         }
1132
1133         D(bug("DF_IteratorRemember: Remembered font: %s/%d\n",
1134               df_data->u.FontsData.RememberFileEntry->Attrs[df_data->u.FontsData.RememberIndex].tta_Name,
1135               df_data->u.FontsData.RememberFileEntry->Attrs[df_data->u.FontsData.RememberIndex].tta_YSize));
1136         break;
1137
1138     case DF_FILEDATA:
1139         df_data->u.FileData.RememberIndex = df_data->u.FileData.AttrsIndex-1;
1140
1141         D(bug("DF_IteratorRemember: Remembered font: %s(%d)\n",
1142               df_data->ReqAttr->tta_Name, df_data->u.FileData.RememberIndex));
1143         break;
1144     }
1145 }
1146
1147 /****************************************************************************************/
1148
1149 /***************************/
1150 /* DF_IteratorRememberOpen */
1151 /***************************/
1152
1153 /****************************************************************************************/
1154
1155 struct TextFont *DF_IteratorRememberOpen(APTR iterator, struct DiskfontBase_intern *DiskfontBase)
1156 {
1157     struct DF_Data *df_data = (struct DF_Data *)iterator;
1158     struct FontDescrHeader *fdh = NULL;
1159     struct TTextAttr *RememberAttr = NULL;
1160     struct TextFont *tf = NULL;
1161     BPTR olddir = 0, lock, dirlock;
1162
1163     D(bug("DF_IteratorRememberOpen(iterator=0x%lx)\n", iterator));
1164
1165     /* Set current dir and get the Remember TextAttr */
1166     switch (df_data->Type)
1167     {
1168     case DF_FONTSDATA:
1169         {
1170             struct FileEntry *rementry = df_data->u.FontsData.RememberFileEntry;
1171
1172             olddir = CurrentDir(rementry->DirEntry->DirLock);
1173             fdh = ReadFontDescr(rementry->FileName, DiskfontBase);
1174             if (rementry->ContentsID == OFCH_ID
1175                 && df_data->u.FontsData.RememberIndex == rementry->Numentries - 1)
1176             {
1177                 /* It is the TAttr generated for best matching */
1178                 RememberAttr = &rementry->Attrs[df_data->u.FontsData.RememberIndex];
1179             }
1180             else
1181                 RememberAttr = &fdh->TAttrArray[df_data->u.FontsData.RememberIndex];
1182         }
1183         break;
1184
1185     case DF_FILEDATA:
1186         if (df_data->u.FileData.LastAttr != NULL)
1187         {
1188             df_data->u.FileData.LastAttr->tta_Name = df_data->u.FileData.OrigName;
1189             df_data->u.FileData.LastAttr = NULL;
1190         }
1191
1192         RememberAttr = NULL;
1193         lock = Lock(df_data->ReqAttr->tta_Name, ACCESS_READ);
1194         if (lock == NULL)
1195         {
1196             D(bug("DF_IteratorRememberOpen: Could not lock file\n"));
1197             break;
1198         }
1199
1200         dirlock = ParentDir(lock);
1201         UnLock(lock);
1202         if (dirlock == NULL)
1203         {
1204             D(bug("DF_IteratorRememberOpen: Could not get ParentDir\n"));
1205             break;
1206         }
1207         olddir = CurrentDir(dirlock);
1208
1209         fdh = df_data->u.FileData.FDH;
1210         if (df_data->u.FileData.RememberIndex == fdh->NumEntries)
1211             RememberAttr = &df_data->u.FileData.ExtraAttr;
1212         else
1213             RememberAttr = &fdh->TAttrArray[df_data->u.FileData.RememberIndex];
1214         break;
1215     }
1216
1217     if (RememberAttr == NULL)
1218         return NULL;
1219
1220     if (fdh != NULL)
1221     {
1222         D(bug("DF_IteratorRememberOpen: Font Description read\n"));
1223
1224         if (IS_OUTLINE_FONT(RememberAttr))
1225         {
1226             D(bug("DF_IteratorRememberOpen: loading outline font\n"));
1227
1228             tf = OTAG_ReadOutlineFont(RememberAttr,
1229                                       df_data->ReqAttr,
1230                                       fdh->OTagList,
1231                                       DiskfontBase);
1232             D(bug("DF_IteratorRememberOpen: tf=0x%lx\n", tf));
1233
1234         }
1235         else
1236         {
1237             D(bug("DF_IteratorRememberOpen: loading bitmap font\n"));
1238
1239             tf = ReadDiskFont(RememberAttr,
1240                               FilePart(df_data->ReqAttr->tta_Name),
1241                               DiskfontBase);
1242
1243             D(bug("DF_IteratorRememberOpen: tf=0x%lx\n", tf));
1244         }
1245     }
1246     else
1247         D(bug("DF_IteratorRememberOpen: Font Description read failed\n"));
1248
1249     dirlock = CurrentDir(olddir);
1250     switch (df_data->Type)
1251     {
1252     case DF_FONTSDATA:
1253         FreeFontDescr(fdh, DiskfontBase);
1254         break;
1255
1256     case DF_FILEDATA:
1257         UnLock(dirlock);
1258         break;
1259     }
1260
1261     if (tf != NULL)
1262     {
1263         struct DiskFontHeader *dfh;
1264
1265         /* PPaint's personal.font/8 has not set FPF_DISKFONT,
1266          (FPF_ROMFONT neither), but AmigaOS diskfont.library
1267          still shows FPF_DISKFONT set when opening this font */
1268
1269         tf->tf_Flags &= ~FPF_ROMFONT;
1270         tf->tf_Flags |= FPF_DISKFONT;
1271
1272         D(bug("Adding font: %p\n", tf));
1273
1274         /* Forbid() must be called before AddFont, because AddFont clears
1275          tf_Accessors and in the worst case it could happen to us that
1276          after the AddFont() another task opens and closes/frees the
1277          diskfont, before we manage to increase tf_Accessors. */
1278
1279         Forbid();
1280
1281         AddFont(tf);
1282         tf->tf_Accessors++;
1283
1284         dfh = (struct DiskFontHeader *)((UBYTE *)(tf) - (IPTR)OFFSET(DiskFontHeader, dfh_TF));
1285
1286         /* Paranoia check */
1287         if (dfh->dfh_FileID == DFH_ID)
1288             ADDTAIL(&DiskfontBase->diskfontlist, &dfh->dfh_DF);
1289
1290         Permit();
1291
1292         D(bug("Font added\n"));
1293     }
1294
1295     return tf;
1296 }
1297
1298 /****************************************************************************************/
1299
1300 /*******************/
1301 /* DF_IteratorFree */
1302 /*******************/
1303
1304 /****************************************************************************************/
1305
1306 VOID DF_IteratorFree(APTR iterator, struct DiskfontBase_intern *DiskfontBase)
1307 {
1308     struct DF_Data *df_data = (struct DF_Data *)iterator;
1309
1310     FreeResources(df_data, DiskfontBase);
1311 }
1312
1313 /****************************************************************************************/
1314
1315 /*******************/
1316 /* DF_OpenFontPath */
1317 /*******************/
1318
1319 /****************************************************************************************/
1320
1321 struct TextFont *DF_OpenFontPath(struct TextAttr *reqattr, struct DiskfontBase_intern *DiskfontBase)
1322 {
1323     struct TextFont *tf = NULL;
1324     struct FontDescrHeader *fdh;
1325     BPTR olddir, lock, dirlock;
1326
1327     D(bug("DF_OpenFontPath(reqattr=0x%lx)\n", reqattr));
1328
1329     lock = Lock(reqattr->ta_Name, ACCESS_READ);
1330     if (lock == NULL)
1331     {
1332         D(bug("DF_OpenFontPath: Could not lock file\n"));
1333         return NULL;
1334     }
1335
1336     dirlock = ParentDir(lock);
1337     UnLock(lock);
1338     if (dirlock == NULL)
1339     {
1340         D(bug("DF_OpenFontPath: Could not get ParentDir\n"));
1341         return NULL;
1342     }
1343
1344     olddir = CurrentDir(dirlock);
1345
1346     fdh = ReadFontDescr(reqattr->ta_Name, DiskfontBase);
1347
1348     if (fdh != NULL)
1349     {
1350         WORD max_match_weight = 0, match_weight;
1351         LONG match_index = -1;
1352         int i;
1353
1354         D(bug("DF_OpenFontPath: Font Description read\n"));
1355
1356         for (i=0; i<fdh->NumEntries; i++)
1357         {
1358             match_weight = WeighTAMatch((struct TextAttr *)reqattr,
1359                                         (struct TextAttr *)&fdh->TAttrArray[i],
1360                                         fdh->TAttrArray[i].tta_Tags);
1361
1362             if (match_weight > max_match_weight)
1363             {
1364                 max_match_weight = match_weight;
1365                 match_index = i;
1366             }
1367         }
1368
1369         if (match_index >= 0)
1370         {
1371            if (IS_OUTLINE_FONT(&fdh->TAttrArray[match_index]))
1372            {
1373                D(bug("DF_OpenFontPath: loading outline font\n"));
1374
1375                tf = OTAG_ReadOutlineFont(&fdh->TAttrArray[match_index],
1376                                          (struct TTextAttr *)reqattr,
1377                                          fdh->OTagList,
1378                                          DiskfontBase);
1379                D(bug("DF_OpenFontPath: tf=0x%lx\n", tf));
1380
1381            }
1382            else
1383            {
1384                D(bug("DF_OpenFontPath: loading bitmap font\n"));
1385
1386                tf = ReadDiskFont(&fdh->TAttrArray[match_index],
1387                                  reqattr->ta_Name,
1388                                  DiskfontBase);
1389
1390                D(bug("DF_OpenFontPath: tf=0x%lx\n", tf));
1391            }
1392         }
1393         else
1394             D(bug("DF_OpenFontPath: No matching font found\n"));
1395
1396         FreeFontDescr(fdh, DiskfontBase);
1397     }
1398     else
1399         D(bug("DF_OpenFontPath: Font Description read failed\n"));
1400
1401     CurrentDir(olddir);
1402     UnLock(dirlock);
1403
1404     if (tf != NULL)
1405     {
1406         struct DiskFontHeader *dfh;
1407
1408         /* PPaint's personal.font/8 has not set FPF_DISKFONT,
1409          (FPF_ROMFONT neither), but AmigaOS diskfont.library
1410          still shows FPF_DISKFONT set when opening this font */
1411
1412         tf->tf_Flags &= ~FPF_ROMFONT;
1413         tf->tf_Flags |= FPF_DISKFONT;
1414
1415         D(bug("Adding font: %p\n", tf));
1416
1417         /* Forbid() must be called before AddFont, because AddFont clears
1418          tf_Accessors and in the worst case it could happen to us that
1419          after the AddFont() another task opens and closes/frees the
1420          diskfont, before we manage to increase tf_Accessors. */
1421
1422         Forbid();
1423
1424         AddFont(tf);
1425         tf->tf_Accessors++;
1426
1427         dfh = (struct DiskFontHeader *)((UBYTE *)(tf) - (IPTR)OFFSET(DiskFontHeader, dfh_TF));
1428
1429         /* Paranoia check */
1430         if (dfh->dfh_FileID == DFH_ID)
1431             ADDTAIL(&DiskfontBase->diskfontlist, &dfh->dfh_DF);
1432
1433         Permit();
1434
1435         D(bug("Font added\n"));
1436     }
1437
1438     return tf;
1439 }