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

/* ftxfont.c -- FreeType font driver on X (without using XFT).
   Copyright (C) 2006, 2007, 2008 Free Software Foundation, Inc.
   Copyright (C) 2006, 2007, 2008
     National Institute of Advanced Industrial Science and Technology (AIST)
     Registration Number H13PRO009

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 3, 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., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.  */

#include <config.h>
#include <stdio.h>
#include <X11/Xlib.h>

#include "lisp.h"
#include "dispextern.h"
#include "xterm.h"
#include "frame.h"
#include "blockinput.h"
#include "character.h"
#include "charset.h"
#include "fontset.h"
#include "font.h"

/* FTX font driver.  */

static Lisp_Object Qftx;

/* Prototypes for helper function.  */
static GC *ftxfont_get_gcs P_ ((FRAME_PTR, unsigned long, unsigned long));
static int ftxfont_draw_bitmap P_ ((FRAME_PTR, GC, GC *, struct font *,
				    unsigned, int, int, XPoint *, int, int *,
				    int));
static void ftxfont_draw_backgrond P_ ((FRAME_PTR, struct font *, GC,
					int, int, int));

struct ftxfont_frame_data
{
  /* Background and foreground colors.  */
  XColor colors[2];
  /* GCs interporationg the above colors.  gcs[0] is for a color
   closest to BACKGROUND, and gcs[5] is for a color closest to
   FOREGROUND.  */
  GC gcs[6];
  struct ftxfont_frame_data *next;
};


/* Return an array of 6 GCs for antialiasing.  */

static GC *
ftxfont_get_gcs (f, foreground, background)
     FRAME_PTR f;
     unsigned long foreground, background;
{
  XColor color;
  XGCValues xgcv;
  int i;
  struct ftxfont_frame_data *data = font_get_frame_data (f, &ftxfont_driver);
  struct ftxfont_frame_data *prev = NULL, *this = NULL, *new;

  if (data)
    {
      for (this = data; this; prev = this, this = this->next)
	{
	  if (this->colors[0].pixel < background)
	    continue;
	  if (this->colors[0].pixel > background)
	    break;
	  if (this->colors[1].pixel < foreground)
	    continue;
	  if (this->colors[1].pixel > foreground)
	    break;
	  return this->gcs;
	}
    }

  new = malloc (sizeof (struct ftxfont_frame_data));
  if (! new)
    return NULL;
  new->next = this;
  if (prev)
    {
      prev->next = new;
    }
  else if (font_put_frame_data (f, &ftxfont_driver, new) < 0)
    {
      free (new);
      return NULL;
    }

  new->colors[0].pixel = background;
  new->colors[1].pixel = foreground;

  BLOCK_INPUT;
  XQueryColors (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), new->colors, 2);
  for (i = 1; i < 7; i++)
    {
      /* Interpolate colors linearly.  Any better algorithm?  */
      color.red
	= (new->colors[1].red * i + new->colors[0].red * (8 - i)) / 8;
      color.green
	= (new->colors[1].green * i + new->colors[0].green * (8 - i)) / 8;
      color.blue
	= (new->colors[1].blue * i + new->colors[0].blue * (8 - i)) / 8;
      if (! x_alloc_nearest_color (f, FRAME_X_COLORMAP (f), &color))
	break;
      xgcv.foreground = color.pixel;
      new->gcs[i - 1] = XCreateGC (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
				   GCForeground, &xgcv);
    }
  UNBLOCK_INPUT;

  if (i < 7)
    {
      BLOCK_INPUT;
      for (i--; i >= 0; i--)
	XFreeGC (FRAME_X_DISPLAY (f), new->gcs[i]);
      UNBLOCK_INPUT;
      if (prev)
	prev->next = new->next;
      else if (data)
	font_put_frame_data (f, &ftxfont_driver, new->next);
      free (new);
      return NULL;
    }
  return new->gcs;
}

