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

/* ftxfont.c -- FreeType font driver on X (without using XFT).
   Copyright (C) 2006-2011 Free Software Foundation, Inc.
   Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
     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 of the License, 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.  If not, see <http://www.gnu.org/licenses/>.  */

#include <config.h>
#include <stdio.h>
#include <setjmp.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;

#if defined HAVE_XFT || !defined HAVE_FREETYPE
static
#endif
struct font_driver ftxfont_driver;

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

struct ftxfont_frame_data
{
  /* Background and foreground colors.  */
  XColor colors[2];
  /* GCs interpolating 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 (FRAME_PTR f, long unsigned int foreground, long unsigned int 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 (FRAME_PTR f, GC gc_fore, GC *gcs, struct font *font, unsigned int code, int x, int y, XPoint *p, int size, int *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 (FRAME_PTR f, struct font *font, GC gc, int x, int y, int 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_BASE (font), width, FONT_HEIGHT (font));
  XSetForeground (FRAME_X_DISPLAY (f), gc, xgcv.foreground);
}

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

static Lisp_Object
ftxfont_list (Lisp_Object frame, Lisp_Object spec)
{
  Lisp_Object list = ftfont_driver.list (frame, spec), tail;

  for (tail = list; CONSP (tail); tail = XCDR (tail))
    ASET (XCAR (tail), FONT_TYPE_INDEX, Qftx);
  return list;
}

static Lisp_Object
ftxfont_match (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 Lisp_Object
ftxfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
{
  Lisp_Object font_object;
  struct font *font;

  font_object = ftfont_driver.open (f, entity, pixel_size);
  if (NILP (font_object))
    return Qnil;
  font = XFONT_OBJECT (font_object);
  font->driver = &ftxfont_driver;
  return font_object;
}

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

static int
ftxfont_draw (struct glyph_string *s, int from, int to, int x, int y, int with_background)
{
  FRAME_PTR f = s->f;
  struct face *face = s->face;
  struct font *font = s->font;
  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 (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 (void)
{
  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);
}
Commit	Line	Data
c2f5bfd6	1	/* ftxfont.c -- FreeType font driver on X (without using XFT).
73b0cd50	2	Copyright (C) 2006-2011 Free Software Foundation, Inc.
5df4f04c	3	Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
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
9ec0b715	9	GNU Emacs is free software: you can redistribute it and/or modify
c2f5bfd6	10	it under the terms of the GNU General Public License as published by
9ec0b715 GM	11	the Free Software Foundation, either version 3 of the License, or
9ec0b715 GM	12	(at your option) any later version.
c2f5bfd6 KH	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
9ec0b715	20	along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
c2f5bfd6 KH	21
	22	#include <config.h>
	23	#include <stdio.h>
d7306fe6	24	#include <setjmp.h>
c2f5bfd6 KH	25	#include <X11/Xlib.h>
	26
	27	#include "lisp.h"
	28	#include "dispextern.h"
	29	#include "xterm.h"
	30	#include "frame.h"
	31	#include "blockinput.h"
	32	#include "character.h"
	33	#include "charset.h"
	34	#include "fontset.h"
	35	#include "font.h"
	36
	37	/* FTX font driver. */
	38
	39	static Lisp_Object Qftx;
	40
1675728f PE	41	#if defined HAVE_XFT \|\| !defined HAVE_FREETYPE
	42	static
	43	#endif
	44	struct font_driver ftxfont_driver;
	45
c2f5bfd6	46	/* Prototypes for helper function. */
f57e2426 J	47	static GC *ftxfont_get_gcs (FRAME_PTR, unsigned long, unsigned long);
	48	static int ftxfont_draw_bitmap (FRAME_PTR, GC, GC , struct font ,
	49	unsigned, int, int, XPoint , int, int ,
	50	int);
	51	static void ftxfont_draw_backgrond (FRAME_PTR, struct font *, GC,
	52	int, int, int);
056360d0	53
00c37e18 KH	54	struct ftxfont_frame_data
	55	{
	56	/* Background and foreground colors. */
	57	XColor colors[2];
53964682	58	/* GCs interpolating the above colors. gcs[0] is for a color
00c37e18 KH	59	closest to BACKGROUND, and gcs[5] is for a color closest to
	60	FOREGROUND. */
	61	GC gcs[6];
	62	struct ftxfont_frame_data *next;
	63	};
056360d0	64
00c37e18 KH	65
	66	/* Return an array of 6 GCs for antialiasing. */
	67
	68	static GC *
971de7fb	69	ftxfont_get_gcs (FRAME_PTR f, long unsigned int foreground, long unsigned int background)
056360d0	70	{
00c37e18	71	XColor color;
056360d0 KH	72	XGCValues xgcv;
056360d0 KH	73	int i;
00c37e18 KH	74	struct ftxfont_frame_data *data = font_get_frame_data (f, &ftxfont_driver);
00c37e18 KH	75	struct ftxfont_frame_data prev = NULL, this = NULL, *new;
056360d0	76
00c37e18 KH	77	if (data)
	78	{
	79	for (this = data; this; prev = this, this = this->next)
	80	{
	81	if (this->colors[0].pixel < background)
	82	continue;
	83	if (this->colors[0].pixel > background)
	84	break;
	85	if (this->colors[1].pixel < foreground)
	86	continue;
	87	if (this->colors[1].pixel > foreground)
	88	break;
	89	return this->gcs;
	90	}
	91	}
	92
	93	new = malloc (sizeof (struct ftxfont_frame_data));
	94	if (! new)
	95	return NULL;
	96	new->next = this;
	97	if (prev)
	98	{
	99	prev->next = new;
	100	}
	101	else if (font_put_frame_data (f, &ftxfont_driver, new) < 0)
	102	{
	103	free (new);
	104	return NULL;
	105	}
	106
	107	new->colors[0].pixel = background;
	108	new->colors[1].pixel = foreground;
056360d0 KH	109
056360d0 KH	110	BLOCK_INPUT;
00c37e18	111	XQueryColors (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), new->colors, 2);
056360d0 KH	112	for (i = 1; i < 7; i++)
056360d0 KH	113	{
00c37e18 KH	114	/* Interpolate colors linearly. Any better algorithm? */
	115	color.red
	116	= (new->colors[1].red * i + new->colors[0].red * (8 - i)) / 8;
	117	color.green
	118	= (new->colors[1].green * i + new->colors[0].green * (8 - i)) / 8;
	119	color.blue
	120	= (new->colors[1].blue * i + new->colors[0].blue * (8 - i)) / 8;
	121	if (! x_alloc_nearest_color (f, FRAME_X_COLORMAP (f), &color))
056360d0	122	break;
00c37e18 KH	123	xgcv.foreground = color.pixel;
	124	new->gcs[i - 1] = XCreateGC (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
	125	GCForeground, &xgcv);
056360d0 KH	126	}
	127	UNBLOCK_INPUT;
	128
	129	if (i < 7)
	130	{
	131	BLOCK_INPUT;
	132	for (i--; i >= 0; i--)
00c37e18	133	XFreeGC (FRAME_X_DISPLAY (f), new->gcs[i]);
056360d0	134	UNBLOCK_INPUT;
00c37e18 KH	135	if (prev)
	136	prev->next = new->next;
	137	else if (data)
	138	font_put_frame_data (f, &ftxfont_driver, new->next);
	139	free (new);
	140	return NULL;
056360d0	141	}
00c37e18	142	return new->gcs;
056360d0	143	}
c2f5bfd6 KH	144
c2f5bfd6 KH	145	static int
971de7fb	146	ftxfont_draw_bitmap (FRAME_PTR f, GC gc_fore, GC gcs, struct font font, unsigned int code, int x, int y, XPoint p, int size, int n, int flush)
c2f5bfd6 KH	147	{
	148	struct font_bitmap bitmap;
	149	unsigned char *b;
	150	int i, j;
	151
056360d0	152	if (ftfont_driver.get_bitmap (font, code, &bitmap, size > 0x100 ? 1 : 8) < 0)
c2f5bfd6	153	return 0;
00c37e18	154	if (size > 0x100)
c2f5bfd6	155	{
00c37e18 KH	156	for (i = 0, b = bitmap.buffer; i < bitmap.rows;
00c37e18 KH	157	i++, b += bitmap.pitch)
c2f5bfd6 KH	158	{
	159	for (j = 0; j < bitmap.width; j++)
	160	if (b[j / 8] & (1 << (7 - (j % 8))))
	161	{
	162	p[n[0]].x = x + bitmap.left + j;
	163	p[n[0]].y = y - bitmap.top + i;
00c37e18	164	if (++n[0] == size)
c2f5bfd6 KH	165	{
c2f5bfd6 KH	166	XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
00c37e18	167	gc_fore, p, size, CoordModeOrigin);
c2f5bfd6 KH	168	n[0] = 0;
	169	}
	170	}
	171	}
00c37e18 KH	172	if (flush && n[0] > 0)
	173	XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
	174	gc_fore, p, n[0], CoordModeOrigin);
	175	}
	176	else
	177	{
	178	for (i = 0, b = bitmap.buffer; i < bitmap.rows;
	179	i++, b += bitmap.pitch)
c2f5bfd6 KH	180	{
	181	for (j = 0; j < bitmap.width; j++)
	182	{
00c37e18 KH	183	int idx = (bitmap.bits_per_pixel == 1
	184	? ((b[j / 8] & (1 << (7 - (j % 8)))) ? 6 : -1)
	185	: (b[j] >> 5) - 1);
c2f5bfd6 KH	186
	187	if (idx >= 0)
	188	{
	189	XPoint pp = p + size idx;
	190
	191	pp[n[idx]].x = x + bitmap.left + j;
	192	pp[n[idx]].y = y - bitmap.top + i;
00c37e18	193	if (++(n[idx]) == size)
c2f5bfd6 KH	194	{
c2f5bfd6 KH	195	XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
00c37e18 KH	196	idx == 6 ? gc_fore : gcs[idx], pp, size,
00c37e18 KH	197	CoordModeOrigin);
c2f5bfd6 KH	198	n[idx] = 0;
	199	}
	200	}
	201	}
	202	}
