[bpt/emacs.git] / src / w32bdf.c

/* Implementation of BDF font handling on the Microsoft W32 API.
   Copyright (C) 1999 Free Software Foundation, Inc.

This file is part of GNU Emacs.

GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING.  If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */

/* Based heavily on code by H. Miyashita for Meadow (a descendant of
   MULE for W32). */

#include <windows.h>
#include "config.h"
#include "lisp.h"
#include "charset.h"
#include "fontset.h"
#include "blockinput.h"
#include "w32gui.h"
#include "w32term.h"
#include "w32bdf.h"

#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))

/* Portion of GDI Objects which the font cache is allowed to use. This
   can be quite high, since the font cache is the only part of Emacs
   that uses a large number of GDI objects, but there should still be
   some GDI objects reserved for other uses.  */
#define CACHE_GDI_ALLOWANCE 9 / 10

void w32_free_bdf_font(bdffont *fontp);
bdffont *w32_init_bdf_font(char *filename);

static int 
search_file_line(char *key, char *start, int len, char **val, char **next)
{
  int linelen;
  unsigned char *p, *q;

  p = memchr(start, '\n', len);
  if (!p) return -1;
  for (;start < p;start++)
    {
      if ((*start != ' ') || (*start != '\t')) break;
    }
  linelen = p - start + 1;
  *next = p + 1;
  if (strncmp(start, key, min(strlen(key), linelen)) == 0)
    {
      *val = start + strlen(key);
      return 1;
    }
  
  return 0;
}

static int
proceed_file_line(char *key, char *start, int *len, char **val, char **next)
{
  int flag = 0;

  do {
    flag = search_file_line(key, start, *len, val, next);
    *len -= (int)(*next - start);
    start = *next;
  }while(flag == 0);

  if (flag == -1) return 0;
  return 1;
}
   
char*
get_quoted_string(char *start, char *end)
{
  char *p, *q, *result;

  p = memchr(start, '\"', end - start);
  q = 0;

  if (!p) return NULL;
  p++;
  q = memchr(p, '\"', end - q);
  if (!q) return NULL;

  result = (char*) xmalloc(q - p + 1);

  memcpy(result, p, q - p);
  result[q - p] = '\0';

  return result;
}

static int
set_bdf_font_info(bdffont *fontp)
{
  unsigned char *start, *p, *q;
  int len, flag;
  int bbw, bbh, bbx, bby;
  int val1;

  len = fontp->size;
  start = fontp->font;

  fontp->yoffset = 0;
  fontp->relative_compose = 0;
  fontp->default_ascent = 0;
  fontp->registry = NULL;
  fontp->encoding = NULL;
  fontp->slant = NULL;
/*  fontp->width = NULL; */

  flag = proceed_file_line("FONTBOUNDINGBOX", start, &len, &p, &q);
  if (!flag) return 0;
  bbw = strtol(p, &start, 10);
  p = start;
  bbh = strtol(p, &start, 10);
  p = start;
  bbx = strtol(p, &start, 10);
  p = start;
  bby = strtol(p, &start, 10);

  fontp->llx = bbx;
  fontp->lly = bby;
  fontp->urx = bbw + bbx;
  fontp->ury = bbh + bby;
  fontp->width = bbw;
  fontp->height = bbh;
  start = q;
  flag = proceed_file_line("STARTPROPERTIES", start, &len, &p, &q);
  if (!flag) return 1;

  flag = 0;

  do {
    start = q;
    if (search_file_line("PIXEL_SIZE", start, len, &p, &q) == 1)
      {
	val1 = atoi(p);
        fontp->pixsz = val1;
      }
    else if (search_file_line("FONT_ASCENT", start, len, &p, &q) == 1)
      {
	val1 = atoi(p);
	fontp->ury = val1;
      }
    else if (search_file_line("FONT_DESCENT", start, len, &p, &q) == 1)
      {
	val1 = atoi(p);
	fontp->lly = -val1;
      }
    else if (search_file_line("_MULE_BASELINE_OFFSET", start, len, &p, &q) == 1)
      {
	val1 = atoi(p);
	fontp->yoffset = val1;
      }
    else if (search_file_line("_MULE_RELATIVE_COMPOSE", start, len, &p, &q) == 1)
      {
	val1 = atoi(p);
	fontp->relative_compose = val1;
      }
    else if (search_file_line("_MULE_DEFAULT_ASCENT", start, len, &p, &q) == 1)
      {
	val1 = atoi(p);
	fontp->default_ascent = val1;
      }
    else if (search_file_line("CHARSET_REGISTRY", start, len, &p, &q) == 1)
      {
        fontp->registry = get_quoted_string(p, q);
      }
    else if (search_file_line("CHARSET_ENCODING", start, len, &p, &q) == 1)
      {
        fontp->encoding = get_quoted_string(p, q);
      }
    else if (search_file_line("SLANT", start, len, &p, &q) == 1)
      {
        fontp->slant = get_quoted_string(p, q);
      }
/*
    else if (search_file_line("SETWIDTH_NAME", start, len, &p, &q) == 1)
      {
        fontp->width = get_quoted_string(p, q);
      }
*/
    else
      {
	flag = search_file_line("ENDPROPERTIES", start, len, &p, &q);
      }
    if (flag == -1) return 0;
    len -= (q - start);
  }while(flag == 0);
  start = q;
  flag = proceed_file_line("CHARS", start, &len, &p, &q);
  if (!flag) return 0;
  fontp->seeked = q;

  return 1;
}

bdffont*
w32_init_bdf_font(char *filename)
{
  HANDLE hfile, hfilemap;
  bdffont *bdffontp;
  unsigned char *font;
  BY_HANDLE_FILE_INFORMATION fileinfo;
  int i;

  hfile = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
		     OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  if (hfile == INVALID_HANDLE_VALUE) return NULL;
  if (!GetFileInformationByHandle(hfile, &fileinfo) ||
      (fileinfo.nFileSizeHigh != 0) ||
      (fileinfo.nFileSizeLow > BDF_FILE_SIZE_MAX))
    {
      CloseHandle(hfile);
      error("Fail to open BDF file.");
    }
  hfilemap = CreateFileMapping(hfile, NULL, PAGE_READONLY, 0, 0, NULL);
  if (hfilemap == INVALID_HANDLE_VALUE)
    {
      CloseHandle(hfile);
      error("Can't map font.");
    }

  font = MapViewOfFile(hfilemap, FILE_MAP_READ, 0, 0, 0);

  if (!font)
    {
      CloseHandle(hfile);
      CloseHandle(hfilemap);
      error("Can't view font.");
    }

  bdffontp = (bdffont *) xmalloc(sizeof(bdffont));
  
  for(i = 0;i < BDF_FIRST_OFFSET_TABLE;i++)
    bdffontp->chtbl[i] = NULL;
  bdffontp->size = fileinfo.nFileSizeLow;
  bdffontp->font = font;
  bdffontp->hfile = hfile;
  bdffontp->hfilemap = hfilemap;
  bdffontp->filename = (char*) xmalloc(strlen(filename) + 1);
  strcpy(bdffontp->filename, filename);
  
  if (!set_bdf_font_info(bdffontp))
    {
      w32_free_bdf_font(bdffontp);
      error("Invalid BDF font!");
    }
  return bdffontp;
}

