URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk
Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [packages/] [services/] [gfx/] [mw/] [v2_0/] [src/] [engine/] [devfont.caching.c] - Blame information for rev 174

Details | Compare with Previous | View Log

/*
 * Copyright (c) 2000 Greg Haerr <greg@censoft.com>
 * T1lib Adobe type1 routines contributed by Vidar Hokstad
 * Freetype TrueType routines contributed by Martin Jolicoeur
 * Han Zi Ku routines contributed by Tanghao and Jauming
 *
 * Device-independent font and text drawing routines
 *
 * These routines do the necessary range checking, clipping, and cursor
 * overwriting checks, and then call the lower level device dependent
 * routines to actually do the drawing.  The lower level routines are
 * only called when it is known that all the pixels to be drawn are
 * within the device area and are visible.
 */
/*#define NDEBUG*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <string.h>
 
#include "device.h"
#if (UNIX | DOS_DJGPP)
#define strcmpi strcasecmp
#endif
 
#if HAVE_T1LIB_SUPPORT
#include <t1lib.h>
#define T1LIB_USE_AA_HIGH
 
typedef struct {
        PMWFONTPROCS    fontprocs;      /* common hdr*/
        MWCOORD         fontsize;
        int             fontrotation;
        int             fontattr;
 
        int             fontid;         /* t1lib stuff*/
} MWT1LIBFONT, *PMWT1LIBFONT;
 
static int  t1lib_init(PSD psd);
static PMWT1LIBFONT t1lib_createfont(const char *name, MWCOORD height,int attr);
static void t1lib_drawtext(PMWFONT pfont, PSD psd, MWCOORD x, MWCOORD y,
                const void *text, int cc, int flags);
static MWBOOL t1lib_getfontinfo(PMWFONT pfont, PMWFONTINFO pfontinfo);
static void t1lib_gettextsize(PMWFONT pfont, const void *text, int cc,
                MWCOORD *pwidth, MWCOORD *pheight, MWCOORD *pbase);
static void t1lib_destroyfont(PMWFONT pfont);
 
/* handling routines for MWT1LIBFONT*/
static MWFONTPROCS t1lib_procs = {
        MWTF_ASCII,                     /* routines expect ascii*/
        t1lib_getfontinfo,
        t1lib_gettextsize,
        NULL,                           /* gettextbits*/
        t1lib_destroyfont,
        t1lib_drawtext,
        NULL,                           /* setfontsize*/
        NULL,                           /* setfontrotation*/
        NULL,                           /* setfontattr*/
};
#endif
 
#ifdef T1LIB_USE_AA_HIGH
typedef unsigned long OUTPIXELVAL;
#else
typedef MWPIXELVAL OUTPIXELVAL;
#endif
 
#if HAVE_FREETYPE_SUPPORT
#include <freetype/freetype.h>
#include <freetype/ftxkern.h>
#include <freetype/ftnameid.h>
#include <freetype/ftxcmap.h>
#include <freetype/ftxwidth.h>
#include <math.h>
 
/************/
 
typedef struct xTT_Glyph_Cache_ {
 
  TT_Error  error;
  TT_Glyph  glyph;
  TT_UShort index;
  TT_UShort flags;
 
  struct xTT_Glyph_Cache_ * l;
  struct xTT_Glyph_Cache_ * r;
 
} xTT_Glyph_Cache;
 
typedef struct xTT_Instance_Object_ {
 
  TT_Face     face;
  TT_Instance instance;
 
  xTT_Glyph_Cache * head;
 
} xTT_Instance_Object;
 
typedef struct xTT_Instance_ {
 
  xTT_Instance_Object * instance;
 
} xTT_Instance;
 
typedef struct xTT_Outline_Object_ {
 
  TT_Outline outline;
  TT_BBox    bbox;
 
} xTT_Outline_Object;
 
typedef struct xTT_Outline_ {
 
  xTT_Outline_Object * outline;
 
} xTT_Outline;
 
typedef struct xTT_Glyph_Object_ {
 
  TT_Glyph * glyph;
 
  xTT_Outline_Object outline;
 
} xTT_Glyph_Object;
 
typedef struct xTT_Glyph_ {
 
  xTT_Glyph_Object * glyph;
 
} xTT_Glyph;
 
TT_Error
xTT_Glyph_Cache_Find ( xTT_Instance instance,
                       xTT_Glyph glyph,
                       TT_UShort glyphIndex,
                       TT_UShort loadFlags )
{
  xTT_Glyph_Cache  * node;
  xTT_Glyph_Cache ** inode = &instance.instance->head;
 
  int miss = 0;
 
  while ( 1 )
  {
    if (*inode == 0)
    {
      miss = 1;
 
      node = *inode = calloc(1,sizeof(**inode));
 
      if (node == 0)
        return TT_Err_Out_Of_Memory;
 
      node->error = TT_New_Glyph(instance.instance->face,&(node->glyph));
 
      if (node->error == 0)
        node->error = TT_Load_Glyph(instance.instance->instance,
                                    node->glyph,
                                    (node->index = glyphIndex),
                                    (node->flags = loadFlags));
 
      if (node->error != 0)
        TT_Done_Glyph(node->glyph);
    }
    else
    {
      node = *inode;
    }
 
    if (glyphIndex < node->index)
      inode = &node->l;
    else if (glyphIndex > node->index)
      inode = &node->r;
    else if (loadFlags < node->flags)
      inode = &node->l;
    else if (loadFlags > node->flags)
      inode = &node->r;
    else
    {
      static int count [] = { 0, 0 };
      ++count[miss];
      printf("\r(%s | hit %d | miss %d)",__TIME__,count[0],count[1]);
      glyph.glyph->glyph = &node->glyph;
      return node->error;
    }
  }
}
 
void
xTT_Glyph_Cache_Free ( xTT_Glyph_Cache ** pnode )
{
  xTT_Glyph_Cache * node;
 
  if (pnode == 0)
    return;
 
  node = *pnode;
 
  if (node == 0)
    return;
 
  if (node->l)
    xTT_Glyph_Cache_Free(&node->l);
 
  if (node->r)
    xTT_Glyph_Cache_Free(&node->r);
 
  TT_Done_Glyph(node->glyph);
  free(node);
 
  *pnode = 0;
}
 
TT_Error
xTT_New_Instance ( TT_Face face,
                   xTT_Instance * instance )
{
  instance->instance = calloc(1,sizeof(*instance->instance));
  if (instance->instance == 0)
    return TT_Err_Out_Of_Memory;
 
  instance->instance->face = face;
  instance->instance->head = 0;
 
  return TT_New_Instance(face,&instance->instance->instance);
}
 
TT_Error
xTT_Done_Instance ( xTT_Instance instance )
{
  TT_Error error;
 
  xTT_Glyph_Cache_Free(&instance.instance->head);
  error = TT_Done_Instance(instance.instance->instance);
 
  free(instance.instance);
 
  return error;
}
 
TT_Error
xTT_Get_Instance_Metrics ( xTT_Instance instance,
                           TT_Instance_Metrics * imetrics )
{
  return TT_Get_Instance_Metrics(instance.instance->instance,imetrics);
}
 
TT_Error
xTT_Set_Instance_CharSize ( xTT_Instance instance,
                            TT_F26Dot6 charsize )
{
  xTT_Glyph_Cache_Free(&instance.instance->head);
  return TT_Set_Instance_CharSize(instance.instance->instance,charsize);
}
 
TT_Error
xTT_Set_Instance_PixelSizes ( xTT_Instance instance,
                              TT_UShort pixelWidth,
                              TT_UShort pixelHeight,
                              TT_F26Dot6 pointSize )
{
  xTT_Glyph_Cache_Free(&instance.instance->head);
  return TT_Set_Instance_PixelSizes(instance.instance->instance,
                                    pixelWidth,
                                    pixelHeight,
                                    pointSize);
}
 
TT_Error
xTT_Set_Instance_Transform_Flags ( xTT_Instance instance,
                                   TT_Bool rotated,
                                   TT_Bool stretched )
{
  xTT_Glyph_Cache_Free(&instance.instance->head);
  return TT_Set_Instance_Resolutions(instance.instance->instance,
                                     rotated,
                                     stretched);
}
 
TT_Error
xTT_Set_Instance_Resolutions ( xTT_Instance instance,
                               TT_UShort xResolution,
                               TT_UShort yResolution )
{
  xTT_Glyph_Cache_Free(&instance.instance->head);
  return TT_Set_Instance_Resolutions(instance.instance->instance,
                                     xResolution,
                                     yResolution);
}
 
TT_Error
xTT_New_Glyph ( TT_Face face,
                xTT_Glyph * glyph )
{
  glyph->glyph = calloc(1,sizeof(*glyph->glyph));
  if (glyph->glyph == 0)
    return TT_Err_Out_Of_Memory;
  return 0;
}
 
TT_Error
xTT_Done_Glyph ( xTT_Glyph glyph )
{
  free(glyph.glyph);
  return 0;
}
 
TT_Error
xTT_Load_Glyph ( xTT_Instance instance,
                 xTT_Glyph glyph,
                 TT_UShort glyphIndex,
                 TT_UShort loadFlags )
{
  TT_Error error;
  error = xTT_Glyph_Cache_Find(instance,glyph,glyphIndex,loadFlags);
  TT_Get_Glyph_Outline(*glyph.glyph->glyph,
                       &glyph.glyph->outline.outline);
  TT_Get_Outline_BBox(&glyph.glyph->outline.outline,
                      &glyph.glyph->outline.bbox);
  return error;
}
 
TT_Error
xTT_Get_Glyph_Metrics ( xTT_Glyph glyph,
                        TT_Glyph_Metrics * metrics )
{
  return TT_Get_Glyph_Metrics(*glyph.glyph->glyph,metrics);
}
 
TT_Error
xTT_Get_Glyph_Outline ( xTT_Glyph glyph,
                        xTT_Outline * outline )
{
  outline->outline = &glyph.glyph->outline;
  return 0;
}
 
TT_Error
xTT_Get_Outline_BBox ( xTT_Outline * outline,
                       TT_BBox * bbox )
{
  *bbox = outline->outline->bbox;
  return 0;
}
 
void
xTT_Transform_Outline ( xTT_Outline * outline,
                        TT_Matrix * matrix )
{
  TT_Transform_Outline(&outline->outline->outline,matrix);
  TT_Get_Outline_BBox(&outline->outline->outline,
                      &outline->outline->bbox);
}
 
TT_Error
xTT_Get_Glyph_Bitmap ( xTT_Glyph glyph,
                       TT_Raster_Map * bitmap,
                       TT_F26Dot6 xOffset,
                       TT_F26Dot6 yOffset )
{
  return TT_Get_Glyph_Bitmap(*glyph.glyph->glyph,
                             bitmap,
                             xOffset,
                             yOffset);
}
 
TT_Error
xTT_Get_Glyph_Pixmap ( xTT_Glyph glyph,
                       TT_Raster_Map * pixmap,
                       TT_F26Dot6 xOffset,
                       TT_F26Dot6 yOffset )
{
  return TT_Get_Glyph_Pixmap(*glyph.glyph->glyph,
                             pixmap,
                             xOffset,
                             yOffset);
}
 
#ifndef xTT_ALIAS
#define xTT_ALIAS 1
#endif
 
#if xTT_ALIAS
 
#define TT_Instance                     xTT_Instance
#define TT_Outline                      xTT_Outline
#define TT_Glyph                        xTT_Glyph
 
#define TT_New_Instance                 xTT_New_Instance
#define TT_Done_Instance                xTT_Done_Instance
 
#define TT_Get_Instance_Metrics         xTT_Get_Instance_Metrics
#define TT_Set_Instance_CharSize        xTT_Set_Instance_CharSize
#define TT_Set_Instance_PixelSizes      xTT_Set_Instance_PixelSizes
#define TT_Set_Instance_Transform_Flags xTT_Set_Instance_Transform_Flags
#define TT_Set_Instance_Resolutions     xTT_Set_Instance_Resolutions
 
#define TT_New_Glyph                    xTT_New_Glyph
#define TT_Done_Glyph                   xTT_Done_Glyph
 
#define TT_Load_Glyph                   xTT_Load_Glyph
#define TT_Get_Glyph_Metrics            xTT_Get_Glyph_Metrics
#define TT_Get_Glyph_Outline            xTT_Get_Glyph_Outline
#define TT_Get_Glyph_Bitmap             xTT_Get_Glyph_Bitmap
#define TT_Get_Glyph_Pixmap             xTT_Get_Glyph_Pixmap
 
