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

/* xftfont.c -- XFT font driver.
   Copyright (C) 2006 Free Software Foundation, Inc.
   Copyright (C) 2006
     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 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., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.  */

#include <config.h>
#include <stdio.h>
#include <X11/Xlib.h>
#include <X11/Xft/Xft.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"

/* Xft font driver.  */

static Lisp_Object Qxft;

/* The actual structure for Xft font that can be casted to struct
   font.  */

struct xftfont_info
{
  struct font font;
  Display *display;
  int screen;
  XftFont *xftfont;
  FT_Face ft_face;
};

/* Structure pointed by (struct face *)->extra  */
struct xftface_info
{
  XftColor xft_fg;
  XftColor xft_bg;
  XftDraw *xft_draw;
};

static void xftfont_get_colors P_ ((FRAME_PTR, struct face *, GC gc,
				    struct xftface_info *,
				    XftColor *fg, XftColor *bg));
static Font xftfont_default_fid P_ ((FRAME_PTR));


/* Setup colors pointed by FG and BG for GC.  If XFTFACE_INFO is not
   NULL, reuse the colors in it if possible.  BG may be NULL.  */
static void
xftfont_get_colors (f, face, gc, xftface_info, fg, bg)
     FRAME_PTR f;
     struct face *face;
     GC gc;
     struct xftface_info *xftface_info;
     XftColor *fg, *bg;
{
  if (xftface_info && face->gc == gc)
    {
      *fg = xftface_info->xft_fg;
      if (bg)
	*bg = xftface_info->xft_bg;
    }
  else
    {
      XGCValues xgcv;
      int fg_done = 0, bg_done = 0;

      BLOCK_INPUT;
      XGetGCValues (FRAME_X_DISPLAY (f), gc,
		    GCForeground | GCBackground, &xgcv);
      if (xftface_info)
	{
	  if (xgcv.foreground == face->foreground)
	    *fg = xftface_info->xft_fg, fg_done = 1;
	  else if (xgcv.foreground == face->background)
	    *fg = xftface_info->xft_bg, fg_done = 1;
	  if (! bg)
	    bg_done = 1;
	  else if (xgcv.background == face->background)
	    *bg = xftface_info->xft_bg, bg_done = 1;
	  else if (xgcv.background == face->foreground)
	    *bg = xftface_info->xft_fg, bg_done = 1;
	}

      if (fg_done + bg_done < 2)
	{
	  XColor colors[2];

	  colors[0].pixel = fg->pixel = xgcv.foreground;
	  if (bg)
	    colors[1].pixel = bg->pixel = xgcv.background;
	  XQueryColors (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), colors,
			bg ? 2 : 1);
	  fg->color.alpha = 0xFFFF;
	  fg->color.red = colors[0].red;
	  fg->color.green = colors[0].green;
	  fg->color.blue = colors[0].blue;
	  if (bg)
	    {
	      bg->color.alpha = 0xFFFF;
	      bg->color.red = colors[1].red;
	      bg->color.green = colors[1].green;
	      bg->color.blue = colors[1].blue;
	    }
	}
      UNBLOCK_INPUT;
    }
}

/* Return the default Font ID on frame F.  */

static Font
xftfont_default_fid (f)
     FRAME_PTR f;
{
  static int fid_known;
  static Font fid;

  if (! fid_known)
    {
      fid = XLoadFont (FRAME_X_DISPLAY (f), "fixed");
      if (! fid)
	{
	  fid = XLoadFont (FRAME_X_DISPLAY (f), "*");
	  if (! fid)
	    abort ();
	}
      fid_known = 1;
    }
  return fid;
}


static Lisp_Object xftfont_list P_ ((Lisp_Object, Lisp_Object));
static struct font *xftfont_open P_ ((FRAME_PTR, Lisp_Object, int));
static void xftfont_close P_ ((FRAME_PTR, struct font *));
static int xftfont_prepare_face P_ ((FRAME_PTR, struct face *));
static void xftfont_done_face P_ ((FRAME_PTR, struct face *));
static unsigned xftfont_encode_char P_ ((struct font *, int));
static int xftfont_text_extents P_ ((struct font *, unsigned *, int,
				     struct font_metrics *));