void
w32_free_bdf_font(bdffont *fontp)
{
  int i, j;
  font_char *pch;
  cache_bitmap *pcb;

  UnmapViewOfFile(fontp->hfilemap);
  CloseHandle(fontp->hfilemap);
  CloseHandle(fontp->hfile);

  if (fontp->registry) xfree(fontp->registry);
  if (fontp->encoding) xfree(fontp->encoding);
  if (fontp->slant) xfree(fontp->slant);
/*  if (fontp->width) xfree(fontp->width); */

  xfree(fontp->filename);
  for(i = 0;i < BDF_FIRST_OFFSET_TABLE;i++)
    {
      pch = fontp->chtbl[i];
      if (pch)
	{
	  for (j = 0;j < BDF_SECOND_OFFSET_TABLE;j++)
	    {
	      pcb = pch[j].pcbmp;
	      if (pcb) pcb->psrc = NULL;
	    }
	  xfree(pch);
        }
    }
  xfree(fontp);
}

static font_char*
get_cached_font_char(bdffont *fontp, int index)
{
  font_char *pch, *result;
  int i;

  if (index > 0xffff)
    return NULL;

  pch = fontp->chtbl[BDF_FIRST_OFFSET(index)];
  if (!pch)
    return NULL;
  result = &pch[BDF_SECOND_OFFSET(index)];

  if (!result->offset) return NULL;

  return result;
}

static font_char*
cache_char_offset(bdffont *fontp, int index, unsigned char *offset)
{
  font_char *pch, *result;
  int i;

  if (index > 0xffff)
    return NULL;

  pch = fontp->chtbl[BDF_FIRST_OFFSET(index)];
  if (!pch)
    {
      pch = fontp->chtbl[BDF_FIRST_OFFSET(index)] =
	(font_char*) xmalloc(sizeof(font_char) *
				   BDF_SECOND_OFFSET_TABLE);
      memset(pch, 0, sizeof(font_char) * BDF_SECOND_OFFSET_TABLE);
    }

  result = &pch[BDF_SECOND_OFFSET(index)];
  result->offset = offset;

  return result;
}

static font_char*
seek_char(bdffont *fontp, int index)
{
  font_char *result;
  int len, flag, font_index;
  unsigned char *start, *p, *q;

  if (!fontp->seeked) return NULL;

  start = fontp->seeked;
  len = fontp->size - (start - fontp->font);

  do {
    flag = proceed_file_line("ENCODING", start, &len, &p, &q);
    if (!flag)
      {
	fontp->seeked = NULL;
	return NULL;
      }
    font_index = atoi(p);
    result = cache_char_offset(fontp, font_index, q);
    if (!result) return NULL;

    start = result->offset;
  } while (font_index != index);
  fontp->seeked = start;

  return result;
}

#define GET_HEX_VAL(x) ((isdigit(x)) ? ((x) - '0') : \
			(((x) >= 'A') && ((x) <= 'Z')) ? ((x) - 'A' + 10) : \
			(((x) >= 'a') && ((x) <= 'z')) ? ((x) - 'a' + 10) : \
			(-1))

int
w32_get_bdf_glyph(bdffont *fontp, int index, int size, glyph_struct *glyph)
{
  font_char *pch;
  unsigned char *start, *p, *q, *bitmapp;
  unsigned char val1, val2;
  int i, j, len, flag;

  pch = get_cached_font_char(fontp, index);
  if (!pch)
    {
      pch = seek_char(fontp, index);
      if (!pch)
        return 0;
    }

  start = pch->offset;

  if ((size == 0) && pch->pcbmp)
    {
      glyph->metric = pch->pcbmp->metric;
      return 1;
    }

  len = fontp->size - (start - fontp->font);

  flag = proceed_file_line("DWIDTH", start, &len, &p, &q);
  if (!flag)
    return 0;
  glyph->metric.dwidth = atoi(p);

  start = q;
  flag = proceed_file_line("BBX", start, &len, &p, &q);
  if (!flag)
    return 0;
  glyph->metric.bbw = strtol(p, &start, 10);
  p = start;
  glyph->metric.bbh = strtol(p, &start, 10);
  p = start;
  glyph->metric.bbox = strtol(p, &start, 10);
  p = start;
  glyph->metric.bboy = strtol(p, &start, 10);

  if (size == 0) return 1;

  start = q;
  flag = proceed_file_line("BITMAP", start, &len, &p, &q);
  if (!flag)
    return 0;

  p = q;
  bitmapp = glyph->bitmap;
  for(i = 0;i < glyph->metric.bbh;i++)
    {
      q = memchr(p, '\n', len);
      if (!q) return 0;
      for(j = 0;((q > p) && (j < ((glyph->metric.bbw + 7) / 8 )));j++)
	{
	  val1 = GET_HEX_VAL(*p);
	  if (val1 == -1) return 0;
	  p++;
	  val2 = GET_HEX_VAL(*p);
	  if (val2 == -1) return 0;
	  p++;
	  size--;
	  if (size <= 0) return 0;
	  /* NAND Operation.  */
	  *bitmapp++ = (unsigned char)~((val1 << 4) | val2);
	}
      /* CreateBitmap requires WORD alignment.  */
      if (j % 2)
	{
	  *bitmapp++ = 0xff;
	}
      p = q + 1;
    }

  return 1;
}

#define NEXT_CACHE_SLOT(n) (((n) + 1 >= BDF_FONT_CACHE_SIZE) ? 0 : ((n) + 1))