static int
ftxfont_draw_bitmap (f, gc_fore, gcs, font, code, x, y, p, size, n, flush)
     FRAME_PTR f;
     GC gc_fore, *gcs;
     struct font *font;
     unsigned code;
     int x, y;
     XPoint *p;
     int size, *n;
     int flush;
{
  struct font_bitmap bitmap;
  unsigned char *b;
  int i, j;

  if (ftfont_driver.get_bitmap (font, code, &bitmap, size > 0x100 ? 1 : 8) < 0)
    return 0;
  if (size > 0x100)
    {
      for (i = 0, b = bitmap.buffer; i < bitmap.rows;
	   i++, b += bitmap.pitch)
	{
	  for (j = 0; j < bitmap.width; j++)
	    if (b[j / 8] & (1 << (7 - (j % 8))))
	      {
		p[n[0]].x = x + bitmap.left + j;
		p[n[0]].y = y - bitmap.top + i;
		if (++n[0] == size)
		  {
		    XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
				 gc_fore, p, size, CoordModeOrigin);
		    n[0] = 0;
		  }
	      }
	}
      if (flush && n[0] > 0)
	XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
		     gc_fore, p, n[0], CoordModeOrigin);
    }
  else
    {
      for (i = 0, b = bitmap.buffer; i < bitmap.rows;
	   i++, b += bitmap.pitch)
	{
	  for (j = 0; j < bitmap.width; j++)
	    {
	      int idx = (bitmap.bits_per_pixel == 1
			 ? ((b[j / 8] & (1 << (7 - (j % 8)))) ? 6 : -1)
			 : (b[j] >> 5) - 1);

	      if (idx >= 0)
		{
		  XPoint *pp = p + size * idx;

		  pp[n[idx]].x = x + bitmap.left + j;
		  pp[n[idx]].y = y - bitmap.top + i;
		  if (++(n[idx]) == size)
		    {
		      XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
				   idx == 6 ? gc_fore : gcs[idx], pp, size,
				   CoordModeOrigin);
		      n[idx] = 0;
		    }
		}
	    }
	}
      if (flush)
	{
	  for (i = 0; i < 6; i++)
	    if (n[i] > 0)
	      XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
			   gcs[i], p + 0x100 * i, n[i], CoordModeOrigin);
	  if (n[6] > 0)
	    XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
			 gc_fore, p + 0x600, n[6], CoordModeOrigin);
	}
    }

  if (ftfont_driver.free_bitmap)
    ftfont_driver.free_bitmap (font, &bitmap);

  return bitmap.advance;
}

static void
ftxfont_draw_backgrond (f, font, gc, x, y, width)
     FRAME_PTR f;
     struct font *font;
     GC gc;
     int x, y, width;
{
  XGCValues xgcv;

  XGetGCValues (FRAME_X_DISPLAY (f), gc,
		GCForeground | GCBackground, &xgcv);
  XSetForeground (FRAME_X_DISPLAY (f), gc, xgcv.background);
  XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
		  x, y - font->ascent, width, y + font->descent);
  XSetForeground (FRAME_X_DISPLAY (f), gc, xgcv.foreground);
}

/* Prototypes for font-driver methods.  */
static Lisp_Object ftxfont_list P_ ((Lisp_Object, Lisp_Object));
static Lisp_Object ftxfont_match P_ ((Lisp_Object, Lisp_Object));
static struct font *ftxfont_open P_ ((FRAME_PTR, Lisp_Object, int));
static void ftxfont_close P_ ((FRAME_PTR, struct font *));
static int ftxfont_draw P_ ((struct glyph_string *, int, int, int, int, int));

struct font_driver ftxfont_driver;

static Lisp_Object
ftxfont_list (frame, spec)
     Lisp_Object frame;
     Lisp_Object spec;
{
  Lisp_Object val = ftfont_driver.list (frame, spec);
  
  if (! NILP (val))
    {
      int i;

      for (i = 0; i < ASIZE (val); i++)
	ASET (AREF (val, i), FONT_TYPE_INDEX, Qftx);
    }
  return val;
}

static Lisp_Object
ftxfont_match (frame, spec)
     Lisp_Object frame;
     Lisp_Object spec;
{
  Lisp_Object entity = ftfont_driver.match (frame, spec);

  if (VECTORP (entity))
    ASET (entity, FONT_TYPE_INDEX, Qftx);
  return entity;
}

