rom/graphics/fontsupport.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Misc font help funcs
   6     Lang: english
   7 */
   8
   9 #include <proto/exec.h>
  10 #include <proto/oop.h>
  11 #include <proto/graphics.h>
  12
  13 #include <exec/memory.h>
  14 #include <graphics/text.h>
  15
  16 #include "graphics_intern.h"
  17 #include "gfxfuncsupport.h"
  18 #include "fontsupport.h"
  19
  20 /****************************************************************************************/
  21
  22 ULONG CalcHashIndex(ULONG n)
  23 {
  24     UBYTE Index = (n        & 0xff) +
  25                  ((n >>  8) & 0xff) +
  26                  ((n >> 16) & 0xff) +
  27                  ((n >> 24) & 0xff);
  28     Index &= 0x07;
  29
  30     return Index;
  31 }
  32 /****************************************************************************************/
  33
  34 /* Functions for solving the TextFontExtension problem using hashes */
  35
  36 #define GFBI(x) ((struct GfxBase_intern *)x)
  37
  38 /****************************************************************************************/
  39
  40 static inline ULONG tfe_calchashidx(APTR ptr)
  41 {
  42     ULONG val = (ULONG)ptr;
  43
  44     ULONG idx =  (val        & 0xff) +
  45                 ((val >> 8)  & 0xff) +
  46                 ((val >> 16) & 0xff) +
  47                 ((val >> 24) & 0xff);
  48
  49     idx &= (TFE_HASHTABSIZE - 1);
  50
  51     return idx;
  52 }
  53
  54 /****************************************************************************************/
  55
  56 struct tfe_hashnode *tfe_hashlookup(struct TextFont *tf, struct GfxBase *GfxBase)
  57 {
  58
  59     ULONG idx = tfe_calchashidx(tf);
  60     struct tfe_hashnode *n = NULL;
  61
  62
  63     ObtainSemaphoreShared( &GFBI(GfxBase)->tfe_hashtab_sema );
  64
  65     for ( n = GFBI(GfxBase)->tfe_hashtab[idx]; n; n = n->next)
  66     {
  67         if (n->back == tf)
  68         {
  69             break;
  70         }
  71     }
  72
  73     ReleaseSemaphore( &GFBI(GfxBase)->tfe_hashtab_sema );
  74
  75     return n;
  76 }
  77
  78 /****************************************************************************************/
  79
  80 struct tfe_hashnode *tfe_hashnode_create(struct GfxBase *GfxBase)
  81 {
  82     struct tfe_hashnode *n;
  83
  84     n = AllocMem( sizeof (struct tfe_hashnode), MEMF_ANY|MEMF_CLEAR);
  85
  86     return n;
  87 }
  88
  89 /****************************************************************************************/
  90
  91 void tfe_hashadd(struct tfe_hashnode *hn
  92                 , struct TextFont *tf
  93                 , struct TextFontExtension      *etf
  94                 , struct GfxBase *GfxBase)
  95
  96 {
  97     ULONG idx = tfe_calchashidx(tf);
  98
  99     hn->back = tf;
 100     hn->ext  = etf;
 101
 102     ObtainSemaphore( &GFBI(GfxBase)->tfe_hashtab_sema );
 103
 104     hn->next = GFBI(GfxBase)->tfe_hashtab[idx];
 105     GFBI(GfxBase)->tfe_hashtab[idx] = hn;
 106
 107     ReleaseSemaphore( &GFBI(GfxBase)->tfe_hashtab_sema );
 108
 109     return;
 110 }
 111
 112 /****************************************************************************************/
 113
 114 void tfe_hashdelete(struct TextFont *tf, struct GfxBase *GfxBase)
 115 {
 116     ULONG idx = tfe_calchashidx(tf);
 117     struct tfe_hashnode *n, *last = NULL;
 118
 119     ObtainSemaphore( &GFBI(GfxBase)->tfe_hashtab_sema );
 120
 121     for (n = GFBI(GfxBase)->tfe_hashtab[idx]; n; n = n->next)
 122     {
 123         if (n->back == tf)
 124         {
 125             if (last)
 126                 last->next = n->next;
 127             else
 128                 GFBI(GfxBase)->tfe_hashtab[idx] = n->next;
 129
 130             FreeMem(n, sizeof (struct tfe_hashnode));
 131             break;
 132         }
 133         last = n;
 134     }
 135
 136     ReleaseSemaphore( &GFBI(GfxBase)->tfe_hashtab_sema );
 137
 138     return;
 139
 140 }
 141
 142 /****************************************************************************************/
 143
 144 OOP_Object *fontbm_to_hiddbm(struct TextFont *font, struct GfxBase *GfxBase)
 145 {
 146     ULONG width, height;
 147     OOP_Object *bm_obj;
 148     OOP_Object *tmp_gc;
 149
 150     /* Caclulate sizes for the font bitmap */
 151     struct TagItem bm_tags[] =
 152     {
 153         { aHidd_BitMap_Width    , 0                     },
 154         { aHidd_BitMap_Height   , 0                     },
 155         { aHidd_BitMap_StdPixFmt, vHidd_StdPixFmt_Plane },
 156         { TAG_DONE                                      }
 157     };
 158
 159     tmp_gc = obtain_cache_object(SDD(GfxBase)->gc_cache, GfxBase);
 160     if (NULL == tmp_gc)
 161         return NULL;
 162
 163     width  = font->tf_Modulo * 8;
 164     height = font->tf_YSize;
 165
 166     bm_tags[0].ti_Data = width;
 167     bm_tags[1].ti_Data = height;
 168
 169     #warning Handle color textfonts
 170
 171     bm_obj = HIDD_Gfx_NewBitMap(SDD(GfxBase)->gfxhidd, bm_tags);
 172     if (NULL != bm_obj)
 173     {
 174         struct TagItem gc_tags[] =
 175         {
 176             { aHidd_GC_DrawMode             , vHidd_GC_DrawMode_Copy    },
 177             { aHidd_GC_Foreground           , 1                         },
 178             { aHidd_GC_Background           , 0                         },
 179             { aHidd_GC_ColorExpansionMode   , vHidd_GC_ColExp_Opaque    },
 180             { TAG_DONE                                                  }
 181         };
 182
 183         /* Copy the character data into the bitmap */
 184         OOP_SetAttrs(tmp_gc, gc_tags);
 185
 186         HIDD_BM_PutTemplate(bm_obj, tmp_gc, font->tf_CharData, font->tf_Modulo,
 187                             0, 0, 0, width, height, FALSE);
 188
 189     }
 190
 191     release_cache_object(SDD(GfxBase)->gc_cache, tmp_gc, GfxBase);
 192
 193     return bm_obj;
 194 }
 195
 196 /****************************************************************************************/
 197
 198 UBYTE *colorfontbm_to_chunkybuffer(struct TextFont *font, struct GfxBase *GfxBase)
 199 {
 200     ULONG  width, height;
 201     UBYTE *chunky;
 202
 203     width  = font->tf_Modulo * 8;
 204     height = font->tf_YSize;
 205
 206     chunky = AllocVec(width * height, MEMF_CLEAR);
 207     if (chunky)
 208     {
 209         struct BitMap bm;
 210         struct RastPort rp;
 211         UBYTE d, shift = 1, plane = 0;
 212
 213         InitBitMap(&bm, CTF(font)->ctf_Depth, width, height);
 214
 215         for(d = 0; d < CTF(font)->ctf_Depth; d++, shift <<= 1)
 216         {
 217             if (CTF(font)->ctf_PlanePick & shift)
 218             {
 219                 bm.Planes[d] = (PLANEPTR)(CTF(font)->ctf_CharData[plane++]);
 220             }
 221             else
 222             {
 223                 bm.Planes[d] = (CTF(font)->ctf_PlaneOnOff & shift) ? (PLANEPTR)-1 : NULL;
 224             }
 225         }
 226
 227         InitRastPort(&rp);
 228         rp.BitMap = &bm;
 229
 230         ReadPixelArray8(&rp, 0, 0, width - 1, height - 1, chunky, NULL);
 231         DeinitRastPort(&rp);
 232     }
 233
 234     return chunky;
 235 }
 236
 237 /****************************************************************************************/
 238
 239
 240