workbench/libs/diskfont/bullet.c

   1 /*
   2     Copyright © 1995-2004, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Functions for reading .font files
   6 */
   7
   8 /****************************************************************************************/
   9
  10 #include <dos/dos.h>
  11 #include <diskfont/diskfont.h>
  12 #include <diskfont/diskfonttag.h>
  13 #include <diskfont/oterrors.h>
  14 #include <diskfont/glyph.h>
  15 #include <aros/macros.h>
  16 #include <aros/debug.h>
  17
  18 #include <proto/exec.h>
  19 #include <proto/dos.h>
  20 #include <proto/utility.h>
  21 #include <proto/bullet.h>
  22 #include <proto/graphics.h>
  23
  24 #include <string.h>
  25
  26 #include "diskfont_intern.h"
  27
  28 /****************************************************************************************/
  29
  30 /* bold -> {OT_EmboldenX, 0xE75}, {OT_EmboldenY, 0x99E} */
  31 /* italic -> {OT_ShearSin, 0x4690}, {OT_ShearCos, 0xF615} */
  32
  33 /* only if OT_InhibitAlgoStyle has corresponding bit cleared! */
  34
  35 /****************************************************************************************/
  36
  37 STRPTR OTAG_MakeFileName(CONST_STRPTR filename, struct DiskfontBase_intern *DiskfontBase)
  38 {
  39     STRPTR  retval;
  40     LONG    l;
  41
  42     l = strlen(filename) + 1;
  43     if (l < 7) return NULL;
  44
  45     retval = AllocVec(l, MEMF_ANY);
  46     if (retval)
  47     {
  48         memcpy(retval, filename, l - 5);
  49         strcpy(retval + l - 5, "otag");
  50     }
  51
  52     return retval;
  53 }
  54
  55 /****************************************************************************************/
  56
  57 VOID OTAG_FreeFileName(STRPTR filename, struct DiskfontBase_intern *DiskfontBase)
  58 {
  59     if (filename) FreeVec(filename);
  60 }
  61
  62 /****************************************************************************************/
  63
  64 #ifdef __AROS__
  65 #warning This needs to be reworked for systems where sizeof(TagItem) is > 8!
  66 #endif
  67
  68 /****************************************************************************************/
  69
  70 struct OTagList *OTAG_GetFile(CONST_STRPTR filename, struct DiskfontBase_intern *DiskfontBase)
  71 {
  72     struct FileInfoBlock    *fib;
  73     struct OTagList         *otaglist;
  74     struct TagItem          *ti;
  75     STRPTR                   otagfilename;
  76     BPTR                     otagfile;
  77     LONG                     l;
  78     BOOL                     ok;
  79
  80     otagfilename = OTAG_MakeFileName(filename, DiskfontBase);
  81     if (!otagfilename) return NULL;
  82
  83     otagfile = Open(otagfilename, MODE_OLDFILE);
  84     if (!otagfile)
  85     {
  86         OTAG_FreeFileName(otagfilename, DiskfontBase);
  87         return NULL;
  88     }
  89
  90     fib = AllocDosObject(DOS_FIB, NULL);
  91     if (!fib)
  92     {
  93         OTAG_FreeFileName(otagfilename, DiskfontBase);
  94         Close(otagfile);
  95         return NULL;
  96     }
  97
  98     ok = ExamineFH(otagfile, fib);
  99     l = fib->fib_Size;
 100     FreeDosObject(DOS_FIB, fib);
 101
 102     if (!ok)
 103     {
 104         OTAG_FreeFileName(otagfilename, DiskfontBase);
 105         Close(otagfile);
 106         return NULL;
 107     }
 108
 109     otaglist = AllocVec(sizeof(struct OTagList) + l, MEMF_PUBLIC | MEMF_CLEAR);
 110     if (!otaglist)
 111     {
 112         OTAG_FreeFileName(otagfilename, DiskfontBase);
 113         Close(otagfile);
 114         return NULL;
 115     }
 116
 117     ok = (Read(otagfile, otaglist->tags, l) == l);
 118     Close(otagfile);
 119
 120     if (AROS_LONG2BE(otaglist->tags[0].ti_Tag)  != OT_FileIdent) ok = FALSE;
 121     if (AROS_LONG2BE(otaglist->tags[0].ti_Data) != l) ok = FALSE;
 122
 123     if (!ok)
 124     {
 125         OTAG_FreeFileName(otagfilename, DiskfontBase);
 126         FreeVec(otaglist);
 127         return NULL;
 128     }
 129
 130     ti = otaglist->tags;
 131
 132     do
 133     {
 134         ti->ti_Tag = AROS_LONG2BE(ti->ti_Tag);
 135         ti->ti_Data = AROS_LONG2BE(ti->ti_Data);
 136
 137         if (ti->ti_Tag & OT_Indirect)
 138         {
 139             ti->ti_Data = (IPTR)otaglist->tags + ti->ti_Data;
 140         }
 141
 142     } while ((ti++)->ti_Tag != TAG_DONE);
 143
 144     otaglist->filename = otagfilename;
 145
 146     return otaglist;
 147
 148 }
 149
 150 /****************************************************************************************/
 151
 152 VOID OTAG_KillFile(struct OTagList *otaglist, struct DiskfontBase_intern *DiskfontBase)
 153 {
 154     if (otaglist)
 155     {
 156         if (otaglist->filename) OTAG_FreeFileName(otaglist->filename, DiskfontBase);
 157         FreeVec(otaglist);
 158     }
 159 }
 160
 161 /****************************************************************************************/
 162
 163 UBYTE OTAG_GetFontStyle(struct OTagList *otaglist, struct DiskfontBase_intern *DiskfontBase)
 164 {
 165     UBYTE style = 0;
 166
 167     /* A font becomes FSF_BOLD if OT_StemWeight >= 0x90 */
 168
 169     if (GetTagData(OT_StemWeight, 0, otaglist->tags) >= 0x90)
 170     {
 171         style |= FSF_BOLD;
 172     }
 173
 174     /* A font becomes FSF_ITALIC if OT_SlantStyle != OTS_Upright */
 175
 176     if (GetTagData(OT_SlantStyle, OTS_Upright, otaglist->tags) != OTS_Upright)
 177     {
 178         style |= FSF_ITALIC;
 179     }
 180
 181     /* A font becomes FSF_EXTENDED if OT_HorizStyle >= 0xA0 */
 182
 183     if (GetTagData(OT_HorizStyle, 0, otaglist->tags) >= 0xA0)
 184     {
 185         style |= FSF_EXTENDED;
 186     }
 187
 188     return style;
 189 }
 190
 191 /****************************************************************************************/
 192
 193 UBYTE OTAG_GetSupportedStyles(struct OTagList *otaglist,
 194                               struct DiskfontBase_intern *DiskfontBase)
 195 {
 196     UBYTE inhibit, supported;
 197
 198     #define STYLES (FSF_BOLD | FSF_ITALIC | FSF_UNDERLINED)
 199
 200     /*
 201     ** If a style bit is set in OT_InhibitAlgoStyle, then this
 202     ** style cannot be handled/calculated/created by the font engine.
 203     **
 204     ** If it is, then the font engine can handle/calculate/create it
 205     */
 206
 207     inhibit = GetTagData(OT_InhibitAlgoStyle, 0, otaglist->tags);
 208     supported = (inhibit & STYLES) ^ STYLES;
 209
 210     return supported;
 211 }
 212
 213 /****************************************************************************************/
 214
 215 UBYTE OTAG_GetFontFlags(struct OTagList *otaglist, struct DiskfontBase_intern *DiskfontBase)
 216 {
 217     UBYTE flags;
 218
 219     flags = FONTTYPE_OUTLINEFONT;
 220     if (GetTagData(OT_IsFixed, FALSE, otaglist->tags) == FALSE)
 221     {
 222         flags |= FPF_PROPORTIONAL;
 223     }
 224
 225     return flags;
 226 }
 227
 228 /****************************************************************************************/
 229
 230 static BOOL OTAG_SetupFontEngine(struct TTextAttr *ta,
 231                                  struct TTextAttr *ra,
 232                                  struct OTagList *otag,
 233                                  struct GlyphEngine *ge,
 234                                  LONG   *xdpi_ptr,
 235                                  LONG   *ydpi_ptr,
 236                                  struct Library *BulletBase,
 237                                  struct DiskfontBase_intern *DiskfontBase)
 238 {
 239     struct TagItem maintags[] =
 240     {
 241         {OT_OTagList, (IPTR)otag->tags      },
 242         {OT_OTagPath, (IPTR)otag->filename  },
 243         {TAG_DONE                           }
 244     };
 245     struct TagItem sizetags[] =
 246     {
 247         {OT_PointHeight, 0  },
 248         {OT_DeviceDPI  , 0  },
 249         {OT_DotSize    , 0  },
 250         {TAG_DONE           }
 251     };
 252     LONG pointheight, xdot, ydot;
 253     LONG xdpi, ydpi, taxdpi, taydpi;
 254     LONG ysizefactor, ysizefactor_low, ysizefactor_high;
 255
 256     ysizefactor      = GetTagData(OT_YSizeFactor, 0x10001, otag->tags);
 257     ysizefactor_low  = ysizefactor & 0xFFFF;
 258     ysizefactor_high = (ysizefactor >> 16) & 0xFFFF;
 259
 260     if (!ysizefactor_low)
 261     {
 262         ysizefactor_low = ysizefactor_high = 1;
 263     }
 264
 265     if ((ra->tta_Style & FSF_TAGGED) && ra->tta_Tags)
 266     {
 267         ULONG devicedpi;
 268
 269         devicedpi = GetTagData(TA_DeviceDPI, 0x10001, ra->tta_Tags);
 270         taxdpi    = (devicedpi >> 16) & 0xFFFF;
 271         taydpi    = devicedpi & 0xFFFF;
 272
 273         if (!taydpi)
 274         {
 275             taxdpi = taydpi = 1;
 276         }
 277     }
 278     else
 279     {
 280         taxdpi = taydpi = 1;
 281     }
 282
 283     xdpi = 72 * ysizefactor_high / ysizefactor_low * taxdpi / taydpi;
 284     ydpi = 72 * ysizefactor_high / ysizefactor_low;
 285
 286     *xdpi_ptr = xdpi;
 287     *ydpi_ptr = ydpi;
 288
 289     pointheight = ra->tta_YSize << 16;
 290     xdot = ydot = 100;
 291
 292     sizetags[0].ti_Data = pointheight;
 293     sizetags[1].ti_Data = (xdpi << 16) | ydpi;
 294     sizetags[2].ti_Data = (xdot << 16) | ydot;
 295
 296     if (SetInfoA(ge, maintags) != OTERR_Success)
 297     {
 298         return FALSE;
 299     }
 300
 301     return (SetInfoA(ge, sizetags) == OTERR_Success);
 302
 303 }
 304
 305 /****************************************************************************************/
 306
 307 static VOID OTAG_FreeAAGlyphMaps(struct GlyphEngine *ge,
 308                                  struct GlyphMap **gm,
 309                                  struct Library *BulletBase,
 310                                  struct DiskfontBase_intern *DiskfontBase)
 311 {
 312     UWORD i;
 313
 314     for(i = 0; i < 257; i++)
 315     {
 316         if (gm[i])
 317         {
 318             struct TagItem releasetags[] =
 319             {
 320                 {OT_GlyphMap8Bits, (IPTR)gm[i]},
 321                 {TAG_DONE                     }
 322             };
 323
 324             ReleaseInfoA(ge, releasetags);
 325
 326             gm[i] = NULL;
 327         }
 328     }
 329 }
 330
 331 /****************************************************************************************/
 332
 333 static VOID OTAG_FreeGlyphMaps(struct GlyphEngine *ge,
 334                                struct GlyphMap **gm,
 335                                struct Library *BulletBase,
 336                                struct DiskfontBase_intern *DiskfontBase)
 337 {
 338     UWORD i;
 339
 340     for(i = 0; i < 257; i++)
 341     {
 342         if (gm[i])
 343         {
 344             struct TagItem releasetags[] =
 345             {
 346                 {OT_GlyphMap, (IPTR)gm[i]},
 347                 {TAG_DONE                }
 348             };
 349
 350             ReleaseInfoA(ge, releasetags);
 351
 352             gm[i] = NULL;
 353         }
 354     }
 355 }
 356
 357 /****************************************************************************************/
 358
 359 static BOOL OTAG_GetGlyphMaps(struct GlyphEngine *ge,
 360                               struct GlyphMap **gm,
 361                               UWORD fontheight,
 362                               WORD *lochar,
 363                               WORD *hichar,
 364                               WORD *baseline,
 365                               LONG *gfxwidth,
 366                               struct Library *BulletBase,
 367                               struct DiskfontBase_intern *DiskfontBase)
 368 {
 369     UWORD i;
 370
 371     *lochar   = -1;
 372     *hichar   = 0;
 373     *baseline = 0;
 374     *gfxwidth = 0;
 375
 376     for(i = 0; i < 257; i++)
 377     {
 378         struct TagItem settags[] =
 379         {
 380             {OT_GlyphCode, (i < 256) ? i : 0x25A1},
 381             {TAG_DONE                            }
 382         };
 383         struct TagItem obtaintags[] =
 384         {
 385             {OT_GlyphMap, (IPTR)&gm[i]          },
 386             {TAG_DONE                           }
 387         };
 388
 389         SetInfoA(ge, settags);
 390         ObtainInfoA(ge, obtaintags);
 391
 392         if (gm[i])
 393         {
 394             if (i < 256)
 395             {
 396                 if (*lochar == -1) *lochar = i;
 397                 *hichar = i;
 398             }
 399
 400             if (gm[i]->glm_Y0/* - (WORD)gm[i]->glm_BlackTop*/ > *baseline)
 401             {
 402                 *baseline = gm[i]->glm_Y0/* - (WORD)gm[i]->glm_BlackTop*/;
 403             }
 404
 405             *gfxwidth += gm[i]->glm_BlackWidth;
 406         }
 407     }
 408
 409     if (*baseline >= fontheight) *baseline = fontheight;
 410     if (*lochar > 32) *lochar = 32;
 411
 412     return (*lochar == -1) ? FALSE : TRUE;
 413 }
 414
 415 /****************************************************************************************/
 416
 417 static BOOL OTAG_GetAAGlyphMaps(struct GlyphEngine *ge,
 418                                 struct GlyphMap **gm,
 419                                 struct Library *BulletBase,
 420                                 struct DiskfontBase_intern *DiskfontBase)
 421 {
 422     UWORD i;
 423
 424     for(i = 0; i < 257; i++)
 425     {
 426         LONG rc;
 427
 428         struct TagItem settags[] =
 429         {
 430             {OT_GlyphCode, (i < 256) ? i : 0x25A1},
 431             {TAG_DONE                            }
 432         };
 433         struct TagItem obtaintags[] =
 434         {
 435             {OT_GlyphMap8Bits, (IPTR)&gm[i]     },
 436             {TAG_DONE                           }
 437         };
 438
 439         SetInfoA(ge, settags);
 440         rc = ObtainInfoA(ge, obtaintags);
 441
 442         if (i == 0 && rc == OTERR_UnknownTag)
 443             return FALSE;
 444     }
 445
 446     return TRUE;
 447 }
 448
 449 /****************************************************************************************/
 450
 451 struct AADiskFontHeader *OTAG_AllocFontStruct(STRPTR name, UWORD numchars, LONG gfxwidth,
 452                                               LONG fontheight, struct DiskfontBase_intern *DiskfontBase)
 453 {
 454     struct AADiskFontHeader *dfh;
 455     APTR                     charkern;
 456     APTR                     charspace;
 457     APTR                     charloc;
 458     APTR                     chardata;
 459     APTR                     prevsegment = NULL;
 460     BOOL                     ok = FALSE;
 461
 462     dfh = prevsegment = AllocSegment(prevsegment,
 463                                      sizeof(*dfh) + sizeof(struct TagItem) * 5,
 464                                      MEMF_ANY | MEMF_CLEAR,
 465                                      DiskfontBase);
 466
 467     if (dfh)
 468     {
 469         charkern = prevsegment = AllocSegment(prevsegment,
 470                                               numchars * sizeof(WORD),
 471                                               MEMF_ANY | MEMF_CLEAR,
 472                                               DiskfontBase);
 473         if (charkern)
 474         {
 475             charspace = prevsegment = AllocSegment(prevsegment,
 476                                                    numchars * sizeof(WORD),
 477                                                    MEMF_ANY | MEMF_CLEAR,
 478                                                    DiskfontBase);
 479
 480             if (charspace)
 481             {
 482                 charloc = prevsegment = AllocSegment(prevsegment,
 483                                                      numchars * sizeof(LONG),
 484                                                      MEMF_ANY | MEMF_CLEAR,
 485                                                      DiskfontBase);
 486
 487                 if (charloc)
 488                 {
 489                     gfxwidth = (gfxwidth + 15) & ~15;
 490
 491                     chardata = prevsegment = AllocSegment(prevsegment,
 492                                                           gfxwidth / 8 * fontheight,
 493                                                           MEMF_ANY | MEMF_CLEAR,
 494                                                           DiskfontBase);
 495
 496                     if (chardata)
 497                     {
 498                         WORD i;
 499
 500                         dfh->dfh_FileID     = DFH_ID;
 501                         dfh->dfh_DF.ln_Name = dfh->dfh_Name;
 502                         dfh->dfh_Segment    = (LONG)MAKE_REAL_SEGMENT(dfh);
 503
 504                         i = strlen(FilePart(name)) + 1;
 505                         if (i >= sizeof(dfh->dfh_Name)) i = sizeof(dfh->dfh_Name) - 1;
 506                         CopyMem(FilePart(name), dfh->dfh_Name, i);
 507
 508                         dfh->dfh_TF.ctf_TF.tf_Message.mn_Node.ln_Name = dfh->dfh_Name;
 509                         dfh->dfh_TF.ctf_TF.tf_Message.mn_Node.ln_Type = NT_FONT;
 510
 511                         dfh->dfh_TF.ctf_TF.tf_YSize     = fontheight;
 512                         dfh->dfh_TF.ctf_TF.tf_CharKern  = charkern;
 513                         dfh->dfh_TF.ctf_TF.tf_CharSpace = charspace;
 514                         dfh->dfh_TF.ctf_TF.tf_CharLoc   = charloc;
 515                         dfh->dfh_TF.ctf_TF.tf_CharData  = chardata;
 516                         dfh->dfh_TF.ctf_TF.tf_Modulo    = gfxwidth / 8;
 517                         dfh->dfh_TF.ctf_TF.tf_BoldSmear = 1;
 518
 519                         ok = TRUE;
 520                     }
 521
 522                 } /* if (charloc) */
 523
 524             } /* if (charspace) */
 525
 526         } /* if (charkern) */
 527
 528     } /* if (dfh) */
 529
 530     if (!ok)
 531     {
 532         if (dfh) UnLoadSeg(MAKE_REAL_SEGMENT(dfh));
 533         dfh = NULL;
 534     }
 535
 536     return dfh;
 537 }
 538
 539 /****************************************************************************************/
 540
 541 static LONG OTAG_AllocAAData(struct ColorTextFont *ctf,
 542                              struct DiskfontBase_intern *DiskfontBase)
 543 {
 544     UBYTE *aadata;
 545     int k;
 546     int gfxwidth, fontheight;
 547
 548     gfxwidth = ctf->ctf_TF.tf_Modulo * 8;
 549     fontheight = ctf->ctf_TF.tf_YSize;
 550
 551     aadata = AllocSegment(ctf->ctf_TF.tf_CharData,
 552                           gfxwidth * fontheight,
 553                           MEMF_ANY | MEMF_CLEAR,
 554                           DiskfontBase);
 555     if (!aadata)
 556         return FALSE;
 557
 558     ctf->ctf_TF.tf_Style |= FSF_COLORFONT;
 559     ctf->ctf_Flags = CT_ANTIALIAS;
 560     ctf->ctf_Depth = 8;
 561     ctf->ctf_High = 0xff;
 562
 563     for (k = 0; k < 8; ++k)
 564         ctf->ctf_CharData[k] = aadata;
 565
 566     return TRUE;
 567 }
 568
 569 /****************************************************************************************/
 570
 571 static VOID OTAG_CalcMetrics(struct GlyphMap **gm, struct TextFont *tf)
 572 {
 573     WORD *charspace = (UWORD *)tf->tf_CharSpace;
 574     WORD *charkern = (UWORD *)tf->tf_CharKern;
 575     UWORD lochar = tf->tf_LoChar;
 576     UWORD hichar = tf->tf_HiChar;
 577     UWORD i;
 578
 579     for(i = lochar; i <= hichar + 1; i++)
 580     {
 581         struct GlyphMap *g;
 582         WORD             index;
 583
 584         index = (i <= hichar) ? i : 256;
 585
 586         g = gm[index];
 587         if (!g && (i != 32)) g = gm[256];
 588
 589         if (g)
 590         {
 591             charkern [i - lochar] = ((WORD)g->glm_BlackLeft) - g->glm_X0;
 592             charspace[i - lochar] = g->glm_X1 - (WORD)g->glm_BlackLeft;
 593
 594             if ((tf->tf_Flags & FPF_PROPORTIONAL) == 0)
 595             {
 596                 /*
 597                     In a fixed font (charkern + charspace) must always equal
 598                     calculated fontwidth.
 599
 600                     x = propspace - propkern
 601                     fixedkern = (fontwidth - x + 1) / 2
 602                     fixedspace = fontwidth - fixedkern
 603                 */
 604
 605                 LONG w = charspace[i - lochar] - charkern[i - lochar];
 606
 607                 charkern[i - lochar]  = ((LONG)tf->tf_XSize - w + 1) / 2;
 608                 charspace[i - lochar] = (LONG)tf->tf_XSize - charkern[i - lochar];
 609
 610             }
 611
 612         }
 613         else if ((i == 32) || ((tf->tf_Flags & FPF_PROPORTIONAL) == 0))
 614         {
 615             charkern[i - lochar] = 0;
 616             charspace[i - lochar] = tf->tf_XSize;
 617         }
 618
 619     } /* for(i = lochar; i <= hichar + 1; i++) */
 620 }
 621
 622 /****************************************************************************************/
 623
 624 static VOID OTAG_BlitGlyph(struct GlyphMap *gm, struct TextFont *tf, LONG xpos,
 625                            LONG ypos, struct DiskfontBase_intern *DiskfontBase)
 626 {
 627     UBYTE *src, *dest;
 628     LONG x, y, width, height;
 629     LONG srcx, destx, srcy;
 630
 631     srcx   = gm->glm_BlackLeft & 7;
 632     srcy   = gm->glm_BlackTop;
 633     destx  = xpos & 7;
 634     width  = gm->glm_BlackWidth;
 635     height = gm->glm_BlackHeight;
 636
 637     if ((width < 1) || (height < 1)) return;
 638
 639     #warning whats the best thing to do here
 640
 641     /* Check if glyph is bigger/elsewhere than expected,
 642        ie. extends outside the bounding box vertically:
 643
 644        possible cases:
 645
 646
 647                                                         ****
 648                                                        **  **
 649                                                        **  **
 650                                                        **  **
 651            *****                         *****         **  **
 652           **   **                       **   **         ****
 653        +--**---**--+  +-----------+  +--**---**--+  +----------+  +----------+
 654        |  **   **  |  |           |  |  **   **  |  |          |  |          |
 655        |  **   **  |  |           |  |  **   **  |  |          |  |          |
 656        |   *****   |  |           |  |  **   **  |  |          |  |          |
 657        |           |  |           |  |  **   **  |  |          |  |          |
 658        |           |  |   *****   |  |  **   **  |  |          |  |          |
 659        |           |  |  **   **  |  |  **   **  |  |          |  |          |
 660        |           |  |  **   **  |  |  **   **  |  |          |  |          |
 661        +-----------+  +--**---**--+  +--**---**--+  +----------+  +----------+
 662                          **   **        **   **                       ****
 663                           *****          *****                       **  **
 664                                                                      **  **
 665                                                                      **  **
 666                                                                      **  **
 667                                                                       ****
 668
 669     */
 670
 671     if (ypos < 0)
 672     {
 673         if (height <= tf->tf_YSize)
 674         {
 675             ypos = 0;
 676         }
 677         else
 678         {
 679             srcy   += (height - tf->tf_YSize) / 2;
 680             height =  tf->tf_YSize;
 681             ypos   =  0;
 682         }
 683     }
 684     else if (ypos + height > tf->tf_YSize)
 685     {
 686         if (height <= tf->tf_YSize)
 687         {
 688             ypos = tf->tf_YSize - height;
 689         }
 690         else
 691         {
 692             srcy += (height - tf->tf_YSize) / 2;
 693             height = tf->tf_YSize;
 694             ypos = 0;
 695         }
 696     }
 697
 698     src = gm->glm_BitMap +
 699           gm->glm_BMModulo * srcy +
 700           gm->glm_BlackLeft / 8 +
 701           srcx / 8;
 702
 703     dest = (UBYTE *)tf->tf_CharData +
 704                     ypos * tf->tf_Modulo +
 705                     xpos / 8 +
 706                     destx / 8;
 707
 708     for(y = 0; y < height; y++)
 709     {
 710         LONG smask = 0x80 >> (srcx & 7);
 711         LONG dmask = 0x80 >> (destx & 7);
 712         UBYTE *srcxp = src;
 713         UBYTE *destxp = dest;
 714
 715         for(x = 0; x < width; x++)
 716         {
 717             if (*srcxp & smask)
 718             {
 719                 *destxp |= dmask;
 720             }
 721
 722             smask >>= 1;
 723             if (!smask)
 724             {
 725                 smask = 0x80;
 726                 srcxp++;
 727             }
 728
 729             dmask >>= 1;
 730             if (!dmask)
 731             {
 732                 dmask = 0x80;
 733                 destxp++;
 734             }
 735         }
 736         src  += gm->glm_BMModulo;
 737         dest += tf->tf_Modulo;
 738     }
 739 };
 740
 741 /****************************************************************************************/
 742
 743 static VOID OTAG_MakeCharData(struct GlyphMap **gm, struct TextFont *tf,
 744                               struct DiskfontBase_intern *DiskfontBase)
 745 {
 746     ULONG *charloc = (ULONG *)tf->tf_CharLoc;
 747     LONG   xpos = 0;
 748     UWORD  lochar = tf->tf_LoChar;
 749     UWORD  hichar = tf->tf_HiChar;
 750     UWORD  i;
 751
 752     for(i = lochar; i <= hichar + 1; i++)
 753     {
 754         struct GlyphMap *g;
 755         WORD             index;
 756
 757         index = (i <= hichar) ? i : 256;
 758         g = gm[index];
 759         if (g)
 760         {
 761             LONG ypos;
 762
 763             ypos = (LONG)tf->tf_Baseline + 1 - (g->glm_Y0/* - (WORD)g->glm_BlackTop*/);
 764
 765             OTAG_BlitGlyph(g, tf, xpos, ypos, DiskfontBase);
 766
 767             charloc[i - lochar] = (xpos << 16) + g->glm_BlackWidth;
 768             xpos += g->glm_BlackWidth;
 769         }
 770
 771     }
 772 }
 773
 774 /****************************************************************************************/
 775
 776 static VOID OTAG_BlitAAGlyph(struct GlyphMap *gm, struct ColorTextFont *tf, LONG xpos,
 777                              LONG ypos, struct DiskfontBase_intern *DiskfontBase)
 778 {
 779     UBYTE *src, *dest;
 780     LONG x, y, width, height;
 781     LONG srcx, srcy;
 782
 783     srcx   = gm->glm_BlackLeft;
 784     srcy   = gm->glm_BlackTop;
 785     width  = gm->glm_BlackWidth;
 786     height = gm->glm_BlackHeight;
 787
 788     if ((width < 1) || (height < 1)) return;
 789
 790     if (ypos < 0)
 791     {
 792         srcy -= ypos;
 793         height += ypos;
 794         ypos = 0;
 795     }
 796     if (ypos + height > tf->ctf_TF.tf_YSize)
 797         height = tf->ctf_TF.tf_YSize - ypos;
 798
 799     src = gm->glm_BitMap +
 800           gm->glm_BMModulo * srcy +
 801           srcx;
 802
 803     dest = (UBYTE *)tf->ctf_CharData[0] +
 804                     ypos * tf->ctf_TF.tf_Modulo * 8 +
 805                     xpos;
 806
 807     for(y = 0; y < height; y++)
 808     {
 809         UBYTE *srcxp = src;
 810         UBYTE *destxp = dest;
 811
 812         for(x = 0; x < width; x++)
 813         {
 814             *destxp++ = *srcxp++;
 815         }
 816
 817         src  += gm->glm_BMModulo;
 818         dest += tf->ctf_TF.tf_Modulo * 8;
 819     }
 820 };
 821
 822 /****************************************************************************************/
 823
 824 static VOID OTAG_MakeAAData(struct GlyphMap **gm, struct ColorTextFont *tf,
 825                             struct DiskfontBase_intern *DiskfontBase)
 826 {
 827     //ULONG *charloc = (ULONG *)tf->ctf_TF.tf_CharLoc;
 828     LONG   xpos = 0;
 829     UWORD  lochar = tf->ctf_TF.tf_LoChar;
 830     UWORD  hichar = tf->ctf_TF.tf_HiChar;
 831     UWORD  i;
 832
 833     for(i = lochar; i <= hichar + 1; i++)
 834     {
 835         struct GlyphMap *g;
 836         WORD             index;
 837
 838         index = (i <= hichar) ? i : 256;
 839         g = gm[index];
 840         if (g)
 841         {
 842             LONG ypos;
 843
 844             ypos = (LONG)tf->ctf_TF.tf_Baseline + 1 - (g->glm_Y0/* - (WORD)g->glm_BlackTop*/);
 845
 846             OTAG_BlitAAGlyph(g, tf, xpos, ypos, DiskfontBase);
 847
 848             xpos += g->glm_BlackWidth;
 849         }
 850
 851     }
 852 }
 853
 854 /****************************************************************************************/
 855
 856 struct TextFont *OTAG_ReadOutlineFont(struct TTextAttr *attr, struct TTextAttr *reqattr,
 857                                       struct OTagList *otag, struct DiskfontBase_intern *DiskfontBase)
 858 {
 859     struct Library          *BulletBase;
 860     struct GlyphEngine      *ge;
 861     struct GlyphMap         **gm;
 862     struct AADiskFontHeader *dfh = NULL;
 863     STRPTR                  enginename, enginenamebuf;
 864
 865     LONG                    gfxwidth, spacewidth, xdpi, ydpi;
 866     WORD                    lochar, hichar, baseline;
 867     UBYTE                   fontstyle, supportedstyle;
 868
 869     enginename = (STRPTR)GetTagData(OT_Engine, (IPTR) NULL, otag->tags);
 870     if (!enginename) return NULL;
 871
 872     enginenamebuf = AllocVec(strlen(enginename) + sizeof(".library") + 1, MEMF_ANY);
 873     if (!enginenamebuf) return NULL;
 874
 875     strcpy(enginenamebuf, enginename);
 876     strcat(enginenamebuf, ".library");
 877
 878     BulletBase = OpenLibrary(enginenamebuf, 0);
 879     FreeVec(enginenamebuf);
 880
 881     if (!BulletBase) return NULL;
 882
 883     ge = OpenEngine();
 884     if (!ge)
 885     {
 886         D(bug("Error opening engine %s\n", enginename));
 887         CloseLibrary(BulletBase);
 888         return NULL;
 889     }
 890
 891     if (!OTAG_SetupFontEngine(attr, reqattr, otag, ge, &xdpi, &ydpi, BulletBase, DiskfontBase))
 892     {
 893         D(bug("Error calling SetupFontengine %s\n", enginename));
 894         CloseEngine(ge);
 895         CloseLibrary(BulletBase);
 896         return NULL;
 897     }
 898
 899     fontstyle = OTAG_GetFontStyle(otag, DiskfontBase);
 900     supportedstyle = OTAG_GetSupportedStyles(otag, DiskfontBase);
 901
 902     if ((reqattr->tta_Style & FSF_BOLD) && !(fontstyle & FSF_BOLD) && (supportedstyle & FSF_BOLD))
 903     {
 904         struct TagItem bold_tags[] =
 905         {
 906             {OT_EmboldenX, 0xE75},
 907             {OT_EmboldenY, 0x99E},
 908             {TAG_DONE           }
 909         };
 910
 911         if (SetInfoA(ge, bold_tags) == OTERR_Success)
 912         {
 913             fontstyle |= FSF_BOLD;
 914         }
 915     }
 916
 917     if ((reqattr->tta_Style & FSF_ITALIC) && !(fontstyle & FSF_ITALIC) && (supportedstyle & FSF_ITALIC))
 918     {
 919         struct TagItem italic_tags[] =
 920         {
 921             {OT_ShearSin, 0x4690},
 922             {OT_ShearCos, 0xF615},
 923             {TAG_DONE           }
 924         };
 925
 926         if (SetInfoA(ge, italic_tags) == OTERR_Success)
 927         {
 928             fontstyle |= FSF_ITALIC;
 929         }
 930     }
 931
 932     gm = (struct GlyphMap **)AllocVec(sizeof(struct GlyhpMap *) * 257, MEMF_ANY | MEMF_CLEAR);
 933     if (!gm)
 934     {
 935         CloseEngine(ge);
 936         CloseLibrary(BulletBase);
 937         return NULL;
 938     }
 939
 940     if (!OTAG_GetGlyphMaps(ge,
 941                            gm,
 942                            reqattr->tta_YSize,
 943                            &lochar,
 944                            &hichar,
 945                            &baseline,
 946                            &gfxwidth,
 947                            BulletBase,
 948                            DiskfontBase))
 949     {
 950         D(bug("Error getting GlyphMaps\n"));
 951         FreeVec(gm);
 952         CloseEngine(ge);
 953         CloseLibrary(BulletBase);
 954         return NULL;
 955     }
 956
 957     dfh = OTAG_AllocFontStruct(reqattr->tta_Name,
 958                                hichar - lochar + 2,
 959                                gfxwidth,
 960                                reqattr->tta_YSize,
 961                                DiskfontBase);
 962     if (!dfh)
 963     {
 964         OTAG_FreeGlyphMaps(ge, gm, BulletBase, DiskfontBase);
 965         FreeVec(gm);
 966         CloseEngine(ge);
 967         CloseLibrary(BulletBase);
 968         return NULL;
 969     }
 970
 971     spacewidth = GetTagData(OT_SpaceWidth, 3000, otag->tags);
 972
 973
 974     /*
 975        OT_SpaceWidth     pointsize
 976        -------------- *  --------- * xdpi
 977            2540            250
 978     */
 979
 980     #warning maybe should do 64 bit calculations (long long)
 981     spacewidth = spacewidth * reqattr->tta_YSize / 250 * xdpi / 2540;
 982
 983     dfh->dfh_TF.ctf_TF.tf_Style    = fontstyle;
 984     dfh->dfh_TF.ctf_TF.tf_Flags    = OTAG_GetFontFlags(otag, DiskfontBase) & ~FPF_ROMFONT;
 985     dfh->dfh_TF.ctf_TF.tf_LoChar   = lochar;
 986     dfh->dfh_TF.ctf_TF.tf_HiChar   = hichar;
 987     dfh->dfh_TF.ctf_TF.tf_Baseline = baseline - 1; /* CHECKME */
 988     dfh->dfh_TF.ctf_TF.tf_XSize    = spacewidth;
 989
 990     OTAG_CalcMetrics(gm, &dfh->dfh_TF.ctf_TF);
 991     OTAG_MakeCharData(gm, &dfh->dfh_TF.ctf_TF, DiskfontBase);
 992
 993     OTAG_FreeGlyphMaps(ge, gm, BulletBase, DiskfontBase);
 994
 995     if (OTAG_GetAAGlyphMaps(ge,
 996                             gm,
 997                             BulletBase,
 998                             DiskfontBase))
 999     {
1000         if (OTAG_AllocAAData(&dfh->dfh_TF, DiskfontBase))
1001             OTAG_MakeAAData(gm, &dfh->dfh_TF, DiskfontBase);
1002         OTAG_FreeAAGlyphMaps(ge, gm, BulletBase, DiskfontBase);
1003     }
1004
1005     FreeVec(gm);
1006     CloseEngine(ge);
1007     CloseLibrary(BulletBase);
1008
1009     {
1010         /* TagItems were allocated in OTAG_AllocFontStruct */
1011
1012         struct TagItem *tags = (struct TagItem *)(dfh + 1);
1013
1014         tags[0].ti_Tag  = OT_PointHeight;
1015         tags[0].ti_Data = reqattr->tta_YSize << 16;
1016         tags[1].ti_Tag  = OT_DeviceDPI;
1017         tags[1].ti_Data = (xdpi << 16) | ydpi;
1018         tags[2].ti_Tag  = OT_DotSize;
1019         tags[2].ti_Data = (100 << 16) | 100;
1020         tags[3].ti_Tag  = TAG_DONE;
1021         tags[3].ti_Data = 0;
1022
1023         ExtendFont(&dfh->dfh_TF.ctf_TF, tags);
1024     }
1025
1026     return &dfh->dfh_TF.ctf_TF;
1027 }
1028
1029
1030 /****************************************************************************************/