static struct font *
ftxfont_open (f, entity, pixel_size)
     FRAME_PTR f;
     Lisp_Object entity;
     int pixel_size;
{
  Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
  struct font *font;
  XFontStruct *xfont = malloc (sizeof (XFontStruct));
  
  if (! xfont)
    return NULL;
  font = ftfont_driver.open (f, entity, pixel_size);
  if (! font)
    {
      free (xfont);
      return NULL;
    }
  xfont->fid = (Font) 0;
  xfont->ascent = font->ascent;
  xfont->descent = font->descent;
  xfont->max_bounds.width = font->font.size;
  xfont->min_bounds.width = font->min_width;
  font->font.font = xfont;
  font->driver = &ftxfont_driver;

  dpyinfo->n_fonts++;

  /* Set global flag fonts_changed_p to non-zero if the font loaded
     has a character with a smaller width than any other character
     before, or if the font loaded has a smaller height than any other
     font loaded before.  If this happens, it will make a glyph matrix
     reallocation necessary.  */
  if (dpyinfo->n_fonts == 1)
    {
      dpyinfo->smallest_font_height = font->font.height;
      dpyinfo->smallest_char_width = font->min_width;
      fonts_changed_p = 1;
    }
  else
    {
      if (dpyinfo->smallest_font_height > font->font.height)
	dpyinfo->smallest_font_height = font->font.height, fonts_changed_p |= 1;
      if (dpyinfo->smallest_char_width > font->min_width)
	dpyinfo->smallest_char_width = font->min_width, fonts_changed_p |= 1;
    }

  if (fonts_changed_p)
    {
      if (dpyinfo->smallest_font_height == 0)
	dpyinfo->smallest_font_height = 1;
      if (dpyinfo->smallest_char_width == 0)
	dpyinfo->smallest_char_width = 1;
    }

  return font;
}

static void
ftxfont_close (f, font)
     FRAME_PTR f;
     struct font *font;
{
  ftfont_driver.close (f, font);
  FRAME_X_DISPLAY_INFO (f)->n_fonts--;
}

static int
ftxfont_draw (s, from, to, x, y, with_background)
     struct glyph_string *s;
     int from, to, x, y, with_background;
{
  FRAME_PTR f = s->f;
  struct face *face = s->face;
  struct font *font = (struct font *) s->font_info;
  XPoint p[0x700];
  int n[7];
  unsigned *code;
  int len = to - from;
  int i;
  GC *gcs;
  int xadvance;

  n[0] = n[1] = n[2] = n[3] = n[4] = n[5] = n[6] = 0;

  BLOCK_INPUT;
  if (with_background)
    ftxfont_draw_backgrond (f, font, s->gc, x, y, s->width);
  code = alloca (sizeof (unsigned) * len);
  for (i = 0; i < len; i++)
    code[i] = ((XCHAR2B_BYTE1 (s->char2b + from + i) << 8)
	       | XCHAR2B_BYTE2 (s->char2b + from + i));

  if (face->gc == s->gc)
    {
      gcs = ftxfont_get_gcs (f, face->foreground, face->background);
    }
  else
    {
      XGCValues xgcv;
      unsigned long mask = GCForeground | GCBackground;

      XGetGCValues (FRAME_X_DISPLAY (f), s->gc, mask, &xgcv);
      gcs = ftxfont_get_gcs (f, xgcv.foreground, xgcv.background);
    }

  if (gcs)
    {
      if (s->num_clips)
	for (i = 0; i < 6; i++)
	  XSetClipRectangles (FRAME_X_DISPLAY (f), gcs[i], 0, 0,
			      s->clip, s->num_clips, Unsorted);

      for (i = 0; i < len; i++)
	{
	  xadvance = ftxfont_draw_bitmap (f, s->gc, gcs, font, code[i], x, y,
					  p, 0x100, n, i + 1 == len);
	  x += (s->padding_p ? 1 : xadvance);
	}
      if (s->num_clips)
	for (i = 0; i < 6; i++)
	  XSetClipMask (FRAME_X_DISPLAY (f), gcs[i], None);
    }
  else
    {
      /* We can't draw with antialiasing.
	 s->gc should already have a proper clipping setting. */
      for (i = 0; i < len; i++)
	{
	  xadvance = ftxfont_draw_bitmap (f, s->gc, NULL, font, code[i], x, y,
					  p, 0x700, n, i + 1 == len);
	  x += (s->padding_p ? 1 : xadvance);
	}
    }

  UNBLOCK_INPUT;

  return len;
}

