[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->font.charset = font->encoding_charset = font->repertory_charset = -1;
  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 0
  /* This doesn't work if face->ascii_face doesn't use an Xft font. */
  if (face != face->ascii_face)
    {
      face->extra = face->ascii_face->extra;
      return 0;
    }
#endif

  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 0
  /* This doesn't work if face->ascii_face doesn't use an Xft font. */
  if (face != face->ascii_face
      || ! face->extra)
    return;
#endif

  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;
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;
c2f5bfd6 KH	263	font->font.size = xftfont->max_advance_width;
8bf90572	264	font->font.charset = font->encoding_charset = font->repertory_charset = -1;
c2f5bfd6 KH	265	font->ascent = xftfont->ascent;
	266	font->descent = xftfont->descent;
	267	font->font.height = xftfont->ascent + xftfont->descent;
	268
	269	if (FcPatternGetInteger (xftfont->pattern, FC_SPACING, 0, &spacing)
	270	!= FcResultMatch)
	271	spacing = FC_PROPORTIONAL;
	272	if (spacing != FC_PROPORTIONAL)
	273	font->font.average_width = font->font.space_width
	274	= xftfont->max_advance_width;
	275	else
	276	{
	277	XGlyphInfo extents;
	278
	279	if (! ascii_printable[0])
	280	{
	281	int i;
	282	for (i = 0; i < 95; i++)
	283	ascii_printable[i] = ' ' + i;
	284	}
	285	XftTextExtents8 (display, xftfont, ascii_printable, 1, &extents);
	286	font->font.space_width = extents.xOff;
	287	if (font->font.space_width <= 0)
	288	/* dirty workaround */
	289	font->font.space_width = pixel_size;
	290	XftTextExtents8 (display, xftfont, ascii_printable + 1, 94, &extents);
	291	font->font.average_width = (font->font.space_width + extents.xOff) / 95;
	292	}
dcce3c58	293	UNBLOCK_INPUT;
c2f5bfd6 KH	294
	295	/* Unfortunately Xft doesn't provide a way to get minimum char
	296	width. So, we use space_width instead. */
	297	font->min_width = font->font.space_width;
	298
	299	font->font.baseline_offset = 0;
	300	font->font.relative_compose = 0;
	301	font->font.default_ascent = 0;
	302	font->font.vertical_centering = 0;
	303
	304	/* Setup pseudo XFontStruct */
	305	xfont->fid = xftfont_default_fid (f);
	306	xfont->ascent = xftfont->ascent;
	307	xfont->descent = xftfont->descent;
	308	xfont->max_bounds.descent = xftfont->descent;
	309	xfont->max_bounds.width = xftfont->max_advance_width;
	310	xfont->min_bounds.width = font->font.space_width;
	311	font->font.font = xfont;
	312
	313	dpyinfo->n_fonts++;
	314
	315	/* Set global flag fonts_changed_p to non-zero if the font loaded
	316	has a character with a smaller width than any other character
	317	before, or if the font loaded has a smaller height than any other
	318	font loaded before. If this happens, it will make a glyph matrix
	319	reallocation necessary. */
	320	if (dpyinfo->n_fonts == 1)
	321	{
	322	dpyinfo->smallest_font_height = font->font.height;
	323	dpyinfo->smallest_char_width = font->min_width;
	324	fonts_changed_p = 1;
	325	}
	326	else
	327	{
	328	if (dpyinfo->smallest_font_height > font->font.height)
	329	dpyinfo->smallest_font_height = font->font.height,
	330	fonts_changed_p \|= 1;
	331	if (dpyinfo->smallest_char_width > font->min_width)
	332	dpyinfo->smallest_char_width = font->min_width,
	333	fonts_changed_p \|= 1;
	334	}
	335
	336	return font;
2d93c6bd KH	337
	338	err:
	339	if (xftfont) XftFontClose (display, xftfont);
	340	UNBLOCK_INPUT;
	341	if (xftfont_info) free (xftfont_info);
	342	if (xfont) free (xfont);
	343	return NULL;
c2f5bfd6 KH	344	}
	345
	346	static void
	347	xftfont_close (f, font)
	348	FRAME_PTR f;
	349	struct font *font;
	350	{
	351	struct xftfont_info xftfont_info = (struct xftfont_info ) font;
	352
	353	XftUnlockFace (xftfont_info->xftfont);
	354	XftFontClose (xftfont_info->display, xftfont_info->xftfont);
dcce3c58 KH	355	if (font->font.name)
dcce3c58 KH	356	free (font->font.name);
c2f5bfd6 KH	357	free (font);
	358	FRAME_X_DISPLAY_INFO (f)->n_fonts--;
	359	}
	360