#define TT_Get_Outline_BBox             xTT_Get_Outline_BBox
#define TT_Transform_Outline            xTT_Transform_Outline
 
#endif
 
/************/
 
#ifndef FREETYPE_FONT_DIR
#define FREETYPE_FONT_DIR "/usr/local/microwin/fonts"
#endif
 
#if TT_FREETYPE_MAJOR != 1 | TT_FREETYPE_MINOR < 3
#error "You must link with freetype lib version 1.3.x +, and not freetype 2. \
Download it at http://www.freetype.org or http://microwindows.org"
#endif
 
#ifndef MWFREETYPEFONT_CACHE
#define MWFREETYPEFONT_CACHE 1
#endif
 
#if MWFREETYPEFONT_CACHE
 
#ifndef MWFREETYPEFONT_CACHEBITMAP
#define MWFREETYPEFONT_CACHEBITMAP 1
#endif
 
typedef struct mwfreetypefontcache {
  unsigned curchar;
  void * buffer;
#if MWFREETYPEFONT_CACHEBITMAP
  MWPIXELVAL fg;
  MWPIXELVAL bg;
  MWBOOL usebg;
  void * bitmap;
#endif
  struct mwfreetypefontcache * l;
  struct mwfreetypefontcache * r;
} MWFREETYPEFONTCACHE;
 
#endif
 
typedef struct {
 
        PMWFONTPROCS    fontprocs;      /* common hdr*/
        MWCOORD         fontsize;
        int             fontrotation;
        int             fontattr;
 
        TT_Face         face;           /* freetype stuff*/
        TT_Instance     instance;
        TT_CharMap      char_map;
        TT_Kerning      directory;
        TT_Matrix       matrix;
        TT_Glyph        glyph;
        MWBOOL          can_kern;
        short           last_glyph_code;
        short           last_pen_pos;
 
#if MWFREETYPEFONT_CACHE
        MWFREETYPEFONTCACHE * glyph_cache;
#endif
 
} MWFREETYPEFONT, *PMWFREETYPEFONT;
 
static int  freetype_init(PSD psd);
static PMWFREETYPEFONT freetype_createfont(const char *name, MWCOORD height,
                int attr);
static MWBOOL freetype_getfontinfo(PMWFONT pfont, PMWFONTINFO pfontinfo);
static void freetype_gettextsize(PMWFONT pfont, const void *text,
                int cc, MWCOORD *pwidth, MWCOORD *pheight, MWCOORD *pbase);
static void freetype_destroyfont(PMWFONT pfont);
static void freetype_drawtext(PMWFONT pfont, PSD psd, MWCOORD x, MWCOORD y,
                const void *text, int cc, int flags);
static void freetype_setfontsize(PMWFONT pfont, MWCOORD fontsize);
static void freetype_setfontrotation(PMWFONT pfont, int tenthdegrees);
 
/* handling routines for MWFREETYPEFONT*/
static MWFONTPROCS freetype_procs = {
        MWTF_UC16,                      /* routines expect unicode 16*/
        freetype_getfontinfo,
        freetype_gettextsize,
        NULL,                           /* gettextbits*/
        freetype_destroyfont,
        freetype_drawtext,
        freetype_setfontsize,
        freetype_setfontrotation,
        NULL,                           /* setfontattr*/
};
 
static TT_Engine        engine;         /* THE ONLY freetype engine */
#endif /* HAVE_FREETYPE_SUPPORT*/
 
#if HAVE_HZK_SUPPORT
/*
 * 12x12 and 16x16 ascii and chinese fonts
 * Big5 and GB2312 encodings supported
 */
#define MAX_PATH        256
typedef struct {
        int     width;
        int     height;
        int     size;
        unsigned long use_count;
        char *  pFont;
        char    file[MAX_PATH + 1];
} HZKFONT;
 
static int use_big5=1;
static HZKFONT CFont[2];        /* font cache*/
static HZKFONT AFont[2];        /* font cache*/
 
/*jmt: moved inside MWHZKFONT*/
static int afont_width = 8;
static int cfont_width = 16;
static int font_height = 16;
static char *afont_address;
static char *cfont_address;
 
typedef struct {
        PMWFONTPROCS    fontprocs;      /* common hdr*/
        MWCOORD         fontsize;
        int             fontrotation;
        int             fontattr;
 
        HZKFONT         CFont;          /* hzkfont stuff */
        HZKFONT         AFont;
        int             afont_width;
        int             cfont_width;
        int             font_height;
        char            *afont_address;
        char            *cfont_address;
} MWHZKFONT, *PMWHZKFONT;
 
static int  hzk_init(PSD psd);
static PMWHZKFONT hzk_createfont(const char *name, MWCOORD height,int fontattr);
static MWBOOL hzk_getfontinfo(PMWFONT pfont, PMWFONTINFO pfontinfo);
static void hzk_gettextsize(PMWFONT pfont, const void *text,
                int cc, MWCOORD *pwidth, MWCOORD *pheight, MWCOORD *pbase);
/*static void hzk_gettextbits(PMWFONT pfont, int ch, IMAGEBITS *retmap,
                MWCOORD *pwidth, MWCOORD *pheight, MWCOORD *pbase);*/
static void hzk_destroyfont(PMWFONT pfont);
static void hzk_drawtext(PMWFONT pfont, PSD psd, MWCOORD x, MWCOORD y,
                const void *text, int cc, int flags);
static void hzk_setfontsize(PMWFONT pfont, MWCOORD fontsize);
/*static void hzk_setfontrotation(PMWFONT pfont, int tenthdegrees);*/
 
/* handling routines for MWHZKFONT*/
static MWFONTPROCS hzk_procs = {
        MWTF_ASCII,                     /* routines expect ASCII*/
        hzk_getfontinfo,
        hzk_gettextsize,
        NULL,                           /* hzk_gettextbits*/
        hzk_destroyfont,
        hzk_drawtext,
        hzk_setfontsize,
        NULL,                           /* setfontrotation*/
        NULL,                           /* setfontattr*/
};
 
static int
UC16_to_GB(const unsigned char *uc16, int cc, unsigned char *ascii);
#endif /* HAVE_HZK_SUPPORT*/
 
static PMWFONT  gr_pfont;               /* current font*/
 
/* temp extern decls*/
extern MWPIXELVAL gr_foreground;
extern MWPIXELVAL gr_background;
extern MWBOOL gr_usebg;
 
static int  utf8_to_utf16(const unsigned char *utf8, int cc,
                unsigned short *unicode16);
 
#if FONTMAPPER
/* entry point for font selection*/
int select_font(const PMWLOGFONT plogfont, char *physname);
#endif
 
/*
 * Set the font for future calls.
 */
PMWFONT
GdSetFont(PMWFONT pfont)
{
        PMWFONT oldfont = gr_pfont;
        gr_pfont = pfont;
        return oldfont;
}
 
/*
 * Select a font, based on various parameters.
 * If plogfont is specified, name and height parms are ignored
 * and instead used from MWLOGFONT.
 *
 * If height is 0, return builtin font from passed name.
 * Otherwise find builtin font best match based on height.
 */
PMWFONT
GdCreateFont(PSD psd, const char *name, MWCOORD height,
        const PMWLOGFONT plogfont)
{
        int             i;
        int             fontht;
        int             fontno;
        int             fontclass;
        int             fontattr = 0;
        PMWFONT         pfont;
        PMWCOREFONT     pf = psd->builtin_fonts;
        MWFONTINFO      fontinfo;
        MWSCREENINFO    scrinfo;
        char            fontname[128];
 
        GdGetScreenInfo(psd, &scrinfo);
 
        /* if plogfont not specified, use name and height*/
        if (!plogfont) {
                if (!name)
                        name = MWFONT_SYSTEM_VAR;
                strcpy(fontname, name);
                fontclass = MWLF_CLASS_ANY;
        } else {
#if FONTMAPPER
                /* otherwise, use MWLOGFONT name and height*/
                fontclass = select_font(plogfont, fontname);
#else
                if (!name)
                        name = MWFONT_SYSTEM_VAR;
                strcpy(fontname, name);
                fontclass = MWLF_CLASS_ANY;
#endif
                height = plogfont->lfHeight;
                if (plogfont->lfUnderline)
                        fontattr = MWTF_UNDERLINE;
        }
        height = abs(height);
 
        if (!fontclass)
                goto first;
 
        /* use builtin screen fonts, FONT_xxx, if height is 0 */
        if (height == 0 || fontclass == MWLF_CLASS_ANY ||
            fontclass == MWLF_CLASS_BUILTIN) {
                for(i = 0; i < scrinfo.fonts; ++i) {
                        if(!strcmpi(pf[i].name, fontname)) {
                                pf[i].fontsize = pf[i].cfont->height;
                                pf[i].fontattr = fontattr;
                                return (PMWFONT)&pf[i];
                        }
                }
 
                /* return first builtin font*/
                if (height == 0 || fontclass == MWLF_CLASS_BUILTIN)
                        goto first;
        }
 
#if HAVE_HZK_SUPPORT
        /* Make sure the library is initialized */
        if (hzk_init(psd)) {
                pfont = (PMWFONT)hzk_createfont(name, height, fontattr);
                if(pfont)
                        return pfont;
                printf("hzk_createfont: %s not found\n", name);
        }
#endif
 
#if HAVE_FREETYPE_SUPPORT
        if (fontclass == MWLF_CLASS_ANY || fontclass == MWLF_CLASS_FREETYPE) {
                if (freetype_init(psd)) {
                /* auto antialias for height > 14 for kaffe*/
                        if (plogfont && plogfont->lfHeight > 14 &&
                                plogfont->lfQuality)
                                        fontattr |= MWTF_ANTIALIAS;
 
                        pfont = (PMWFONT)freetype_createfont(fontname, height,
                                        fontattr);
                        if(pfont) {
                                /* temp kaffe kluge*/
                                pfont->fontattr |= FS_FREETYPE;
                                return pfont;
                        }
                        DPRINTF("freetype_createfont: %s,%d not found\n",
                                fontname, height);
                }
        }
#endif
 
#if HAVE_T1LIB_SUPPORT
        if (fontclass == MWLF_CLASS_ANY || fontclass == MWLF_CLASS_T1LIB) {
                if (t1lib_init(psd)) {
                        pfont = (PMWFONT)t1lib_createfont(fontname, height,
                                        fontattr);
                        if(pfont)
                                return pfont;
                        DPRINTF("t1lib_createfont: %s,%d not found\n",
                                fontname, height);
                }
        }
#endif
 
        /* find builtin font closest in height*/
        if(height != 0) {
                fontno = 0;
                height = abs(height);
                fontht = MAX_MWCOORD;
                for(i = 0; i < scrinfo.fonts; ++i) {
                        pfont = (PMWFONT)&pf[i];
                        GdGetFontInfo(pfont, &fontinfo);
                        if(fontht > abs(height-fontinfo.height)) {
                                fontno = i;
                                fontht = abs(height-fontinfo.height);
                        }
                }
                pf[fontno].fontsize = pf[fontno].cfont->height;
                pf[fontno].fontattr = fontattr;
                return (PMWFONT)&pf[fontno];
        }
 
first:
        /* Return first builtin font*/
        pf->fontsize = pf->cfont->height;
        pf->fontattr = fontattr;
        return (PMWFONT)&pf[0];
}
 
/* Set the font size for the passed font*/
MWCOORD
GdSetFontSize(PMWFONT pfont, MWCOORD fontsize)
{
        MWCOORD oldfontsize = pfont->fontsize;
 
        pfont->fontsize = fontsize;
 
        if (pfont->fontprocs->SetFontSize)
            pfont->fontprocs->SetFontSize(pfont, fontsize);
 
        return oldfontsize;
}
 
/* Set the font rotation angle in tenths of degrees for the passed font*/
int
GdSetFontRotation(PMWFONT pfont, int tenthdegrees)
{
        MWCOORD oldrotation = pfont->fontrotation;
 
        pfont->fontrotation = tenthdegrees;
 
        if (pfont->fontprocs->SetFontRotation)
            pfont->fontprocs->SetFontRotation(pfont, tenthdegrees);
 
        return oldrotation;
}
 
/*
 * Set/reset font attributes (MWTF_KERNING, MWTF_ANTIALIAS)
 * for the passed font.
 */