static int
ftxfont_end_for_frame (f)
     FRAME_PTR f;
{
  struct ftxfont_frame_data *data = font_get_frame_data (f, &ftxfont_driver);
  
  BLOCK_INPUT;
  while (data)
    {
      struct ftxfont_frame_data *next = data->next;
      int i;
      
      for (i = 0; i < 6; i++)
	XFreeGC (FRAME_X_DISPLAY (f), data->gcs[i]);
      free (data);
      data = next;
    }
  UNBLOCK_INPUT;
  font_put_frame_data (f, &ftxfont_driver, NULL);
  return 0;
}

\f

void
syms_of_ftxfont ()
{
  DEFSYM (Qftx, "ftx");

  ftxfont_driver = ftfont_driver;
  ftxfont_driver.type = Qftx;
  ftxfont_driver.list = ftxfont_list;
  ftxfont_driver.match = ftxfont_match;
  ftxfont_driver.open = ftxfont_open;
  ftxfont_driver.close = ftxfont_close;
  ftxfont_driver.draw = ftxfont_draw;
  ftxfont_driver.end_for_frame = ftxfont_end_for_frame;
  register_font_driver (&ftxfont_driver, NULL);
}

/* arch-tag: 59bd3469-5330-413f-b29d-1aa36492abe8
   (do not change this comment) */
Commit	Line	Data
c2f5bfd6	1	/* ftxfont.c -- FreeType font driver on X (without using XFT).
77ad4cfe GM	2	Copyright (C) 2006, 2007, 2008 Free Software Foundation, Inc.
77ad4cfe GM	3	Copyright (C) 2006, 2007, 2008
c2f5bfd6 KH	4	National Institute of Advanced Industrial Science and Technology (AIST)
	5	Registration Number H13PRO009
	6
	7	This file is part of GNU Emacs.
	8
	9	GNU Emacs is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
77ad4cfe	11	the Free Software Foundation; either version 3, or (at your option)
c2f5bfd6 KH	12	any later version.
	13
	14	GNU Emacs is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18
	19	You should have received a copy of the GNU General Public License
	20	along with GNU Emacs; see the file COPYING. If not, write to
	21	the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	22	Boston, MA 02110-1301, USA. */
	23
	24	#include <config.h>
	25	#include <stdio.h>
	26	#include <X11/Xlib.h>
	27
	28	#include "lisp.h"
	29	#include "dispextern.h"
	30	#include "xterm.h"
	31	#include "frame.h"
	32	#include "blockinput.h"
	33	#include "character.h"
	34	#include "charset.h"
	35	#include "fontset.h"
	36	#include "font.h"
	37
	38	/* FTX font driver. */
	39
	40	static Lisp_Object Qftx;
	41
	42	/* Prototypes for helper function. */
00c37e18 KH	43	static GC *ftxfont_get_gcs P_ ((FRAME_PTR, unsigned long, unsigned long));
	44	static int ftxfont_draw_bitmap P_ ((FRAME_PTR, GC, GC , struct font ,
	45	unsigned, int, int, XPoint , int, int ,
	46	int));
c2f5bfd6 KH	47	static void ftxfont_draw_backgrond P_ ((FRAME_PTR, struct font *, GC,
c2f5bfd6 KH	48	int, int, int));
056360d0	49
00c37e18 KH	50	struct ftxfont_frame_data
	51	{
	52	/* Background and foreground colors. */
	53	XColor colors[2];
	54	/* GCs interporationg the above colors. gcs[0] is for a color
	55	closest to BACKGROUND, and gcs[5] is for a color closest to
	56	FOREGROUND. */
	57	GC gcs[6];
	58	struct ftxfont_frame_data *next;
	59	};
056360d0	60
00c37e18 KH	61
	62	/* Return an array of 6 GCs for antialiasing. */
	63
	64	static GC *
	65	ftxfont_get_gcs (f, foreground, background)