static int xftfont_draw P_ ((struct glyph_string *, int, int, int, int, int));

static int xftfont_anchor_point P_ ((struct font *, unsigned, int,
				     int *, int *));

struct font_driver xftfont_driver;

static Lisp_Object
xftfont_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, Qxft);
    }
  return val;
}

static FcChar8 ascii_printable[95];

static struct font *
xftfont_open (f, entity, pixel_size)
     FRAME_PTR f;
     Lisp_Object entity;
     int pixel_size;
{
  Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
  Display *display = FRAME_X_DISPLAY (f);
  Lisp_Object val;
  FcPattern *pattern, *pat;
  FcChar8 *file;
  XFontStruct *xfont;
  struct xftfont_info *xftfont_info;
  struct font *font;
  double size = 0;
  XftFont *xftfont;
  int spacing;

  val = AREF (entity, FONT_EXTRA_INDEX);
  if (XTYPE (val) != Lisp_Misc
      || XMISCTYPE (val) != Lisp_Misc_Save_Value)
    return NULL;
  pattern = XSAVE_VALUE (val)->pointer;
  if (FcPatternGetString (pattern, FC_FILE, 0, &file) != FcResultMatch)
    return NULL;

  size = XINT (AREF (entity, FONT_SIZE_INDEX));
  if (size == 0)
    size = pixel_size;
  pat = FcPatternCreate ();
  FcPatternAddString (pat, FC_FILE, file);
  FcPatternAddDouble (pat, FC_PIXEL_SIZE, pixel_size);
  FcPatternAddBool (pat, FC_ANTIALIAS, FcTrue);
  xftfont = XftFontOpenPattern (display, pat);
  /* We should not destroy PAT here because it is kept in XFTFONT and
     destroyed automatically when XFTFONT is closed.  */
  if (! xftfont)
    return NULL;

  xftfont_info = malloc (sizeof (struct xftfont_info));
  if (! xftfont_info)
    {
      XftFontClose (display, xftfont);
      return NULL;
    }
  xfont = malloc (sizeof (XFontStruct));
  if (! xftfont_info)
    {
      XftFontClose (display, xftfont);
      free (xftfont_info);
      return NULL;
    }
  xftfont_info->display = display;
  xftfont_info->screen = FRAME_X_SCREEN_NUMBER (f);
  xftfont_info->xftfont = xftfont;
  xftfont_info->ft_face = XftLockFace (xftfont);

  font = (struct font *) xftfont_info;
  font->entity = entity;
  font->pixel_size = size;
  font->driver = &xftfont_driver;
  font->font.name = font->font.full_name = NULL;
  font->file_name = (char *) file;
  font->font.size = xftfont->max_advance_width;
  font->ascent = xftfont->ascent;
  font->descent = xftfont->descent;
  font->font.height = xftfont->ascent + xftfont->descent;

  if (FcPatternGetInteger (xftfont->pattern, FC_SPACING, 0, &spacing)
      != FcResultMatch)
    spacing = FC_PROPORTIONAL;
  if (spacing != FC_PROPORTIONAL)
    font->font.average_width = font->font.space_width
      = xftfont->max_advance_width;
  else
    {
      XGlyphInfo extents;

      if (! ascii_printable[0])
	{
	  int i;
	  for (i = 0; i < 95; i++)
	    ascii_printable[i] = ' ' + i;
	}
      XftTextExtents8 (display, xftfont, ascii_printable, 1, &extents);
      font->font.space_width = extents.xOff;
      if (font->font.space_width <= 0)
	/* dirty workaround */
	font->font.space_width = pixel_size;	
      XftTextExtents8 (display, xftfont, ascii_printable + 1, 94, &extents);
      font->font.average_width = (font->font.space_width + extents.xOff) / 95;
    }

  /* Unfortunately Xft doesn't provide a way to get minimum char
     width.  So, we use space_width instead.  */
  font->min_width = font->font.space_width;

  font->font.baseline_offset = 0;
  font->font.relative_compose = 0;
  font->font.default_ascent = 0;
  font->font.vertical_centering = 0;

  /* Setup pseudo XFontStruct */
  xfont->fid = xftfont_default_fid (f);
  xfont->ascent = xftfont->ascent;
  xfont->descent = xftfont->descent;
  xfont->max_bounds.descent = xftfont->descent;
  xfont->max_bounds.width = xftfont->max_advance_width;
  xfont->min_bounds.width = font->font.space_width;
  font->font.font = xfont;

  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;
    }

  return font;
}

