rom/graphics/fontsupport.c

   1 /*
   2     Copyright © 1995-2010, 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(IPTR n, UWORD hashsize)
  23 {
  24     UBYTE Index =  (n        & 0xff)
  25                 + ((n >>  8) & 0xff)
  26                 + ((n >> 16) & 0xff)
  27                 + ((n >> 24) & 0xff)
  28 #if __WORDSIZE == 64
  29                 + ((n >> 32) & 0xff)
  30                 + ((n >> 40) & 0xff)
  31                 + ((n >> 48) & 0xff)
  32                 + ((n >> 56) & 0xff)
  33 #endif
  34                 ;
  35
  36     Index &= (hashsize - 1);
  37
  38     return Index;
  39 }
  40 /****************************************************************************************/
  41
  42 /* Functions for solving the TextFontExtension problem using hashes */
  43
  44 #define GFBI(x) ((struct GfxBase_intern *)x)
  45
  46 /****************************************************************************************/
  47
  48 struct tfe_hashnode *tfe_hashlookup(struct TextFont *tf, struct GfxBase *GfxBase)
  49 {
  50
  51     ULONG idx = CalcHashIndex((IPTR)tf, TFE_HASHTABSIZE);
  52     struct tfe_hashnode *n = NULL;
  53
  54
  55     ObtainSemaphoreShared( &GFBI(GfxBase)->tfe_hashtab_sema );
  56
  57     for ( n = GFBI(GfxBase)->tfe_hashtab[idx]; n; n = n->next)
  58     {
  59         if (n->back == tf)
  60         {
  61             break;
  62         }
  63     }
  64
  65     ReleaseSemaphore( &GFBI(GfxBase)->tfe_hashtab_sema );
  66
  67     return n;
  68 }
  69
  70 /****************************************************************************************/
  71
  72 struct tfe_hashnode *tfe_hashnode_create(struct GfxBase *GfxBase)
  73 {
  74     struct tfe_hashnode *n;
  75
  76     n = AllocMem( sizeof (struct tfe_hashnode), MEMF_ANY|MEMF_CLEAR);
  77
  78     return n;
  79 }
  80
  81 /****************************************************************************************/
  82
  83 void tfe_hashadd(struct tfe_hashnode *hn
  84                 , struct TextFont *tf
  85                 , struct TextFontExtension      *etf
  86                 , struct GfxBase *GfxBase)
  87
  88 {
  89     ULONG idx = CalcHashIndex((IPTR)tf, TFE_HASHTABSIZE);
  90
  91     hn->back = tf;
  92     hn->ext  = etf;
  93
  94     ObtainSemaphore( &GFBI(GfxBase)->tfe_hashtab_sema );
  95
  96     hn->next = GFBI(GfxBase)->tfe_hashtab[idx];
  97     GFBI(GfxBase)->tfe_hashtab[idx] = hn;
  98
  99     ReleaseSemaphore( &GFBI(GfxBase)->tfe_hashtab_sema );
 100
 101     return;
 102 }
 103
 104 /****************************************************************************************/
 105
 106 void tfe_hashdelete(struct TextFont *tf, struct GfxBase *GfxBase)
 107 {
 108     ULONG idx = CalcHashIndex((IPTR)tf, TFE_HASHTABSIZE);
 109     struct tfe_hashnode *n, *last = NULL;
 110
 111     ObtainSemaphore( &GFBI(GfxBase)->tfe_hashtab_sema );
 112
 113     for (n = GFBI(GfxBase)->tfe_hashtab[idx]; n; n = n->next)
 114     {
 115         if (n->back == tf)
 116         {
 117             if (last)
 118                 last->next = n->next;
 119             else
 120                 GFBI(GfxBase)->tfe_hashtab[idx] = n->next;
 121
 122             FreeMem(n, sizeof (struct tfe_hashnode));
 123             break;
 124         }
 125         last = n;
 126     }
 127
 128     ReleaseSemaphore( &GFBI(GfxBase)->tfe_hashtab_sema );
 129
 130     return;
 131
 132 }
 133
 134 /****************************************************************************************/
 135
 136 UBYTE *colorfontbm_to_chunkybuffer(struct TextFont *font, struct GfxBase *GfxBase)
 137 {
 138     ULONG  width, height;
 139     UBYTE *chunky;
 140
 141     width  = font->tf_Modulo * 8;
 142     height = font->tf_YSize;
 143
 144     chunky = AllocVec(width * height, MEMF_CLEAR);
 145     if (chunky)
 146     {
 147         struct BitMap bm;
 148         struct RastPort rp;
 149         UBYTE d, shift = 1, plane = 0;
 150
 151         InitBitMap(&bm, CTF(font)->ctf_Depth, width, height);
 152
 153         for(d = 0; d < CTF(font)->ctf_Depth; d++, shift <<= 1)
 154         {
 155             if (CTF(font)->ctf_PlanePick & shift)
 156             {
 157                 bm.Planes[d] = (PLANEPTR)(CTF(font)->ctf_CharData[plane++]);
 158             }
 159             else
 160             {
 161                 bm.Planes[d] = (CTF(font)->ctf_PlaneOnOff & shift) ? (PLANEPTR)-1 : NULL;
 162             }
 163         }
 164
 165         InitRastPort(&rp);
 166         rp.BitMap = &bm;
 167
 168         ReadPixelArray8(&rp, 0, 0, width - 1, height - 1, chunky, NULL);
 169     }
 170
 171     return chunky;
 172 }
 173
 174 /****************************************************************************************/
 175
 176
 177