int
GdSetFontAttr(PMWFONT pfont, int setflags, int clrflags)
{
        MWCOORD oldattr = pfont->fontattr;
 
        pfont->fontattr &= ~clrflags;
        pfont->fontattr |= setflags;
 
        if (pfont->fontprocs->SetFontAttr)
            pfont->fontprocs->SetFontAttr(pfont, setflags, clrflags);
 
        return oldattr;
}
 
/* Unload and deallocate font*/
void
GdDestroyFont(PMWFONT pfont)
{
        if (pfont->fontprocs->DestroyFont)
                pfont->fontprocs->DestroyFont(pfont);
}
 
/* Return information about a specified font*/
MWBOOL
GdGetFontInfo(PMWFONT pfont, PMWFONTINFO pfontinfo)
{
        if(!pfont || !pfont->fontprocs->GetFontInfo)
                return FALSE;
 
        return pfont->fontprocs->GetFontInfo(pfont, pfontinfo);
}
 
/*
 * Convert from one encoding to another
 * Input cc and returned cc is character count, not bytes
 * Return < 0 on error or can't translate
 */
int
GdConvertEncoding(const void *istr, int iflags, int cc, void *ostr, int oflags)
{
        const unsigned char     *istr8;
        const unsigned short    *istr16;
        const unsigned long     *istr32;
        unsigned char           *ostr8;
        unsigned short          *ostr16;
        unsigned long           *ostr32;
        unsigned int            ch;
        int                     icc;
        unsigned short          buf16[512];
 
        iflags &= MWTF_PACKMASK;
        oflags &= MWTF_PACKMASK;
 
        /* allow -1 for len with ascii*/
        if(cc == -1 && (iflags == MWTF_ASCII))
                cc = strlen((char *)istr);
 
        /* first check for utf8 input encoding*/
        if(iflags == MWTF_UTF8) {
                /* we've only got uc16 now so convert to uc16...*/
                cc = utf8_to_utf16((unsigned char *)istr, cc,
                        oflags==MWTF_UC16?(unsigned short*) ostr: buf16);
 
                if(oflags == MWTF_UC16 || cc < 0)
                        return cc;
 
                /* will decode again to requested format (probably ascii)*/
                iflags = MWTF_UC16;
                istr = buf16;
        }
 
#if HAVE_HZK_SUPPORT
        if(iflags == MWTF_UC16 && oflags == MWTF_ASCII) {
                /* only support uc16 convert to ascii now...*/
                cc = UC16_to_GB( istr, cc, ostr);
                return cc;
        }
#endif
 
        icc = cc;
        istr8 = istr;
        istr16 = istr;
        istr32 = istr;
        ostr8 = ostr;
        ostr16 = ostr;
        ostr32 = ostr;
 
        /* Convert between formats.  Note that there's no error
         * checking here yet.
         */
        while(--icc >= 0) {
                switch(iflags) {
                default:
                        ch = *istr8++;
                        break;
                case MWTF_UC16:
                        ch = *istr16++;
                        break;
                case MWTF_UC32:
                        ch = *istr32++;
                }
                switch(oflags) {
                default:
                        *ostr8++ = (unsigned char)ch;
                        break;
                case MWTF_UC16:
                        *ostr16++ = (unsigned short)ch;
                        break;
                case MWTF_UC32:
                        *ostr32++ = ch;
                }
        }
        return cc;
}
 
/* Get the width and height of passed text string in the passed font*/
void
GdGetTextSize(PMWFONT pfont, const void *str, int cc, MWCOORD *pwidth,
        MWCOORD *pheight, MWCOORD *pbase, int flags)
{
        const void *    text;
        unsigned long   buf[256];
        int             defencoding = pfont->fontprocs->encoding;
 
        /* convert encoding if required*/
        if((flags & MWTF_PACKMASK) != defencoding) {
                cc = GdConvertEncoding(str, flags, cc, buf, defencoding);
                flags &= ~MWTF_PACKMASK;
                flags |= defencoding;
                text = buf;
        } else text = str;
 
        if(cc == -1 && (flags & MWTF_PACKMASK) == MWTF_ASCII)
                cc = strlen((char *)str);
 
        if(cc <= 0 || !pfont->fontprocs->GetTextSize) {
                *pwidth = *pheight = *pbase = 0;
                return;
        }
 
        /* calc height and width of string*/
        pfont->fontprocs->GetTextSize(pfont, text, cc, pwidth, pheight, pbase);
}
 
/* Draw a text string at a specifed coordinates in the foreground color
 * (and possibly the background color), applying clipping if necessary.
 * The background color is only drawn if the gr_usebg flag is set.
 * Use the current font.
 */
void
GdText(PSD psd, MWCOORD x, MWCOORD y, const void *str, int cc, int flags)
{
        const void *    text;
        unsigned long   buf[256];
        int             defencoding = gr_pfont->fontprocs->encoding;
 
        /* convert encoding if required*/
        if((flags & MWTF_PACKMASK) != defencoding) {
                cc = GdConvertEncoding(str, flags, cc, buf, defencoding);
                flags &= ~MWTF_PACKMASK;
                flags |= defencoding;
                text = buf;
        } else text = str;
 
        if(cc == -1 && (flags & MWTF_PACKMASK) == MWTF_ASCII)
                cc = strlen((char *)str);
 
        if(cc <= 0 || !gr_pfont->fontprocs->DrawText)
                return;
 
        /* draw text string*/
        gr_pfont->fontprocs->DrawText(gr_pfont, psd, x, y, text, cc, flags);
}
 
/*
 * Draw ascii text using COREFONT type font.
 */
void
corefont_drawtext(PMWFONT pfont, PSD psd, MWCOORD x, MWCOORD y,
        const void *text, int cc, int flags)
{
        const unsigned char *str = text;
        MWCOORD         width;                  /* width of text area */
        MWCOORD         height;                 /* height of text area */
        MWCOORD         base;                   /* baseline of text*/
        MWCOORD         startx, starty;
                                                /* bitmap for characters */
        MWIMAGEBITS bitmap[MAX_CHAR_HEIGHT*MAX_CHAR_WIDTH/MWIMAGE_BITSPERIMAGE];
 
        pfont->fontprocs->GetTextSize(pfont, str, cc, &width, &height, &base);
 
        if(flags & MWTF_BASELINE)
                y -= base;
        else if(flags & MWTF_BOTTOM)
                y -= (height - 1);
        startx = x;
        starty = y + base;
 
        switch (GdClipArea(psd, x, y, x + width - 1, y + height - 1)) {
        case CLIP_VISIBLE:
                /*
                 * For size considerations, there's no low-level text
                 * draw, so we've got to draw all text
                 * with per-point clipping for the time being
                if (gr_usebg)
                        psd->FillRect(psd, x, y, x + width - 1, y + height - 1,
                                gr_background);
                psd->DrawText(psd, x, y, str, cc, gr_foreground, pfont);
                GdFixCursor(psd);
                return;
                */
                break;
 
        case CLIP_INVISIBLE:
                return;
        }
 
        /* Get the bitmap for each character individually, and then display
         * them using clipping for each one.
         */
        while (--cc >= 0 && x < psd->xvirtres) {
                unsigned int ch = *str++;
#if HAVE_BIG5_SUPPORT
                /* chinese big5 decoding*/
                if (ch >= 0xA1 && ch <= 0xF9 && cc >= 1 &&
                        ((*str >= 0x40 && *str <= 0x7E) ||
                         (*str >= 0xA1 && *str <= 0xFE)) ) {
                                ch = (ch << 8) | *str++;
                                --cc;
                }
#endif
#if HAVE_GB2312_SUPPORT
                /* chinese gb2312 decoding*/
                if (ch >= 0xA1 && ch < 0xF8 && cc >= 1 &&
                        *str >= 0xA1 && *str < 0xFF) {
                                ch = (ch << 8) | *str++;
                                --cc;
                }
#endif
                pfont->fontprocs->GetTextBits(pfont, ch, bitmap, &width,
                        &height, &base);
 
                /* note: change to bitmap*/
                GdBitmap(psd, x, y, width, height, bitmap);
                x += width;
        }
 
        if (pfont->fontattr & MWTF_UNDERLINE)
                GdLine(psd, startx, starty, x, starty, FALSE);
 
        GdFixCursor(psd);
}
 
#if HAVE_T1LIB_SUPPORT | HAVE_FREETYPE_SUPPORT
/*
 * Produce blend table from src and dst based on passed alpha table
 * Used because we don't quite yet have GdArea with alphablending,
 * so we pre-blend fg/bg colors for fade effect.
 */
static void
alphablend(PSD psd, OUTPIXELVAL *out, MWPIXELVAL src, MWPIXELVAL dst,
        unsigned char *alpha, int count)
{
        unsigned int    a, d;
        unsigned char   r, g, b;
        MWCOLORVAL      palsrc, paldst;
        extern MWPALENTRY gr_palette[256];
 
        while (--count >= 0) {
            a = *alpha++;
 
#define BITS(pixel,shift,mask)  (((pixel)>>shift)&(mask))
            if(a == 0)
                *out++ = dst;
            else if(a == 255)
                *out++ = src;
            else
                switch(psd->pixtype) {
                case MWPF_TRUECOLOR0888:
                case MWPF_TRUECOLOR888:
                    d = BITS(dst, 16, 0xff);
                    r = (unsigned char)(((BITS(src, 16, 0xff) - d)*a)>>8) + d;
                    d = BITS(dst, 8, 0xff);
                    g = (unsigned char)(((BITS(src, 8, 0xff) - d)*a)>>8) + d;
                    d = BITS(dst, 0, 0xff);
                    b = (unsigned char)(((BITS(src, 0, 0xff) - d)*a)>>8) + d;
                    *out++ = (r << 16) | (g << 8) | b;
                    break;
 
                case MWPF_TRUECOLOR565:
                    d = BITS(dst, 11, 0x1f);
                    r = (unsigned char)(((BITS(src, 11, 0x1f) - d)*a)>>8) + d;
                    d = BITS(dst, 5, 0x3f);
                    g = (unsigned char)(((BITS(src, 5, 0x3f) - d)*a)>>8) + d;
                    d = BITS(dst, 0, 0x1f);
                    b = (unsigned char)(((BITS(src, 0, 0x1f) - d)*a)>>8) + d;
                    *out++ = (r << 11) | (g << 5) | b;
                    break;
 
                case MWPF_TRUECOLOR555:
                    d = BITS(dst, 10, 0x1f);
                    r = (unsigned char)(((BITS(src, 10, 0x1f) - d)*a)>>8) + d;
                    d = BITS(dst, 5, 0x1f);
                    g = (unsigned char)(((BITS(src, 5, 0x1f) - d)*a)>>8) + d;
                    d = BITS(dst, 0, 0x1f);
                    b = (unsigned char)(((BITS(src, 0, 0x1f) - d)*a)>>8) + d;
                    *out++ = (r << 10) | (g << 5) | b;
                    break;
 
                case MWPF_TRUECOLOR332:
                    d = BITS(dst, 5, 0x07);
                    r = (unsigned char)(((BITS(src, 5, 0x07) - d)*a)>>8) + d;
                    d = BITS(dst, 2, 0x07);
                    g = (unsigned char)(((BITS(src, 2, 0x07) - d)*a)>>8) + d;
                    d = BITS(dst, 0, 0x03);
                    b = (unsigned char)(((BITS(src, 0, 0x03) - d)*a)>>8) + d;
                    *out++ = (r << 5) | (g << 2) | b;
                    break;
 
                case MWPF_PALETTE:
                    /* reverse lookup palette entry for blend ;-)*/
                    palsrc = GETPALENTRY(gr_palette, src);
                    paldst = GETPALENTRY(gr_palette, dst);
                    d = REDVALUE(paldst);
                    r = (unsigned char)(((REDVALUE(palsrc) - d)*a)>>8) + d;
                    d = GREENVALUE(paldst);
                    g = (unsigned char)(((GREENVALUE(palsrc) - d)*a)>>8) + d;
                    d = BLUEVALUE(paldst);
                    b = (unsigned char)(((BLUEVALUE(palsrc) - d)*a)>>8) + d;
                    *out++ = GdFindNearestColor(gr_palette, (int)psd->ncolors,
                                MWRGB(r, g, b));
                    break;
                }
        }
}
#endif /*HAVE_T1LIB_SUPPORT | HAVE_FREETYPE_SUPPORT*/
 
#if HAVE_T1LIB_SUPPORT
/* contributed by Vidar Hokstad*/
 