static void
xftfont_close (f, font)
     FRAME_PTR f;
     struct font *font;
{
  struct xftfont_info *xftfont_info = (struct xftfont_info *) font;

  XftUnlockFace (xftfont_info->xftfont);
  XftFontClose (xftfont_info->display, xftfont_info->xftfont);
  free (font);
  FRAME_X_DISPLAY_INFO (f)->n_fonts--;
}

static int
xftfont_prepare_face (f, face)
     FRAME_PTR f;
     struct face *face;
{
  struct xftface_info *xftface_info = malloc (sizeof (struct xftface_info));

  if (! xftface_info)
    return -1;

  BLOCK_INPUT;
  xftface_info->xft_draw = XftDrawCreate (FRAME_X_DISPLAY (f),
					  FRAME_X_WINDOW (f),
					  FRAME_X_VISUAL (f),
					  FRAME_X_COLORMAP (f));
  xftfont_get_colors (f, face, face->gc, NULL,
		      &xftface_info->xft_fg, &xftface_info->xft_bg);
  UNBLOCK_INPUT;

  face->extra = xftface_info;
  return 0;
}

static void
xftfont_done_face (f, face)
     FRAME_PTR f;
     struct face *face;
{
  struct xftface_info *xftface_info = (struct xftface_info *) face->extra;

  if (xftface_info)
    {
      BLOCK_INPUT;
      XftDrawDestroy (xftface_info->xft_draw);
      UNBLOCK_INPUT;
      free (xftface_info);
      face->extra = NULL;
    }
}

static unsigned
xftfont_encode_char (font, c)
     struct font *font;
     int c;
{
  struct xftfont_info *xftfont_info = (struct xftfont_info *) font;
  unsigned code = XftCharIndex (xftfont_info->display, xftfont_info->xftfont,
				(FcChar32) c);
  
  return (code ? code : 0xFFFFFFFF);
}

static int
xftfont_text_extents (font, code, nglyphs, metrics)
     struct font *font;
     unsigned *code;
     int nglyphs;
     struct font_metrics *metrics;
{
  struct xftfont_info *xftfont_info = (struct xftfont_info *) font;
  XGlyphInfo extents;

  BLOCK_INPUT;
  XftGlyphExtents (xftfont_info->display, xftfont_info->xftfont, code, nglyphs,
		   &extents);
  UNBLOCK_INPUT;
  if (metrics)
    {
      metrics->lbearing = - extents.x;
      metrics->rbearing = - extents.x + extents.width;
      metrics->width = extents.xOff;
      metrics->ascent = extents.y;
      metrics->descent = extents.y - extents.height;
    }
  return extents.xOff;
}

static int
xftfont_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 xftfont_info *xftfont_info = (struct xftfont_info *) face->font_info;
  struct xftface_info *xftface_info = (struct xftface_info *) face->extra;
  FT_UInt *code;
  XftColor fg, bg;
  XRectangle r;
  int len = to - from;
  int i;

  xftfont_get_colors (f, face, s->gc, xftface_info,
		      &fg, with_background ? &bg : NULL);
  BLOCK_INPUT;
  if (s->clip_width)
    {
      r.x = s->clip_x, r.width = s->clip_width;
      r.y = s->clip_y, r.height = s->clip_height;
      XftDrawSetClipRectangles (xftface_info->xft_draw, 0, 0, &r, 1);
    }
  if (with_background)
    {
      struct font *font = (struct font *) face->font_info;

      XftDrawRect (xftface_info->xft_draw, &bg,
		   x, y - face->font->ascent, s->width, font->font.height);
    }
  code = alloca (sizeof (FT_UInt) * len);
  for (i = 0; i < len; i++)
    code[i] = ((XCHAR2B_BYTE1 (s->char2b + from + i) << 8)
	       | XCHAR2B_BYTE2 (s->char2b + from + i));

  XftDrawGlyphs (xftface_info->xft_draw, &fg, xftfont_info->xftfont,
		 x, y, code, len);
  if (s->clip_width)
    XftDrawSetClip (xftface_info->xft_draw, NULL);
  UNBLOCK_INPUT;

  return len;
}