static
cache_bitmap*
get_bitmap_with_cache(bdffont *fontp, int index)
{
  int bitmap_size;
  font_char *pch;
  cache_bitmap* pcb;
  HBITMAP hbmp;
  glyph_struct glyph;
  static cache_bitmap cached_bitmap_slots[BDF_FONT_CACHE_SIZE];
  static int cache_in_slot = 0;		/* the next slot to use */
  static int cache_out_slot = 0;	/* the last slot allocated */
  static int cache_occupancy = 0;	/* current cache occupancy */
  static int cache_limit = BDF_FONT_CACHE_SIZE; /* allowed maximum occupancy */

  pch = get_cached_font_char(fontp, index);
  if (pch)
    {
      pcb = pch->pcbmp;
      if (pcb) return pcb;
    }

  bitmap_size = ((fontp->urx - fontp->llx) / 8 + 2) * (fontp->ury - fontp->lly)
    + 256;
  glyph.bitmap = (unsigned char*) alloca(sizeof(unsigned char) * bitmap_size);

  if (!w32_get_bdf_glyph(fontp, index, bitmap_size, &glyph))
    return NULL;

  pch = get_cached_font_char(fontp, index);
  if (!pch) return NULL;

  hbmp = CreateBitmap(glyph.metric.bbw, glyph.metric.bbh, 1, 1, glyph.bitmap);

  /* if bitmap allocation fails reduce the limit of the occupancy so
     that we can hope it will not happen again.  */
  if (hbmp == NULL)
    cache_limit = cache_occupancy * CACHE_GDI_ALLOWANCE;

  /* if cache occupancy reaches at the limit release some cache slots */
  if (cache_occupancy >= cache_limit)
    {
      register int size_to_clear = cache_limit * BDF_FONT_CLEAR_SIZE
                                   / BDF_FONT_CACHE_SIZE;
      for (; size_to_clear; size_to_clear--,
                            cache_out_slot = NEXT_CACHE_SLOT(cache_out_slot))
        {
          register cache_bitmap *p = &cached_bitmap_slots[cache_out_slot];
          if (p->psrc)
            {
              DeleteObject(p->hbmp);
              p->psrc->pcbmp = NULL;
              p->psrc = NULL;
              cache_occupancy--;
            }
        }
    }

  if (hbmp == NULL)
    hbmp = CreateBitmap (glyph.metric.bbw, glyph.metric.bbh,
                         1, 1, glyph.bitmap);

  pcb = &cached_bitmap_slots[cache_in_slot];

  pcb->psrc = pch;
  pcb->metric = glyph.metric;
  pcb->hbmp = hbmp;

  pch->pcbmp = pcb;
  
  cache_in_slot = NEXT_CACHE_SLOT(cache_in_slot);
  cache_occupancy++;

  return pcb;
}

int
w32_BDF_TextOut(bdffont *fontp, HDC hdc, int left,
		 int top, unsigned char *text, int dim, int bytelen,
		 int fixed_pitch_size)
{
  int index, btop;
  unsigned char *textp;
  HDC hCompatDC = 0;
  cache_bitmap *pcb;
  HBITMAP hBMP;
  HBRUSH hFgBrush, hOrgBrush;
  HANDLE horgobj = 0;
  UINT textalign;
  int flag = 0;

  hCompatDC = CreateCompatibleDC(hdc);

  textalign = GetTextAlign(hdc);
  
  SaveDC(hdc);

  hFgBrush = CreateSolidBrush(GetTextColor(hdc));
  hOrgBrush = SelectObject(hdc, hFgBrush);
  SetTextColor(hdc, RGB(0, 0, 0));
  SetBkColor(hdc, RGB(0xff, 0xff, 0xff));

  textp = text;
  while(bytelen > 0)
    {
      if (dim == 1)
	{
	  index = *textp++;
	  bytelen--;
	}
      else
	{
	  bytelen -= 2;
	  if (bytelen < 0) break;
	  index = MAKELENDSHORT(textp[1], textp[0]);
	  textp += 2;
	}
      pcb = get_bitmap_with_cache(fontp, index);
      if (!pcb)
	{
	  if (horgobj)
	    {
	      SelectObject(hCompatDC, horgobj);
	      DeleteObject(hBMP);
	    }
	  DeleteDC(hCompatDC);
	  return 0;
	}
      hBMP = pcb->hbmp;

      if (textalign & TA_BASELINE)
	  btop = top - (pcb->metric.bbh + pcb->metric.bboy);
      else if (textalign & TA_BOTTOM)
	  btop = top - pcb->metric.bbh;
      else
	  btop = top;

      if (horgobj)
	  SelectObject(hCompatDC, hBMP);
      else
	  horgobj = SelectObject(hCompatDC, hBMP);
#if 0
      BitBlt(hdc, left, btop, pcb->metric.bbw, pcb->metric.bbh, hCompatDC, 0, 0, SRCCOPY);
#else
      BitBlt(hdc, left, btop, pcb->metric.bbw, pcb->metric.bbh, hCompatDC, 0, 0, 0xB8074A);
#endif
      if (fixed_pitch_size)
	left += fixed_pitch_size;
      else
	left += pcb->metric.dwidth;
    }
  SelectObject(hCompatDC, horgobj);
  SelectObject(hdc, hOrgBrush);
  DeleteObject(hFgBrush);
  DeleteDC(hCompatDC);
  RestoreDC(hdc, -1);

  return 1;
}

