home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / misc / wingnuplot / source.lha / source / OutlineFont.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-22  |  6.0 KB  |  286 lines
  1. /* this defines some routines for handling of Outline-Fonts */
  2.  
  3. #include "struct.c"
  4. #include "OutlineFont.h"
  5.  
  6. #define CW 80
  7. #define CH 35
  8.  
  9. static int   cwidth, cheight;
  10. static ULONG XYdpi, PointSize;
  11.  
  12. struct Glyph
  13. {
  14.  int    top, left, width, height;
  15.  int    basex, basey;
  16.  int    bmsize, bpr;
  17.  UBYTE *bitmap;
  18. };
  19.  
  20. static struct Glyph *HGlyphs[256], *VGlyphs[256];
  21.  
  22.        struct Library     *BulletBase   = NULL;
  23. static struct GlyphEngine *BulletEngine = NULL;
  24.  
  25.  
  26. static BOOL IsOutlineFont(char *fontname)
  27. {
  28.  BPTR                       FontsDir, Font;
  29.  char                       FullFontName[255];
  30.  BOOL                       h = FALSE;
  31.  struct FontContentsHeader *fch;
  32.  
  33.  /* hack to get the real font-directory incase of MultiAssign !! */
  34.  strcpy(FullFontName, "FONTS:"); AddPart(FullFontName, fontname, 255);
  35.  if (Font = Lock(FullFontName, ACCESS_READ))
  36.   {
  37.    FontsDir = ParentDir(Font);
  38.    if (fch = NewFontContents(FontsDir, fontname))
  39.     {
  40.      if (fch->fch_FileID == OFCH_ID)
  41.       h = TRUE;
  42.      DisposeFontContents(fch);
  43.     }
  44.    UnLock(FontsDir);
  45.    UnLock(Font);
  46.   }
  47.  
  48.  return h;
  49. }
  50.  
  51. static struct GlyphEngine *GetEngine(char *fontname, struct TagItem **OTags)
  52. {
  53.  BPTR                f;
  54.  int                 l;
  55.  char                enginename[80];
  56.  struct TagItem     *Tags, *ti, *tstate;
  57.  struct GlyphEngine *Engine = NULL;
  58.  
  59.  if (f = Open(fontname, MODE_OLDFILE))
  60.   {
  61.    Seek(f, 0, OFFSET_END);
  62.    l = Seek(f, 0, OFFSET_BEGINNING);
  63.    if (Tags = malloc(l))
  64.     {
  65.      Read(f, Tags, l);
  66.  
  67.      tstate = Tags;
  68.      while (ti = NextTagItem(&tstate))
  69.       if (ti->ti_Tag & OT_Indirect)
  70.        ti->ti_Data += (ULONG)Tags;
  71.      
  72.      if ((ti = FindTagItem(OT_FileIdent, Tags)) && ti->ti_Data == l)
  73.       {
  74.        if (ti = FindTagItem(OT_Engine, Tags))
  75.     {
  76.      strcpy(enginename, (char *)(ti->ti_Data));
  77.      strcat(enginename, ".library");
  78.      if (BulletBase = OpenLibrary(enginename, 0))
  79.       {
  80.        Engine = OpenEngine();
  81.        *OTags = Tags;
  82.       }
  83.     }
  84.       }
  85.     }
  86.    Close(f);
  87.   }
  88.  
  89.  return Engine;
  90. }
  91.  
  92. static struct Glyph *GetGlyph(char ch, BOOL Vertical)
  93. {
  94.  struct GlyphMap  *GlyphMap;
  95.  struct Glyph    **glyphs;
  96.  
  97.  glyphs = (Vertical) ? VGlyphs : HGlyphs;
  98.  if (!glyphs[ch])
  99.   {
  100.    glyphs[ch] = malloc(sizeof(struct Glyph));
  101.    SetInfo(BulletEngine,
  102.        OT_GlyphCode, ch,
  103.        OT_RotateSin,   (Vertical) ? 0x00010000 : 0x00000000,
  104.        OT_RotateCos,   (Vertical) ? 0x00000000 : 0x00010000,
  105.        OT_PointHeight, PointSize,
  106.        OT_DeviceDPI,   XYdpi,
  107.        OT_DotSize,     0x00640064,
  108.        TAG_END);
  109.    if (ObtainInfo(BulletEngine,
  110.           OT_GlyphMap, &GlyphMap,
  111.           TAG_END) == OTERR_Success)
  112.     {
  113.      glyphs[ch]->top = GlyphMap->glm_BlackTop;
  114.      glyphs[ch]->left = GlyphMap->glm_BlackLeft;
  115.      glyphs[ch]->height = GlyphMap->glm_BlackHeight+1;
  116.      glyphs[ch]->width = GlyphMap->glm_BlackWidth+1;
  117.      glyphs[ch]->basey = GlyphMap->glm_Y0-GlyphMap->glm_BlackTop;
  118.      glyphs[ch]->basex = GlyphMap->glm_X0-GlyphMap->glm_BlackLeft;
  119.      glyphs[ch]->bpr = GlyphMap->glm_BMModulo;
  120.      glyphs[ch]->bmsize = GlyphMap->glm_BMModulo*GlyphMap->glm_BMRows;
  121.      if (glyphs[ch]->bitmap = AllocMem(glyphs[ch]->bmsize, MEMF_CHIP))
  122.       CopyMemQuick(GlyphMap->glm_BitMap, glyphs[ch]->bitmap, glyphs[ch]->bmsize);
  123.      ReleaseInfo(BulletEngine,
  124.          OT_GlyphMap, GlyphMap,
  125.          TAG_END);
  126.     }
  127.    else
  128.     {
  129.      glyphs[ch]->top = 0;
  130.      glyphs[ch]->left = 0;
  131.      glyphs[ch]->height = cheight;
  132.      glyphs[ch]->width = cwidth;
  133.      glyphs[ch]->basey = 0;
  134.      glyphs[ch]->basex = 0;
  135.      glyphs[ch]->bpr = (cwidth/32 + 1) * 4;
  136.      glyphs[ch]->bmsize = glyphs[ch]->bpr * cheight;
  137.      glyphs[ch]->bitmap = AllocMem(glyphs[ch]->bmsize, MEMF_CHIP|MEMF_CLEAR);
  138.     }
  139.   }
  140.  
  141.  
  142.  return glyphs[ch];
  143. }
  144.  
  145. static void FreeGlyph(struct Glyph *glyph)
  146. {
  147.  FreeMem(glyph->bitmap, glyph->bmsize);
  148. }
  149.  
  150. static void FreeGlyphs(void)
  151. {
  152.  int ch;
  153.  
  154.  for(ch=0; ch <= 255; ch++)
  155.   {
  156.    if (HGlyphs[ch])
  157.     {
  158.      FreeGlyph(HGlyphs[ch]);
  159.      free(HGlyphs[ch]);
  160.      HGlyphs[ch] = NULL;
  161.     }
  162.    if (VGlyphs[ch])
  163.     {
  164.      FreeGlyph(VGlyphs[ch]);
  165.      free(VGlyphs[ch]);
  166.      VGlyphs[ch] = NULL;
  167.     }
  168.   }
  169. }
  170.  
  171. BOOL OpenOutlineFont(char *font)
  172. {
  173.  char            fontname[80], otagname[80];
  174.  struct TagItem *OTags;
  175.  int             ch;
  176.  
  177.  strcpy(fontname, font); strcat(fontname, ".font");
  178.  if (IsOutlineFont(fontname))
  179.   {
  180.    strcpy(otagname, "FONTS:"); strcat(otagname, font); strcat(otagname, ".otag");
  181.    if (BulletEngine = GetEngine(otagname, &OTags))
  182.     {
  183.      strcpy(fontname, "FONTS:"); strcat(fontname, font); strcat(fontname, ".font");
  184.      SetInfo(BulletEngine,
  185.          OT_OTagPath, fontname,
  186.          OT_OTagList, OTags,
  187.          TAG_END);
  188.  
  189.      for(ch=0; ch <= 255; ch++)
  190.       HGlyphs[ch] = VGlyphs[ch] = NULL;
  191.  
  192.      return TRUE;
  193.     }
  194.   }
  195.  return FALSE;
  196. }
  197.  
  198. void CloseOutlineFont(void)
  199. {
  200.  FreeGlyphs();
  201.  if (BulletEngine) CloseEngine(BulletEngine);
  202.  if (BulletBase)   CloseLibrary(BulletBase);
  203. }
  204.  
  205. void PrintString(struct RastPort *rp, int x0, int y0, char *s, BOOL Vertical)
  206. {
  207.  char         *ch;
  208.  int           x, y;
  209.  struct Glyph *glyph;
  210.  
  211.  x = x0; y = y0;
  212.  for(ch = s; *ch; ch++)
  213.   {
  214.    glyph = GetGlyph(*ch, Vertical);
  215.    BltTemplate(glyph->bitmap+glyph->top*glyph->bpr,
  216.            glyph->left, glyph->bpr,
  217.            rp,
  218.            x-glyph->basex, 
  219.            y-glyph->basey,
  220.            glyph->width, glyph->height);
  221.    WaitBlit();
  222.    if (Vertical)
  223.     y -= glyph->height;
  224.    else
  225.     x += glyph->width;
  226.   }
  227. }
  228.  
  229. void SetFontSize(int w, int h)
  230. {
  231.  static int last_x = 0, last_y = 0, last_p = 0;
  232.  int x, y, p;
  233.  
  234.  cwidth = w/CW; cheight = h/CH;
  235.  
  236.  if (w*CH < h*CW)
  237.   {
  238.    x = 100;
  239.    y = (100 * h * CW) / (w * CH);
  240.    p = (w * 65536L) / CW;
  241.   }
  242.  else
  243.   {
  244.    y = 100;
  245.    x = (100 * w * CH) / (h * CW);
  246.    p = (h * 65536L) / CH;
  247.   }
  248.  
  249.  PointSize = p;
  250.  XYdpi = x<<16 | y;
  251.  
  252.  if (last_x != x || last_y != y || last_p != PointSize)
  253.   {
  254.    FreeGlyphs();
  255.    last_x = x;
  256.    last_y = y;
  257.    last_p = PointSize;
  258.   }
  259. }
  260.  
  261. int TextLen(char *s)
  262. {
  263.  char *ch;
  264.  int   txtlen = 0;
  265.  
  266.  for(ch = s; *ch; ch++)
  267.   txtlen += (GetGlyph(*ch, FALSE))->width;
  268.  
  269.  return txtlen;
  270. }
  271.  
  272. static int _STI_10000_InitGlyphs(void)
  273. {
  274.  char ch;
  275.  
  276.  for(ch=0; ch <= 255; ch++)
  277.   HGlyphs[ch] = VGlyphs[ch] = NULL;
  278.  
  279.  return 0;
  280. }
  281.  
  282. static void _STD_10000_CloseOutlineFonts(void)
  283. {
  284.  CloseOutlineFont();
  285. }
  286.