static int
xftfont_anchor_point (font, code, index, x, y)
     struct font *font;
     unsigned code;
     int index;
     int *x, *y;
{
  struct xftfont_info *xftfont_info = (struct xftfont_info *) font;
  FT_Face ft_face = xftfont_info->ft_face;

  if (FT_Load_Glyph (ft_face, code, FT_LOAD_DEFAULT) != 0)
    return -1;
  if (ft_face->glyph->format != FT_GLYPH_FORMAT_OUTLINE)
    return -1;
  if (index >= ft_face->glyph->outline.n_points)
    return -1;
  *x = ft_face->glyph->outline.points[index].x;
  *y = ft_face->glyph->outline.points[index].y;
  return 0;
}


void
syms_of_xftfont ()
{
  DEFSYM (Qxft, "xft");

  xftfont_driver = ftfont_driver;
  xftfont_driver.type = Qxft;
  xftfont_driver.get_cache = xfont_driver.get_cache;
  xftfont_driver.list = xftfont_list;
  xftfont_driver.open = xftfont_open;
  xftfont_driver.close = xftfont_close;
  xftfont_driver.prepare_face = xftfont_prepare_face;
  xftfont_driver.done_face = xftfont_done_face;
  xftfont_driver.encode_char = xftfont_encode_char;
  xftfont_driver.text_extents = xftfont_text_extents;
  xftfont_driver.draw = xftfont_draw;
  xftfont_driver.anchor_point = xftfont_anchor_point;

  register_font_driver (&xftfont_driver, NULL);
}

/* arch-tag: 64ec61bf-7c8e-4fe6-b953-c6a85d5e1605
   (do not change this comment) */