struct font_info *w32_load_bdf_font (struct frame *f, char *fontname,
                                     int size, char* filename)
{
  struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
  struct font_info *fontp;
  XFontStruct *font;
  bdffont* bdf_font;

  bdf_font = w32_init_bdf_font (filename);

  if (!bdf_font) return NULL;

  font = (XFontStruct *) xmalloc (sizeof (XFontStruct));

  font->bdf = bdf_font;
  font->hfont = 0;

  /* Do we need to create the table?  */
  if (dpyinfo->font_table_size == 0)
    {
      dpyinfo->font_table_size = 16;
      dpyinfo->font_table
        = (struct font_info *) xmalloc (dpyinfo->font_table_size
                                        * sizeof (struct font_info));
    }
  /* Do we need to grow the table?  */
  else if (dpyinfo->n_fonts
           >= dpyinfo->font_table_size)
    {
      dpyinfo->font_table_size *= 2;
      dpyinfo->font_table
        = (struct font_info *) xrealloc (dpyinfo->font_table,
                                         (dpyinfo->font_table_size
                                          * sizeof (struct font_info)));
    }

  fontp = dpyinfo->font_table + dpyinfo->n_fonts;

  /* Now fill in the slots of *FONTP.  */
  BLOCK_INPUT;
  fontp->font = font;
  fontp->font_idx = dpyinfo->n_fonts;
  fontp->name = (char *) xmalloc (strlen (fontname) + 1);
  bcopy (fontname, fontp->name, strlen (fontname) + 1);
  fontp->full_name = fontp->name;
  fontp->size = FONT_WIDTH (font);
  fontp->height = FONT_HEIGHT (font);

    /* The slot `encoding' specifies how to map a character
       code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
       the font code-points (0:0x20..0x7F, 1:0xA0..0xFF, 0:0x2020..0x7F7F,
       the font code-points (0:0x20..0x7F, 1:0xA0..0xFF,
       0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF, or
       2:0xA020..0xFF7F).  For the moment, we don't know which charset
       uses this font.  So, we set informatoin in fontp->encoding[1]
       which is never used by any charset.  If mapping can't be
       decided, set FONT_ENCODING_NOT_DECIDED.  */
    fontp->encoding[1] = FONT_ENCODING_NOT_DECIDED;
    fontp->baseline_offset = bdf_font->yoffset;
    fontp->relative_compose = bdf_font->relative_compose;
    fontp->default_ascent = bdf_font->default_ascent;

    UNBLOCK_INPUT;
    dpyinfo->n_fonts++;
    return fontp;
}