static int
t1lib_init(PSD psd)
{
        static int inited = 0;
 
        if (inited)
                return 1;
 
        T1_SetBitmapPad(8);
        if (!T1_InitLib(0))
                return 0;
#ifdef T1LIB_USE_AA_HIGH         
        T1_AASetLevel(T1_AA_HIGH);
#else
        T1_AASetLevel(T1_AA_LOW);
#endif   
#if 0
        /* kluge: this is required if 16bpp drawarea driver is used*/
        if(psd->bpp == 16)
                T1_AASetBitsPerPixel(16);
        else
#endif
                T1_AASetBitsPerPixel(sizeof(MWPIXELVAL)*8);
 
        inited = 1;
        return 1;
}
 
static PMWT1LIBFONT
t1lib_createfont(const char *name, MWCOORD height, int attr)
{
        PMWT1LIBFONT    pf;
        int             id;
        char *          p;
        char            buf[256];
 
        /* match name against t1 font id's from t1 font database*/
        for(id=0; id<T1_Get_no_fonts(); ++id) {
                strncpy(buf, T1_GetFontFileName(id), sizeof(buf));
 
                /* remove extension*/
                for(p=buf; *p; ++p) {
                        if(*p == '.') {
                                *p = 0;
                                break;
                        }
                }
 
                if(!strcmpi(name, buf)) {
                        /* allocate font structure*/
                        pf = (PMWT1LIBFONT)calloc(sizeof(MWT1LIBFONT), 1);
                        if (!pf)
                                return NULL;
                        pf->fontprocs = &t1lib_procs;
                        GdSetFontSize((PMWFONT)pf, height);
                        GdSetFontRotation((PMWFONT)pf, 0);
                        GdSetFontAttr((PMWFONT)pf, attr, 0);
                        pf->fontid = id;
                        return pf;
                }
        }
        return NULL;
}
 
/*
 * Draw ascii text string using T1LIB type font
 */
static void
t1lib_drawtext(PMWFONT pfont, PSD psd, MWCOORD x, MWCOORD y,
        const void *text, int cc, int flags)
{
        PMWT1LIBFONT    pf = (PMWT1LIBFONT)pfont;
        const unsigned char *str = text;
        MWCOORD         width;                  /* width of text area */
        MWCOORD         height;                 /* height of text area */
        MWCOORD         underliney;
        GLYPH * g; /* T1lib glyph structure. Memory handling by T1lib */
#ifdef T1LIB_USE_AA_HIGH   
        OUTPIXELVAL     gvals[17];
 
        /* Blending array for antialiasing. The steeper the values increase
         * near the end, the sharper the characters look, but also more jagged
         */
        static unsigned char blend[17] = {
           0x00, 0x00, 0x04, 0x0c, 0x10, 0x14, 0x18, 0x20,
           0x30, 0x38, 0x40, 0x50, 0x70, 0x80, 0xa0, 0xc0, 0xff
        };
#else   
        OUTPIXELVAL     gvals[5];
        static unsigned char blend[5] = { 0x00, 0x44, 0x88, 0xcc, 0xff };
#endif   
 
        /* Check if we should throw out some fonts */
 
        if (pf->fontattr&MWTF_ANTIALIAS) {
#ifdef T1LIB_USE_AA_HIGH      
           alphablend(psd, gvals, gr_foreground, gr_background, blend, 17);
           T1_AAHSetGrayValues(gvals);
#else      
           alphablend(psd, gvals, gr_foreground, gr_background, blend, 5);
           T1_AASetGrayValues(gvals[0],gvals[1],gvals[2],gvals[3],gvals[4]);
#endif
           g = T1_AASetString(pf->fontid,(char *)str,cc,0,
                (pf->fontattr&MWTF_KERNING)? T1_KERNING: 0,
                pf->fontsize * 1.0, 0);
 
           if (g && g->bits) {
              /*MWPIXELVAL save = gr_background;*/
              width = g->metrics.rightSideBearing - g->metrics.leftSideBearing;
              height = g->metrics.ascent - g->metrics.descent;
 
              if(flags & MWTF_BASELINE)
                y -= g->metrics.ascent;
              else if(flags & MWTF_BOTTOM)
                y -= (height - 1);
              underliney = y + g->metrics.ascent;
 
              /* FIXME: Looks damn ugly if usebg is false.
               * Will be handled when using alphablending in GdArea...
               */
              /* clipping handled in GdArea*/
              /*FIXME kluge for transparency*/
              /*gr_background = gr_foreground + 1;*/
              /*gr_usebg = 0;*/
              GdArea(psd,x,y, width, height, g->bits, MWPF_PIXELVAL);
              /*gr_background = save;*/
 
              if (pf->fontattr & MWTF_UNDERLINE)
                   GdLine(psd, x, underliney, x+width, underliney, FALSE);
 
           }
        } else {
           /* Do non-aa drawing */
           g = T1_SetString(pf->fontid,(char *)str,cc,0,
                        (pf->fontattr&MWTF_KERNING)? T1_KERNING: 0,
                        pf->fontsize * 1.0, 0);
 
           if (g && g->bits) {
              unsigned char * b;
              int xoff;
              int maxy;
              int xmod;
 
              /* I'm sure this sorry excuse for a bitmap rendering routine can
               * be optimized quite a bit ;)
               */
              width = g->metrics.rightSideBearing - g->metrics.leftSideBearing;
              height = g->metrics.ascent - g->metrics.descent;
 
              if(flags & MWTF_BASELINE)
                y -= g->metrics.ascent;
              else if(flags & MWTF_BOTTOM)
                y -= (height - 1);
              underliney = y + g->metrics.ascent;
 
              b = g->bits;
              maxy = y + height;
 
/*            if ((x + width) > psd->xvirtres) {
                 xmod = (x + width - psd->xvirtres + 7) >> 3;
                 width = width + x + width - psd->xvirtres;
              } else xmod = 0;
*/
              xmod = 0;
              while (y < maxy) {
                 unsigned char data;
                 xoff = 0;
                 while (xoff < width ) {
                    if (!(xoff % 8)) {
                       data = *b;
                       b++;
                    }
 
                    if (GdClipPoint(psd, x+xoff,y)) {
                       if (gr_usebg) {
                          psd->DrawPixel(psd,x+xoff,y,
                              data & (1 << (xoff % 8)) ?
                                    gr_foreground : gr_background);
                       } else if (data & (1 << (xoff % 8))) {
                          psd->DrawPixel(psd,x+xoff,y, gr_foreground);
                       }
                    }
                    xoff++;
                 }
                 b += xmod;
                 y++;
              }
              if (pf->fontattr & MWTF_UNDERLINE)
                   GdLine(psd, x, underliney, x+xoff, underliney, FALSE);
           }
        }
 
   if (g && g->bits) {
           /* Save some memory */
           free(g->bits);
           g->bits = 0; /* Make sure T1lib doesnt try to free it again */
   }
 
   GdFixCursor(psd);
}
 
static MWBOOL
t1lib_getfontinfo(PMWFONT pfont, PMWFONTINFO pfontinfo)
{
        int     i;
        MWCOORD width, height, baseline;
 
        /* FIXME, guess all sizes*/
        GdGetTextSize(pfont, "A", 1, &width, &height, &baseline, MWTF_ASCII);
        pfontinfo->height = height;
        pfontinfo->maxwidth = width;
        pfontinfo->baseline = 0;
        pfontinfo->firstchar = 32;
        pfontinfo->lastchar = 255;
        pfontinfo->fixed = TRUE;
        for(i=0; i<256; ++i)
                pfontinfo->widths[i] = width;
        return TRUE;
}
 
/* Get the width and height of passed text string in the current font*/
static void
t1lib_gettextsize(PMWFONT pfont, const void *text, int cc,
        MWCOORD *pwidth, MWCOORD *pheight, MWCOORD *pbase)
{
        PMWT1LIBFONT            pf = (PMWT1LIBFONT)pfont;
        const unsigned char *   str = text;
        GLYPH *                 g;
 
        g = T1_SetString(pf->fontid, (char *)str, cc, 0,
                        (pf->fontattr&MWTF_KERNING)? T1_KERNING: 0, pf->fontsize * 1.0, 0);
        *pwidth = g->metrics.rightSideBearing - g->metrics.leftSideBearing;
        *pheight = g->metrics.ascent - g->metrics.descent;
        if(g && g->bits) {
                free(g->bits);
                g->bits = 0;
        }
#if 0
        BBox                    b;
 
        /* FIXME. Something is *VERY* wrong here */
        b = T1_GetStringBBox(pf->fontid, str, cc, 0, (pf->fontattr&MWTF_KERNING)?T1_KERNING:0);
 
        DPRINTF("b.urx = %d, b.llx = %d\n",b.urx, b.llx);
        DPRINTF("b.ury = %d, b.lly = %d\n",b.ury, b.lly);
        *pwidth = (b.urx - b.llx);
        *pheight = (b.lly - b.ury);
#endif
}
 
static void
t1lib_destroyfont(PMWFONT pfont)
{
        PMWT1LIBFONT    pf = (PMWT1LIBFONT)pfont;
 
        T1_DeleteAllSizes(pf->fontid);
        free(pf);
}
 
#endif /* HAVE_T1LIB_SUPPORT*/
 
#if HAVE_FREETYPE_SUPPORT
static OUTPIXELVAL gray_palette[5];
 
static int
freetype_init(PSD psd)
{
        static int inited = 0;
 
        if (inited)
                return 1;
 
        /* Init freetype library */
        if (TT_Init_FreeType (&engine) != TT_Err_Ok) {
                return 0;
        }
 
        /* Init kerning extension */
        if (TT_Init_Kerning_Extension (engine) != TT_Err_Ok)
                return 0;
 
        inited = 1;
        return 1;
}
 
static PMWFREETYPEFONT
freetype_createfont(const char *name, MWCOORD height, int attr)
{
        PMWFREETYPEFONT         pf;
        unsigned short          i, n;
        unsigned short          platform, encoding;
        TT_Face_Properties      properties;
        char *                  p;
        char                    fontname[128];
 
        /* check for pathname prefix*/
        if (strchr(name, '/') != NULL)
                strcpy(fontname, name);
        else {
                strcpy(fontname, FREETYPE_FONT_DIR);
                strcat(fontname, "/");
                strcat(fontname, name);
        }
 
        /* check for extension*/
        if ((p = strrchr(fontname, '.')) == NULL ||
            strcmp(p, ".ttf") != 0) {
                strcat(fontname, ".ttf");
        }
 
        /* allocate font structure*/
        pf = (PMWFREETYPEFONT)calloc(sizeof(MWFREETYPEFONT), 1);
        if (!pf)
                return NULL;
        pf->fontprocs = &freetype_procs;
 
        /* Load face */
        if (TT_Open_Face (engine, fontname, &pf->face) != TT_Err_Ok)
                goto out;
 
        /* Load first kerning table */
        pf->can_kern = TRUE;
        if (TT_Load_Kerning_Table (pf->face, 0) != TT_Err_Ok)
                pf->can_kern = FALSE;
        else {
                if (TT_Get_Kerning_Directory (pf->face, &pf->directory)
                    != TT_Err_Ok)
                        pf->can_kern = FALSE;
                else {
                        /* Support only version 0 kerning table ... */
                        if ((pf->directory.version != 0) ||
                                (pf->directory.nTables <= 0) ||
                                (pf->directory.tables->loaded != 1) ||
                                (pf->directory.tables->version != 0) ||
                                (pf->directory.tables->t.kern0.nPairs <= 0))
                                        pf->can_kern = FALSE;
                }
        }
 
        /* get face properties and allocate preload arrays */
        TT_Get_Face_Properties (pf->face, &properties);
 
#if 0
        /*
         * Use header information for ascent and descent
         * to compute scaled ascent/descent for current font height.
         */
        h = properties.os2->sTypoAscender - properties.os2->sTypoDescender
                + properties.os2->sTypoLineGap;
        ascent = properties.os2->sTypoAscender
                + properties.os2->sTypoLineGap/2;
        pf->ascent = (ascent * height + h/2) / h;
        pf->descent = height - pf->ascent;
#endif
        /* Create a glyph container */
        if (TT_New_Glyph (pf->face, &pf->glyph) != TT_Err_Ok)
                goto out;
 
        /* create instance */
        if (TT_New_Instance (pf->face, &pf->instance) != TT_Err_Ok)
                goto out;
 
        /* Set the instance resolution */
        if (TT_Set_Instance_Resolutions (pf->instance, 96, 96) != TT_Err_Ok)
                goto out;
 
        /* Look for a Unicode charmap: Windows flavor of Apple flavor only */
        n = properties.num_CharMaps;
 
        for (i = 0; i < n; i++) {
                TT_Get_CharMap_ID (pf->face, i, &platform, &encoding);
                if (((platform == TT_PLATFORM_MICROSOFT) &&
                        (encoding == TT_MS_ID_UNICODE_CS)) ||
                                ((platform == TT_PLATFORM_APPLE_UNICODE) &&
                                        (encoding == TT_APPLE_ID_DEFAULT)))
                {
                        TT_Get_CharMap (pf->face, i, &pf->char_map);
                        i = n + 1;
                }
        }
        if (i == n) {
                DPRINTF("freetype_createfont: no unicode map table\n");
                goto out;
        }
 
        GdSetFontSize((PMWFONT)pf, height);
        GdSetFontRotation((PMWFONT)pf, 0);
        GdSetFontAttr((PMWFONT)pf, attr, 0);
 
        return pf;
 
out:
        free(pf);
        return NULL;
}
 