00c37e18 KH	203	if (flush)
	204	{
	205	for (i = 0; i < 6; i++)
	206	if (n[i] > 0)
	207	XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
	208	gcs[i], p + 0x100 * i, n[i], CoordModeOrigin);
	209	if (n[6] > 0)
	210	XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
	211	gc_fore, p + 0x600, n[6], CoordModeOrigin);
	212	}
c2f5bfd6 KH	213	}
	214
	215	if (ftfont_driver.free_bitmap)
	216	ftfont_driver.free_bitmap (font, &bitmap);
	217
	218	return bitmap.advance;
	219	}
	220
	221	static void
971de7fb	222	ftxfont_draw_backgrond (FRAME_PTR f, struct font *font, GC gc, int x, int y, int width)
c2f5bfd6 KH	223	{
	224	XGCValues xgcv;
	225
	226	XGetGCValues (FRAME_X_DISPLAY (f), gc,
	227	GCForeground \| GCBackground, &xgcv);
	228	XSetForeground (FRAME_X_DISPLAY (f), gc, xgcv.background);
	229	XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
ab193662	230	x, y - FONT_BASE (font), width, FONT_HEIGHT (font));
c2f5bfd6 KH	231	XSetForeground (FRAME_X_DISPLAY (f), gc, xgcv.foreground);
	232	}
	233
	234	/* Prototypes for font-driver methods. */