/* Check a file for an XFLD string describing it.  */
int w32_BDF_to_x_font (char *file, char* xstr, int len)
{
  HANDLE hfile, hfilemap;
  BY_HANDLE_FILE_INFORMATION fileinfo;
  unsigned char *font, *start, *p, *q;
  int flag, size, retval = 0;

  hfile = CreateFile (file, GENERIC_READ, FILE_SHARE_READ, NULL,
                      OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  if (hfile == INVALID_HANDLE_VALUE) return 0;
  if (!GetFileInformationByHandle(hfile, &fileinfo) ||
      (fileinfo.nFileSizeHigh != 0) ||
      (fileinfo.nFileSizeLow > BDF_FILE_SIZE_MAX))
    {
      CloseHandle (hfile);
      return 0;
    }
  size = fileinfo.nFileSizeLow;

  hfilemap = CreateFileMapping (hfile, NULL, PAGE_READONLY, 0, 0, NULL);
  if (hfilemap == INVALID_HANDLE_VALUE)
    {
      CloseHandle (hfile);
      return 0;
    }

  font = MapViewOfFile (hfilemap, FILE_MAP_READ, 0, 0, 0);
  if (!font)
    {
      CloseHandle (hfile);
      CloseHandle (hfilemap);
      return 0;
    }
  start = font;

  flag = proceed_file_line ("FONT ", start, &size, &p, &q);
  if (flag)
    {
      /* If font provides a description of itself, check it is a
         full XLFD before accepting it.  */
      int count = 0;
      char *s;

      for (s = p; s < q; s++)
        if (*s == '\n')
          break;
        else if (*s == '-')
          count++;
      if (count == 14 && q - p - 1 <= len)
        {
          strncpy (xstr, p, q-p-1);
          xstr[q-p-1] = '\0';
          /* Files may have DOS line ends (ie still ^M on end).  */
          if (iscntrl(xstr[q-p-2]))
            xstr[q-p-2] = '\0';

          retval = 1;
        }
    }
  CloseHandle (hfile);
  CloseHandle (hfilemap);
  return retval;
}
Commit	Line	Data
7b416d42 GV	1	/* Implementation of BDF font handling on the Microsoft W32 API.
	2	Copyright (C) 1999 Free Software Foundation, Inc.
	3
	4	This file is part of GNU Emacs.
	5
	6	GNU Emacs is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2, or (at your option)
	9	any later version.
	10
	11	GNU Emacs is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GNU Emacs; see the file COPYING. If not, write to
	18	the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	19	Boston, MA 02111-1307, USA. */
	20
	21	/* Based heavily on code by H. Miyashita for Meadow (a descendant of
	22	MULE for W32). */
	23
	24	#include <windows.h>
	25	#include "config.h"
	26	#include "lisp.h"
	27	#include "charset.h"
	28	#include "fontset.h"
	29	#include "blockinput.h"
	30	#include "w32gui.h"
	31	#include "w32term.h"
	32	#include "w32bdf.h"
	33
	34	#define min(a, b) ((a) < (b) ? (a) : (b))
	35	#define max(a, b) ((a) > (b) ? (a) : (b))
	36
9c332a80 JR	37	/* Portion of GDI Objects which the font cache is allowed to use. This
	38	can be quite high, since the font cache is the only part of Emacs
	39	that uses a large number of GDI objects, but there should still be
	40	some GDI objects reserved for other uses. */
	41	#define CACHE_GDI_ALLOWANCE 9 / 10
	42
7b416d42 GV	43	void w32_free_bdf_font(bdffont *fontp);
	44	bdffont w32_init_bdf_font(char filename);
	45
	46	static int
	47	search_file_line(char key, char start, int len, char val, char next)
	48	{
	49	int linelen;
	50	unsigned char p, q;
	51
	52	p = memchr(start, '\n', len);
	53	if (!p) return -1;
	54	for (;start < p;start++)
	55	{
	56	if ((start != ' ') \|\| (start != '\t')) break;
	57	}
	58	linelen = p - start + 1;
	59	*next = p + 1;
	60	if (strncmp(start, key, min(strlen(key), linelen)) == 0)
	61	{
	62	*val = start + strlen(key);
	63	return 1;
	64	}
	65
	66	return 0;
	67	}
	68
	69	static int
	70	proceed_file_line(char key, char start, int len, char val, char *next)
	71	{
	72	int flag = 0;
	73
	74	do {
	75	flag = search_file_line(key, start, *len, val, next);
	76	len -= (int)(next - start);
	77	start = *next;
	78	}while(flag == 0);
	79
	80	if (flag == -1) return 0;
	81	return 1;
	82	}
	83
865203c3 GV	84	char*
	85	get_quoted_string(char start, char end)
	86	{
	87	char p, q, *result;
	88
	89	p = memchr(start, '\"', end - start);
	90	q = 0;
	91
	92	if (!p) return NULL;
	93	p++;
	94	q = memchr(p, '\"', end - q);
	95	if (!q) return NULL;
	96
	97	result = (char*) xmalloc(q - p + 1);
	98
	99	memcpy(result, p, q - p);
	100	result[q - p] = '\0';
	101
	102	return result;
	103	}
	104
7b416d42 GV	105	static int
	106	set_bdf_font_info(bdffont *fontp)
	107	{
	108	unsigned char start, p, *q;
	109	int len, flag;
	110	int bbw, bbh, bbx, bby;
	111	int val1;
	112
	113	len = fontp->size;
	114	start = fontp->font;
	115
	116	fontp->yoffset = 0;
	117	fontp->relative_compose = 0;
	118	fontp->default_ascent = 0;
865203c3 GV	119	fontp->registry = NULL;
	120	fontp->encoding = NULL;
	121	fontp->slant = NULL;
	122	/* fontp->width = NULL; */
7b416d42 GV	123
	124	flag = proceed_file_line("FONTBOUNDINGBOX", start, &len, &p, &q);
	125	if (!flag) return 0;
	126	bbw = strtol(p, &start, 10);
	127	p = start;
	128	bbh = strtol(p, &start, 10);
	129	p = start;
	130	bbx = strtol(p, &start, 10);
	131	p = start;
	132	bby = strtol(p, &start, 10);
	133
	134	fontp->llx = bbx;
	135	fontp->lly = bby;
	136	fontp->urx = bbw + bbx;
	137	fontp->ury = bbh + bby;
	138	fontp->width = bbw;
	139	fontp->height = bbh;
	140	start = q;
	141	flag = proceed_file_line("STARTPROPERTIES", start, &len, &p, &q);
	142	if (!flag) return 1;
	143
865203c3 GV	144	flag = 0;
865203c3 GV	145
7b416d42 GV	146	do {
	147	start = q;
	148	if (search_file_line("PIXEL_SIZE", start, len, &p, &q) == 1)
	149	{
	150	val1 = atoi(p);
	151	fontp->pixsz = val1;
	152	}
	153	else if (search_file_line("FONT_ASCENT", start, len, &p, &q) == 1)
	154	{
	155	val1 = atoi(p);
	156	fontp->ury = val1;
	157	}
	158	else if (search_file_line("FONT_DESCENT", start, len, &p, &q) == 1)
	159	{
	160	val1 = atoi(p);
	161	fontp->lly = -val1;
	162	}
	163	else if (search_file_line("_MULE_BASELINE_OFFSET", start, len, &p, &q) == 1)
	164	{
	165	val1 = atoi(p);
	166	fontp->yoffset = val1;
	167	}
	168	else if (search_file_line("_MULE_RELATIVE_COMPOSE", start, len, &p, &q) == 1)
	169	{
	170	val1 = atoi(p);
	171	fontp->relative_compose = val1;
	172	}
	173	else if (search_file_line("_MULE_DEFAULT_ASCENT", start, len, &p, &q) == 1)
	174	{
	175	val1 = atoi(p);
	176	fontp->default_ascent = val1;
	177	}
865203c3 GV	178	else if (search_file_line("CHARSET_REGISTRY", start, len, &p, &q) == 1)
	179	{
	180	fontp->registry = get_quoted_string(p, q);
	181	}
	182	else if (search_file_line("CHARSET_ENCODING", start, len, &p, &q) == 1)
	183	{
	184	fontp->encoding = get_quoted_string(p, q);
	185	}
	186	else if (search_file_line("SLANT", start, len, &p, &q) == 1)
	187	{
	188	fontp->slant = get_quoted_string(p, q);
	189	}
	190	/*
	191	else if (search_file_line("SETWIDTH_NAME", start, len, &p, &q) == 1)
	192	{
	193	fontp->width = get_quoted_string(p, q);
	194	}
	195	*/
7b416d42 GV	196	else
	197	{
	198	flag = search_file_line("ENDPROPERTIES", start, len, &p, &q);
	199	}
	200	if (flag == -1) return 0;
	201	len -= (q - start);
	202	}while(flag == 0);
	203	start = q;
	204	flag = proceed_file_line("CHARS", start, &len, &p, &q);
	205	if (!flag) return 0;
	206	fontp->seeked = q;
	207
	208	return 1;
	209	}
	210
	211	bdffont*
	212	w32_init_bdf_font(char *filename)
	213	{
	214	HANDLE hfile, hfilemap;
	215	bdffont *bdffontp;
	216	unsigned char *font;
	217	BY_HANDLE_FILE_INFORMATION fileinfo;
	218	int i;
	219
	220	hfile = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
	221	OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	222	if (hfile == INVALID_HANDLE_VALUE) return NULL;
	223	if (!GetFileInformationByHandle(hfile, &fileinfo) \|\|
	224	(fileinfo.nFileSizeHigh != 0) \|\|
	225	(fileinfo.nFileSizeLow > BDF_FILE_SIZE_MAX))
	226	{
	227	CloseHandle(hfile);
	228	error("Fail to open BDF file.");
	229	}
	230	hfilemap = CreateFileMapping(hfile, NULL, PAGE_READONLY, 0, 0, NULL);
	231	if (hfilemap == INVALID_HANDLE_VALUE)
	232	{
	233	CloseHandle(hfile);
	234	error("Can't map font.");
	235	}
	236
	237	font = MapViewOfFile(hfilemap, FILE_MAP_READ, 0, 0, 0);
	238
	239	if (!font)
	240	{
	241	CloseHandle(hfile);
	242	CloseHandle(hfilemap);
	243	error("Can't view font.");
	244	}
	245
	246	bdffontp = (bdffont *) xmalloc(sizeof(bdffont));
	247
	248	for(i = 0;i < BDF_FIRST_OFFSET_TABLE;i++)
865203c3	249	bdffontp->chtbl[i] = NULL;
7b416d42 GV	250	bdffontp->size = fileinfo.nFileSizeLow;
	251	bdffontp->font = font;
	252	bdffontp->hfile = hfile;
	253	bdffontp->hfilemap = hfilemap;
	254	bdffontp->filename = (char*) xmalloc(strlen(filename) + 1);
	255	strcpy(bdffontp->filename, filename);
	256
	257	if (!set_bdf_font_info(bdffontp))
	258	{
	259	w32_free_bdf_font(bdffontp);
	260	error("Invalid BDF font!");
	261	}
	262	return bdffontp;
	263	}
	264
	265	void
	266	w32_free_bdf_font(bdffont *fontp)
	267	{
865203c3 GV	268	int i, j;
	269	font_char *pch;
	270	cache_bitmap *pcb;
7b416d42 GV	271
	272	UnmapViewOfFile(fontp->hfilemap);
	273	CloseHandle(fontp->hfilemap);
	274	CloseHandle(fontp->hfile);
865203c3 GV	275
	276	if (fontp->registry) xfree(fontp->registry);
	277	if (fontp->encoding) xfree(fontp->encoding);
	278	if (fontp->slant) xfree(fontp->slant);
	279	/* if (fontp->width) xfree(fontp->width); */
	280
7b416d42 GV	281	xfree(fontp->filename);
	282	for(i = 0;i < BDF_FIRST_OFFSET_TABLE;i++)
	283	{
865203c3 GV	284	pch = fontp->chtbl[i];
	285	if (pch)
	286	{
	287	for (j = 0;j < BDF_SECOND_OFFSET_TABLE;j++)
	288	{
	289	pcb = pch[j].pcbmp;
	290	if (pcb) pcb->psrc = NULL;
	291	}
	292	xfree(pch);
	293	}
7b416d42 GV	294	}
	295	xfree(fontp);
	296	}
	297
865203c3 GV	298	static font_char*
865203c3 GV	299	get_cached_font_char(bdffont *fontp, int index)
7b416d42	300	{
865203c3	301	font_char pch, result;
7b416d42 GV	302	int i;
	303
	304	if (index > 0xffff)
	305	return NULL;
	306
865203c3 GV	307	pch = fontp->chtbl[BDF_FIRST_OFFSET(index)];
865203c3 GV	308	if (!pch)
7b416d42	309	return NULL;
865203c3	310	result = &pch[BDF_SECOND_OFFSET(index)];
7b416d42	311
865203c3	312	if (!result->offset) return NULL;
7b416d42	313
865203c3	314	return result;
7b416d42 GV	315	}
7b416d42 GV	316
865203c3	317	static font_char*
7b416d42 GV	318	cache_char_offset(bdffont fontp, int index, unsigned char offset)
7b416d42 GV	319	{
865203c3	320	font_char pch, result;
7b416d42 GV	321	int i;
	322
	323	if (index > 0xffff)
865203c3	324	return NULL;
7b416d42	325
865203c3 GV	326	pch = fontp->chtbl[BDF_FIRST_OFFSET(index)];
865203c3 GV	327	if (!pch)
7b416d42	328	{
865203c3 GV	329	pch = fontp->chtbl[BDF_FIRST_OFFSET(index)] =
865203c3 GV	330	(font_char) xmalloc(sizeof(font_char)
7b416d42	331	BDF_SECOND_OFFSET_TABLE);
865203c3	332	memset(pch, 0, sizeof(font_char) * BDF_SECOND_OFFSET_TABLE);
7b416d42	333	}
7b416d42	334
865203c3 GV	335	result = &pch[BDF_SECOND_OFFSET(index)];
	336	result->offset = offset;
	337
	338	return result;
7b416d42 GV	339	}
7b416d42 GV	340
865203c3 GV	341	static font_char*
865203c3 GV	342	seek_char(bdffont *fontp, int index)
7b416d42	343	{
865203c3	344	font_char *result;
7b416d42 GV	345	int len, flag, font_index;
	346	unsigned char start, p, *q;
	347
	348	if (!fontp->seeked) return NULL;
	349
	350	start = fontp->seeked;
	351	len = fontp->size - (start - fontp->font);
	352
	353	do {
	354	flag = proceed_file_line("ENCODING", start, &len, &p, &q);
	355	if (!flag)
	356	{
	357	fontp->seeked = NULL;
	358	return NULL;
	359	}
	360	font_index = atoi(p);
865203c3 GV	361	result = cache_char_offset(fontp, font_index, q);
	362	if (!result) return NULL;
	363
	364	start = result->offset;
7b416d42	365	} while (font_index != index);
865203c3	366	fontp->seeked = start;
7b416d42	367
865203c3 GV	368	return result;
	369	}
	370
7b416d42 GV	371	#define GET_HEX_VAL(x) ((isdigit(x)) ? ((x) - '0') : \
	372	(((x) >= 'A') && ((x) <= 'Z')) ? ((x) - 'A' + 10) : \
	373	(((x) >= 'a') && ((x) <= 'z')) ? ((x) - 'a' + 10) : \
	374	(-1))
	375
	376	int
	377	w32_get_bdf_glyph(bdffont fontp, int index, int size, glyph_struct glyph)
	378	{
865203c3	379	font_char *pch;
7b416d42 GV	380	unsigned char start, p, q, bitmapp;
	381	unsigned char val1, val2;
	382	int i, j, len, flag;
	383
865203c3 GV	384	pch = get_cached_font_char(fontp, index);
	385	if (!pch)
	386	{
	387	pch = seek_char(fontp, index);
	388	if (!pch)
	389	return 0;
	390	}
	391
	392	start = pch->offset;
	393
	394	if ((size == 0) && pch->pcbmp)
	395	{
	396	glyph->metric = pch->pcbmp->metric;
	397	return 1;
	398	}
7b416d42 GV	399
	400	len = fontp->size - (start - fontp->font);
	401
	402	flag = proceed_file_line("DWIDTH", start, &len, &p, &q);
	403	if (!flag)
	404	return 0;
865203c3	405	glyph->metric.dwidth = atoi(p);
7b416d42 GV	406
	407	start = q;
	408	flag = proceed_file_line("BBX", start, &len, &p, &q);
	409	if (!flag)
	410	return 0;
865203c3	411	glyph->metric.bbw = strtol(p, &start, 10);
7b416d42	412	p = start;
865203c3	413	glyph->metric.bbh = strtol(p, &start, 10);
7b416d42	414	p = start;
865203c3	415	glyph->metric.bbox = strtol(p, &start, 10);
7b416d42	416	p = start;
865203c3	417	glyph->metric.bboy = strtol(p, &start, 10);
7b416d42 GV	418
	419	if (size == 0) return 1;
	420
	421	start = q;
	422	flag = proceed_file_line("BITMAP", start, &len, &p, &q);
	423	if (!flag)
	424	return 0;
	425
	426	p = q;
	427	bitmapp = glyph->bitmap;
865203c3	428	for(i = 0;i < glyph->metric.bbh;i++)
7b416d42 GV	429	{
	430	q = memchr(p, '\n', len);
	431	if (!q) return 0;
865203c3	432	for(j = 0;((q > p) && (j < ((glyph->metric.bbw + 7) / 8 )));j++)
7b416d42 GV	433	{
	434	val1 = GET_HEX_VAL(*p);
	435	if (val1 == -1) return 0;
	436	p++;
	437	val2 = GET_HEX_VAL(*p);
	438	if (val2 == -1) return 0;
	439	p++;
	440	size--;
	441	if (size <= 0) return 0;
	442	/* NAND Operation. */
	443	*bitmapp++ = (unsigned char)~((val1 << 4) \| val2);
	444	}
	445	/* CreateBitmap requires WORD alignment. */
	446	if (j % 2)
	447	{
	448	*bitmapp++ = 0xff;
	449	}
	450	p = q + 1;
	451	}
	452
	453	return 1;
	454	}
	455