static int
compute_kernval(PMWFREETYPEFONT pf, short current_glyph_code)
{
        int             i = 0;
        int             kernval;
        int             nPairs = pf->directory.tables->t.kern0.nPairs;
        TT_Kern_0_Pair *pair = pf->directory.tables->t.kern0.pairs;
 
        if (pf->last_glyph_code != -1) {
                while ((pair->left != pf->last_glyph_code)
                        && (pair->right != current_glyph_code))
                {
                        pair++;
                        i++;
                        if (i == nPairs)
                        break;
                }
 
                if (i == nPairs)
                        kernval = 0;
                else
                        /* We round the value (hence the +32) */
                        kernval = (pair->value + 32) & -64;
        } else
                kernval = 0;
 
        return kernval;
}
 
static TT_UShort
Get_Glyph_Width(PMWFREETYPEFONT pf, TT_UShort glyph_index)
{
        TT_Glyph_Metrics metrics;
 
        if (TT_Load_Glyph ( pf->instance, pf->glyph,
                TT_Char_Index (pf->char_map,glyph_index),
                TTLOAD_SCALE_GLYPH|TTLOAD_HINT_GLYPH) != TT_Err_Ok)
        {
                /* Try to load default glyph: index 0 */
                if (TT_Load_Glyph ( pf->instance, pf->glyph, 0,
                        TTLOAD_SCALE_GLYPH|TTLOAD_HINT_GLYPH) != TT_Err_Ok)
                    return 0;
        }
 
        TT_Get_Glyph_Metrics (pf->glyph, &metrics);
        return((metrics.advance & 0xFFFFFFC0) >> 6);
}
 
static MWFREETYPEFONTCACHE *
find_cache_glyph ( PMWFREETYPEFONT pf, unsigned curchar )
{
  MWFREETYPEFONTCACHE ** inode = &pf->glyph_cache;
 
  while (1)
    {
      if (*inode == 0)
        {
          *inode = calloc(sizeof(MWFREETYPEFONTCACHE),1);
          (*inode)->curchar = curchar;
        }
 
      if (curchar < (*inode)->curchar)
        inode = &(*inode)->l;
      else if (curchar > (*inode)->curchar)
        inode = &(*inode)->r;
      else
        return *inode;
    }
}
 
static void
free_cache_glyph ( MWFREETYPEFONTCACHE * node )
{
  if (node->l != 0)
    free_cache_glyph(node->l);
 
  if (node->r != 0)
    free_cache_glyph(node->r);
 
  free(node);
}
 
/* Render a single glyph*/
static void
drawchar(PMWFREETYPEFONT pf, PSD psd, unsigned curchar, int x_offset,
        int y_offset)
{
        TT_F26Dot6      xmin, ymin, xmax, ymax, x, y, z;
        unsigned char   *src, *srcptr;
        MWPIXELVAL      *dst, *dstptr;
        MWPIXELVAL      *bitmap;
        int             size, width, height;
        TT_Outline      outline;
        TT_BBox         bbox;
        TT_Raster_Map   Raster;
        TT_Error        error;
        /*MWPIXELVAL    save;*/
        MWFREETYPEFONTCACHE * cache;
 
        /* we begin by grid-fitting the bounding box */
        TT_Get_Glyph_Outline (pf->glyph, &outline);
        TT_Get_Outline_BBox (&outline, &bbox);
 
        xmin = (bbox.xMin & -64) >> 6;
        ymin = (bbox.yMin & -64) >> 6;
        xmax = ((bbox.xMax + 63) & -64) >> 6;
        ymax = ((bbox.yMax + 63) & -64) >> 6;
        width = xmax - xmin;
        height = ymax - ymin;
        size = width * height;
 
        /* now re-allocate the raster bitmap */
        Raster.rows = height;
        Raster.width = width;
 
        if (pf->fontattr&MWTF_ANTIALIAS)
                Raster.cols = (Raster.width + 3) & -4;  /* pad to 32-bits */
        else
                Raster.cols = (Raster.width + 7) & -8;  /* pad to 64-bits ??? */
 
        cache = find_cache_glyph(pf,curchar);
        /* SDR: if cache is 0 here, something really really bad happened */
 
        Raster.flow = TT_Flow_Up;
        Raster.size = Raster.rows * Raster.cols;
        Raster.bitmap = cache->buffer;
 
        if (Raster.bitmap == 0)
          {
            Raster.bitmap = malloc (Raster.size);
 
            memset (Raster.bitmap, 0, Raster.size);
 
            /* now render the glyph in the small pixmap */
 
            /* IMPORTANT NOTE: the offset parameters passed to the function     */
            /* TT_Get_Glyph_Bitmap() must be integer pixel values, i.e.,        */
            /* multiples of 64.  HINTING WILL BE RUINED IF THIS ISN'T THE CASE! */
            /* This is why we _did_ grid-fit the bounding box, especially xmin  */
            /* and ymin.                                                        */
 
            if (!(pf->fontattr&MWTF_ANTIALIAS))
              error = TT_Get_Glyph_Bitmap (pf->glyph, &Raster,
                                           -xmin * 64, -ymin * 64);
            else
              error = TT_Get_Glyph_Pixmap (pf->glyph, &Raster,
                                           -xmin * 64, -ymin * 64);
 
            if (error) {
              free (Raster.bitmap);
              return;
            }
 
            cache->buffer = Raster.bitmap;
          }
 
#if MWFREETYPEFONT_CACHEBITMAP
        if ((memcmp(&gr_foreground,&cache->fg,sizeof(gr_foreground)) != 0) ||
            (memcmp(&gr_background,&cache->bg,sizeof(gr_background)) != 0) ||
            (gr_usebg != cache->usebg))
          {
            if (cache->bitmap)
              {
                free(cache->bitmap);
                cache->bitmap = 0;
              }
          }
 
        bitmap = cache->bitmap;
#else
        bitmap = 0;
#endif
 
        if (bitmap == 0)
          {
            bitmap = malloc (size * sizeof (MWPIXELVAL));
            memset (bitmap, 0, size * sizeof (MWPIXELVAL));
 
            src = (char *) Raster.bitmap;
            dst = bitmap + (size - width);
 
            for (y = ymin; y < ymax; y++)
              {
                srcptr = src;
                dstptr = dst;
 
                for (x = xmin; x < xmax; x++)
                  {
                    if (pf->fontattr&MWTF_ANTIALIAS)
                      *dstptr++ = gray_palette[(int) *srcptr];
                    else
                      {
                        for ( z=0;
                              z <= ((xmax-x-1) < 7 ? (xmax-x-1) : 7);
                              z++ )
                            *dstptr++ = ((*srcptr << z) & 0x80) ? gr_foreground : gr_background;
                        x += 7;
                      }
 
                    srcptr++;
                  }
 
                src += Raster.cols;
                dst -= width;
              }
#if MWFREETYPEFONT_CACHEBITMAP
            cache->fg = gr_foreground;
            cache->bg = gr_background;
            cache->usebg = gr_usebg;
            cache->bitmap = bitmap;
#endif
          }
 
        /* Now draw the bitmap ... */
        GdArea(psd, x_offset + xmin, y_offset - (ymin + height), width, height,
                bitmap, MWPF_PIXELVAL);
 
#if !MWFREETYPEFONT_CACHEBITMAP
        free(bitmap);
#endif
}
 
/*
 * Draw unicode 16 text string using FREETYPE type font
 */
static void
freetype_drawtext(PMWFONT pfont, PSD psd, MWCOORD ax, MWCOORD ay,
        const void *text, int cc, int flags)
{
        PMWFREETYPEFONT pf = (PMWFREETYPEFONT)pfont;
        const unsigned short *  str = text;
        TT_F26Dot6      x = ax, y = ay;
        TT_Pos          vec_x, vec_y;
        int             i;
        TT_F26Dot6      startx, starty;
        TT_Outline      outline;
        TT_UShort       curchar;
        TT_Glyph_Metrics metrics;
        TT_Face_Properties properties;
        TT_Instance_Metrics imetrics;
        TT_F26Dot6 ascent, descent;
        static unsigned char blend[5] = { 0x00, 0x44, 0x88, 0xcc, 0xff };
        static unsigned char virtual_palette[5] = { 0, 1, 2, 3, 4 };
 
        pf->last_glyph_code = -1;               /* reset kerning*/
        pf->last_pen_pos = -32767;
 
        /*
         * Compute instance ascent & descent values
         * in fractional units (1/64th pixel)
         */
        TT_Get_Face_Properties (pf->face, &properties);
        TT_Get_Instance_Metrics(pf->instance, &imetrics);
 
        ascent = ((properties.horizontal->Ascender * imetrics.y_scale)/0x10000);
        descent = ((properties.horizontal->Descender*imetrics.y_scale)/0x10000);
 
        /*
         * Offset the starting point if necessary,
         * FreeType always aligns at baseline
         */
        if (flags&MWTF_BOTTOM) {
                vec_x = 0;
                vec_y = descent;
                TT_Transform_Vector(&vec_x, &vec_y,&pf->matrix);
                x -= vec_x / 64;
                y += vec_y / 64;
        } else if (flags&MWTF_TOP) {
                vec_x = 0;
                vec_y = ascent;
                TT_Transform_Vector(&vec_x, &vec_y,&pf->matrix);
                x -= vec_x / 64;
                y += vec_y / 64;
        }
 
        /* Set the "graylevels" */
        if (pf->fontattr&MWTF_ANTIALIAS) {
                TT_Set_Raster_Gray_Palette (engine, virtual_palette);
 
                alphablend(psd, gray_palette, gr_foreground, gr_background,
                        blend, 5);
        }
 
        startx = x;
        starty = y;
        for (i = 0; i < cc; i++) {
                curchar = TT_Char_Index (pf->char_map, str[i]);
 
                if (TT_Load_Glyph (pf->instance, pf->glyph, curchar,
                        TTLOAD_DEFAULT) != TT_Err_Ok)
                                continue;
 
                if (pf->fontrotation) {
                        TT_Get_Glyph_Outline (pf->glyph, &outline);
                        TT_Transform_Outline (&outline, &pf->matrix);
                }
 
                TT_Get_Glyph_Metrics (pf->glyph, &metrics);
 
                if ((pf->fontattr&MWTF_KERNING) && pf->can_kern) {
                        if (pf->fontrotation) {
                                vec_x = compute_kernval(pf, curchar);
                                vec_y = 0;
                                TT_Transform_Vector(&vec_x, &vec_y,&pf->matrix);
 
                                x += vec_x / 64;
                                y -= vec_y / 64;
                        } else
                                x += compute_kernval(pf, curchar) / 64;
                }
 
                drawchar(pf, psd, curchar, x, y);
 
                if (pf->fontrotation) {
                        vec_x = metrics.advance;
                        vec_y = 0;
                        TT_Transform_Vector (&vec_x, &vec_y, &pf->matrix);
 
                        x += vec_x / 64;
                        y -= vec_y / 64;
                } else {
                        x += metrics.advance / 64;
 
                        /* Kerning point syndrome avoidance */
                        if (pf->last_pen_pos > x)
                                x = pf->last_pen_pos;
                        pf->last_pen_pos = x;
                }
 
                pf->last_glyph_code = curchar;
        }
 
        if (pf->fontattr & MWTF_UNDERLINE)
                GdLine(psd, startx, starty, x, y, FALSE);
}
 