056360d0	66	FRAME_PTR f;
056360d0 KH	67	unsigned long foreground, background;
056360d0 KH	68	{
00c37e18	69	XColor color;
056360d0 KH	70	XGCValues xgcv;
056360d0 KH	71	int i;
00c37e18 KH	72	struct ftxfont_frame_data *data = font_get_frame_data (f, &ftxfont_driver);
00c37e18 KH	73	struct ftxfont_frame_data prev = NULL, this = NULL, *new;
056360d0	74
00c37e18 KH	75	if (data)
	76	{
	77	for (this = data; this; prev = this, this = this->next)
	78	{
	79	if (this->colors[0].pixel < background)
	80	continue;
	81	if (this->colors[0].pixel > background)
	82	break;
	83	if (this->colors[1].pixel < foreground)
	84	continue;
	85	if (this->colors[1].pixel > foreground)
	86	break;
	87	return this->gcs;
	88	}
	89	}
	90
	91	new = malloc (sizeof (struct ftxfont_frame_data));
	92	if (! new)
	93	return NULL;
	94	new->next = this;
	95	if (prev)
	96	{
	97	prev->next = new;
	98	}
	99	else if (font_put_frame_data (f, &ftxfont_driver, new) < 0)
	100	{
	101	free (new);
	102	return NULL;
	103	}
	104
	105	new->colors[0].pixel = background;
	106	new->colors[1].pixel = foreground;
056360d0 KH	107
056360d0 KH	108	BLOCK_INPUT;
00c37e18	109	XQueryColors (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), new->colors, 2);
056360d0 KH	110	for (i = 1; i < 7; i++)
056360d0 KH	111	{
00c37e18 KH	112	/* Interpolate colors linearly. Any better algorithm? */
	113	color.red
	114	= (new->colors[1].red * i + new->colors[0].red * (8 - i)) / 8;
	115	color.green
	116	= (new->colors[1].green * i + new->colors[0].green * (8 - i)) / 8;
	117	color.blue
	118	= (new->colors[1].blue * i + new->colors[0].blue * (8 - i)) / 8;
	119	if (! x_alloc_nearest_color (f, FRAME_X_COLORMAP (f), &color))
056360d0	120	break;
00c37e18 KH	121	xgcv.foreground = color.pixel;
	122	new->gcs[i - 1] = XCreateGC (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
	123	GCForeground, &xgcv);
056360d0 KH	124	}
	125	UNBLOCK_INPUT;
	126
	127	if (i < 7)
	128	{
	129	BLOCK_INPUT;
	130	for (i--; i >= 0; i--)
00c37e18	131	XFreeGC (FRAME_X_DISPLAY (f), new->gcs[i]);
056360d0	132	UNBLOCK_INPUT;
00c37e18 KH	133	if (prev)
	134	prev->next = new->next;
	135	else if (data)
	136	font_put_frame_data (f, &ftxfont_driver, new->next);
	137	free (new);
	138	return NULL;
056360d0	139	}
00c37e18	140	return new->gcs;
056360d0	141	}
c2f5bfd6 KH	142
c2f5bfd6 KH	143	static int
00c37e18	144	ftxfont_draw_bitmap (f, gc_fore, gcs, font, code, x, y, p, size, n, flush)
c2f5bfd6	145	FRAME_PTR f;
00c37e18	146	GC gc_fore, *gcs;
c2f5bfd6 KH	147	struct font *font;
	148	unsigned code;
	149	int x, y;
	150	XPoint *p;
	151	int size, *n;