c2f5bfd6 KH	361	static int
	362	xftfont_prepare_face (f, face)
	363	FRAME_PTR f;
	364	struct face *face;
	365	{
e2d0c925	366	struct xftface_info *xftface_info;
c2f5bfd6	367
a703d27d KH	368	#if 0
a703d27d KH	369	/* This doesn't work if face->ascii_face doesn't use an Xft font. */
e2d0c925 KH	370	if (face != face->ascii_face)
	371	{
	372	face->extra = face->ascii_face->extra;
	373	return 0;
	374	}
a703d27d	375	#endif
e2d0c925 KH	376
e2d0c925 KH	377	xftface_info = malloc (sizeof (struct xftface_info));
c2f5bfd6 KH	378	if (! xftface_info)
	379	return -1;
	380
	381	BLOCK_INPUT;
	382	xftface_info->xft_draw = XftDrawCreate (FRAME_X_DISPLAY (f),
	383	FRAME_X_WINDOW (f),
	384	FRAME_X_VISUAL (f),
	385	FRAME_X_COLORMAP (f));
c2f5bfd6 KH	386	xftfont_get_colors (f, face, face->gc, NULL,
	387	&xftface_info->xft_fg, &xftface_info->xft_bg);
	388	UNBLOCK_INPUT;
	389
	390	face->extra = xftface_info;
	391	return 0;
	392	}
	393
	394	static void
	395	xftfont_done_face (f, face)
	396	FRAME_PTR f;
	397	struct face *face;
	398	{
e2d0c925 KH	399	struct xftface_info *xftface_info;
e2d0c925 KH	400
a703d27d KH	401	#if 0
a703d27d KH	402	/* This doesn't work if face->ascii_face doesn't use an Xft font. */
e2d0c925 KH	403	if (face != face->ascii_face
	404	\|\| ! face->extra)
	405	return;
a703d27d	406	#endif
c2f5bfd6	407
e2d0c925	408	xftface_info = (struct xftface_info *) face->extra;
773039e8 JD	409	if (xftface_info)
	410	{
	411	BLOCK_INPUT;
	412	XftDrawDestroy (xftface_info->xft_draw);
	413	UNBLOCK_INPUT;
	414	free (xftface_info);
	415	}
e2d0c925	416	face->extra = NULL;
c2f5bfd6 KH	417	}
	418
	419	static unsigned
	420	xftfont_encode_char (font, c)
	421	struct font *font;
	422	int c;
	423	{
	424	struct xftfont_info xftfont_info = (struct xftfont_info ) font;
	425	unsigned code = XftCharIndex (xftfont_info->display, xftfont_info->xftfont,
	426	(FcChar32) c);
	427
	428	return (code ? code : 0xFFFFFFFF);
	429	}
	430
	431	static int
	432	xftfont_text_extents (font, code, nglyphs, metrics)
	433	struct font *font;
	434	unsigned *code;
	435	int nglyphs;
	436	struct font_metrics *metrics;
	437	{
	438	struct xftfont_info xftfont_info = (struct xftfont_info ) font;
	439	XGlyphInfo extents;
	440
	441	BLOCK_INPUT;
	442	XftGlyphExtents (xftfont_info->display, xftfont_info->xftfont, code, nglyphs,
	443	&extents);
	444	UNBLOCK_INPUT;
	445	if (metrics)
	446	{
	447	metrics->lbearing = - extents.x;
	448	metrics->rbearing = - extents.x + extents.width;
	449	metrics->width = extents.xOff;
	450	metrics->ascent = extents.y;
	451	metrics->descent = extents.y - extents.height;
	452	}
	453	return extents.xOff;
	454	}
	455
	456	static int
	457	xftfont_draw (s, from, to, x, y, with_background)
	458	struct glyph_string *s;
	459	int from, to, x, y, with_background;
	460	{
	461	FRAME_PTR f = s->f;
	462	struct face *face = s->face;
	463	struct xftfont_info xftfont_info = (struct xftfont_info ) face->font_info;
	464	struct xftface_info xftface_info = (struct xftface_info ) face->extra;
	465	FT_UInt *code;
	466	XftColor fg, bg;
	467	XRectangle r;
	468	int len = to - from;
	469	int i;
	470
	471	xftfont_get_colors (f, face, s->gc, xftface_info,
322f8671	472	&fg, with_background ? &bg : NULL);
c2f5bfd6 KH	473	BLOCK_INPUT;
	474	if (s->clip_width)
	475	{
	476	r.x = s->clip_x, r.width = s->clip_width;
	477	r.y = s->clip_y, r.height = s->clip_height;
	478	XftDrawSetClipRectangles (xftface_info->xft_draw, 0, 0, &r, 1);
	479	}
	480	if (with_background)
	481	{
	482	struct font font = (struct font ) face->font_info;
	483
	484	XftDrawRect (xftface_info->xft_draw, &bg,
	485	x, y - face->font->ascent, s->width, font->font.height);
	486	}
	487	code = alloca (sizeof (FT_UInt) * len);
	488	for (i = 0; i < len; i++)
	489	code[i] = ((XCHAR2B_BYTE1 (s->char2b + from + i) << 8)
	490	\| XCHAR2B_BYTE2 (s->char2b + from + i));
	491
	492	XftDrawGlyphs (xftface_info->xft_draw, &fg, xftfont_info->xftfont,
	493	x, y, code, len);
	494	if (s->clip_width)
	495	XftDrawSetClip (xftface_info->xft_draw, NULL);
	496	UNBLOCK_INPUT;
	497
	498	return len;
	499	}
	500
	501	static int
	502	xftfont_anchor_point (font, code, index, x, y)
	503	struct font *font;
	504	unsigned code;
	505	int index;
	506	int x, y;
	507	{
	508	struct xftfont_info xftfont_info = (struct xftfont_info ) font;
	509	FT_Face ft_face = xftfont_info->ft_face;
	510
	511	if (FT_Load_Glyph (ft_face, code, FT_LOAD_DEFAULT) != 0)
	512	return -1;
	513	if (ft_face->glyph->format != FT_GLYPH_FORMAT_OUTLINE)
	514	return -1;
	515	if (index >= ft_face->glyph->outline.n_points)
	516	return -1;
	517	*x = ft_face->glyph->outline.points[index].x;
	518	*y = ft_face->glyph->outline.points[index].y;
	519	return 0;
	520	}
	521
	522
	523	void
	524	syms_of_xftfont ()
	525	{
	526	DEFSYM (Qxft, "xft");
	527
	528	xftfont_driver = ftfont_driver;
	529	xftfont_driver.type = Qxft;
	530	xftfont_driver.get_cache = xfont_driver.get_cache;
	531	xftfont_driver.list = xftfont_list;
	532	xftfont_driver.open = xftfont_open;
	533	xftfont_driver.close = xftfont_close;
	534	xftfont_driver.prepare_face = xftfont_prepare_face;
	535	xftfont_driver.done_face = xftfont_done_face;
	536	xftfont_driver.encode_char = xftfont_encode_char;
537	xftfont_driver.text_extents = xftfont_text_extents;
538	xftfont_driver.draw = xftfont_draw;
539	xftfont_driver.anchor_point = xftfont_anchor_point;
540
541	register_font_driver (&xftfont_driver, NULL);
542	}
885b7d09 MB	543
	544	/* arch-tag: 64ec61bf-7c8e-4fe6-b953-c6a85d5e1605
	545	(do not change this comment) */