f57e2426 J	235	static Lisp_Object ftxfont_list (Lisp_Object, Lisp_Object);
	236	static Lisp_Object ftxfont_match (Lisp_Object, Lisp_Object);
	237	static Lisp_Object ftxfont_open (FRAME_PTR, Lisp_Object, int);
	238	static void ftxfont_close (FRAME_PTR, struct font *);
	239	static int ftxfont_draw (struct glyph_string *, int, int, int, int, int);
c2f5bfd6	240
c2f5bfd6	241	static Lisp_Object
971de7fb	242	ftxfont_list (Lisp_Object frame, Lisp_Object spec)
c2f5bfd6	243	{
a952e54c	244	Lisp_Object list = ftfont_driver.list (frame, spec), tail;
1675728f	245
a952e54c KH	246	for (tail = list; CONSP (tail); tail = XCDR (tail))
	247	ASET (XCAR (tail), FONT_TYPE_INDEX, Qftx);
	248	return list;
c2f5bfd6 KH	249	}
c2f5bfd6 KH	250
3a91626c	251	static Lisp_Object
971de7fb	252	ftxfont_match (Lisp_Object frame, Lisp_Object spec)
3a91626c KH	253	{
	254	Lisp_Object entity = ftfont_driver.match (frame, spec);
	255
	256	if (VECTORP (entity))
	257	ASET (entity, FONT_TYPE_INDEX, Qftx);
	258	return entity;
	259	}
	260
a952e54c	261	static Lisp_Object
971de7fb	262	ftxfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
c2f5bfd6	263	{
a952e54c	264	Lisp_Object font_object;
c2f5bfd6	265	struct font *font;
c2f5bfd6	266
a952e54c KH	267	font_object = ftfont_driver.open (f, entity, pixel_size);
	268	if (NILP (font_object))
	269	return Qnil;
	270	font = XFONT_OBJECT (font_object);
	271	font->driver = &ftxfont_driver;
	272	return font_object;
c2f5bfd6 KH	273	}
	274
	275	static void