00c37e18	152	int flush;
c2f5bfd6 KH	153	{
	154	struct font_bitmap bitmap;
	155	unsigned char *b;
	156	int i, j;
	157
056360d0	158	if (ftfont_driver.get_bitmap (font, code, &bitmap, size > 0x100 ? 1 : 8) < 0)
c2f5bfd6	159	return 0;
00c37e18	160	if (size > 0x100)
c2f5bfd6	161	{
00c37e18 KH	162	for (i = 0, b = bitmap.buffer; i < bitmap.rows;
00c37e18 KH	163	i++, b += bitmap.pitch)
c2f5bfd6 KH	164	{
	165	for (j = 0; j < bitmap.width; j++)
	166	if (b[j / 8] & (1 << (7 - (j % 8))))
	167	{
	168	p[n[0]].x = x + bitmap.left + j;
	169	p[n[0]].y = y - bitmap.top + i;
00c37e18	170	if (++n[0] == size)
c2f5bfd6 KH	171	{
c2f5bfd6 KH	172	XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
00c37e18	173	gc_fore, p, size, CoordModeOrigin);
c2f5bfd6 KH	174	n[0] = 0;
	175	}
	176	}
	177	}
00c37e18 KH	178	if (flush && n[0] > 0)
	179	XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
	180	gc_fore, p, n[0], CoordModeOrigin);
	181	}
	182	else
	183	{
	184	for (i = 0, b = bitmap.buffer; i < bitmap.rows;
	185	i++, b += bitmap.pitch)
c2f5bfd6 KH	186	{
	187	for (j = 0; j < bitmap.width; j++)
	188	{
00c37e18 KH	189	int idx = (bitmap.bits_per_pixel == 1
	190	? ((b[j / 8] & (1 << (7 - (j % 8)))) ? 6 : -1)
	191	: (b[j] >> 5) - 1);
c2f5bfd6 KH	192
	193	if (idx >= 0)
	194	{
	195	XPoint pp = p + size idx;
	196
	197	pp[n[idx]].x = x + bitmap.left + j;
	198	pp[n[idx]].y = y - bitmap.top + i;
00c37e18	199	if (++(n[idx]) == size)
c2f5bfd6 KH	200	{
c2f5bfd6 KH	201	XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
00c37e18 KH	202	idx == 6 ? gc_fore : gcs[idx], pp, size,
00c37e18 KH	203	CoordModeOrigin);
c2f5bfd6 KH	204	n[idx] = 0;
	205	}
	206	}
	207	}
	208	}
00c37e18 KH	209	if (flush)
	210	{
	211	for (i = 0; i < 6; i++)
	212	if (n[i] > 0)
	213	XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
	214	gcs[i], p + 0x100 * i, n[i], CoordModeOrigin);
	215	if (n[6] > 0)
	216	XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
	217	gc_fore, p + 0x600, n[6], CoordModeOrigin);
	218	}
c2f5bfd6 KH	219	}
	220
	221	if (ftfont_driver.free_bitmap)
	222	ftfont_driver.free_bitmap (font, &bitmap);
	223
	224	return bitmap.advance;
	225	}
	226
	227	static void
	228	ftxfont_draw_backgrond (f, font, gc, x, y, width)
	229	FRAME_PTR f;
	230	struct font *font;
	231	GC gc;
	232	int x, y, width;
	233	{
	234	XGCValues xgcv;
	235
	236	XGetGCValues (FRAME_X_DISPLAY (f), gc,
	237	GCForeground \| GCBackground, &xgcv);
	238	XSetForeground (FRAME_X_DISPLAY (f), gc, xgcv.background);
	239	XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
056360d0	240	x, y - font->ascent, width, y + font->descent);
c2f5bfd6 KH	241	XSetForeground (FRAME_X_DISPLAY (f), gc, xgcv.foreground);
	242	}
	243
	244	/* Prototypes for font-driver methods. */
	245	static Lisp_Object ftxfont_list P_ ((Lisp_Object, Lisp_Object));
3a91626c	246	static Lisp_Object ftxfont_match P_ ((Lisp_Object, Lisp_Object));
c2f5bfd6 KH	247	static struct font *ftxfont_open P_ ((FRAME_PTR, Lisp_Object, int));
c2f5bfd6 KH	248	static void ftxfont_close P_ ((FRAME_PTR, struct font *));
c2f5bfd6 KH	249	static int ftxfont_draw P_ ((struct glyph_string *, int, int, int, int, int));
	250
	251	struct font_driver ftxfont_driver;
	252
	253	static Lisp_Object
	254	ftxfont_list (frame, spec)
	255	Lisp_Object frame;
	256	Lisp_Object spec;
	257	{
	258	Lisp_Object val = ftfont_driver.list (frame, spec);
	259
	260	if (! NILP (val))
	261	{
	262	int i;
	263
	264	for (i = 0; i < ASIZE (val); i++)
	265	ASET (AREF (val, i), FONT_TYPE_INDEX, Qftx);
	266	}
	267	return val;
	268	}
	269