/*
 * Return information about a specified font.
 */
static MWBOOL
freetype_getfontinfo(PMWFONT pfont, PMWFONTINFO pfontinfo)
{
        int     i;
        PMWFREETYPEFONT pf = (PMWFREETYPEFONT)pfont;
        TT_Face_Properties      properties;
        TT_Instance_Metrics imetrics;
        TT_UShort last_glyph_index;
 
        TT_Get_Face_Properties (pf->face, &properties);
        TT_Get_Instance_Metrics(pf->instance, &imetrics);
 
        /* Fill up the fields */
        pfontinfo->height = (((properties.horizontal->Ascender * \
                                imetrics.y_scale)/ 0x10000) >> 6) -
                            (((properties.horizontal->Descender * \
                                imetrics.y_scale)/ 0x10000) >> 6);
        pfontinfo->maxwidth = ((properties.horizontal->xMax_Extent * \
                                imetrics.x_scale)/ 0x10000) >> 6;
        pfontinfo->baseline = ((properties.horizontal->Ascender * \
                                imetrics.y_scale)/ 0x10000) >> 6;
        pfontinfo->firstchar = TT_CharMap_First(pf->char_map, NULL);
        pfontinfo->lastchar = TT_CharMap_Last(pf->char_map, NULL);
        pfontinfo->fixed = properties.postscript->isFixedPitch;
 
        last_glyph_index = properties.num_Glyphs > 255 ? 255: properties.num_Glyphs-1;
 
        /* Doesn't work ... don't know why ....*/
#if 0
        if (TT_Get_Face_Widths( pf->face, 0,
                                last_glyph_index, widths, NULL ) != TT_Err_Ok) {
          return TRUE;
        }
 
        for(i=0; i<=last_glyph_index; i++)
          DPRINTF("widths[%d]: %d\n", i, widths[i]);
#endif
 
        /* Get glyphs widths */
        for(i=0; i<=last_glyph_index; i++)
          pfontinfo->widths[i] = Get_Glyph_Width(pf, i);
 
#if 0
        DPRINTF("x_ppem: %d\ny_ppem: %d\nx_scale: %d\ny_scale: %d\n\
    x_resolution: %d\ny_resolution: %d\n",
    imetrics.x_ppem, imetrics.y_ppem, imetrics.x_scale, \
    imetrics.y_scale, imetrics.x_resolution, imetrics.y_resolution);
 
    DPRINTF("Ascender: %d\nDescender: %d\nxMax_Extent: %d\n\
    Mac Style Say Italic?: %d\nMac Style Say Bold?: %d\n\
    sTypoAscender: %d\nsTypoDescender: %d\nusWinAscent: %d\n\
    usWinDescent: %d\nusFirstCharIndex: %d\nusLastCharIndex: %d\n\
    OS2 Say Italic?: %d\nOS2 Say Bold?: %d\nOS2 Say monospaced?: %d\n\
    Postscript Say monospaced?: %d\n",\
    properties.horizontal->Ascender,
    properties.horizontal->Descender,
    properties.horizontal->xMax_Extent,
    (properties.header->Mac_Style & 0x2)?1:0,
    (properties.header->Mac_Style & 0x1)?1:0,
    properties.os2->sTypoAscender,
    properties.os2->sTypoDescender,
    properties.os2->usWinAscent,
    properties.os2->usWinDescent,
    properties.os2->usFirstCharIndex,
    properties.os2->usLastCharIndex,
    (properties.os2->fsSelection & 0x1)?1:0,
    (properties.os2->fsSelection & 0x20)?1:0,
    properties.postscript->isFixedPitch,
    (properties.os2->panose[3] == 9)?1:0);
#endif  
 
        return TRUE;
}
 
static void
freetype_gettextsize(PMWFONT pfont, const void *text, int cc,
        MWCOORD *pwidth, MWCOORD *pheight, MWCOORD *pbase)
{
        PMWFREETYPEFONT pf = (PMWFREETYPEFONT)pfont;
        const unsigned short *  str = text;
        TT_F26Dot6      x = 0;
        int             i;
        TT_UShort       curchar;
        TT_Glyph_Metrics metrics;
        TT_Face_Properties      properties;
        TT_Instance_Metrics imetrics;
 
        TT_Get_Face_Properties (pf->face, &properties);
        TT_Get_Instance_Metrics(pf->instance, &imetrics);
 
        pf->last_glyph_code = -1;               /* reset kerning*/
        pf->last_pen_pos = -32767;
 
        for (i = 0; i < cc; i++) {
                curchar = TT_Char_Index (pf->char_map, str[i]);
 
                if (TT_Load_Glyph (pf->instance, pf->glyph, curchar,
                        TTLOAD_SCALE_GLYPH|TTLOAD_HINT_GLYPH) != TT_Err_Ok)
                                continue;
 
                TT_Get_Glyph_Metrics (pf->glyph, &metrics);
 
                if ((pf->fontattr&MWTF_KERNING) && pf->can_kern) {
                                x += compute_kernval(pf, curchar) / 64;
                }
 
                x += metrics.advance / 64;
 
                /* Kerning point syndrome avoidance */
                if (pf->last_pen_pos > x)
                        x = pf->last_pen_pos;
                pf->last_pen_pos = x;
 
                pf->last_glyph_code = curchar;
        }
 
        *pwidth = x;
        *pheight =  (((properties.horizontal->Ascender *
                        imetrics.y_scale)/ 0x10000) >> 6) -
                    (((properties.horizontal->Descender *
                    imetrics.y_scale)/ 0x10000) >> 6);
        /* FIXME: is it what's required ?? */
        *pbase = (((-properties.horizontal->Descender) *
                    imetrics.y_scale)/ 0x10000) >> 6;
}
 
static void
freetype_destroyfont(PMWFONT pfont)
{
        PMWFREETYPEFONT pf = (PMWFREETYPEFONT)pfont;
 
        TT_Close_Face(pf->face);
 
        /*----------*/
 
        if (pf->glyph_cache != 0)
          free_cache_glyph(pf->glyph_cache);
 
        /*----------*/
 
        free(pf);
}
 
static void
freetype_setfontsize(PMWFONT pfont, MWCOORD fontsize)
{
        PMWFREETYPEFONT pf = (PMWFREETYPEFONT)pfont;
 
        pf->fontsize = fontsize;
 
        /* We want real pixel sizes ... not points ...*/
        TT_Set_Instance_PixelSizes( pf->instance, pf->fontsize,
                                pf->fontsize, pf->fontsize * 64 );
#if 0
        /* set charsize (convert to points for freetype)*/
        TT_Set_Instance_CharSize (pf->instance,
                ((pf->fontsize * 72 + 96/2) / 96) * 64);
#endif
}
 
static void
freetype_setfontrotation(PMWFONT pfont, int tenthdegrees)
{
        PMWFREETYPEFONT pf = (PMWFREETYPEFONT)pfont;
        float           angle;
 
        pf->fontrotation = tenthdegrees;
 
        /* Build the rotation matrix with the given angle */
        TT_Set_Instance_Transform_Flags (pf->instance, TRUE, FALSE);
 
        angle = pf->fontrotation * M_PI / 1800;
        pf->matrix.yy = (TT_Fixed) (cos (angle) * (1 << 16));
        pf->matrix.yx = (TT_Fixed) (sin (angle) * (1 << 16));
        pf->matrix.xx = pf->matrix.yy;
        pf->matrix.xy = -pf->matrix.yx;
}
 
#endif /* HAVE_FREETYPE_SUPPORT*/
 
/* UTF-8 to UTF-16 conversion.  Surrogates are handeled properly, e.g.
 * a single 4-byte UTF-8 character is encoded into a surrogate pair.
 * On the other hand, if the UTF-8 string contains surrogate values, this
 * is considered an error and returned as such.
 *
 * The destination array must be able to hold as many Unicode-16 characters
 * as there are ASCII characters in the UTF-8 string.  This in case all UTF-8
 * characters are ASCII characters.  No more will be needed.
 *
 * Copyright (c) 2000 Morten Rolland, Screen Media
 */
static int
utf8_to_utf16(const unsigned char *utf8, int cc, unsigned short *unicode16)
{
        int count = 0;
        unsigned char c0, c1;
        unsigned long scalar;
 
        while(--cc >= 0) {
                c0 = *utf8++;
                /*DPRINTF("Trying: %02x\n",c0);*/
 
                if ( c0 < 0x80 ) {
                        /* Plain ASCII character, simple translation :-) */
                        *unicode16++ = c0;
                        count++;
                        continue;
                }
 
                if ( (c0 & 0xc0) == 0x80 )
                        /* Illegal; starts with 10xxxxxx */
                        return -1;
 
                /* c0 must be 11xxxxxx if we get here => at least 2 bytes */
                scalar = c0;
                if(--cc < 0)
                        return -1;
                c1 = *utf8++;
                /*DPRINTF("c1=%02x\n",c1);*/
                if ( (c1 & 0xc0) != 0x80 )
                        /* Bad byte */
                        return -1;
                scalar <<= 6;
                scalar |= (c1 & 0x3f);
 
                if ( !(c0 & 0x20) ) {
                        /* Two bytes UTF-8 */
                        if ( scalar < 0x80 )
                                return -1;      /* Overlong encoding */
                        *unicode16++ = scalar & 0x7ff;
                        count++;
                        continue;
                }
 
                /* c0 must be 111xxxxx if we get here => at least 3 bytes */
                if(--cc < 0)
                        return -1;
                c1 = *utf8++;
                /*DPRINTF("c1=%02x\n",c1);*/
                if ( (c1 & 0xc0) != 0x80 )
                        /* Bad byte */
                        return -1;
                scalar <<= 6;
                scalar |= (c1 & 0x3f);
 
                if ( !(c0 & 0x10) ) {
                        /*DPRINTF("####\n");*/
                        /* Three bytes UTF-8 */
                        if ( scalar < 0x800 )
                                return -1;      /* Overlong encoding */
                        if ( scalar >= 0xd800 && scalar < 0xe000 )
                                return -1;      /* UTF-16 high/low halfs */
                        *unicode16++ = scalar & 0xffff;
                        count++;
                        continue;
                }
 
                /* c0 must be 1111xxxx if we get here => at least 4 bytes */
                c1 = *utf8++;
                if(--cc < 0)
                        return -1;
                /*DPRINTF("c1=%02x\n",c1);*/
                if ( (c1 & 0xc0) != 0x80 )
                        /* Bad byte */
                        return -1;
                scalar <<= 6;
                scalar |= (c1 & 0x3f);
 
                if ( !(c0 & 0x08) ) {
                        /* Four bytes UTF-8, needs encoding as surrogates */
                        if ( scalar < 0x10000 )
                                return -1;      /* Overlong encoding */
                        scalar -= 0x10000;
                        *unicode16++ = ((scalar >> 10) & 0x3ff) + 0xd800;
                        *unicode16++ = (scalar & 0x3ff) + 0xdc00;
                        count += 2;
                        continue;
                }
 
                return -1;      /* No support for more than four byte UTF-8 */
        }
        return count;
}
 
#if HAVE_HZK_SUPPORT
 
/* UniCode-16 (MWTF_UC16) to GB(MWTF_ASCII) Chinese Characters conversion.
 * a single 2-byte UC16 character is encoded into a surrogate pair.
 * return -1 ,if error;
 * The destination array must be able to hold as many
 * as there are Unicode-16 characters.
 *
 * Copyright (c) 2000 Tang Hao (TownHall)(tang_hao@263.net).
 */