971de7fb	276	ftxfont_close (FRAME_PTR f, struct font *font)
c2f5bfd6 KH	277	{
c2f5bfd6 KH	278	ftfont_driver.close (f, font);
c2f5bfd6 KH	279	}
c2f5bfd6 KH	280
c2f5bfd6	281	static int
971de7fb	282	ftxfont_draw (struct glyph_string *s, int from, int to, int x, int y, int with_background)
c2f5bfd6 KH	283	{
	284	FRAME_PTR f = s->f;
	285	struct face *face = s->face;
a952e54c	286	struct font *font = s->font;
c2f5bfd6 KH	287	XPoint p[0x700];
	288	int n[7];
	289	unsigned *code;
	290	int len = to - from;
	291	int i;
056360d0	292	GC *gcs;
b9c2785e	293	int xadvance;
c2f5bfd6 KH	294
	295	n[0] = n[1] = n[2] = n[3] = n[4] = n[5] = n[6] = 0;
	296
	297	BLOCK_INPUT;
c2f5bfd6 KH	298	if (with_background)
	299	ftxfont_draw_backgrond (f, font, s->gc, x, y, s->width);
	300	code = alloca (sizeof (unsigned) * len);
	301	for (i = 0; i < len; i++)
	302	code[i] = ((XCHAR2B_BYTE1 (s->char2b + from + i) << 8)
	303	\| XCHAR2B_BYTE2 (s->char2b + from + i));
	304
00c37e18 KH	305	if (face->gc == s->gc)
	306	{
	307	gcs = ftxfont_get_gcs (f, face->foreground, face->background);
	308	}
	309	else
c2f5bfd6	310	{
056360d0 KH	311	XGCValues xgcv;
	312	unsigned long mask = GCForeground \| GCBackground;
	313
056360d0	314	XGetGCValues (FRAME_X_DISPLAY (f), s->gc, mask, &xgcv);
00c37e18	315	gcs = ftxfont_get_gcs (f, xgcv.foreground, xgcv.background);
056360d0 KH	316	}
056360d0 KH	317
00c37e18	318	if (gcs)
056360d0	319	{
00c37e18 KH	320	if (s->num_clips)
	321	for (i = 0; i < 6; i++)
	322	XSetClipRectangles (FRAME_X_DISPLAY (f), gcs[i], 0, 0,
	323	s->clip, s->num_clips, Unsorted);
	324
c2f5bfd6	325	for (i = 0; i < len; i++)
b9c2785e KH	326	{
	327	xadvance = ftxfont_draw_bitmap (f, s->gc, gcs, font, code[i], x, y,
	328	p, 0x100, n, i + 1 == len);
	329	x += (s->padding_p ? 1 : xadvance);
	330	}
00c37e18 KH	331	if (s->num_clips)
	332	for (i = 0; i < 6; i++)
	333	XSetClipMask (FRAME_X_DISPLAY (f), gcs[i], None);
c2f5bfd6 KH	334	}
	335	else
	336	{
00c37e18 KH	337	/* We can't draw with antialiasing.
00c37e18 KH	338	s->gc should already have a proper clipping setting. */
c2f5bfd6	339	for (i = 0; i < len; i++)
b9c2785e KH	340	{
	341	xadvance = ftxfont_draw_bitmap (f, s->gc, NULL, font, code[i], x, y,
	342	p, 0x700, n, i + 1 == len);
	343	x += (s->padding_p ? 1 : xadvance);
	344	}
c2f5bfd6 KH	345	}
	346
	347	UNBLOCK_INPUT;
	348
	349	return len;
	350	}
	351
00c37e18	352	static int
971de7fb	353	ftxfont_end_for_frame (FRAME_PTR f)
00c37e18 KH	354	{
00c37e18 KH	355	struct ftxfont_frame_data *data = font_get_frame_data (f, &ftxfont_driver);
1675728f	356
00c37e18 KH	357	BLOCK_INPUT;
	358	while (data)
	359	{
	360	struct ftxfont_frame_data *next = data->next;
	361	int i;
1675728f	362
b9217c57	363	for (i = 0; i < 6; i++)
00c37e18 KH	364	XFreeGC (FRAME_X_DISPLAY (f), data->gcs[i]);
	365	free (data);
	366	data = next;
	367	}
	368	UNBLOCK_INPUT;
559474f1	369	font_put_frame_data (f, &ftxfont_driver, NULL);
00c37e18 KH	370	return 0;
	371	}
	372
c2f5bfd6 KH	373	\f
	374
	375	void
971de7fb	376	syms_of_ftxfont (void)
c2f5bfd6 KH	377	{
	378	DEFSYM (Qftx, "ftx");
	379
	380	ftxfont_driver = ftfont_driver;
	381	ftxfont_driver.type = Qftx;
	382	ftxfont_driver.list = ftxfont_list;
3a91626c	383	ftxfont_driver.match = ftxfont_match;
c2f5bfd6 KH	384	ftxfont_driver.open = ftxfont_open;
c2f5bfd6 KH	385	ftxfont_driver.close = ftxfont_close;
c2f5bfd6	386	ftxfont_driver.draw = ftxfont_draw;
00c37e18	387	ftxfont_driver.end_for_frame = ftxfont_end_for_frame;
c2f5bfd6 KH	388	register_font_driver (&ftxfont_driver, NULL);
c2f5bfd6 KH	389	}