[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 = NULL;
  FcChar8 *file;
  struct xftfont_info *xftfont_info = NULL;
  XFontStruct *xfont = NULL;
  struct font *font;
  double size = 0;
  XftFont *xftfont = NULL;
  int spacing;
  char *name;
  int len;

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

  BLOCK_INPUT;
  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)
    goto err;

  xftfont_info = malloc (sizeof (struct xftfont_info));
  if (! xftfont_info)
    goto err;
  xfont = malloc (sizeof (XFontStruct));
  if (! xfont)
    goto err;
  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;
  len = 96;
  name = malloc (len);
  while (name && font_unparse_fcname (entity, pixel_size, name, len) < 0)
    {
      char *new = realloc (name, len += 32);

      if (! new)
	free (name);
      name = new;
    }
  if (! name)
    goto err;
  font->font.full_name = font->font.name = name;
  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;
    }
  UNBLOCK_INPUT;

  /* 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;

 err:
  if (xftfont) XftFontClose (display, xftfont);
  UNBLOCK_INPUT;
  if (xftfont_info) free (xftfont_info);
  if (xfont) free (xfont);
  return NULL;
}

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);
  if (font->font.name)
    free (font->font.name);
  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;

  if (face != face->ascii_face)
    {
      face->extra = face->ascii_face->extra;
      return 0;
    }

  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;
  
  if (face != face->ascii_face
      || ! face->extra)
    return;

  xftface_info = (struct xftface_info *) face->extra;
  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;
2d93c6bd KH	199	FcPattern pattern, pat = NULL;
	200	FcChar8 *file;
	201	struct xftfont_info *xftfont_info = NULL;
	202	XFontStruct *xfont = NULL;
c2f5bfd6 KH	203	struct font *font;
c2f5bfd6 KH	204	double size = 0;
2d93c6bd	205	XftFont *xftfont = NULL;
c2f5bfd6	206	int spacing;
2d93c6bd	207	char *name;
dcce3c58	208	int len;
c2f5bfd6 KH	209
	210	val = AREF (entity, FONT_EXTRA_INDEX);
	211	if (XTYPE (val) != Lisp_Misc
	212	\|\| XMISCTYPE (val) != Lisp_Misc_Save_Value)
	213	return NULL;
	214	pattern = XSAVE_VALUE (val)->pointer;
	215	if (FcPatternGetString (pattern, FC_FILE, 0, &file) != FcResultMatch)
	216	return NULL;
	217
	218	size = XINT (AREF (entity, FONT_SIZE_INDEX));
	219	if (size == 0)
	220	size = pixel_size;
dcce3c58	221
c2f5bfd6 KH	222	pat = FcPatternCreate ();
	223	FcPatternAddString (pat, FC_FILE, file);
	224	FcPatternAddDouble (pat, FC_PIXEL_SIZE, pixel_size);
	225	FcPatternAddBool (pat, FC_ANTIALIAS, FcTrue);
dcce3c58 KH	226
dcce3c58 KH	227	BLOCK_INPUT;
c2f5bfd6 KH	228	xftfont = XftFontOpenPattern (display, pat);
	229	/* We should not destroy PAT here because it is kept in XFTFONT and
	230	destroyed automatically when XFTFONT is closed. */
	231	if (! xftfont)
2d93c6bd	232	goto err;
c2f5bfd6 KH	233
	234	xftfont_info = malloc (sizeof (struct xftfont_info));
	235	if (! xftfont_info)
2d93c6bd	236	goto err;
c2f5bfd6	237	xfont = malloc (sizeof (XFontStruct));
2d93c6bd KH	238	if (! xfont)
2d93c6bd KH	239	goto err;
c2f5bfd6 KH	240	xftfont_info->display = display;
	241	xftfont_info->screen = FRAME_X_SCREEN_NUMBER (f);
	242	xftfont_info->xftfont = xftfont;
	243	xftfont_info->ft_face = XftLockFace (xftfont);
	244
	245	font = (struct font *) xftfont_info;
	246	font->entity = entity;
	247	font->pixel_size = size;
	248	font->driver = &xftfont_driver;