static int
UC16_to_GB(const unsigned char *uc16, int cc, unsigned char *ascii)
{
        FILE* fp;
        char buffer[256];
        unsigned char *uc16p;
        int i=0,j=0, k;
        unsigned char *filebuffer;
        unsigned short *uc16pp,*table;
        unsigned short uc16px;
        int length=31504;
 
        if (use_big5)
                length=54840;
 
        uc16p=(unsigned char *) uc16;
        uc16pp=(unsigned short *) uc16;
 
        strcpy(buffer,HZK_FONT_DIR);
        if (use_big5)
                strcat(buffer,"/BG2UBG.KU");
        else
                strcat(buffer,"/UGB2GB.KU");
        if(!(fp = fopen(buffer, "rb")))
        {
                 fprintf (stderr, "Error.\nThe %s file can not be found!\n",buffer);
                 return -1;
        }
 
        filebuffer= (unsigned char *)malloc ( length);
 
        if(fread(filebuffer, sizeof(char),length, fp) < length) {
                  fprintf (stderr, "Error in reading ugb2gb.ku file!\n");
                  fclose(fp);
                  return -1;
        }
        fclose(fp);
 
        if (use_big5)
        {
                table=(unsigned short *)filebuffer;
                while(1)
                {
                        if(j>=cc)
                        {
                                ascii[i]=0;
                                break;
                        }
                        uc16px=*uc16pp;
                        if((uc16px)<=0x00ff)
                        {
                                ascii[i]=(char)(*uc16pp);
                                i++;
                        }
                        else
                        {
                                ascii[i]=0xa1; ascii[i+1]=0x40;
                                for (k=0; k<13710; k++)
                                {
                                        if (*(table+(k*2+1))==(uc16px))
                                        {
                                                ascii[i]=(char)((*(table+(k*2)) & 0xff00) >> 8);
                                                ascii[i+1]=(char)(*(table+(k*2)) & 0x00ff);
                                                break;
                                        }
                                }
                                i+=2;
                        }
                        uc16pp++; j++;
                }
        }
        else
        {
        while(1)
        {
                if(j>=cc)
                {
                        ascii[i]=0;
                        break;
                }
                if((*((uc16p)+j)==0)&&(*((uc16p)+j+1)==0))
                {
                        ascii[i]=0;
                        break;
                }
                else
                {
                        if(*((uc16p)+j+1)==0)
                        {
                                ascii[i]=*((uc16p)+j);
                                i++;
                                j+=2;
                        }
                        else
                        {
                        /*       to find the place of unicode charater .���ַ�ƥ��*/
                        {
                                int p1=0,p2=length-4,p;
                                unsigned int c1,c2,c,d;
                                c1=((unsigned int )filebuffer[p1])*0x100+(filebuffer[p1+1]);
                                c2=((unsigned int )filebuffer[p2])*0x100+(filebuffer[p2+1]);
                                d=((unsigned int )*((uc16p)+j))*0x100+*((uc16p)+j+1);
                                if(c1==d)
                                {
                                        ascii[i]=filebuffer[p1+2];
                                        ascii[i+1]=filebuffer[p1+3];
                                        goto findit;
                                }
                                if(c2==d)
                                {
                                        ascii[i]=filebuffer[p2+2];
                                        ascii[i+1]=filebuffer[p2+3];
                                        goto findit;
                                }
                                while(1)
                                {
                                        p=(((p2-p1)/2+p1)>>2)<<2;
                                        c=((unsigned int )filebuffer[p])*0x100+(filebuffer[p+1]);
                                        if(d==c)        /*find it*/
                                        {
                                                ascii[i]=filebuffer[p+2];
                                                ascii[i+1]=filebuffer[p+3];
                                                break;
                                        }
                                        else if(p2<=p1+4) /*can't find.*/
                                        {
                                                ascii[i]='.';/*((uc16p)+j);*/
                                                ascii[i+1]='.';/*((uc16p)+j+1);*/
                                                break;
                                        }
                                        else if(d<c)
                                        {
                                                p2=p;
                                                c2=c;
                                        }
                                        else
                                        {
                                                p1=p;
                                                c1=c;
                                        }
                                }
                        }
                        findit:
                        i+=2;
                        j+=2;
                        }
                }
        }
        }
        free(filebuffer);
 
        return i;
}
 
/************************** functions definition ******************************/
 
static int hzk_id( PMWHZKFONT pf )
{
        switch(pf->font_height)
        {
        case 12:
                return 0;
        case 16: default:
                return 1;
        }
}
 
/* This function get Chinese font info from etc file.*/
static MWBOOL GetCFontInfo( PMWHZKFONT pf )
{
        int charset;
 
        if (use_big5)
                charset=(13094+408);
        else
                charset=8178;
 
        CFont[hzk_id(pf)].width = pf->cfont_width;
        pf->CFont.width = pf->cfont_width;
 
        CFont[hzk_id(pf)].height = pf->font_height;
        pf->CFont.height = pf->font_height;
 
        CFont[hzk_id(pf)].size = ((pf->CFont.width + 7) / 8) *
                pf->CFont.height * charset;
        pf->CFont.size = ((pf->CFont.width + 7) / 8) * pf->CFont.height * charset;
 
        if(pf->CFont.size < charset * 8)
                return FALSE;
 
        strcpy(CFont[hzk_id(pf)].file,HZK_FONT_DIR);
        strcpy(pf->CFont.file,HZK_FONT_DIR);
 
        if(pf->font_height==16)
        {
                strcat(CFont[hzk_id(pf)].file,"/hzk16");
                strcat(pf->CFont.file,"/hzk16");
        }
        else
        {
                strcat(CFont[hzk_id(pf)].file,"/hzk12");
                strcat(pf->CFont.file,"/hzk12");
        }
 
        if (use_big5)
        {
                CFont[hzk_id(pf)].file[strlen(pf->CFont.file)-3]+=use_big5;
                pf->CFont.file[strlen(pf->CFont.file)-3]+=use_big5;
        }
 
        return TRUE;
}
 
/* This function get ASCII font info from etc file.*/
static MWBOOL GetAFontInfo( PMWHZKFONT pf )
{
        AFont[hzk_id(pf)].width = pf->afont_width;
        pf->AFont.width = pf->afont_width;
 
        AFont[hzk_id(pf)].height = pf->font_height;
        pf->AFont.height = pf->font_height;
 
        AFont[hzk_id(pf)].size = ((pf->AFont.width + 7) / 8) *
                pf->AFont.height * 255;
        pf->AFont.size = ((pf->AFont.width + 7) / 8) * pf->AFont.height * 255;
 
        if(pf->AFont.size < 255 * 8)
                return FALSE;
 
        strcpy(AFont[hzk_id(pf)].file,HZK_FONT_DIR);
        strcpy(pf->AFont.file,HZK_FONT_DIR);
 
        if(pf->font_height==16)
        {
                strcat(AFont[hzk_id(pf)].file,"/asc16");
                strcat(pf->AFont.file,"/asc16");
        }
        else
        {
                strcat(AFont[hzk_id(pf)].file,"/asc12");
                strcat(pf->AFont.file,"/asc12");
        }
        return TRUE;
}
 
/* This function load system font into memory.*/
static MWBOOL LoadFont( PMWHZKFONT pf )
{
        FILE* fp;
 
        if(!GetCFontInfo(pf))
        {
                fprintf (stderr, "Get Chinese HZK font info failure!\n");
                return FALSE;
        }
        if(CFont[hzk_id(pf)].pFont == NULL)/*check font cache*/
        {
 
 
                /* Allocate system memory for Chinese font.*/
                if( !(CFont[hzk_id(pf)].pFont = (char *)malloc(pf->CFont.size)) )
                {
                        fprintf (stderr, "Allocate memory for Chinese HZK font failure.\n");
                        return FALSE;
                }
 
                /* Open font file and read information to the system memory.*/
                fprintf (stderr, "Loading Chinese HZK font from file(%s)..." ,pf->CFont.file);
                if(!(fp = fopen(CFont[hzk_id(pf)].file, "rb")))
                {
                        fprintf (stderr, "Error.\nThe Chinese HZK font file can not be found!\n");
                        return FALSE;
                }
                if(fread(CFont[hzk_id(pf)].pFont, sizeof(char), pf->CFont.size, fp) < pf->CFont.size)
                {
                        fprintf (stderr, "Error in reading Chinese HZK font file!\n");
                        fclose(fp);
                        return FALSE;
                }
 
                fclose(fp);
 
                CFont[hzk_id(pf)].use_count=0;
 
                fprintf (stderr, "done.\n" );
 
        }
        cfont_address = CFont[hzk_id(pf)].pFont;
        pf->cfont_address = CFont[hzk_id(pf)].pFont;
        pf->CFont.pFont = CFont[hzk_id(pf)].pFont;
 
        CFont[hzk_id(pf)].use_count++;
 
        if(!GetAFontInfo(pf))
        {
               fprintf (stderr, "Get ASCII HZK font info failure!\n");
               return FALSE;
        }
        if(AFont[hzk_id(pf)].pFont == NULL)/*check font cache*/
        {
 
 
                /* Allocate system memory for ASCII font.*/
                if( !(AFont[hzk_id(pf)].pFont = (char *)malloc(pf->AFont.size)) )
                {
                        fprintf (stderr, "Allocate memory for ASCII HZK font failure.\n");
                        free(CFont[hzk_id(pf)].pFont);
                        CFont[hzk_id(pf)].pFont = NULL;
                        return FALSE;
                }
 
                /* Load ASCII font information to the near memory.*/
                fprintf (stderr, "Loading ASCII HZK font..." );
                if(!(fp = fopen(AFont[hzk_id(pf)].file, "rb")))
                {
                        fprintf (stderr, "Error.\nThe ASCII HZK font file can not be found!\n");
                        return FALSE;
                }
                if(fread(AFont[hzk_id(pf)].pFont, sizeof(char), pf->AFont.size, fp) < pf->AFont.size)
                {
                        fprintf (stderr, "Error in reading ASCII HZK font file!\n");
                        fclose(fp);
                        return FALSE;
                }
 
                fclose(fp);
 
                AFont[hzk_id(pf)].use_count=0;
 
                fprintf (stderr, "done.\n" );
 
        }
        afont_address = AFont[hzk_id(pf)].pFont;
        pf->afont_address = AFont[hzk_id(pf)].pFont;
        pf->AFont.pFont = AFont[hzk_id(pf)].pFont;
 
        AFont[hzk_id(pf)].use_count++;
 
        return TRUE;
}
 
/* This function unload system font from memory.*/
static void UnloadFont( PMWHZKFONT pf )
{
        CFont[hzk_id(pf)].use_count--;
        AFont[hzk_id(pf)].use_count--;
 
        if (!CFont[hzk_id(pf)].use_count)
        {
                free(pf->CFont.pFont);
                free(pf->AFont.pFont);
 
                CFont[hzk_id(pf)].pFont = NULL;
                AFont[hzk_id(pf)].pFont = NULL;
        }
}
 
static int
hzk_init(PSD psd)
{
        /* FIXME: *.KU file should be opened and
         * read in here...*/
        return 1;
}
 
static PMWHZKFONT
hzk_createfont(const char *name, MWCOORD height, int attr)
{
        PMWHZKFONT      pf;
 
        if(strcmp(name,"HZKFONT")!=0 && strcmp(name,"HZXFONT")!=0)
                return FALSE;
 
printf("hzk_createfont(%s,%d)\n",name,height);
 
        use_big5=name[2]-'K';
 
        /* allocate font structure*/
        pf = (PMWHZKFONT)calloc(sizeof(MWHZKFONT), 1);
        if (!pf)
                return NULL;
        pf->fontprocs = &hzk_procs;
 
        pf->fontsize=height;
        /*GdSetFontSize((PMWFONT)pf, height);*/
        GdSetFontRotation((PMWFONT)pf, 0);
        GdSetFontAttr((PMWFONT)pf, attr, 0);
 
        if(height==12)
        {
                afont_width = 6;
                cfont_width = 12;
                font_height = 12;
 
                pf->afont_width = 6;
                pf->cfont_width = 12;
                pf->font_height = 12;
        }
        else
        {
                afont_width = 8;
                cfont_width = 16;
                font_height = 16;
 
                pf->afont_width = 8;
                pf->cfont_width = 16;
                pf->font_height = 16;
        }
 
        /* Load the font library to the system memory.*/
        if(!LoadFont(pf))
                return FALSE;
 
        return pf;
}
 
int IsBig5(int i)
{
        if ((i>=0xa140 && i<=0xa3bf) || /* a140-a3bf(!a3e0) */
            (i>=0xa440 && i<=0xc67e) || /* a440-c67e        */
            (i>=0xc6a1 && i<=0xc8d3) || /* c6a1-c8d3(!c8fe) */
            (i>=0xc940 && i<=0xf9fe))   /* c940-f9fe        */
                return 1;
        else
                return 0;
}
 
/*
 * following several function is used in hzk_drawtext
 */
 
static int getnextchar(char* s, unsigned char* cc)
{
        if( s[0] == '\0') return 0;
 
        cc[0] = (unsigned char)(*s);
        cc[1] = (unsigned char)(*(s + 1));
 
        if (use_big5)
        {
                if( IsBig5( (int) ( (cc[0] << 8) + cc[1]) ) )
                        return 1;
        }
        else
        {
                if( ((unsigned char)cc[0] > 0xa0) &&
                    ((unsigned char)cc[1] > 0xa0) )
                        return 1;
        }
 
        cc[1] = '\0';
 
        return 1;
}
 