3a91626c KH	270	static Lisp_Object
	271	ftxfont_match (frame, spec)
	272	Lisp_Object frame;
	273	Lisp_Object spec;
	274	{
	275	Lisp_Object entity = ftfont_driver.match (frame, spec);
	276
	277	if (VECTORP (entity))
	278	ASET (entity, FONT_TYPE_INDEX, Qftx);
	279	return entity;
	280	}
	281
c2f5bfd6 KH	282	static struct font *
	283	ftxfont_open (f, entity, pixel_size)
	284	FRAME_PTR f;
	285	Lisp_Object entity;
	286	int pixel_size;
	287	{
	288	Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
	289	struct font *font;
	290	XFontStruct *xfont = malloc (sizeof (XFontStruct));
	291
	292	if (! xfont)
	293	return NULL;
	294	font = ftfont_driver.open (f, entity, pixel_size);
	295	if (! font)
	296	{
	297	free (xfont);
	298	return NULL;
	299	}
559474f1	300	xfont->fid = (Font) 0;
c2f5bfd6 KH	301	xfont->ascent = font->ascent;
	302	xfont->descent = font->descent;
	303	xfont->max_bounds.width = font->font.size;
	304	xfont->min_bounds.width = font->min_width;
	305	font->font.font = xfont;
	306	font->driver = &ftxfont_driver;
	307
	308	dpyinfo->n_fonts++;
	309
	310	/* Set global flag fonts_changed_p to non-zero if the font loaded
	311	has a character with a smaller width than any other character
	312	before, or if the font loaded has a smaller height than any other
	313	font loaded before. If this happens, it will make a glyph matrix
	314	reallocation necessary. */
	315	if (dpyinfo->n_fonts == 1)
	316	{
	317	dpyinfo->smallest_font_height = font->font.height;
	318	dpyinfo->smallest_char_width = font->min_width;
	319	fonts_changed_p = 1;
	320	}
	321	else
	322	{
	323	if (dpyinfo->smallest_font_height > font->font.height)
	324	dpyinfo->smallest_font_height = font->font.height, fonts_changed_p \|= 1;
	325	if (dpyinfo->smallest_char_width > font->min_width)
	326	dpyinfo->smallest_char_width = font->min_width, fonts_changed_p \|= 1;
	327	}
	328
562af9bc KH	329	if (fonts_changed_p)
	330	{
	331	if (dpyinfo->smallest_font_height == 0)
	332	dpyinfo->smallest_font_height = 1;
	333	if (dpyinfo->smallest_char_width == 0)
	334	dpyinfo->smallest_char_width = 1;
	335	}
	336
c2f5bfd6 KH	337	return font;
	338	}
	339
	340	static void
	341	ftxfont_close (f, font)
	342	FRAME_PTR f;
	343	struct font *font;
	344	{
	345	ftfont_driver.close (f, font);
	346	FRAME_X_DISPLAY_INFO (f)->n_fonts--;
	347	}
	348