9c332a80 JR	456	#define NEXT_CACHE_SLOT(n) (((n) + 1 >= BDF_FONT_CACHE_SIZE) ? 0 : ((n) + 1))
9c332a80 JR	457
865203c3 GV	458	static
	459	cache_bitmap*
	460	get_bitmap_with_cache(bdffont *fontp, int index)
	461	{
	462	int bitmap_size;
	463	font_char *pch;
	464	cache_bitmap* pcb;
	465	HBITMAP hbmp;
	466	glyph_struct glyph;
9c332a80 JR	467	static cache_bitmap cached_bitmap_slots[BDF_FONT_CACHE_SIZE];
	468	static int cache_in_slot = 0; /* the next slot to use */
	469	static int cache_out_slot = 0; /* the last slot allocated */
	470	static int cache_occupancy = 0; /* current cache occupancy */
	471	static int cache_limit = BDF_FONT_CACHE_SIZE; /* allowed maximum occupancy */
865203c3 GV	472
	473	pch = get_cached_font_char(fontp, index);
	474	if (pch)
	475	{
	476	pcb = pch->pcbmp;
	477	if (pcb) return pcb;
	478	}
	479
	480	bitmap_size = ((fontp->urx - fontp->llx) / 8 + 2) * (fontp->ury - fontp->lly)
	481	+ 256;
	482	glyph.bitmap = (unsigned char) alloca(sizeof(unsigned char) bitmap_size);
	483
	484	if (!w32_get_bdf_glyph(fontp, index, bitmap_size, &glyph))
	485	return NULL;
	486
	487	pch = get_cached_font_char(fontp, index);
	488	if (!pch) return NULL;
	489
	490	hbmp = CreateBitmap(glyph.metric.bbw, glyph.metric.bbh, 1, 1, glyph.bitmap);
	491
9c332a80 JR	492	/* if bitmap allocation fails reduce the limit of the occupancy so
	493	that we can hope it will not happen again. */
	494	if (hbmp == NULL)
	495	cache_limit = cache_occupancy * CACHE_GDI_ALLOWANCE;
	496
	497	/* if cache occupancy reaches at the limit release some cache slots */
	498	if (cache_occupancy >= cache_limit)
	499	{
	500	register int size_to_clear = cache_limit * BDF_FONT_CLEAR_SIZE
	501	/ BDF_FONT_CACHE_SIZE;
	502	for (; size_to_clear; size_to_clear--,
	503	cache_out_slot = NEXT_CACHE_SLOT(cache_out_slot))
	504	{
	505	register cache_bitmap *p = &cached_bitmap_slots[cache_out_slot];
	506	if (p->psrc)
	507	{
	508	DeleteObject(p->hbmp);
	509	p->psrc->pcbmp = NULL;
	510	p->psrc = NULL;
	511	cache_occupancy--;
	512	}
	513	}
	514	}
	515
	516	if (hbmp == NULL)
	517	hbmp = CreateBitmap (glyph.metric.bbw, glyph.metric.bbh,
	518	1, 1, glyph.bitmap);
	519
	520	pcb = &cached_bitmap_slots[cache_in_slot];
865203c3 GV	521
	522	pcb->psrc = pch;
	523	pcb->metric = glyph.metric;
	524	pcb->hbmp = hbmp;
	525
	526	pch->pcbmp = pcb;
	527
9c332a80 JR	528	cache_in_slot = NEXT_CACHE_SLOT(cache_in_slot);
9c332a80 JR	529	cache_occupancy++;
865203c3 GV	530
	531	return pcb;
	532	}
	533