Commit	Line	Data
c2f5bfd6 KH	1	/* xftfont.c -- XFT font driver.
	2	Copyright (C) 2006 Free Software Foundation, Inc.
	3	Copyright (C) 2006
	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
	11	the Free Software Foundation; either version 2, or (at your option)
	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	#include <X11/Xft/Xft.h>
	28
	29	#include "lisp.h"
	30	#include "dispextern.h"
	31	#include "xterm.h"
	32	#include "frame.h"
	33	#include "blockinput.h"
	34	#include "character.h"
	35	#include "charset.h"
	36	#include "fontset.h"
	37	#include "font.h"
	38
	39	/* Xft font driver. */
	40
	41	static Lisp_Object Qxft;
	42
	43	/* The actual structure for Xft font that can be casted to struct
	44	font. */
	45
	46	struct xftfont_info
	47	{
	48	struct font font;
	49	Display *display;
	50	int screen;
	51	XftFont *xftfont;
	52	FT_Face ft_face;
	53	};
	54
	55	/* Structure pointed by (struct face )->extra /
	56	struct xftface_info
	57	{
	58	XftColor xft_fg;
	59	XftColor xft_bg;
	60	XftDraw *xft_draw;
	61	};
	62
	63	static void xftfont_get_colors P_ ((FRAME_PTR, struct face *, GC gc,
	64	struct xftface_info *,
65	XftColor fg, XftColor bg));
66	static Font xftfont_default_fid P_ ((FRAME_PTR));
67
68
69	/* Setup colors pointed by FG and BG for GC. If XFTFACE_INFO is not
70	NULL, reuse the colors in it if possible. BG may be NULL. */
71	static void
72	xftfont_get_colors (f, face, gc, xftface_info, fg, bg)
73	FRAME_PTR f;
74	struct face *face;
75	GC gc;
76	struct xftface_info *xftface_info;
77	XftColor fg, bg;
78	{
79	if (xftface_info && face->gc == gc)
80	{
81	*fg = xftface_info->xft_fg;
82	if (bg)
83	*bg = xftface_info->xft_bg;
84	}
85	else
86	{
87	XGCValues xgcv;
88	int fg_done = 0, bg_done = 0;
89
90	BLOCK_INPUT;
91	XGetGCValues (FRAME_X_DISPLAY (f), gc,
92	GCForeground \| GCBackground, &xgcv);
93	if (xftface_info)
94	{
95	if (xgcv.foreground == face->foreground)
96	*fg = xftface_info->xft_fg, fg_done = 1;
97	else if (xgcv.foreground == face->background)
98	*fg = xftface_info->xft_bg, fg_done = 1;
99	if (! bg)
100	bg_done = 1;
101	else if (xgcv.background == face->background)
102	*bg = xftface_info->xft_bg, bg_done = 1;
103	else if (xgcv.background == face->foreground)
104	*bg = xftface_info->xft_fg, bg_done = 1;
105	}
106
107	if (fg_done + bg_done < 2)
108	{
109	XColor colors[2];
110
111	colors[0].pixel = fg->pixel = xgcv.foreground;
112	if (bg)
113	colors[1].pixel = bg->pixel = xgcv.background;
114	XQueryColors (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), colors,
115	bg ? 2 : 1);
116	fg->color.alpha = 0xFFFF;
117	fg->color.red = colors[0].red;
118	fg->color.green = colors[0].green;
119	fg->color.blue = colors[0].blue;
120	if (bg)
121	{
122	bg->color.alpha = 0xFFFF;
123	bg->color.red = colors[1].red;
124	bg->color.green = colors[1].green;
125	bg->color.blue = colors[1].blue;
126	}
127	}
128	UNBLOCK_INPUT;
129	}
130	}
131
132	/* Return the default Font ID on frame F. */
133
134	static Font
135	xftfont_default_fid (f)
136	FRAME_PTR f;
137	{
138	static int fid_known;
139	static Font fid;
140
141	if (! fid_known)
142	{
143	fid = XLoadFont (FRAME_X_DISPLAY (f), "fixed");
144	if (! fid)
145	{
146	fid = XLoadFont (FRAME_X_DISPLAY (f), "*");
147	if (! fid)
148	abort ();
149	}
322f8671	150	fid_known = 1;
c2f5bfd6 KH	151	}
	152	return fid;
	153	}
	154
	155
	156	static Lisp_Object xftfont_list P_ ((Lisp_Object, Lisp_Object));
	157	static struct font *xftfont_open P_ ((FRAME_PTR, Lisp_Object, int));
	158	static void xftfont_close P_ ((FRAME_PTR, struct font *));
	159	static int xftfont_prepare_face P_ ((FRAME_PTR, struct face *));
	160	static void xftfont_done_face P_ ((FRAME_PTR, struct face *));
	161	static unsigned xftfont_encode_char P_ ((struct font *, int));
	162	static int xftfont_text_extents P_ ((struct font , unsigned , int,
	163	struct font_metrics *));
	164	static int xftfont_draw P_ ((struct glyph_string *, int, int, int, int, int));
	165
	166	static int xftfont_anchor_point P_ ((struct font *, unsigned, int,
	167	int , int ));
	168
	169	struct font_driver xftfont_driver;
	170
	171	static Lisp_Object
	172	xftfont_list (frame, spec)
	173	Lisp_Object frame;
	174	Lisp_Object spec;
	175	{
	176	Lisp_Object val = ftfont_driver.list (frame, spec);
	177
	178	if (! NILP (val))
	179	{
	180	int i;
	181
	182	for (i = 0; i < ASIZE (val); i++)
	183	ASET (AREF (val, i), FONT_TYPE_INDEX, Qxft);
	184	}
	185	return val;
	186	}
	187
	188	static FcChar8 ascii_printable[95];
	189
	190	static struct font *
	191	xftfont_open (f, entity, pixel_size)
	192	FRAME_PTR f;
	193	Lisp_Object entity;
	194	int pixel_size;
	195	{
	196	Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
	197	Display *display = FRAME_X_DISPLAY (f);
	198	Lisp_Object val;
	199	FcPattern pattern, pat;
	200	FcChar8 *file;
	201	XFontStruct *xfont;
	202	struct xftfont_info *xftfont_info;
	203	struct font *font;
	204	double size = 0;
	205	XftFont *xftfont;
	206	int spacing;
	207
	208	val = AREF (entity, FONT_EXTRA_INDEX);
	209	if (XTYPE (val) != Lisp_Misc
	210	\|\| XMISCTYPE (val) != Lisp_Misc_Save_Value)
	211	return NULL;
	212	pattern = XSAVE_VALUE (val)->pointer;
	213	if (FcPatternGetString (pattern, FC_FILE, 0, &file) != FcResultMatch)
	214	return NULL;
215
216	size = XINT (AREF (entity, FONT_SIZE_INDEX));
217	if (size == 0)
218	size = pixel_size;
219	pat = FcPatternCreate ();
220	FcPatternAddString (pat, FC_FILE, file);
221	FcPatternAddDouble (pat, FC_PIXEL_SIZE, pixel_size);
222	FcPatternAddBool (pat, FC_ANTIALIAS, FcTrue);
223	xftfont = XftFontOpenPattern (display, pat);
224	/* We should not destroy PAT here because it is kept in XFTFONT and
225	destroyed automatically when XFTFONT is closed. */
226	if (! xftfont)
227	return NULL;
228
229	xftfont_info = malloc (sizeof (struct xftfont_info));
230	if (! xftfont_info)
231	{
232	XftFontClose (display, xftfont);
233	return NULL;
234	}
235	xfont = malloc (sizeof (XFontStruct));
236	if (! xftfont_info)
237	{
238	XftFontClose (display, xftfont);
239	free (xftfont_info);
240	return NULL;
241	}
242	xftfont_info->display = display;
243	xftfont_info->screen = FRAME_X_SCREEN_NUMBER (f);
244	xftfont_info->xftfont = xftfont;
245	xftfont_info->ft_face = XftLockFace (xftfont);
246
247	font = (struct font *) xftfont_info;
248	font->entity = entity;
249	font->pixel_size = size;
250	font->driver = &xftfont_driver;
251	font->font.name = font->font.full_name = NULL;
252	font->file_name = (char *) file;
253	font->font.size = xftfont->max_advance_width;
254	font->ascent = xftfont->ascent;
255	font->descent = xftfont->descent;
256	font->font.height = xftfont->ascent + xftfont->descent;
257
258	if (FcPatternGetInteger (xftfont->pattern, FC_SPACING, 0, &spacing)
259	!= FcResultMatch)
260	spacing = FC_PROPORTIONAL;
261	if (spacing != FC_PROPORTIONAL)
262	font->font.average_width = font->font.space_width
263	= xftfont->max_advance_width;
264	else
265	{
266	XGlyphInfo extents;
267
268	if (! ascii_printable[0])
269	{
270	int i;
271	for (i = 0; i < 95; i++)
272	ascii_printable[i] = ' ' + i;
273	}
274	XftTextExtents8 (display, xftfont, ascii_printable, 1, &extents);
275	font->font.space_width = extents.xOff;
276	if (font->font.space_width <= 0)
277	/* dirty workaround */
278	font->font.space_width = pixel_size;
279	XftTextExtents8 (display, xftfont, ascii_printable + 1, 94, &extents);
280	font->font.average_width = (font->font.space_width + extents.xOff) / 95;
281	}
282
283	/* Unfortunately Xft doesn't provide a way to get minimum char
284	width. So, we use space_width instead. */
285	font->min_width = font->font.space_width;
286
287	font->font.baseline_offset = 0;
288	font->font.relative_compose = 0;
289	font->font.default_ascent = 0;
290	font->font.vertical_centering = 0;
291
292	/* Setup pseudo XFontStruct */
293	xfont->fid = xftfont_default_fid (f);
294	xfont->ascent = xftfont->ascent;
295	xfont->descent = xftfont->descent;
296	xfont->max_bounds.descent = xftfont->descent;
297	xfont->max_bounds.width = xftfont->max_advance_width;
298	xfont->min_bounds.width = font->font.space_width;
299	font->font.font = xfont;
300
301	dpyinfo->n_fonts++;
302
303	/* Set global flag fonts_changed_p to non-zero if the font loaded
304	has a character with a smaller width than any other character
305	before, or if the font loaded has a smaller height than any other
306	font loaded before. If this happens, it will make a glyph matrix
307	reallocation necessary. */
308	if (dpyinfo->n_fonts == 1)
309	{
310	dpyinfo->smallest_font_height = font->font.height;
311	dpyinfo->smallest_char_width = font->min_width;
312	fonts_changed_p = 1;
313	}
314	else
315	{
316	if (dpyinfo->smallest_font_height > font->font.height)
317	dpyinfo->smallest_font_height = font->font.height,
318	fonts_changed_p \|= 1;
319	if (dpyinfo->smallest_char_width > font->min_width)
320	dpyinfo->smallest_char_width = font->min_width,
321	fonts_changed_p \|= 1;
322	}
323
324	return font;
325	}
326
327	static void
328	xftfont_close (f, font)
329	FRAME_PTR f;
330	struct font *font;
331	{
332	struct xftfont_info xftfont_info = (struct xftfont_info ) font;
333
334	XftUnlockFace (xftfont_info->xftfont);
335	XftFontClose (xftfont_info->display, xftfont_info->xftfont);
336	free (font);
337	FRAME_X_DISPLAY_INFO (f)->n_fonts--;
338	}
339
c2f5bfd6 KH	340	static int
	341	xftfont_prepare_face (f, face)
	342	FRAME_PTR f;
	343	struct face *face;
	344	{
	345	struct xftface_info *xftface_info = malloc (sizeof (struct xftface_info));
	346
	347	if (! xftface_info)
	348	return -1;
	349
	350	BLOCK_INPUT;
	351	xftface_info->xft_draw = XftDrawCreate (FRAME_X_DISPLAY (f),
	352	FRAME_X_WINDOW (f),
	353	FRAME_X_VISUAL (f),
	354	FRAME_X_COLORMAP (f));
c2f5bfd6 KH	355	xftfont_get_colors (f, face, face->gc, NULL,
	356	&xftface_info->xft_fg, &xftface_info->xft_bg);
	357	UNBLOCK_INPUT;
	358
	359	face->extra = xftface_info;
	360	return 0;
	361	}
	362
	363	static void
	364	xftfont_done_face (f, face)
	365	FRAME_PTR f;
	366	struct face *face;
	367	{
	368	struct xftface_info xftface_info = (struct xftface_info ) face->extra;
	369
	370	if (xftface_info)
	371	{
	372	BLOCK_INPUT;
c2f5bfd6 KH	373	XftDrawDestroy (xftface_info->xft_draw);
	374	UNBLOCK_INPUT;
	375	free (xftface_info);
	376	face->extra = NULL;
	377	}
	378	}
	379
	380	static unsigned
	381	xftfont_encode_char (font, c)
	382	struct font *font;
	383	int c;
	384	{
	385	struct xftfont_info xftfont_info = (struct xftfont_info ) font;
	386	unsigned code = XftCharIndex (xftfont_info->display, xftfont_info->xftfont,
	387	(FcChar32) c);
	388
	389	return (code ? code : 0xFFFFFFFF);
	390	}
	391
	392	static int
	393	xftfont_text_extents (font, code, nglyphs, metrics)
	394	struct font *font;
	395	unsigned *code;
	396	int nglyphs;
	397	struct font_metrics *metrics;
	398	{
	399	struct xftfont_info xftfont_info = (struct xftfont_info ) font;
	400	XGlyphInfo extents;
	401
	402	BLOCK_INPUT;
	403	XftGlyphExtents (xftfont_info->display, xftfont_info->xftfont, code, nglyphs,
	404	&extents);
	405	UNBLOCK_INPUT;
	406	if (metrics)
	407	{
	408	metrics->lbearing = - extents.x;
	409	metrics->rbearing = - extents.x + extents.width;
	410	metrics->width = extents.xOff;
	411	metrics->ascent = extents.y;
	412	metrics->descent = extents.y - extents.height;
	413	}
	414	return extents.xOff;
	415	}
	416
	417	static int
	418	xftfont_draw (s, from, to, x, y, with_background)
	419	struct glyph_string *s;
	420	int from, to, x, y, with_background;
	421	{
	422	FRAME_PTR f = s->f;
	423	struct face *face = s->face;
	424	struct xftfont_info xftfont_info = (struct xftfont_info ) face->font_info;
	425	struct xftface_info xftface_info = (struct xftface_info ) face->extra;
	426	FT_UInt *code;
	427	XftColor fg, bg;
	428	XRectangle r;
	429	int len = to - from;
	430	int i;
	431
	432	xftfont_get_colors (f, face, s->gc, xftface_info,
322f8671	433	&fg, with_background ? &bg : NULL);
c2f5bfd6 KH	434	BLOCK_INPUT;
	435	if (s->clip_width)
	436	{
	437	r.x = s->clip_x, r.width = s->clip_width;
	438	r.y = s->clip_y, r.height = s->clip_height;
	439	XftDrawSetClipRectangles (xftface_info->xft_draw, 0, 0, &r, 1);
	440	}
	441	if (with_background)
	442	{
	443	struct font font = (struct font ) face->font_info;
	444
	445	XftDrawRect (xftface_info->xft_draw, &bg,
	446	x, y - face->font->ascent, s->width, font->font.height);
	447	}
	448	code = alloca (sizeof (FT_UInt) * len);
	449	for (i = 0; i < len; i++)
	450	code[i] = ((XCHAR2B_BYTE1 (s->char2b + from + i) << 8)
	451	\| XCHAR2B_BYTE2 (s->char2b + from + i));
	452
	453	XftDrawGlyphs (xftface_info->xft_draw, &fg, xftfont_info->xftfont,
	454	x, y, code, len);
	455	if (s->clip_width)
	456	XftDrawSetClip (xftface_info->xft_draw, NULL);
	457	UNBLOCK_INPUT;
	458
	459	return len;
	460	}
	461
	462	static int
	463	xftfont_anchor_point (font, code, index, x, y)
	464	struct font *font;
	465	unsigned code;
	466	int index;
	467	int x, y;
	468	{
	469	struct xftfont_info xftfont_info = (struct xftfont_info ) font;
	470	FT_Face ft_face = xftfont_info->ft_face;
	471
	472	if (FT_Load_Glyph (ft_face, code, FT_LOAD_DEFAULT) != 0)
	473	return -1;
	474	if (ft_face->glyph->format != FT_GLYPH_FORMAT_OUTLINE)
	475	return -1;
	476	if (index >= ft_face->glyph->outline.n_points)
	477	return -1;
	478	*x = ft_face->glyph->outline.points[index].x;
	479	*y = ft_face->glyph->outline.points[index].y;
	480	return 0;
	481	}
	482
	483
	484	void
	485	syms_of_xftfont ()
	486	{
	487	DEFSYM (Qxft, "xft");
	488
	489	xftfont_driver = ftfont_driver;
	490	xftfont_driver.type = Qxft;
	491	xftfont_driver.get_cache = xfont_driver.get_cache;
	492	xftfont_driver.list = xftfont_list;
	493	xftfont_driver.open = xftfont_open;
	494	xftfont_driver.close = xftfont_close;
	495	xftfont_driver.prepare_face = xftfont_prepare_face;
	496	xftfont_driver.done_face = xftfont_done_face;
	497	xftfont_driver.encode_char = xftfont_encode_char;
498	xftfont_driver.text_extents = xftfont_text_extents;
499	xftfont_driver.draw = xftfont_draw;
500	xftfont_driver.anchor_point = xftfont_anchor_point;
501
502	register_font_driver (&xftfont_driver, NULL);
503	}
885b7d09 MB	504
	505	/* arch-tag: 64ec61bf-7c8e-4fe6-b953-c6a85d5e1605
	506	(do not change this comment) */