c2f5bfd6 KH	349	static int
	350	ftxfont_draw (s, from, to, x, y, with_background)
	351	struct glyph_string *s;
	352	int from, to, x, y, with_background;
	353	{
	354	FRAME_PTR f = s->f;
	355	struct face *face = s->face;
794e558c	356	struct font font = (struct font ) s->font_info;
c2f5bfd6 KH	357	XPoint p[0x700];
	358	int n[7];
	359	unsigned *code;
	360	int len = to - from;
	361	int i;
056360d0	362	GC *gcs;
b9c2785e	363	int xadvance;
c2f5bfd6 KH	364
	365	n[0] = n[1] = n[2] = n[3] = n[4] = n[5] = n[6] = 0;
	366
	367	BLOCK_INPUT;
c2f5bfd6 KH	368	if (with_background)
	369	ftxfont_draw_backgrond (f, font, s->gc, x, y, s->width);
	370	code = alloca (sizeof (unsigned) * len);
	371	for (i = 0; i < len; i++)
	372	code[i] = ((XCHAR2B_BYTE1 (s->char2b + from + i) << 8)
	373	\| XCHAR2B_BYTE2 (s->char2b + from + i));
	374
00c37e18 KH	375	if (face->gc == s->gc)
	376	{
	377	gcs = ftxfont_get_gcs (f, face->foreground, face->background);
	378	}
	379	else
c2f5bfd6	380	{
056360d0 KH	381	XGCValues xgcv;
	382	unsigned long mask = GCForeground \| GCBackground;
	383
056360d0	384	XGetGCValues (FRAME_X_DISPLAY (f), s->gc, mask, &xgcv);
00c37e18	385	gcs = ftxfont_get_gcs (f, xgcv.foreground, xgcv.background);
056360d0 KH	386	}
056360d0 KH	387
00c37e18	388	if (gcs)
056360d0	389	{
00c37e18 KH	390	if (s->num_clips)
	391	for (i = 0; i < 6; i++)
	392	XSetClipRectangles (FRAME_X_DISPLAY (f), gcs[i], 0, 0,
	393	s->clip, s->num_clips, Unsorted);
	394
c2f5bfd6	395	for (i = 0; i < len; i++)
b9c2785e KH	396	{
	397	xadvance = ftxfont_draw_bitmap (f, s->gc, gcs, font, code[i], x, y,
	398	p, 0x100, n, i + 1 == len);
	399	x += (s->padding_p ? 1 : xadvance);
	400	}
00c37e18 KH	401	if (s->num_clips)
	402	for (i = 0; i < 6; i++)
	403	XSetClipMask (FRAME_X_DISPLAY (f), gcs[i], None);
c2f5bfd6 KH	404	}
	405	else
	406	{
00c37e18 KH	407	/* We can't draw with antialiasing.
00c37e18 KH	408	s->gc should already have a proper clipping setting. */
c2f5bfd6	409	for (i = 0; i < len; i++)
b9c2785e KH	410	{
	411	xadvance = ftxfont_draw_bitmap (f, s->gc, NULL, font, code[i], x, y,
	412	p, 0x700, n, i + 1 == len);
	413	x += (s->padding_p ? 1 : xadvance);
	414	}
c2f5bfd6 KH	415	}
	416
	417	UNBLOCK_INPUT;
	418
	419	return len;
	420	}
	421
00c37e18 KH	422	static int
	423	ftxfont_end_for_frame (f)
	424	FRAME_PTR f;
	425	{
	426	struct ftxfont_frame_data *data = font_get_frame_data (f, &ftxfont_driver);
	427
	428	BLOCK_INPUT;
	429	while (data)
	430	{
	431	struct ftxfont_frame_data *next = data->next;
	432	int i;
	433
b9217c57	434	for (i = 0; i < 6; i++)
00c37e18 KH	435	XFreeGC (FRAME_X_DISPLAY (f), data->gcs[i]);
	436	free (data);
	437	data = next;
	438	}
	439	UNBLOCK_INPUT;
559474f1	440	font_put_frame_data (f, &ftxfont_driver, NULL);
00c37e18 KH	441	return 0;
	442	}
	443
c2f5bfd6 KH	444	\f
	445
	446	void
	447	syms_of_ftxfont ()
	448	{
	449	DEFSYM (Qftx, "ftx");
	450
	451	ftxfont_driver = ftfont_driver;
	452	ftxfont_driver.type = Qftx;
	453	ftxfont_driver.list = ftxfont_list;
3a91626c	454	ftxfont_driver.match = ftxfont_match;
c2f5bfd6 KH	455	ftxfont_driver.open = ftxfont_open;
c2f5bfd6 KH	456	ftxfont_driver.close = ftxfont_close;
c2f5bfd6	457	ftxfont_driver.draw = ftxfont_draw;
00c37e18	458	ftxfont_driver.end_for_frame = ftxfont_end_for_frame;
c2f5bfd6 KH	459	register_font_driver (&ftxfont_driver, NULL);
c2f5bfd6 KH	460	}
885b7d09 MB	461
	462	/* arch-tag: 59bd3469-5330-413f-b29d-1aa36492abe8
	463	(do not change this comment) */