static void
expandcchar(PMWHZKFONT pf, int bg, int fg, unsigned char* c, MWPIXELVAL* bitmap)
{
        int i=0;
        int c1, c2, seq;
        int x,y;
        unsigned char *font;
        int b = 0;               /* keep gcc happy with b = 0 - MW */
 
        int pixelsize;
        pixelsize=sizeof(MWPIXELVAL);
 
        c1 = c[0];
        c2 = c[1];
        if (use_big5)
        {
                seq=0;
                /*ladd=loby-(if(loby<127)?64:98)*/
                c2-=(c2<127?64:98);
 
                /*hadd=(hiby-164)*157*/
                if (c1>=0xa4)/*standard font*/
                {
                        seq=(((c1-164)*157)+c2);
                        if (seq>=5809) seq-=408;
                }
 
                /*hadd=(hiby-161)*157*/
                if (c1<=0xa3)/*special font*/
                        seq=(((c1-161)*157)+c2)+13094;
        }
        else
                seq=((c1 - 161)*94 + c2 - 161);
 
        font = pf->cfont_address + ((seq) *
                  (pf->font_height * ((pf->cfont_width + 7) / 8)));
 
        for (y = 0; y < pf->font_height; y++)
                for (x = 0; x < pf->cfont_width; x++)
                {
                        if (x % 8 == 0)
                                b = *font++;
 
                        if (b & (128 >> (x % 8)))   /* pixel */
                                bitmap[i++]=fg;
                        else
                                bitmap[i++]=bg;
                }
}
 
static void expandchar(PMWHZKFONT pf, int bg, int fg, int c, MWPIXELVAL* bitmap)
{
        int i=0;
        int x,y;
        unsigned char *font;
        int pixelsize;
        int b = 0;               /* keep gcc happy with b = 0 - MW */
 
        pixelsize=sizeof(MWPIXELVAL);
 
        font = pf->afont_address + c * (pf->font_height *
                ((pf->afont_width + 7) / 8));
 
        for (y = 0; y < pf->font_height; y++)
                for (x = 0; x < pf->afont_width; x++)
                {
                        if (x % 8 == 0)
                                b = *font++;
                        if (b & (128 >> (x % 8)))       /* pixel */
                                bitmap[i++]=fg;
                        else
                                bitmap[i++]=bg;
                }
}
 
/*
 * Draw ASCII text string using HZK type font
 */
static void
hzk_drawtext(PMWFONT pfont, PSD psd, MWCOORD ax, MWCOORD ay,
        const void *text, int cc, int flags)
{
        PMWHZKFONT pf=(PMWHZKFONT)pfont;
 
        unsigned char c[2];
        MWPIXELVAL *bitmap;
        unsigned char s1[3];
        char *s,*sbegin;
 
        s=(char *)text;
 
        if(cc==1)
        {
                s1[0]=*((unsigned char*)text);
                s1[1]=0x0;
                s1[2]=0x0;
                s=s1;
        }
 
        sbegin=s;
        bitmap = (MWPIXELVAL *)ALLOCA(pf->cfont_width * pf->font_height *
                        sizeof(MWPIXELVAL));
 
        while( getnextchar(s, c) )
        {
                if( c[1] != '\0')
                {
                        expandcchar(pf, gr_background,gr_foreground,
                            c, bitmap);
                        /* Now draw the bitmap ... */
 
                        if (flags&MWTF_TOP)
                                GdArea(psd,ax, ay, pf->cfont_width,
                                        pf->font_height, bitmap, MWPF_PIXELVAL);
                        else
                                GdArea(psd,ax, ay-pf->font_height+2,
                                        pf->cfont_width, pf->font_height,
                                        bitmap, MWPF_PIXELVAL);
 
                        s += 2;
                        ax += pf->cfont_width;
                }
                else
                {
                        expandchar(pf, gr_background,gr_foreground,
                           c[0], bitmap);
                        /* Now draw the bitmap ... */
 
                        if (flags&MWTF_TOP)
                                GdArea(psd,ax, ay, pf->afont_width,
                                        pf->font_height, bitmap, MWPF_PIXELVAL);
                        else
                                GdArea(psd,ax, ay-pf->font_height+2,
                                        pf->afont_width, pf->font_height,
                                        bitmap, MWPF_PIXELVAL);
 
                        s += 1;
                        ax += pf->afont_width;
                }
 
                if(s>=sbegin+cc)break;
        }
 
        FREEA(bitmap);
}
 
/*
 * Return information about a specified font.
 */
static MWBOOL
hzk_getfontinfo(PMWFONT pfont, PMWFONTINFO pfontinfo)
{
        PMWHZKFONT pf=(PMWHZKFONT)pfont;
 
        int i;
 
        pfontinfo->height = pf->font_height;
        pfontinfo->maxwidth = pf->cfont_width;
        pfontinfo->baseline = pf->font_height-2;
        pfontinfo->firstchar = 0;
        pfontinfo->lastchar = 0;
        pfontinfo->fixed = TRUE;
 
        for(i=0; i<=256; i++)
                pfontinfo->widths[i] = pf->afont_width;
 
        return TRUE;
}
 
static void
hzk_gettextsize(PMWFONT pfont, const void *text, int cc,
        MWCOORD *pwidth, MWCOORD *pheight, MWCOORD *pbase)
{
        PMWHZKFONT pf=(PMWHZKFONT)pfont;
 
        unsigned char c[2];
        char *s,*sbegin;
        unsigned char s1[3];
 
        int ax=0;
 
 
 
        s=(char *)text;
        if(cc==0)
        {
                *pwidth = 0;
                *pheight = pf->font_height;
                *pbase = pf->font_height-2;
 
        }
        if(cc==1)
        {
                s1[0]=*((unsigned char*)text);
                s1[1]=0x0;
                s1[2]=0x0;
                s=s1;
        }
        sbegin=s;
        while( getnextchar(s, c) )
        {
                if( c[1] != '\0')
                {
                        s += 2;
                        ax += pf->cfont_width;
                }
                else
                {
                        s += 1;
                        ax += pf->afont_width;
                }
                if(s>=sbegin+cc)break;
                /*      fprintf(stderr,"s=%x,sbegin=%x,cc=%x\n",s,sbegin,cc);*/
 
        }
/*      fprintf(stderr,"ax=%d,\n",ax);*/
 
        *pwidth = ax;
        *pheight = pf->font_height;
        *pbase = pf->font_height-2;
}
 
static void
hzk_destroyfont(PMWFONT pfont)
{
        PMWHZKFONT pf=(PMWHZKFONT)pfont;
 
        UnloadFont(pf);
        free(pf);
}
 
static void
hzk_setfontsize(PMWFONT pfont, MWCOORD fontsize)
{
        PMWHZKFONT pf=(PMWHZKFONT)pfont;
 
        /*jmt: hzk_setfontsize not supported*/
        /*jmt: & pf->fontsize can't be changed*/
        /*jmt: because of hzk_id() :p*/
        pf->fontsize=pf->font_height;
}
#endif /* HAVE_HZK_SUPPORT*/
 
/* FIXME: this routine should work for all font renderers...*/
int
GdGetTextSizeEx(PMWFONT pfont, const void *str, int cc,int nMaxExtent,
        int* lpnFit, int* alpDx,MWCOORD *pwidth,MWCOORD *pheight,
        MWCOORD *pbase, int flags)
{
#ifdef HAVE_FREETYPE_SUPPORT
        unsigned short  buf[256];
        unsigned short* text;
        PMWFREETYPEFONT pf = (PMWFREETYPEFONT)pfont;
        int             defencoding = pf->fontprocs->encoding;
        int             x = 0;
        int             i;
        TT_UShort       curchar;
        TT_Glyph_Metrics metrics;
        TT_Face_Properties      properties;
        TT_Instance_Metrics imetrics;
 
        if ((cc<0)||(!str))
        {
                *pwidth = *pheight = *pbase = 0;
                return 0;
        }
        /* convert encoding if required*/
        if((flags & MWTF_PACKMASK) != defencoding)
        {
                cc = GdConvertEncoding(str, flags, cc, buf, defencoding);
                flags &= ~MWTF_PACKMASK;
                flags |= defencoding;
                text=buf;
        } else text =(unsigned short*)str;
        if(cc <= 0)
        {
                *pwidth = *pheight = *pbase = 0;
                return 0;
        }
 
        TT_Get_Face_Properties (pf->face, &properties);
        TT_Get_Instance_Metrics(pf->instance, &imetrics);
 
        pf->last_glyph_code = -1;               /* reset kerning*/
        pf->last_pen_pos = -32767;
        if (lpnFit)
             *lpnFit=-1;
        for (i = 0; i < cc; i++)
        {
                curchar = TT_Char_Index (pf->char_map,text[i]);
 
                if (TT_Load_Glyph (pf->instance, pf->glyph, curchar,
                        TTLOAD_SCALE_GLYPH|TTLOAD_HINT_GLYPH) != TT_Err_Ok)
                {
                     printf("Unable to load glyph with index=%d\n",curchar);
                        return 0;
                }
                TT_Get_Glyph_Metrics (pf->glyph, &metrics);
                if ((pf->fontattr&MWTF_KERNING) && pf->can_kern)
                {
                        x += compute_kernval(pf, curchar) / 64;
                }
                x += metrics.advance / 64;
                if((lpnFit)&&(alpDx))
                {
                        if (x<=nMaxExtent)
                             alpDx[i]=x;
                        else
                             if (*lpnFit==-1)
                                        (*lpnFit)=i;
                }
                /* Kerning point syndrome avoidance */
                if (pf->last_pen_pos > x)
                        x = pf->last_pen_pos;
                pf->last_pen_pos = x;
                pf->last_glyph_code = curchar;
        }
        if ((lpnFit)&&(*lpnFit==-1))
                *lpnFit=cc;
        *pwidth = x;
        *pheight = (((properties.horizontal->Ascender *
                        imetrics.y_scale)/ 0x10000) >> 6) -
                            (((properties.horizontal->Descender *
                            imetrics.y_scale)/ 0x10000) >> 6);
        /*FIXME: is it what's required ??*/
        if (pbase)
                *pbase = (((-properties.horizontal->Descender) *
                            imetrics.y_scale)/ 0x10000) >> 6;
        return 1;
#else /* HAVE_FREETYPE_SUPPORT*/
        *pwidth = *pheight = *pbase = 0;
        return 0;
#endif
}
Browse

Tools

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [packages/] [services/] [gfx/] [mw/] [v2_0/] [src/] [engine/] [devfont.caching.c] - Blame information for rev 174

Line No.	Rev	Author	Line
1	27	unneback	`/*`
2			`* Copyright (c) 2000 Greg Haerr <greg@censoft.com>`
3			`* T1lib Adobe type1 routines contributed by Vidar Hokstad`
4			`* Freetype TrueType routines contributed by Martin Jolicoeur`
5			`* Han Zi Ku routines contributed by Tanghao and Jauming`
6			`*`
7			`* Device-independent font and text drawing routines`
8			`*`
9			`* These routines do the necessary range checking, clipping, and cursor`
10			`* overwriting checks, and then call the lower level device dependent`
11			`* routines to actually do the drawing. The lower level routines are`
12			`* only called when it is known that all the pixels to be drawn are`
13			`* within the device area and are visible.`
14			`*/`
15			`/#define NDEBUG/`
16			`#include <stdio.h>`
17			`#include <stdlib.h>`
18			`#include <string.h>`
19			`#include <assert.h>`
20			`#include <string.h>`
21
22			`#include "device.h"`
23			`#if (UNIX \| DOS_DJGPP)`
24			`#define strcmpi strcasecmp`
25			`#endif`
26
27			`#if HAVE_T1LIB_SUPPORT`
28			`#include <t1lib.h>`
29			`#define T1LIB_USE_AA_HIGH`
30
31			`typedef struct {`
32			`PMWFONTPROCS fontprocs; /* common hdr*/`
33			`MWCOORD fontsize;`
34			`int fontrotation;`
35			`int fontattr;`
36
37			`int fontid; /* t1lib stuff*/`
38			`} MWT1LIBFONT, *PMWT1LIBFONT;`
39
40			`static int t1lib_init(PSD psd);`