7b416d42 GV	534	int
	535	w32_BDF_TextOut(bdffont *fontp, HDC hdc, int left,
	536	int top, unsigned char *text, int dim, int bytelen,
	537	int fixed_pitch_size)
	538	{
865203c3	539	int index, btop;
7b416d42	540	unsigned char *textp;
7b416d42	541	HDC hCompatDC = 0;
865203c3	542	cache_bitmap *pcb;
7b416d42 GV	543	HBITMAP hBMP;
7b416d42 GV	544	HBRUSH hFgBrush, hOrgBrush;
865203c3	545	HANDLE horgobj = 0;
7b416d42 GV	546	UINT textalign;
	547	int flag = 0;
	548
7b416d42 GV	549	hCompatDC = CreateCompatibleDC(hdc);
	550
	551	textalign = GetTextAlign(hdc);
	552
	553	SaveDC(hdc);
	554
	555	hFgBrush = CreateSolidBrush(GetTextColor(hdc));
	556	hOrgBrush = SelectObject(hdc, hFgBrush);
	557	SetTextColor(hdc, RGB(0, 0, 0));
	558	SetBkColor(hdc, RGB(0xff, 0xff, 0xff));
	559
	560	textp = text;
	561	while(bytelen > 0)
	562	{
	563	if (dim == 1)
	564	{
	565	index = *textp++;
	566	bytelen--;
	567	}
	568	else
	569	{
	570	bytelen -= 2;
	571	if (bytelen < 0) break;
	572	index = MAKELENDSHORT(textp[1], textp[0]);
	573	textp += 2;
	574	}
865203c3 GV	575	pcb = get_bitmap_with_cache(fontp, index);
865203c3 GV	576	if (!pcb)
7b416d42 GV	577	{
	578	if (horgobj)
	579	{
	580	SelectObject(hCompatDC, horgobj);
	581	DeleteObject(hBMP);
	582	}
	583	DeleteDC(hCompatDC);
	584	return 0;
	585	}
865203c3 GV	586	hBMP = pcb->hbmp;
865203c3 GV	587
7b416d42	588	if (textalign & TA_BASELINE)
865203c3	589	btop = top - (pcb->metric.bbh + pcb->metric.bboy);
7b416d42	590	else if (textalign & TA_BOTTOM)
865203c3	591	btop = top - pcb->metric.bbh;
7b416d42	592	else
7b416d42	593	btop = top;
7b416d42 GV	594
7b416d42 GV	595	if (horgobj)
7b416d42	596	SelectObject(hCompatDC, hBMP);
7b416d42	597	else
7b416d42	598	horgobj = SelectObject(hCompatDC, hBMP);
7b416d42	599	#if 0
865203c3	600	BitBlt(hdc, left, btop, pcb->metric.bbw, pcb->metric.bbh, hCompatDC, 0, 0, SRCCOPY);
7b416d42	601	#else
865203c3	602	BitBlt(hdc, left, btop, pcb->metric.bbw, pcb->metric.bbh, hCompatDC, 0, 0, 0xB8074A);
7b416d42 GV	603	#endif
	604	if (fixed_pitch_size)
	605	left += fixed_pitch_size;
	606	else
865203c3	607	left += pcb->metric.dwidth;
7b416d42 GV	608	}
	609	SelectObject(hCompatDC, horgobj);
	610	SelectObject(hdc, hOrgBrush);
	611	DeleteObject(hFgBrush);
7b416d42 GV	612	DeleteDC(hCompatDC);
	613	RestoreDC(hdc, -1);
	614
	615	return 1;
	616	}
	617
	618	struct font_info w32_load_bdf_font (struct frame f, char *fontname,
	619	int size, char* filename)
	620	{
	621	struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
	622	struct font_info *fontp;
	623	XFontStruct *font;
	624	bdffont* bdf_font;
	625
	626	bdf_font = w32_init_bdf_font (filename);
	627
	628	if (!bdf_font) return NULL;
	629
	630	font = (XFontStruct *) xmalloc (sizeof (XFontStruct));
	631
	632	font->bdf = bdf_font;
	633	font->hfont = 0;
	634
	635	/* Do we need to create the table? */
	636	if (dpyinfo->font_table_size == 0)
	637	{
	638	dpyinfo->font_table_size = 16;
	639	dpyinfo->font_table
	640	= (struct font_info *) xmalloc (dpyinfo->font_table_size
	641	* sizeof (struct font_info));
	642	}
	643	/* Do we need to grow the table? */
	644	else if (dpyinfo->n_fonts
	645	>= dpyinfo->font_table_size)
	646	{
	647	dpyinfo->font_table_size *= 2;
	648	dpyinfo->font_table
	649	= (struct font_info *) xrealloc (dpyinfo->font_table,
	650	(dpyinfo->font_table_size
	651	* sizeof (struct font_info)));
	652	}
	653
	654	fontp = dpyinfo->font_table + dpyinfo->n_fonts;
	655
	656	/* Now fill in the slots of FONTP. /
	657	BLOCK_INPUT;
	658	fontp->font = font;
	659	fontp->font_idx = dpyinfo->n_fonts;
	660	fontp->name = (char *) xmalloc (strlen (fontname) + 1);
	661	bcopy (fontname, fontp->name, strlen (fontname) + 1);
	662	fontp->full_name = fontp->name;
	663	fontp->size = FONT_WIDTH (font);
	664	fontp->height = FONT_HEIGHT (font);
	665
	666	/* The slot `encoding' specifies how to map a character
	667	code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
	668	the font code-points (0:0x20..0x7F, 1:0xA0..0xFF, 0:0x2020..0x7F7F,
	669	the font code-points (0:0x20..0x7F, 1:0xA0..0xFF,
	670	0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF, or
	671	2:0xA020..0xFF7F). For the moment, we don't know which charset
	672	uses this font. So, we set informatoin in fontp->encoding[1]
	673	which is never used by any charset. If mapping can't be
	674	decided, set FONT_ENCODING_NOT_DECIDED. */
	675	fontp->encoding[1] = FONT_ENCODING_NOT_DECIDED;
676	fontp->baseline_offset = bdf_font->yoffset;
677	fontp->relative_compose = bdf_font->relative_compose;
678	fontp->default_ascent = bdf_font->default_ascent;
679
680	UNBLOCK_INPUT;
681	dpyinfo->n_fonts++;
682	return fontp;
683	}
684
685	/* Check a file for an XFLD string describing it. */
686	int w32_BDF_to_x_font (char file, char xstr, int len)
687	{
688	HANDLE hfile, hfilemap;
689	BY_HANDLE_FILE_INFORMATION fileinfo;
690	unsigned char font, start, p, q;
691	int flag, size, retval = 0;
692
693	hfile = CreateFile (file, GENERIC_READ, FILE_SHARE_READ, NULL,
694	OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
695	if (hfile == INVALID_HANDLE_VALUE) return 0;
696	if (!GetFileInformationByHandle(hfile, &fileinfo) \|\|
697	(fileinfo.nFileSizeHigh != 0) \|\|
698	(fileinfo.nFileSizeLow > BDF_FILE_SIZE_MAX))
699	{
700	CloseHandle (hfile);
701	return 0;
702	}
703	size = fileinfo.nFileSizeLow;
704
705	hfilemap = CreateFileMapping (hfile, NULL, PAGE_READONLY, 0, 0, NULL);
706	if (hfilemap == INVALID_HANDLE_VALUE)
707	{
708	CloseHandle (hfile);
709	return 0;
710	}
711
712	font = MapViewOfFile (hfilemap, FILE_MAP_READ, 0, 0, 0);
713	if (!font)
714	{
715	CloseHandle (hfile);
716	CloseHandle (hfilemap);
717	return 0;
718	}
719	start = font;
720
721	flag = proceed_file_line ("FONT ", start, &size, &p, &q);
722	if (flag)
723	{
724	/* If font provides a description of itself, check it is a
725	full XLFD before accepting it. */
726	int count = 0;
727	char *s;
728
729	for (s = p; s < q; s++)
730	if (*s == '\n')
731	break;
732	else if (*s == '-')
733	count++;
734	if (count == 14 && q - p - 1 <= len)
735	{
736	strncpy (xstr, p, q-p-1);
737	xstr[q-p-1] = '\0';
738	/* Files may have DOS line ends (ie still ^M on end). */
739	if (iscntrl(xstr[q-p-2]))
740	xstr[q-p-2] = '\0';
741
742	retval = 1;
743	}
744	}
745	CloseHandle (hfile);
746	CloseHandle (hfilemap);
747	return retval;
748	}