560fd3fa	249	len = 96;
2d93c6bd KH	250	name = malloc (len);
	251	while (name && font_unparse_fcname (entity, pixel_size, name, len) < 0)
	252	{
	253	char *new = realloc (name, len += 32);
	254
	255	if (! new)
	256	free (name);
	257	name = new;
	258	}
	259	if (! name)
	260	goto err;
	261	font->font.full_name = font->font.name = name;
c2f5bfd6 KH	262	font->file_name = (char *) file;
	263	font->font.size = xftfont->max_advance_width;
	264	font->ascent = xftfont->ascent;
	265	font->descent = xftfont->descent;
	266	font->font.height = xftfont->ascent + xftfont->descent;
	267
	268	if (FcPatternGetInteger (xftfont->pattern, FC_SPACING, 0, &spacing)
	269	!= FcResultMatch)
	270	spacing = FC_PROPORTIONAL;
	271	if (spacing != FC_PROPORTIONAL)
	272	font->font.average_width = font->font.space_width
	273	= xftfont->max_advance_width;
	274	else
	275	{
	276	XGlyphInfo extents;
	277
	278	if (! ascii_printable[0])
	279	{
	280	int i;
	281	for (i = 0; i < 95; i++)
	282	ascii_printable[i] = ' ' + i;
	283	}
	284	XftTextExtents8 (display, xftfont, ascii_printable, 1, &extents);
	285	font->font.space_width = extents.xOff;
	286	if (font->font.space_width <= 0)
	287	/* dirty workaround */
	288	font->font.space_width = pixel_size;
	289	XftTextExtents8 (display, xftfont, ascii_printable + 1, 94, &extents);
	290	font->font.average_width = (font->font.space_width + extents.xOff) / 95;
	291	}
dcce3c58	292	UNBLOCK_INPUT;
c2f5bfd6 KH	293
	294	/* Unfortunately Xft doesn't provide a way to get minimum char
	295	width. So, we use space_width instead. */
	296	font->min_width = font->font.space_width;
	297
	298	font->font.baseline_offset = 0;
	299	font->font.relative_compose = 0;
	300	font->font.default_ascent = 0;
	301	font->font.vertical_centering = 0;
	302
	303	/* Setup pseudo XFontStruct */
	304	xfont->fid = xftfont_default_fid (f);
	305	xfont->ascent = xftfont->ascent;
	306	xfont->descent = xftfont->descent;
	307	xfont->max_bounds.descent = xftfont->descent;
	308	xfont->max_bounds.width = xftfont->max_advance_width;
	309	xfont->min_bounds.width = font->font.space_width;
	310	font->font.font = xfont;
	311
	312	dpyinfo->n_fonts++;
	313
	314	/* Set global flag fonts_changed_p to non-zero if the font loaded
	315	has a character with a smaller width than any other character
	316	before, or if the font loaded has a smaller height than any other
	317	font loaded before. If this happens, it will make a glyph matrix
	318	reallocation necessary. */
	319	if (dpyinfo->n_fonts == 1)
	320	{
	321	dpyinfo->smallest_font_height = font->font.height;
	322	dpyinfo->smallest_char_width = font->min_width;
	323	fonts_changed_p = 1;
	324	}
	325	else
	326	{
	327	if (dpyinfo->smallest_font_height > font->font.height)
	328	dpyinfo->smallest_font_height = font->font.height,
	329	fonts_changed_p \|= 1;
	330	if (dpyinfo->smallest_char_width > font->min_width)
	331	dpyinfo->smallest_char_width = font->min_width,
	332	fonts_changed_p \|= 1;
	333	}
	334
	335	return font;
