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 *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 + 1) & ~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 *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 *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 *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 *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, (APTR)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, (APTR)fh);
 366         ok = ok && WriteLong(&DiskfontBase->dsh, fe->FileChanged.ds_Minute, (APTR)fh);
 367         ok = ok && WriteLong(&DiskfontBase->dsh, fe->FileChanged.ds_Tick, (APTR)fh);
 368         ok = ok && WriteWord(&DiskfontBase->dsh, fe->ContentsID, (APTR)fh);
 369         ok = ok && WriteByte(&DiskfontBase->dsh, fe->SupportedStyles, (APTR)fh);
 370         ok = ok && WriteByte(&DiskfontBase->dsh, fe->FontStyle, (APTR)fh);
 371         D(bug("StreamOutFileList: Write numentries=%d\n", fe->Numentries));
 372         ok = ok && WriteLong(&DiskfontBase->dsh, fe->Numentries, (APTR)fh);
 373
 374         for (i=0; ok && i<fe->Numentries; i++)
 375         {
 376             ok = ok && WriteWord(&DiskfontBase->dsh, fe->Attrs[i].tta_YSize, (APTR)fh);
 377             ok = ok && WriteByte(&DiskfontBase->dsh, fe->Attrs[i].tta_Style, (APTR)fh);
 378             ok = ok && WriteByte(&DiskfontBase->dsh, fe->Attrs[i].tta_Flags, (APTR)fh);
 379             ok = ok && WriteTagsNum(fh, fe->Attrs[i].tta_Tags, DiskfontBase);
 380         }
 381     }
 382     ok = ok && WriteString(&DiskfontBase->dsh, "", (APTR)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 *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, (APTR)fh);
 404          ok && strlen(fe2.FileName)>0;
 405          ok = ok && ReadString(&DiskfontBase->dsh, &fe2.FileName, (APTR)fh))
 406     {
 407         D(bug("StreamInFileList: reading data for \"%s\"\n", fe2.FileName));
 408
 409         ok = ok && ReadLong(&DiskfontBase->dsh, &fe2.FileChanged.ds_Days, (APTR)fh);
 410         ok = ok && ReadLong(&DiskfontBase->dsh, &fe2.FileChanged.ds_Minute, (APTR)fh);
 411         ok = ok && ReadLong(&DiskfontBase->dsh, &fe2.FileChanged.ds_Tick, (APTR)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, (APTR)fh);
 416         ok = ok && ReadByte(&DiskfontBase->dsh, &fe2.SupportedStyles, (APTR)fh);
 417         ok = ok && ReadByte(&DiskfontBase->dsh, &fe2.FontStyle, (APTR)fh);
 418         ok = ok && ReadLong(&DiskfontBase->dsh, &fe2.Numentries, (APTR)fh);
 419
 420         if (ok)
 421         {
 422             int namelen = (strlen(fe2.FileName) + 1 + 1) & ~1;
 423             attrs = AllocVec(fe2.Numentries * sizeof(struct TTextAttr), MEMF_ANY|MEMF_CLEAR);
 424
 425             ok = ok && attrs != NULL;
 426
 427             if (ok)
 428                 for (i = 0; i < fe2.Numentries; i++)
 429                     attrs[i].tta_Tags = NULL;
 430
 431             for (i = 0, totnumtags = 0; ok && i < fe2.Numentries; i++)
 432             {
 433                 ok = ok && ReadWord(&DiskfontBase->dsh, &attrs[i].tta_YSize, (APTR)fh);
 434                 ok = ok && ReadByte(&DiskfontBase->dsh, &attrs[i].tta_Style, (APTR)fh);
 435                 ok = ok && ReadByte(&DiskfontBase->dsh, &attrs[i].tta_Flags, (APTR)fh);
 436                 if (ok)
 437                 {
 438                     attrs[i].tta_Tags = ReadTagsNum(fh, &numtags, DiskfontBase);
 439                     D(bug("StreamInFileList: read tags %p\n", attrs[i].tta_Tags));
 440                     totnumtags += numtags;
 441                     ok = ok && numtags > 0;
 442                 }
 443             }
 444             D(bug("StreamInFileList: totnumtags == %u\n", totnumtags));
 445
 446             if (ok)
 447             {
 448                 ULONG size = sizeof(struct FileEntry) +
 449                     namelen +
 450                     fe2.Numentries * sizeof(struct TTextAttr) +
 451                     totnumtags * sizeof(struct TagItem);
 452
 453                 fe = (struct FileEntry *)AllocVec(size, MEMF_ANY);
 454                 ok = ok && fe != NULL;
 455             }
 456             if (ok)
 457             {
 458                 fe->DirEntry = direntry;
 459                 fe->FileName = (STRPTR)(fe+1);
 460                 strcpy(fe->FileName, fe2.FileName);
 461                 fe->FileChanged = fe2.FileChanged;
 462                 fe->ContentsID = fe2.ContentsID;
 463                 fe->SupportedStyles = fe2.SupportedStyles;
 464                 fe->FontStyle = fe2.FontStyle;
 465                 fe->Numentries = fe2.Numentries;
 466                 fe->Attrs = (struct TTextAttr *)(fe->FileName + namelen);
 467
 468                 tagptr = (struct TagItem *)(fe->Attrs + fe2.Numentries);
 469                 for (i = 0; i < fe2.Numentries; i++)
 470                 {
 471                     fe->Attrs[i].tta_Name = fe->FileName;
 472                     fe->Attrs[i].tta_YSize = attrs[i].tta_YSize;
 473                     fe->Attrs[i].tta_Style = attrs[i].tta_Style;
 474                     fe->Attrs[i].tta_Flags = attrs[i].tta_Flags;
 475                     numtags = CopyTagItems(tagptr, attrs[i].tta_Tags, DiskfontBase);
 476                     fe->Attrs[i].tta_Tags = tagptr;
 477                     tagptr += numtags;
 478                 }
 479                 ADDTAIL(&direntry->FileList, fe);
 480             }
 481
 482             if (attrs != NULL)
 483             {
 484                 for (i = 0; i < fe2.Numentries; i++)
 485                     if (attrs[i].tta_Tags != NULL)
 486                     {
 487                         D(bug("StreamInFileList: freeing tags %p\n", attrs[i].tta_Tags));
 488                         FreeVec(attrs[i].tta_Tags);
 489                     }
 490                 FreeVec(attrs);
 491             }
 492         }
 493
 494         FreeVec(fe2.FileName);
 495     }
 496     if (ok)
 497     {
 498         D(bug("StreamInFileList: FileName empty\n"));
 499         FreeVec(fe2.FileName);
 500     }
 501     else
 502     {
 503         D(bug("StreamInFileList: Error reading chachefile\n"));
 504         FreeFileList(&direntry->FileList, DiskfontBase);
 505     }
 506
 507     return ok;
 508 }
 509
 510 /****************************************************************************************/
 511
 512 /****************/
 513 /* FreeDirEntry */
 514 /****************/
 515
 516 /****************************************************************************************/
 517
 518 STATIC VOID FreeDirEntry(struct DirEntry *direntry, struct DiskfontBase *DiskfontBase)
 519 {
 520     if (direntry!=NULL)
 521     {
 522         FreeFileList(&direntry->FileList, DiskfontBase);
 523         UnLock(direntry->DirLock);
 524         FreeVec(direntry);
 525     }
 526 }
 527
 528 /****************************************************************************************/
 529
 530 /****************/
 531 /* ReadDirEntry */
 532 /****************/
 533
 534 /****************************************************************************************/
 535
 536 STATIC struct DirEntry *ReadDirEntry(BPTR dirlock, struct DirEntry *direntry, struct DiskfontBase *DiskfontBase)
 537 {
 538     struct Process *Self;
 539     APTR oldwinptr;
 540     struct FileInfoBlock *fib;
 541     BPTR olddir;
 542     BPTR fh;
 543
 544     D(bug("ReadDirEntry(dirlock=0x%lx, direntry=0x%lx)\n", dirlock, direntry));
 545
 546     Self               = (struct Process *) FindTask(NULL);
 547     oldwinptr          = Self->pr_WindowPtr;
 548     Self->pr_WindowPtr = (APTR) -1;
 549
 550     fib = AllocDosObject(DOS_FIB, NULL);
 551     if (fib == NULL)
 552     {
 553         D(bug("ReadDirEntry: Could not allocate DosObject\n"));
 554         Self->pr_WindowPtr = oldwinptr;
 555         ReturnPtr("ReadDirEntry", struct DirEntry *, NULL);
 556     }
 557     Examine(dirlock, fib);
 558     Self->pr_WindowPtr = oldwinptr;
 559
 560     olddir = CurrentDir(dirlock);
 561
 562     if (direntry == NULL)
 563     {
 564         direntry = AllocVec(sizeof(struct DirEntry), MEMF_ANY | MEMF_CLEAR);
 565         if (direntry==NULL)
 566         {
 567             D(bug("ReadDirEntry: Could not allocate DirEntry\n"));
 568             FreeDosObject(DOS_FIB, fib);
 569             CurrentDir(olddir);
 570             ReturnPtr("ReadDirEntry", struct DirEntry *, NULL);
 571         }
 572         else
 573             D(bug("ReadDirEntry: allocated direntry = 0x%lx\n", direntry));
 574
 575         direntry->DirLock  = dirlock;
 576         NEWLIST(&direntry->FileList);
 577
 578         /* Try to read the direntry from the file */
 579         fh = Open(CACHE_FILE, MODE_OLDFILE);
 580         if (fh != BNULL)
 581         {
 582             BOOL ok;
 583
 584             ok = ReadLong(&DiskfontBase->dsh, &direntry->DirChanged.ds_Days, (APTR)fh);
 585             ok = ok && ReadLong(&DiskfontBase->dsh, &direntry->DirChanged.ds_Minute, (APTR)fh);
 586             ok = ok && ReadLong(&DiskfontBase->dsh, &direntry->DirChanged.ds_Tick, (APTR)fh);
 587
 588             if (ok)
 589                 ok = StreamInFileList(direntry, fh, DiskfontBase);
 590
 591             Close(fh);
 592
 593         /* TODO: */
 594 #if 0
 595             /* This part is disabled because in emul_handler on UNIX the date
 596              * of a parent directory is changed only when a file is added or
 597              * removed from the directory
 598              */
 599
 600             /* If dates are the same return the direntry as is */
 601             if (ok && CompareDates(&direntry->DirChanged, &fib->fib_Date) == 0)
 602             {
 603                 D(bug("ReadDirEntry: date in cache not changed\n"));
 604                 FreeDosObject(DOS_FIB, fib);
 605                 Self->pr_WindowPtr = oldwinptr;
 606                 CurrentDir(olddir);
 607                 ReturnPtr("ReadDirEntry", struct DirEntry *, direntry);
 608             }
 609 #endif
 610         }
 611     }
 612     else
 613     {
 614         CurrentDir(direntry->DirLock);
 615         UnLock(dirlock);
 616         if (CompareDates(&direntry->DirChanged, &fib->fib_Date) == 0)
 617         {
 618             D(bug("ReadDirEntry: direntry 0x%lx not changed\n", direntry));
 619             FreeDosObject(DOS_FIB, fib);
 620             Self->pr_WindowPtr = oldwinptr;
 621             CurrentDir(olddir);
 622             ReturnPtr("ReadDirEntry", struct DirEntry *, direntry);
 623         }
 624     }
 625
 626     direntry->DirChanged = fib->fib_Date;
 627
 628     if (!GetFileList(direntry, DiskfontBase))
 629     {
 630         D(bug("ReadDirEntry: Error reading FileList\n"));
 631         FreeDosObject(DOS_FIB, fib);
 632         CurrentDir(olddir);
 633         UnLock(direntry->DirLock);
 634         FreeVec(direntry);
 635         Self->pr_WindowPtr = oldwinptr;
 636         ReturnPtr("ReadDirEntry", struct DirEntry *, NULL);
 637     }
 638
 639     /* If everything went OK Write the cache file */
 640     fh = Open(CACHE_FILE, MODE_NEWFILE);
 641     if (fh != BNULL)
 642     {
 643         BOOL ok;
 644
 645         ok = WriteLong(&DiskfontBase->dsh, fib->fib_Date.ds_Days, (APTR)fh);
 646         ok = ok && WriteLong(&DiskfontBase->dsh, fib->fib_Date.ds_Minute, (APTR)fh);
 647         ok = ok && WriteLong(&DiskfontBase->dsh, fib->fib_Date.ds_Tick, (APTR)fh);
 648
 649         if (ok)
 650             ok = StreamOutFileList(&direntry->FileList, fh, DiskfontBase);
 651
 652         Close(fh);
 653
 654         if (ok)
 655         {
 656             Examine(direntry->DirLock, fib);
 657             direntry->DirChanged = fib->fib_Date;
 658             fh = Open(CACHE_FILE, MODE_OLDFILE);
 659             if (fh != BNULL)
 660             {
 661                 Seek(fh, 0, OFFSET_BEGINNING);
 662                 ok = WriteLong(&DiskfontBase->dsh, fib->fib_Date.ds_Days, (APTR)fh);
 663                 ok = ok && WriteLong(&DiskfontBase->dsh, fib->fib_Date.ds_Minute, (APTR)fh);
 664                 ok = ok && WriteLong(&DiskfontBase->dsh, fib->fib_Date.ds_Tick, (APTR)fh);
 665                 Close(fh);
 666             }
 667         }
 668
 669         if (!ok)
 670             DeleteFile(CACHE_FILE);
 671     }
 672
 673     FreeDosObject(DOS_FIB, fib);
 674     CurrentDir(olddir);
 675     Self->pr_WindowPtr = oldwinptr;
 676
 677     ReturnPtr("ReadDirEntry", struct DirEntry *, direntry);
 678 }
 679
 680 /****************************************************************************************/
 681
 682 /****************/
 683 /* FreeResouces */
 684 /****************/
 685
 686 /****************************************************************************************/
 687
 688 STATIC VOID FreeResources(struct DF_Data *df_data, struct DiskfontBase *DiskfontBase)
 689 {
 690     D(bug("FreeResources(df_data=%p)\n", df_data));
 691
 692     ReleaseSemaphore(&DiskfontBase->fontssemaphore);
 693
 694     switch (df_data->Type)
 695     {
 696     case DF_FONTSDATA:
 697 #ifdef PROGDIRFONTSDIR
 698         FreeDirEntry(df_data->u.FontsData.ProgdirDirEntry, DiskfontBase);
 699 #endif
 700         break;
 701
 702     case DF_FILEDATA:
 703         if (df_data->u.FileData.FDH != NULL)
 704             FreeFontDescr(df_data->u.FileData.FDH, DiskfontBase);
 705         break;
 706     }
 707
 708     FreeMem(df_data, sizeof (struct DF_Data));
 709
 710     ReturnVoid("FreeResources");
 711 }
 712
 713 /****************************************************************************************/
 714
 715 /****************************/
 716 /* CleanUpFontsDirEntryList */
 717 /****************************/
 718
 719 /****************************************************************************************/
 720
 721 VOID CleanUpFontsDirEntryList(struct DiskfontBase *DiskfontBase)
 722 {
 723     struct DirEntry *direntry, *direntry2;
 724
 725     ForeachNodeSafe(&DiskfontBase->fontsdirentrylist, direntry, direntry2)
 726         FreeDirEntry(direntry, DiskfontBase);
 727
 728     ReturnVoid("CleanUpFontsDirEntryList");
 729 }
 730
 731 /****************************************************************************************/
 732
 733 /******************/
 734 /* AllocResources */
 735 /******************/
 736
 737 /****************************************************************************************/
 738
 739 STATIC struct DF_Data *AllocResources(struct TTextAttr *reqattr, struct DiskfontBase *DiskfontBase)
 740 {
 741     struct DF_Data *df_data;
 742
 743     D(bug("AllocResources(void)\n"));
 744
 745     ObtainSemaphore(&DiskfontBase->fontssemaphore);
 746
 747     /* Allocate user data */
 748     if ((df_data = AllocMem( sizeof (struct DF_Data), MEMF_ANY | MEMF_CLEAR)))
 749     {
 750         df_data->ReqAttr = reqattr;
 751
 752         if (reqattr==NULL || FilePart(reqattr->tta_Name)==reqattr->tta_Name)
 753         {
 754             struct DevProc *dp = NULL;
 755             struct MinList newdirlist;
 756             struct DirEntry *direntry, *direntry2;
 757
 758             df_data->Type = DF_FONTSDATA;
 759
 760 #ifdef PROGDIRFONTSDIR
 761             do
 762             {
 763                 struct Process *Self;
 764                 APTR oldwinptr;
 765                 BPTR lock;
 766
 767                 df_data->u.FontsData.ProgdirDirEntry = NULL;
 768
 769                 if (!GetProgramDir())
 770                     break;
 771
 772                 Self               = (struct Process *) FindTask(NULL);
 773                 oldwinptr          = Self->pr_WindowPtr;
 774                 Self->pr_WindowPtr = (APTR) -1;
 775                 lock               = Lock(PROGDIRFONTSDIR, ACCESS_READ);
 776                 Self->pr_WindowPtr = oldwinptr;
 777
 778                 D(bug("AllocResources: PROGDIR:Fonts DirLock = 0x%lx\n", lock));
 779
 780                 if (!lock)
 781                     break;
 782
 783                 df_data->u.FontsData.ProgdirDirEntry = ReadDirEntry(lock, NULL, DiskfontBase);
 784                 D(bug("AllocResources: PROGDIR:Fonts direntry 0x%lx\n", df_data->u.FontsData.ProgdirDirEntry));
 785             } while (0);
 786 #endif
 787
 788             NEWLIST(&newdirlist);
 789             while((dp = GetDeviceProc(FONTSDIR, dp))!=NULL)
 790             {
 791                 BPTR lock;
 792
 793                 D(bug("AllocResources: FONTS: lock = 0x%lx\n", dp->dvp_Lock));
 794
 795                 lock = DupLock(dp->dvp_Lock);
 796                 if (lock==BNULL)
 797                 {
 798                     D(bug("AllocResources: Could not duplicate lock\n"));
 799                     continue;
 800                 }
 801
 802                 /* See if direntry is already in memory */
 803                 for (direntry = (struct DirEntry *)GetHead(&DiskfontBase->fontsdirentrylist);
 804                      direntry != NULL;
 805                      direntry = (struct DirEntry *)GetSucc(direntry))
 806                 {
 807                     if (SameLock(direntry->DirLock, lock) == LOCK_SAME)
 808                     {
 809                         REMOVE(direntry);
 810                         break;
 811                     }
 812                 }
 813
 814                 /* Read or update fonts information in this directory */
 815                 direntry = ReadDirEntry(lock, direntry, DiskfontBase);
 816                 if (direntry!=NULL)
 817                 {
 818                     D(bug("AllocResources: addtail direntry 0x%lx\n", direntry));
 819                     D(bug("AllocResources: first FileEntry: %p\n", GetHead(&direntry->FileList)));
 820                     ADDTAIL(&newdirlist, direntry);
 821                 }
 822                 else
 823                     D(bug("AllocResources: Error reading DirEntry\n"));
 824             }
 825
 826             /* Clean up directory lists that are in memory but not in the
 827              * FONTS: assign anymore */
 828             ForeachNodeSafe(&DiskfontBase->fontsdirentrylist, direntry, direntry2)
 829             {
 830                 REMOVE(direntry);
 831                 FreeDirEntry(direntry, DiskfontBase);
 832             }
 833
 834             ForeachNodeSafe(&newdirlist, direntry, direntry2)
 835             {
 836                 REMOVE(direntry);
 837                 ADDTAIL(&DiskfontBase->fontsdirentrylist, direntry);
 838             }
 839
 840             FreeDeviceProc(dp);
 841         }
 842         else
 843         {
 844             struct FontDescrHeader *fdh;
 845
 846             df_data->Type = DF_FILEDATA;
 847             fdh = ReadFontDescr(reqattr->tta_Name, DiskfontBase);
 848             df_data->u.FileData.FDH = fdh;
 849
 850             if (fdh != NULL)
 851             {
 852                 if (fdh->ContentsID==OFCH_ID)
 853                 {
 854                     UBYTE SupportedStyles = OTAG_GetSupportedStyles(fdh->OTagList, DiskfontBase);
 855
 856                     df_data->u.FileData.ExtraAttr.tta_Name = reqattr->tta_Name;
 857                     df_data->u.FileData.ExtraAttr.tta_YSize = reqattr->tta_YSize;
 858                     df_data->u.FileData.ExtraAttr.tta_Style = OTAG_GetFontStyle(fdh->OTagList, DiskfontBase);
 859                     df_data->u.FileData.ExtraAttr.tta_Flags = OTAG_GetFontFlags(fdh->OTagList, DiskfontBase);
 860
 861                     df_data->u.FileData.ExtraAttr.tta_Tags = NULL;
 862                     if (reqattr->tta_Style & FSF_TAGGED)
 863                     {
 864                         df_data->u.FileData.ExtraAttr.tta_Style |= FSF_TAGGED;
 865                         df_data->u.FileData.ExtraAttr.tta_Tags = reqattr->tta_Tags;
 866                     }
 867
 868                     if ((reqattr->tta_Style & FSF_BOLD)
 869                         && !(df_data->u.FileData.ExtraAttr.tta_Style & FSF_BOLD)
 870                         && (SupportedStyles & FSF_BOLD))
 871                     {
 872                         df_data->u.FileData.ExtraAttr.tta_Style |= FSF_BOLD;
 873                     }
 874
 875                     if ((reqattr->tta_Style & FSF_ITALIC)
 876                         && !(df_data->u.FileData.ExtraAttr.tta_Style & FSF_ITALIC)
 877                         && (SupportedStyles & FSF_ITALIC))
 878                     {
 879                         df_data->u.FileData.ExtraAttr.tta_Style |= FSF_ITALIC;
 880                     }
 881                 }
 882             }
 883         }
 884     }
 885
 886     ReturnPtr("AllocResources", struct DF_Data *, df_data);
 887 }
 888
 889 /****************************************************************************************/
 890
 891 /*******************/
 892 /* DF_IteratorInit */
 893 /*******************/
 894
 895 /****************************************************************************************/
 896
 897 APTR DF_IteratorInit(struct TTextAttr *reqattr, struct DiskfontBase *DiskfontBase)
 898 {
 899     struct DF_Data *df_data;
 900
 901     D(bug("DF_IteratorInit(reqattr=0x%lx)\n", reqattr));
 902
 903     df_data = AllocResources(reqattr, DiskfontBase);
 904     if (df_data == NULL)
 905     {
 906         D(bug("DF_IteratorInit: Error executing Allocresources\n"));
 907         ReturnPtr("DF_IteratorInit", APTR, NULL);
 908     }
 909
 910     switch (df_data->Type)
 911     {
 912     case DF_FONTSDATA:
 913         df_data->u.FontsData.CurrentDirEntry = NULL;
 914         df_data->u.FontsData.CurrentFileEntry = NULL;
 915
 916 #ifdef PROGDIRFONTSDIR
 917         if (df_data->u.FontsData.ProgdirDirEntry != NULL)
 918         {
 919             D(bug("DF_IteratorInit: ProgdirDirEntry found\n"));
 920             df_data->u.FontsData.CurrentDirEntry = df_data->u.FontsData.ProgdirDirEntry;
 921             df_data->u.FontsData.CurrentFileEntry = (struct FileEntry *)GetHead(&df_data->u.FontsData.ProgdirDirEntry->FileList);
 922         }
 923         else
 924             D(bug("DF_IteratorInit: No ProgdirEntry found\n"));
 925 #endif
 926         if (df_data->u.FontsData.CurrentDirEntry == NULL || df_data->u.FontsData.CurrentFileEntry == NULL)
 927         {
 928             df_data->u.FontsData.CurrentDirEntry = (struct DirEntry *)GetHead(&DiskfontBase->fontsdirentrylist);
 929             if (df_data->u.FontsData.CurrentDirEntry != NULL)
 930                 df_data->u.FontsData.CurrentFileEntry = (struct FileEntry *)GetHead(&df_data->u.FontsData.CurrentDirEntry->FileList);
 931         }
 932
 933         D(bug("DF_IteratorInit: CurrentDirEntry: %p CurrentFileEntry: %p\n",
 934               df_data->u.FontsData.CurrentDirEntry, df_data->u.FontsData.CurrentFileEntry));
 935
 936         /* If DirEntry was empty search for one that is not empty */
 937         while (df_data->u.FontsData.CurrentDirEntry != NULL && df_data->u.FontsData.CurrentFileEntry == NULL)
 938         {
 939             df_data->u.FontsData.CurrentDirEntry = (struct DirEntry *)GetSucc(df_data->u.FontsData.CurrentDirEntry);
 940             if (df_data->u.FontsData.CurrentDirEntry != NULL)
 941                 df_data->u.FontsData.CurrentFileEntry = (struct FileEntry *)GetHead(&df_data->u.FontsData.CurrentDirEntry->FileList);
 942
 943             D(bug("DF_IteratorInit: CurrentDirEntry: %p CurrentFileEntry: %p\n",
 944                   df_data->u.FontsData.CurrentDirEntry, df_data->u.FontsData.CurrentFileEntry));
 945         }
 946         df_data->u.FontsData.AttrsIndex = 0;
 947
 948         break;
 949
 950     case DF_FILEDATA:
 951         df_data->u.FileData.AttrsIndex = 0;
 952         df_data->u.FileData.FilePart = FilePart(df_data->ReqAttr->tta_Name);
 953         df_data->u.FileData.LastAttr = NULL;
 954         break;
 955     }
 956
 957     ReturnPtr("DF_IteratorInit", APTR, df_data);
 958 }
 959
 960 /****************************************************************************************/
 961
 962 /**********************/
 963 /* DF_IteratorGetNext */
 964 /**********************/
 965
 966 /****************************************************************************************/
 967
 968 struct TTextAttr *DF_IteratorGetNext(APTR iterator, struct DiskfontBase *DiskfontBase)
 969 {
 970     struct TTextAttr *retval = NULL;
 971     struct DF_Data *df_data = (struct DF_Data *)iterator;
 972
 973     D(bug("DF_IteratorGetNext(iterator=0x%lx)\n", iterator));
 974
 975     if (df_data==NULL)
 976         ReturnPtr("DF_IteratorGetNext", struct TTextAttr *, NULL);
 977
 978     switch (df_data->Type)
 979     {
 980     case DF_FONTSDATA:
 981         if (df_data->u.FontsData.CurrentDirEntry==NULL)
 982             ReturnPtr("DF_IteratorGetNext", struct TTextAttr *, NULL);
 983
 984         retval = df_data->u.FontsData.CurrentFileEntry->Attrs + df_data->u.FontsData.AttrsIndex;
 985         D(bug("DF_IteratorGetNext:\n"
 986               "  ContentsID: 0x%x == 0x%x\n"
 987               "  ReqAttr: %p\n"
 988               "  AttrIndex: %d, Numentries: %d\n",
 989               df_data->u.FontsData.CurrentFileEntry->ContentsID, OFCH_ID,
 990               df_data->ReqAttr,
 991               df_data->u.FontsData.AttrsIndex, df_data->u.FontsData.CurrentFileEntry->Numentries));
 992
 993         if (df_data->u.FontsData.CurrentFileEntry->ContentsID == OFCH_ID
 994             && df_data->ReqAttr != NULL
 995             && df_data->u.FontsData.AttrsIndex == df_data->u.FontsData.CurrentFileEntry->Numentries-1)
 996         {
 997             D(bug("DF_IteratorGetNext: Setting last outline element\n"));
 998
 999             /* The last attr for a outline font is filled with values matching
1000              * as close as possible the reqattr */
1001             retval->tta_YSize = df_data->ReqAttr->tta_YSize;
1002             retval->tta_Style = df_data->u.FontsData.CurrentFileEntry->FontStyle;
1003
1004             retval->tta_Tags  = NULL;
1005
1006             if (df_data->ReqAttr->tta_Style & FSF_TAGGED)
1007             {
1008                 retval->tta_Style |= FSF_TAGGED;
1009                 retval->tta_Tags  = df_data->ReqAttr->tta_Tags;
1010             }
1011
1012             if ((df_data->ReqAttr->tta_Style & FSF_BOLD)
1013                 && !(retval->tta_Style & FSF_BOLD)
1014                 && (df_data->u.FontsData.CurrentFileEntry->SupportedStyles & FSF_BOLD))
1015             {
1016                 retval->tta_Style |= FSF_BOLD;
1017             }
1018
1019             if ((df_data->ReqAttr->tta_Style & FSF_ITALIC)
1020                 && !(retval->tta_Style & FSF_ITALIC)
1021                 && (df_data->u.FontsData.CurrentFileEntry->SupportedStyles & FSF_ITALIC))
1022             {
1023                 retval->tta_Style |= FSF_ITALIC;
1024             }
1025         }
1026
1027         /* Let the iterator point to the next attr */
1028         if ((df_data->u.FontsData.AttrsIndex == df_data->u.FontsData.CurrentFileEntry->Numentries-1)
1029             || (df_data->u.FontsData.CurrentFileEntry->ContentsID == OFCH_ID
1030                 && df_data->ReqAttr==NULL &&
1031                 df_data->u.FontsData.AttrsIndex == df_data->u.FontsData.CurrentFileEntry->Numentries-2
1032                )
1033            )
1034         {
1035             df_data->u.FontsData.PrevFileEntry = df_data->u.FontsData.CurrentFileEntry;
1036             df_data->u.FontsData.CurrentFileEntry = (struct FileEntry *)GetSucc(df_data->u.FontsData.CurrentFileEntry);
1037             df_data->u.FontsData.AttrsIndex = 0;
1038             if (df_data->u.FontsData.CurrentFileEntry == NULL)
1039             {
1040                 while (df_data->u.FontsData.CurrentDirEntry != NULL && df_data->u.FontsData.CurrentFileEntry == NULL)
1041                 {
1042 #ifdef PROGDIRFONTSDIR
1043                     if (df_data->u.FontsData.CurrentDirEntry == df_data->u.FontsData.ProgdirDirEntry)
1044                         df_data->u.FontsData.CurrentDirEntry = (struct DirEntry *)GetHead(&DiskfontBase->fontsdirentrylist);
1045                     else
1046                         df_data->u.FontsData.CurrentDirEntry = (struct DirEntry *)GetSucc(df_data->u.FontsData.CurrentDirEntry);
1047 #else
1048                     df_data->u.FontsData.CurrentDirEntry = (struct DirEntry *)GetSucc(df_data->u.FontsData.CurrentDirEntry);
1049 #endif
1050                     if (df_data->u.FontsData.CurrentDirEntry != NULL)
1051                         df_data->u.FontsData.CurrentFileEntry = (struct FileEntry *)GetHead(&df_data->u.FontsData.CurrentDirEntry->FileList);
1052                 }
1053             }
1054
1055         }
1056         else
1057             df_data->u.FontsData.AttrsIndex++;
1058         break;
1059
1060     case DF_FILEDATA:
1061         if (df_data->u.FileData.LastAttr != NULL)
1062         {
1063             df_data->u.FileData.LastAttr->tta_Name = df_data->u.FileData.OrigName;
1064             df_data->u.FileData.LastAttr = NULL;
1065         }
1066
1067         /* Do not return the best-match attribute if it is not an outline font! */
1068
1069         if (df_data->u.FileData.FDH==NULL
1070             || df_data->u.FileData.AttrsIndex > df_data->u.FileData.FDH->NumEntries
1071             || (df_data->u.FileData.FDH->ContentsID != OFCH_ID &&
1072                 df_data->u.FileData.AttrsIndex == df_data->u.FileData.FDH->NumEntries))
1073
1074             ReturnPtr("DF_IteratorGetNext", struct TTextAttr *, NULL);
1075
1076         /* Get the TextAttr the iterator is pointing to
1077          * If it points to the element after the last element return
1078          * the Extra Attr that matches the outline font as close as possible
1079          */
1080         if (df_data->u.FileData.AttrsIndex == df_data->u.FileData.FDH->NumEntries)
1081             retval = &df_data->u.FileData.ExtraAttr;
1082         else
1083         {
1084             retval = &df_data->u.FileData.FDH->TAttrArray[df_data->u.FileData.AttrsIndex];
1085             df_data->u.FileData.OrigName = retval->tta_Name;
1086             retval->tta_Name = df_data->u.FileData.FilePart;
1087             df_data->u.FileData.LastAttr = retval;
1088         }
1089
1090         /* Let the iterator point to the next element.
1091          */
1092         df_data->u.FileData.AttrsIndex++;
1093
1094         break;
1095     }
1096
1097     ReturnPtr("DF_IteratorGetNext", struct TTextAttr *, retval);
1098 }
1099
1100 /****************************************************************************************/
1101
1102 /***********************/
1103 /* DF_IteratorRemember */
1104 /***********************/
1105
1106 /****************************************************************************************/
1107
1108 VOID DF_IteratorRemember(APTR iterator, struct DiskfontBase *DiskfontBase)
1109 {
1110     struct DF_Data *df_data = (struct DF_Data *)iterator;
1111
1112     D(bug("DF_IteratorRemember(iterator=0x%lx)\n", iterator));
1113
1114     switch (df_data->Type)
1115     {
1116     case DF_FONTSDATA:
1117         if (df_data->u.FontsData.AttrsIndex > 0)
1118         {
1119             df_data->u.FontsData.RememberIndex = df_data->u.FontsData.AttrsIndex-1;
1120             df_data->u.FontsData.RememberFileEntry = df_data->u.FontsData.CurrentFileEntry;
1121         }
1122         else
1123         {
1124             df_data->u.FontsData.RememberFileEntry = df_data->u.FontsData.PrevFileEntry;
1125             df_data->u.FontsData.RememberIndex = df_data->u.FontsData.RememberFileEntry->Numentries-1;
1126             if (df_data->u.FontsData.RememberFileEntry->ContentsID == OFCH_ID
1127                 && df_data->ReqAttr == NULL
1128                )
1129             {
1130                 df_data->u.FontsData.RememberIndex--;
1131             }
1132         }
1133
1134         D(bug("DF_IteratorRemember: Remembered font: %s/%d\n",
1135               df_data->u.FontsData.RememberFileEntry->Attrs[df_data->u.FontsData.RememberIndex].tta_Name,
1136               df_data->u.FontsData.RememberFileEntry->Attrs[df_data->u.FontsData.RememberIndex].tta_YSize));
1137         break;
1138
1139     case DF_FILEDATA:
1140         df_data->u.FileData.RememberIndex = df_data->u.FileData.AttrsIndex-1;
1141
1142         D(bug("DF_IteratorRemember: Remembered font: %s(%d)\n",
1143               df_data->ReqAttr->tta_Name, df_data->u.FileData.RememberIndex));
1144         break;
1145     }
1146 }
1147
1148 /****************************************************************************************/
1149
1150 /***************************/
1151 /* DF_IteratorRememberOpen */
1152 /***************************/
1153
1154 /****************************************************************************************/
1155
1156 struct TextFont *DF_IteratorRememberOpen(APTR iterator, struct DiskfontBase *DiskfontBase)
1157 {
1158     struct DF_Data *df_data = (struct DF_Data *)iterator;
1159     struct FontDescrHeader *fdh = NULL;
1160     struct TTextAttr *RememberAttr = NULL;
1161     struct TextFont *tf = NULL;
1162     BPTR olddir = 0, lock, dirlock;
1163
1164     D(bug("DF_IteratorRememberOpen(iterator=0x%lx)\n", iterator));
1165
1166     /* Set current dir and get the Remember TextAttr */
1167     switch (df_data->Type)
1168     {
1169     case DF_FONTSDATA:
1170         {
1171             struct FileEntry *rementry = df_data->u.FontsData.RememberFileEntry;
1172
1173             olddir = CurrentDir(rementry->DirEntry->DirLock);
1174             fdh = ReadFontDescr(rementry->FileName, DiskfontBase);
1175             if (fdh == NULL)
1176                 RememberAttr = NULL;
1177             else if (rementry->ContentsID == OFCH_ID
1178                 && df_data->u.FontsData.RememberIndex == rementry->Numentries - 1)
1179             {
1180                 /* It is the TAttr generated for best matching */
1181                 RememberAttr = &rementry->Attrs[df_data->u.FontsData.RememberIndex];
1182             }
1183             else
1184                 RememberAttr = &fdh->TAttrArray[df_data->u.FontsData.RememberIndex];
1185         }
1186         break;
1187
1188     case DF_FILEDATA:
1189         if (df_data->u.FileData.LastAttr != NULL)
1190         {
1191             df_data->u.FileData.LastAttr->tta_Name = df_data->u.FileData.OrigName;
1192             df_data->u.FileData.LastAttr = NULL;
1193         }
1194
1195         RememberAttr = NULL;
1196         lock = Lock(df_data->ReqAttr->tta_Name, ACCESS_READ);
1197         if (lock == BNULL)
1198         {
1199             D(bug("DF_IteratorRememberOpen: Could not lock file\n"));
1200             break;
1201         }
1202
1203         dirlock = ParentDir(lock);
1204         UnLock(lock);
1205         if (dirlock == BNULL)
1206         {
1207             D(bug("DF_IteratorRememberOpen: Could not get ParentDir\n"));
1208             break;
1209         }
1210         olddir = CurrentDir(dirlock);
1211
1212         fdh = df_data->u.FileData.FDH;
1213         if (df_data->u.FileData.RememberIndex == fdh->NumEntries)
1214             RememberAttr = &df_data->u.FileData.ExtraAttr;
1215         else
1216             RememberAttr = &fdh->TAttrArray[df_data->u.FileData.RememberIndex];
1217         break;
1218     }
1219
1220     if (RememberAttr == NULL)
1221         return NULL;
1222
1223     if (fdh != NULL)
1224     {
1225         D(bug("DF_IteratorRememberOpen: Font Description read\n"));
1226
1227         if (IS_OUTLINE_FONT(RememberAttr))
1228         {
1229             D(bug("DF_IteratorRememberOpen: loading outline font\n"));
1230
1231             tf = OTAG_ReadOutlineFont(RememberAttr,
1232                                       df_data->ReqAttr,
1233                                       fdh->OTagList,
1234                                       DiskfontBase);
1235             D(bug("DF_IteratorRememberOpen: tf=0x%lx\n", tf));
1236
1237         }
1238         else
1239         {
1240             D(bug("DF_IteratorRememberOpen: loading bitmap font\n"));
1241
1242             tf = ReadDiskFont(RememberAttr,
1243                               FilePart(df_data->ReqAttr->tta_Name),
1244                               DiskfontBase);
1245
1246             D(bug("DF_IteratorRememberOpen: tf=0x%lx\n", tf));
1247         }
1248     }
1249     else
1250         D(bug("DF_IteratorRememberOpen: Font Description read failed\n"));
1251
1252     dirlock = CurrentDir(olddir);
1253     switch (df_data->Type)
1254     {
1255     case DF_FONTSDATA:
1256         FreeFontDescr(fdh, DiskfontBase);
1257         break;
1258
1259     case DF_FILEDATA:
1260         UnLock(dirlock);
1261         break;
1262     }
1263
1264     if (tf != NULL)
1265     {
1266         struct DiskFontHeader *dfh;
1267
1268         /* PPaint's personal.font/8 has not set FPF_DISKFONT,
1269          (FPF_ROMFONT neither), but AmigaOS diskfont.library
1270          still shows FPF_DISKFONT set when opening this font */
1271
1272         tf->tf_Flags &= ~FPF_ROMFONT;
1273         tf->tf_Flags |= FPF_DISKFONT;
1274
1275         D(bug("Adding font: %p\n", tf));
1276
1277         /* Forbid() must be called before AddFont, because AddFont clears
1278          tf_Accessors and in the worst case it could happen to us that
1279          after the AddFont() another task opens and closes/frees the
1280          diskfont, before we manage to increase tf_Accessors. */
1281
1282         Forbid();
1283
1284         AddFont(tf);
1285         tf->tf_Accessors++;
1286
1287         dfh = (struct DiskFontHeader *)((UBYTE *)(tf) - (IPTR)OFFSET(DiskFontHeader, dfh_TF));
1288
1289         /* Paranoia check */
1290         if (dfh->dfh_FileID == DFH_ID)
1291             ADDTAIL(&DiskfontBase->diskfontlist, &dfh->dfh_DF);
1292
1293         Permit();
1294
1295         D(bug("Font added\n"));
1296     }
1297
1298     return tf;
1299 }
1300
1301 /****************************************************************************************/
1302
1303 /*******************/
1304 /* DF_IteratorFree */
1305 /*******************/
1306
1307 /****************************************************************************************/
1308
1309 VOID DF_IteratorFree(APTR iterator, struct DiskfontBase *DiskfontBase)
1310 {
1311     struct DF_Data *df_data = (struct DF_Data *)iterator;
1312
1313     FreeResources(df_data, DiskfontBase);
1314 }
1315
1316 /****************************************************************************************/
1317
1318 /*******************/
1319 /* DF_OpenFontPath */
1320 /*******************/
1321
1322 /****************************************************************************************/
1323
1324 struct TextFont *DF_OpenFontPath(struct TextAttr *reqattr, struct DiskfontBase *DiskfontBase)
1325 {
1326     struct TextFont *tf = NULL;
1327     struct FontDescrHeader *fdh;
1328     BPTR olddir, lock, dirlock;
1329
1330     D(bug("DF_OpenFontPath(reqattr=0x%lx)\n", reqattr));
1331
1332     lock = Lock(reqattr->ta_Name, ACCESS_READ);
1333     if (lock == BNULL)
1334     {
1335         D(bug("DF_OpenFontPath: Could not lock file\n"));
1336         return NULL;
1337     }
1338
1339     dirlock = ParentDir(lock);
1340     UnLock(lock);
1341     if (dirlock == BNULL)
1342     {
1343         D(bug("DF_OpenFontPath: Could not get ParentDir\n"));
1344         return NULL;
1345     }
1346
1347     olddir = CurrentDir(dirlock);
1348
1349     fdh = ReadFontDescr(reqattr->ta_Name, DiskfontBase);
1350
1351     if (fdh != NULL)
1352     {
1353         WORD max_match_weight = 0, match_weight;
1354         LONG match_index = -1;
1355         int i;
1356
1357         D(bug("DF_OpenFontPath: Font Description read\n"));
1358
1359         for (i=0; i<fdh->NumEntries; i++)
1360         {
1361             match_weight = WeighTAMatch((struct TextAttr *)reqattr,
1362                                         (struct TextAttr *)&fdh->TAttrArray[i],
1363                                         fdh->TAttrArray[i].tta_Tags);
1364
1365             if (match_weight > max_match_weight)
1366             {
1367                 max_match_weight = match_weight;
1368                 match_index = i;
1369             }
1370         }
1371
1372         if (match_index >= 0)
1373         {
1374            if (IS_OUTLINE_FONT(&fdh->TAttrArray[match_index]))
1375            {
1376                D(bug("DF_OpenFontPath: loading outline font\n"));
1377
1378                tf = OTAG_ReadOutlineFont(&fdh->TAttrArray[match_index],
1379                                          (struct TTextAttr *)reqattr,
1380                                          fdh->OTagList,
1381                                          DiskfontBase);
1382                D(bug("DF_OpenFontPath: tf=0x%lx\n", tf));
1383
1384            }
1385            else
1386            {
1387                D(bug("DF_OpenFontPath: loading bitmap font\n"));
1388
1389                tf = ReadDiskFont(&fdh->TAttrArray[match_index],
1390                                  reqattr->ta_Name,
1391                                  DiskfontBase);
1392
1393                D(bug("DF_OpenFontPath: tf=0x%lx\n", tf));
1394            }
1395         }
1396         else
1397             D(bug("DF_OpenFontPath: No matching font found\n"));
1398
1399         FreeFontDescr(fdh, DiskfontBase);
1400     }
1401     else
1402         D(bug("DF_OpenFontPath: Font Description read failed\n"));
1403
1404     CurrentDir(olddir);
1405     UnLock(dirlock);
1406
1407     if (tf != NULL)
1408     {
1409         struct DiskFontHeader *dfh;
1410
1411         /* PPaint's personal.font/8 has not set FPF_DISKFONT,
1412          (FPF_ROMFONT neither), but AmigaOS diskfont.library
1413          still shows FPF_DISKFONT set when opening this font */
1414
1415         tf->tf_Flags &= ~FPF_ROMFONT;
1416         tf->tf_Flags |= FPF_DISKFONT;
1417
1418         D(bug("Adding font: %p\n", tf));
1419
1420         /* Forbid() must be called before AddFont, because AddFont clears
1421          tf_Accessors and in the worst case it could happen to us that
1422          after the AddFont() another task opens and closes/frees the
1423          diskfont, before we manage to increase tf_Accessors. */
1424
1425         Forbid();
1426
1427         AddFont(tf);
1428         tf->tf_Accessors++;
1429
1430         dfh = (struct DiskFontHeader *)((UBYTE *)(tf) - (IPTR)OFFSET(DiskFontHeader, dfh_TF));
1431
1432         /* Paranoia check */
1433         if (dfh->dfh_FileID == DFH_ID)
1434             ADDTAIL(&DiskfontBase->diskfontlist, &dfh->dfh_DF);
1435
1436         Permit();
1437
1438         D(bug("Font added\n"));
1439     }
1440
1441     return tf;
1442 }