2d93c6bd KH	336
	337	err:
	338	if (xftfont) XftFontClose (display, xftfont);
	339	UNBLOCK_INPUT;
	340	if (xftfont_info) free (xftfont_info);
	341	if (xfont) free (xfont);
	342	return NULL;
c2f5bfd6 KH	343	}
	344
	345	static void
	346	xftfont_close (f, font)
	347	FRAME_PTR f;
	348	struct font *font;
	349	{
	350	struct xftfont_info xftfont_info = (struct xftfont_info ) font;
	351
	352	XftUnlockFace (xftfont_info->xftfont);
	353	XftFontClose (xftfont_info->display, xftfont_info->xftfont);
dcce3c58 KH	354	if (font->font.name)
dcce3c58 KH	355	free (font->font.name);
c2f5bfd6 KH	356	free (font);
	357	FRAME_X_DISPLAY_INFO (f)->n_fonts--;
	358	}
	359
c2f5bfd6 KH	360	static int
	361	xftfont_prepare_face (f, face)
	362	FRAME_PTR f;
	363	struct face *face;
	364	{
e2d0c925	365	struct xftface_info *xftface_info;
c2f5bfd6	366
e2d0c925 KH	367	if (face != face->ascii_face)
	368	{
	369	face->extra = face->ascii_face->extra;
	370	return 0;
	371	}
	372
	373	xftface_info = malloc (sizeof (struct xftface_info));
c2f5bfd6 KH	374	if (! xftface_info)
	375	return -1;
	376
	377	BLOCK_INPUT;
	378	xftface_info->xft_draw = XftDrawCreate (FRAME_X_DISPLAY (f),
	379	FRAME_X_WINDOW (f),
	380	FRAME_X_VISUAL (f),
	381	FRAME_X_COLORMAP (f));
c2f5bfd6 KH	382	xftfont_get_colors (f, face, face->gc, NULL,
	383	&xftface_info->xft_fg, &xftface_info->xft_bg);
	384	UNBLOCK_INPUT;
	385
	386	face->extra = xftface_info;
	387	return 0;
	388	}
	389
	390	static void
	391	xftfont_done_face (f, face)
	392	FRAME_PTR f;
	393	struct face *face;
	394	{
e2d0c925 KH	395	struct xftface_info *xftface_info;
	396
	397	if (face != face->ascii_face
	398	\|\| ! face->extra)
	399	return;
c2f5bfd6	400
e2d0c925 KH	401	xftface_info = (struct xftface_info *) face->extra;
	402	BLOCK_INPUT;
	403	XftDrawDestroy (xftface_info->xft_draw);
	404	UNBLOCK_INPUT;
	405	free (xftface_info);
	406	face->extra = NULL;
c2f5bfd6 KH	407	}
	408
	409	static unsigned
	410	xftfont_encode_char (font, c)
	411	struct font *font;
	412	int c;
	413	{
	414	struct xftfont_info xftfont_info = (struct xftfont_info ) font;
	415	unsigned code = XftCharIndex (xftfont_info->display, xftfont_info->xftfont,
	416	(FcChar32) c);
	417
	418	return (code ? code : 0xFFFFFFFF);
	419	}
	420
	421	static int
	422	xftfont_text_extents (font, code, nglyphs, metrics)
	423	struct font *font;
	424	unsigned *code;
	425	int nglyphs;
	426	struct font_metrics *metrics;
	427	{
	428	struct xftfont_info xftfont_info = (struct xftfont_info ) font;
	429	XGlyphInfo extents;
	430
	431	BLOCK_INPUT;
	432	XftGlyphExtents (xftfont_info->display, xftfont_info->xftfont, code, nglyphs,
	433	&extents);
	434	UNBLOCK_INPUT;
	435	if (metrics)
	436	{
	437	metrics->lbearing = - extents.x;
	438	metrics->rbearing = - extents.x + extents.width;
	439	metrics->width = extents.xOff;
	440	metrics->ascent = extents.y;
	441	metrics->descent = extents.y - extents.height;
	442	}
	443	return extents.xOff;
	444	}
	445
	446	static int
	447	xftfont_draw (s, from, to, x, y, with_background)
	448	struct glyph_string *s;
	449	int from, to, x, y, with_background;
	450	{
	451	FRAME_PTR f = s->f;
	452	struct face *face = s->face;
	453	struct xftfont_info xftfont_info = (struct xftfont_info ) face->font_info;
	454	struct xftface_info xftface_info = (struct xftface_info ) face->extra;
	455	FT_UInt *code;
	456	XftColor fg, bg;
	457	XRectangle r;
	458	int len = to - from;
	459	int i;
	460
	461	xftfont_get_colors (f, face, s->gc, xftface_info,
322f8671	462	&fg, with_background ? &bg : NULL);
c2f5bfd6 KH	463	BLOCK_INPUT;
	464	if (s->clip_width)
	465	{
	466	r.x = s->clip_x, r.width = s->clip_width;
	467	r.y = s->clip_y, r.height = s->clip_height;
	468	XftDrawSetClipRectangles (xftface_info->xft_draw, 0, 0, &r, 1);
	469	}
	470	if (with_background)
	471	{
	472	struct font font = (struct font ) face->font_info;
	473
	474	XftDrawRect (xftface_info->xft_draw, &bg,
	475	x, y - face->font->ascent, s->width, font->font.height);
	476	}
	477	code = alloca (sizeof (FT_UInt) * len);
	478	for (i = 0; i < len; i++)
	479	code[i] = ((XCHAR2B_BYTE1 (s->char2b + from + i) << 8)
	480	\| XCHAR2B_BYTE2 (s->char2b + from + i));
	481
	482	XftDrawGlyphs (xftface_info->xft_draw, &fg, xftfont_info->xftfont,
	483	x, y, code, len);
	484	if (s->clip_width)
	485	XftDrawSetClip (xftface_info->xft_draw, NULL);
	486	UNBLOCK_INPUT;
	487
	488	return len;
	489	}
	490
	491	static int
	492	xftfont_anchor_point (font, code, index, x, y)
	493	struct font *font;
	494	unsigned code;
	495	int index;
	496	int x, y;
	497	{
	498	struct xftfont_info xftfont_info = (struct xftfont_info ) font;
	499	FT_Face ft_face = xftfont_info->ft_face;
	500
	501	if (FT_Load_Glyph (ft_face, code, FT_LOAD_DEFAULT) != 0)
	502	return -1;
	503	if (ft_face->glyph->format != FT_GLYPH_FORMAT_OUTLINE)
	504	return -1;
	505	if (index >= ft_face->glyph->outline.n_points)
	506	return -1;
	507	*x = ft_face->glyph->outline.points[index].x;
	508	*y = ft_face->glyph->outline.points[index].y;
	509	return 0;
	510	}
	511
	512
	513	void
	514	syms_of_xftfont ()
	515	{
	516	DEFSYM (Qxft, "xft");
	517
	518	xftfont_driver = ftfont_driver;
	519	xftfont_driver.type = Qxft;
	520	xftfont_driver.get_cache = xfont_driver.get_cache;
	521	xftfont_driver.list = xftfont_list;
	522	xftfont_driver.open = xftfont_open;
	523	xftfont_driver.close = xftfont_close;
	524	xftfont_driver.prepare_face = xftfont_prepare_face;
	525	xftfont_driver.done_face = xftfont_done_face;
	526	xftfont_driver.encode_char = xftfont_encode_char;
527	xftfont_driver.text_extents = xftfont_text_extents;
528	xftfont_driver.draw = xftfont_draw;
529	xftfont_driver.anchor_point = xftfont_anchor_point;
530
531	register_font_driver (&xftfont_driver, NULL);
532	}
885b7d09 MB	533
	534	/* arch-tag: 64ec61bf-7c8e-4fe6-b953-c6a85d5e1605
	535	(do not change this comment) */