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

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

This file is part of GNU Emacs.

GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING.  If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.  */

#include <config.h>
#include <stdio.h>
#include <X11/Xlib.h>
#include <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"
#include "ftfont.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;
#ifdef HAVE_LIBOTF
  int maybe_otf;	  /* Flag to tell if this may be OTF or not.  */
  OTF *otf;
#endif	/* HAVE_LIBOTF */
};

/* Structure pointed by (struct face *)->extra  */

struct xftface_info
{
  XftColor xft_fg;		/* color for face->foreground */
  XftColor xft_bg;		/* color for face->background */
};

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


/* Setup foreground and background colors of GC into FG and BG.  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;
    }
}


static Lisp_Object xftfont_list P_ ((Lisp_Object, Lisp_Object));
static Lisp_Object xftfont_match 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 *));
static int xftfont_end_for_frame P_ ((FRAME_PTR f));

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);
  int i;
  
  if (! NILP (val))
    for (i = 0; i < ASIZE (val); i++)
      ASET (AREF (val, i), FONT_TYPE_INDEX, Qxft);
  return val;
}

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

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

extern Lisp_Object ftfont_font_format P_ ((FcPattern *));

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;
  XGlyphInfo extents;
  FT_Face ft_face;

  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);*/
  val = AREF (entity, FONT_FAMILY_INDEX);
  if (! NILP (val))
    FcPatternAddString (pat, FC_FAMILY, (FcChar8 *) SDATA (SYMBOL_NAME (val)));
  FcConfigSubstitute (NULL, pat, FcMatchPattern);

  BLOCK_INPUT;
  XftDefaultSubstitute (display, FRAME_X_SCREEN_NUMBER (f), pat);
  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;
#ifdef HAVE_LIBOTF
  ft_face = XftLockFace (xftfont);
  xftfont_info->maybe_otf = ft_face->face_flags & FT_FACE_FLAG_SFNT;
  XftUnlockFace (xftfont);
  xftfont_info->otf = NULL;
#endif	/* HAVE_LIBOTF */

  font = (struct font *) xftfont_info;
  font->format = ftfont_font_format (xftfont->pattern);
  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;

  if (FcPatternGetInteger (xftfont->pattern, FC_SPACING, 0, &spacing)
      != FcResultMatch)
    spacing = FC_PROPORTIONAL;
  if (! ascii_printable[0])
    {
      int i;
      for (i = 0; i < 95; i++)
	ascii_printable[i] = ' ' + i;
    }
  if (spacing != FC_PROPORTIONAL)
    {
      font->font.average_width = font->font.space_width
	= xftfont->max_advance_width;
      XftTextExtents8 (display, xftfont, ascii_printable + 1, 94, &extents);
    }
  else
    {
      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;

  font->ascent = xftfont->ascent;
  if (font->ascent < extents.y)
    font->ascent = extents.y;
  font->descent = xftfont->descent;
  if (font->descent < extents.height - extents.y)
    font->descent = extents.height - extents.y;
  font->font.height = font->ascent + font->descent;

  /* 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 = 0;
  xfont->ascent = font->ascent;
  xfont->descent = font->descent;
  xfont->max_bounds.descent = font->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;

#ifdef HAVE_LIBOTF
  if (xftfont_info->otf)
    OTF_close (xftfont_info->otf);
#endif
  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;
  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)
    {
      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 : FONT_INVALID_CODE);
}

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.height - extents.y;
    }
  return extents.xOff;
}

static XftDraw *
xftfont_get_xft_draw (f)
     FRAME_PTR f;
{
  XftDraw *xft_draw = font_get_frame_data (f, &xftfont_driver);;

  if (! xft_draw)
    {
      BLOCK_INPUT;
      xft_draw= XftDrawCreate (FRAME_X_DISPLAY (f),
			       FRAME_X_WINDOW (f),
			       FRAME_X_VISUAL (f),
			       FRAME_X_COLORMAP (f));
      UNBLOCK_INPUT;
      if (! xft_draw)
	abort ();
      font_put_frame_data (f, &xftfont_driver, xft_draw);
    }
  return xft_draw;
}

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 *) s->font_info;
  struct xftface_info *xftface_info = NULL;
  XftDraw *xft_draw = xftfont_get_xft_draw (f);
  FT_UInt *code;
  XftColor fg, bg;
  XRectangle r;
  int len = to - from;
  int i;

  if (s->font_info == face->font_info)
    xftface_info = (struct xftface_info *) face->extra;
  xftfont_get_colors (f, face, s->gc, xftface_info,
		      &fg, with_background ? &bg : NULL);
  BLOCK_INPUT;
  if (s->num_clips > 0)
    XftDrawSetClipRectangles (xft_draw, 0, 0, s->clip, s->num_clips);
  else
    XftDrawSetClip (xft_draw, NULL);

  if (with_background)
    {
      struct font *font = (struct font *) face->font_info;

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

  if (s->padding_p)
    for (i = 0; i < len; i++)
      XftDrawGlyphs (xft_draw, &fg, xftfont_info->xftfont,
		     x + i, y, code + i, 1);
  else
    XftDrawGlyphs (xft_draw, &fg, xftfont_info->xftfont,
		   x, y, code, len);
  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 = XftLockFace (xftfont_info->xftfont);
  int result;

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

static int
xftfont_end_for_frame (f)
     FRAME_PTR f;
{
  XftDraw *xft_draw = font_get_frame_data (f, &xftfont_driver);

  if (xft_draw)
    {
      BLOCK_INPUT;
      XftDrawDestroy (xft_draw);
      UNBLOCK_INPUT;
      font_put_frame_data (f, &xftfont_driver, NULL);
    }
  return 0;
}

#ifdef HAVE_LIBOTF
#ifdef HAVE_M17N_FLT
static Lisp_Object
xftfont_shape (lgstring)
     Lisp_Object lgstring;
{
  struct font *font;
  struct xftfont_info *xftfont_info;
  int result;
  FT_Face ft_face;

  CHECK_FONT_GET_OBJECT (LGSTRING_FONT (lgstring), font);
  xftfont_info = (struct xftfont_info *) font;
  if (! xftfont_info->maybe_otf)
    return Qnil;
  ft_face = XftLockFace (xftfont_info->xftfont);
  if (! xftfont_info->otf)
    {
      OTF *otf = OTF_open_ft_face (ft_face);

      if (! otf || OTF_get_table (otf, "head") < 0)
	{
	  if (otf)
	    OTF_close (otf);
	  xftfont_info->maybe_otf = 0;
	  XftUnlockFace (xftfont_info->xftfont);
	  return 0;
	}
      xftfont_info->otf = otf;
    }

  result = ftfont_shape_by_flt (lgstring, font, ft_face, xftfont_info->otf);
  XftUnlockFace (xftfont_info->xftfont);
  return result;
}
#endif	/* HAVE_M17N_FLT */
#endif	/* HAVE_LIBOTF */

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.match = xftfont_match;
  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;
  xftfont_driver.end_for_frame = xftfont_end_for_frame;
#ifdef HAVE_LIBOTF
#ifdef HAVE_M17N_FLT
  xftfont_driver.shape = xftfont_shape;
#endif	/* HAVE_M17N_FLT */
#endif	/* HAVE_LIBOTF */

  register_font_driver (&xftfont_driver, NULL);
}

/* arch-tag: 64ec61bf-7c8e-4fe6-b953-c6a85d5e1605
   (do not change this comment) */
Commit	Line	Data
c2f5bfd6	1	/* xftfont.c -- XFT font driver.
77ad4cfe GM	2	Copyright (C) 2006, 2007, 2008 Free Software Foundation, Inc.
77ad4cfe GM	3	Copyright (C) 2006, 2007, 2008
c2f5bfd6 KH	4	National Institute of Advanced Industrial Science and Technology (AIST)
	5	Registration Number H13PRO009
	6
	7	This file is part of GNU Emacs.
	8
	9	GNU Emacs is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
77ad4cfe	11	the Free Software Foundation; either version 3, or (at your option)
c2f5bfd6 KH	12	any later version.
	13
	14	GNU Emacs is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18
	19	You should have received a copy of the GNU General Public License
	20	along with GNU Emacs; see the file COPYING. If not, write to
	21	the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	22	Boston, MA 02110-1301, USA. */
	23
	24	#include <config.h>
	25	#include <stdio.h>
	26	#include <X11/Xlib.h>
	27	#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"
4613015e	38	#include "ftfont.h"
c2f5bfd6 KH	39
	40	/* Xft font driver. */
	41
	42	static Lisp_Object Qxft;
	43
	44	/* The actual structure for Xft font that can be casted to struct
	45	font. */
	46
	47	struct xftfont_info
	48	{
	49	struct font font;
	50	Display *display;
	51	int screen;
	52	XftFont *xftfont;
4613015e KH	53	#ifdef HAVE_LIBOTF
	54	int maybe_otf; /* Flag to tell if this may be OTF or not. */
	55	OTF *otf;
794eba0f	56	#endif /* HAVE_LIBOTF */
c2f5bfd6 KH	57	};
	58
	59	/* Structure pointed by (struct face )->extra /
10aca0f7	60
c2f5bfd6 KH	61	struct xftface_info
c2f5bfd6 KH	62	{
10aca0f7 KH	63	XftColor xft_fg; /* color for face->foreground */
10aca0f7 KH	64	XftColor xft_bg; /* color for face->background */
c2f5bfd6 KH	65	};
	66
	67	static void xftfont_get_colors P_ ((FRAME_PTR, struct face *, GC gc,
	68	struct xftface_info *,
	69	XftColor fg, XftColor bg));
c2f5bfd6 KH	70
c2f5bfd6 KH	71
10aca0f7 KH	72	/* Setup foreground and background colors of GC into FG and BG. If
	73	XFTFACE_INFO is not NULL, reuse the colors in it if possible. BG
	74	may be NULL. */
	75
c2f5bfd6 KH	76	static void
	77	xftfont_get_colors (f, face, gc, xftface_info, fg, bg)
	78	FRAME_PTR f;
	79	struct face *face;
	80	GC gc;
	81	struct xftface_info *xftface_info;
	82	XftColor fg, bg;
	83	{
	84	if (xftface_info && face->gc == gc)
	85	{
	86	*fg = xftface_info->xft_fg;
	87	if (bg)
	88	*bg = xftface_info->xft_bg;
	89	}
	90	else
	91	{
	92	XGCValues xgcv;
	93	int fg_done = 0, bg_done = 0;
	94
	95	BLOCK_INPUT;
	96	XGetGCValues (FRAME_X_DISPLAY (f), gc,
	97	GCForeground \| GCBackground, &xgcv);
	98	if (xftface_info)
	99	{
	100	if (xgcv.foreground == face->foreground)
	101	*fg = xftface_info->xft_fg, fg_done = 1;
	102	else if (xgcv.foreground == face->background)
	103	*fg = xftface_info->xft_bg, fg_done = 1;
	104	if (! bg)
	105	bg_done = 1;
	106	else if (xgcv.background == face->background)
	107	*bg = xftface_info->xft_bg, bg_done = 1;
	108	else if (xgcv.background == face->foreground)
	109	*bg = xftface_info->xft_fg, bg_done = 1;
	110	}
	111
	112	if (fg_done + bg_done < 2)
	113	{
	114	XColor colors[2];
	115
	116	colors[0].pixel = fg->pixel = xgcv.foreground;
	117	if (bg)
	118	colors[1].pixel = bg->pixel = xgcv.background;
	119	XQueryColors (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), colors,
	120	bg ? 2 : 1);
	121	fg->color.alpha = 0xFFFF;
	122	fg->color.red = colors[0].red;
	123	fg->color.green = colors[0].green;
	124	fg->color.blue = colors[0].blue;
	125	if (bg)
	126	{
	127	bg->color.alpha = 0xFFFF;
	128	bg->color.red = colors[1].red;
	129	bg->color.green = colors[1].green;
	130	bg->color.blue = colors[1].blue;
	131	}
	132	}
	133	UNBLOCK_INPUT;
	134	}
	135	}
	136
c2f5bfd6 KH	137
c2f5bfd6 KH	138	static Lisp_Object xftfont_list P_ ((Lisp_Object, Lisp_Object));
10aca0f7	139	static Lisp_Object xftfont_match P_ ((Lisp_Object, Lisp_Object));
c2f5bfd6 KH	140	static struct font *xftfont_open P_ ((FRAME_PTR, Lisp_Object, int));
	141	static void xftfont_close P_ ((FRAME_PTR, struct font *));
	142	static int xftfont_prepare_face P_ ((FRAME_PTR, struct face *));
	143	static void xftfont_done_face P_ ((FRAME_PTR, struct face *));
	144	static unsigned xftfont_encode_char P_ ((struct font *, int));
	145	static int xftfont_text_extents P_ ((struct font , unsigned , int,
	146	struct font_metrics *));
	147	static int xftfont_draw P_ ((struct glyph_string *, int, int, int, int, int));
	148
	149	static int xftfont_anchor_point P_ ((struct font *, unsigned, int,
	150	int , int ));
a92ee6bf	151	static int xftfont_end_for_frame P_ ((FRAME_PTR f));
c2f5bfd6 KH	152
	153	struct font_driver xftfont_driver;
	154
	155	static Lisp_Object
	156	xftfont_list (frame, spec)
	157	Lisp_Object frame;
	158	Lisp_Object spec;
	159	{
	160	Lisp_Object val = ftfont_driver.list (frame, spec);
10aca0f7	161	int i;
c2f5bfd6 KH	162
c2f5bfd6 KH	163	if (! NILP (val))
10aca0f7 KH	164	for (i = 0; i < ASIZE (val); i++)
10aca0f7 KH	165	ASET (AREF (val, i), FONT_TYPE_INDEX, Qxft);
c2f5bfd6 KH	166	return val;
	167	}
	168
10aca0f7 KH	169	static Lisp_Object
	170	xftfont_match (frame, spec)
	171	Lisp_Object frame;
	172	Lisp_Object spec;
	173	{
	174	Lisp_Object entity = ftfont_driver.match (frame, spec);
	175
	176	if (VECTORP (entity))
	177	ASET (entity, FONT_TYPE_INDEX, Qxft);
	178	return entity;
	179	}
	180
98d12656 KH	181	extern Lisp_Object ftfont_font_format P_ ((FcPattern *));
98d12656 KH	182
c2f5bfd6 KH	183	static FcChar8 ascii_printable[95];
	184
	185	static struct font *
	186	xftfont_open (f, entity, pixel_size)
	187	FRAME_PTR f;
	188	Lisp_Object entity;
	189	int pixel_size;
	190	{
	191	Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
	192	Display *display = FRAME_X_DISPLAY (f);
	193	Lisp_Object val;
2d93c6bd KH	194	FcPattern pattern, pat = NULL;
	195	FcChar8 *file;
	196	struct xftfont_info *xftfont_info = NULL;
	197	XFontStruct *xfont = NULL;
c2f5bfd6 KH	198	struct font *font;
c2f5bfd6 KH	199	double size = 0;
2d93c6bd	200	XftFont *xftfont = NULL;
c2f5bfd6	201	int spacing;
2d93c6bd	202	char *name;
dcce3c58	203	int len;
91c5bb27	204	XGlyphInfo extents;
365131ac	205	FT_Face ft_face;
c2f5bfd6 KH	206
	207	val = AREF (entity, FONT_EXTRA_INDEX);
	208	if (XTYPE (val) != Lisp_Misc
	209	\|\| XMISCTYPE (val) != Lisp_Misc_Save_Value)
	210	return NULL;
	211	pattern = XSAVE_VALUE (val)->pointer;
	212	if (FcPatternGetString (pattern, FC_FILE, 0, &file) != FcResultMatch)
	213	return NULL;
	214
	215	size = XINT (AREF (entity, FONT_SIZE_INDEX));
	216	if (size == 0)
	217	size = pixel_size;
dcce3c58	218
c2f5bfd6 KH	219	pat = FcPatternCreate ();
	220	FcPatternAddString (pat, FC_FILE, file);
	221	FcPatternAddDouble (pat, FC_PIXEL_SIZE, pixel_size);
fa762662	222	/FcPatternAddBool (pat, FC_ANTIALIAS, FcTrue);/
3cc2aca0 KH	223	val = AREF (entity, FONT_FAMILY_INDEX);
	224	if (! NILP (val))
	225	FcPatternAddString (pat, FC_FAMILY, (FcChar8 *) SDATA (SYMBOL_NAME (val)));
	226	FcConfigSubstitute (NULL, pat, FcMatchPattern);
dcce3c58 KH	227
dcce3c58 KH	228	BLOCK_INPUT;
4f4426f9	229	XftDefaultSubstitute (display, FRAME_X_SCREEN_NUMBER (f), pat);
c2f5bfd6 KH	230	xftfont = XftFontOpenPattern (display, pat);
	231	/* We should not destroy PAT here because it is kept in XFTFONT and
	232	destroyed automatically when XFTFONT is closed. */
	233	if (! xftfont)
2d93c6bd	234	goto err;
c2f5bfd6 KH	235
	236	xftfont_info = malloc (sizeof (struct xftfont_info));
	237	if (! xftfont_info)
2d93c6bd	238	goto err;
c2f5bfd6	239	xfont = malloc (sizeof (XFontStruct));
2d93c6bd KH	240	if (! xfont)
2d93c6bd KH	241	goto err;
c2f5bfd6 KH	242	xftfont_info->display = display;
	243	xftfont_info->screen = FRAME_X_SCREEN_NUMBER (f);
	244	xftfont_info->xftfont = xftfont;
4613015e	245	#ifdef HAVE_LIBOTF
365131ac KH	246	ft_face = XftLockFace (xftfont);
	247	xftfont_info->maybe_otf = ft_face->face_flags & FT_FACE_FLAG_SFNT;
	248	XftUnlockFace (xftfont);
4613015e	249	xftfont_info->otf = NULL;
794eba0f	250	#endif /* HAVE_LIBOTF */
c2f5bfd6 KH	251
c2f5bfd6 KH	252	font = (struct font *) xftfont_info;
b2e0f618	253	font->format = ftfont_font_format (xftfont->pattern);
c2f5bfd6 KH	254	font->entity = entity;
	255	font->pixel_size = size;
	256	font->driver = &xftfont_driver;
560fd3fa	257	len = 96;
2d93c6bd KH	258	name = malloc (len);
	259	while (name && font_unparse_fcname (entity, pixel_size, name, len) < 0)
	260	{
	261	char *new = realloc (name, len += 32);
	262
	263	if (! new)
	264	free (name);
	265	name = new;
	266	}
	267	if (! name)
	268	goto err;
	269	font->font.full_name = font->font.name = name;
c2f5bfd6 KH	270	font->file_name = (char *) file;
c2f5bfd6 KH	271	font->font.size = xftfont->max_advance_width;
8bf90572	272	font->font.charset = font->encoding_charset = font->repertory_charset = -1;
c2f5bfd6 KH	273
	274	if (FcPatternGetInteger (xftfont->pattern, FC_SPACING, 0, &spacing)
	275	!= FcResultMatch)
	276	spacing = FC_PROPORTIONAL;
91c5bb27 KH	277	if (! ascii_printable[0])
	278	{
	279	int i;
	280	for (i = 0; i < 95; i++)
	281	ascii_printable[i] = ' ' + i;
	282	}
c2f5bfd6	283	if (spacing != FC_PROPORTIONAL)
91c5bb27 KH	284	{
	285	font->font.average_width = font->font.space_width
	286	= xftfont->max_advance_width;
	287	XftTextExtents8 (display, xftfont, ascii_printable + 1, 94, &extents);
	288	}
c2f5bfd6 KH	289	else
c2f5bfd6 KH	290	{
c2f5bfd6 KH	291	XftTextExtents8 (display, xftfont, ascii_printable, 1, &extents);
	292	font->font.space_width = extents.xOff;
	293	if (font->font.space_width <= 0)
	294	/* dirty workaround */
	295	font->font.space_width = pixel_size;
	296	XftTextExtents8 (display, xftfont, ascii_printable + 1, 94, &extents);
	297	font->font.average_width = (font->font.space_width + extents.xOff) / 95;
	298	}
dcce3c58	299	UNBLOCK_INPUT;
c2f5bfd6	300
91c5bb27 KH	301	font->ascent = xftfont->ascent;
	302	if (font->ascent < extents.y)
	303	font->ascent = extents.y;
	304	font->descent = xftfont->descent;
	305	if (font->descent < extents.height - extents.y)
	306	font->descent = extents.height - extents.y;
	307	font->font.height = font->ascent + font->descent;
	308
c2f5bfd6 KH	309	/* Unfortunately Xft doesn't provide a way to get minimum char
	310	width. So, we use space_width instead. */
	311	font->min_width = font->font.space_width;
	312
	313	font->font.baseline_offset = 0;
	314	font->font.relative_compose = 0;
	315	font->font.default_ascent = 0;
	316	font->font.vertical_centering = 0;
	317
	318	/* Setup pseudo XFontStruct */
3370d9f5	319	xfont->fid = 0;
91c5bb27 KH	320	xfont->ascent = font->ascent;
	321	xfont->descent = font->descent;
	322	xfont->max_bounds.descent = font->descent;
c2f5bfd6 KH	323	xfont->max_bounds.width = xftfont->max_advance_width;
	324	xfont->min_bounds.width = font->font.space_width;
	325	font->font.font = xfont;
	326
	327	dpyinfo->n_fonts++;
	328
	329	/* Set global flag fonts_changed_p to non-zero if the font loaded
	330	has a character with a smaller width than any other character
	331	before, or if the font loaded has a smaller height than any other
	332	font loaded before. If this happens, it will make a glyph matrix
	333	reallocation necessary. */
	334	if (dpyinfo->n_fonts == 1)
	335	{
	336	dpyinfo->smallest_font_height = font->font.height;
	337	dpyinfo->smallest_char_width = font->min_width;
	338	fonts_changed_p = 1;
	339	}
	340	else
	341	{
	342	if (dpyinfo->smallest_font_height > font->font.height)
	343	dpyinfo->smallest_font_height = font->font.height,
	344	fonts_changed_p \|= 1;
	345	if (dpyinfo->smallest_char_width > font->min_width)
	346	dpyinfo->smallest_char_width = font->min_width,
	347	fonts_changed_p \|= 1;
	348	}
	349
	350	return font;
2d93c6bd KH	351
	352	err:
	353	if (xftfont) XftFontClose (display, xftfont);
	354	UNBLOCK_INPUT;
	355	if (xftfont_info) free (xftfont_info);
	356	if (xfont) free (xfont);
	357	return NULL;
c2f5bfd6 KH	358	}
	359
	360	static void
	361	xftfont_close (f, font)
	362	FRAME_PTR f;
	363	struct font *font;
	364	{
	365	struct xftfont_info xftfont_info = (struct xftfont_info ) font;
	366
4613015e KH	367	#ifdef HAVE_LIBOTF
	368	if (xftfont_info->otf)
	369	OTF_close (xftfont_info->otf);
	370	#endif
c2f5bfd6	371	XftFontClose (xftfont_info->display, xftfont_info->xftfont);
dcce3c58 KH	372	if (font->font.name)
dcce3c58 KH	373	free (font->font.name);
c2f5bfd6 KH	374	free (font);
	375	FRAME_X_DISPLAY_INFO (f)->n_fonts--;
	376	}
	377
c2f5bfd6 KH	378	static int
	379	xftfont_prepare_face (f, face)
	380	FRAME_PTR f;
	381	struct face *face;
	382	{
e2d0c925	383	struct xftface_info *xftface_info;
c2f5bfd6	384
a703d27d KH	385	#if 0
a703d27d KH	386	/* This doesn't work if face->ascii_face doesn't use an Xft font. */
e2d0c925 KH	387	if (face != face->ascii_face)
	388	{
	389	face->extra = face->ascii_face->extra;
	390	return 0;
	391	}
a703d27d	392	#endif
e2d0c925 KH	393
e2d0c925 KH	394	xftface_info = malloc (sizeof (struct xftface_info));
c2f5bfd6 KH	395	if (! xftface_info)
	396	return -1;
	397
	398	BLOCK_INPUT;
c2f5bfd6 KH	399	xftfont_get_colors (f, face, face->gc, NULL,
	400	&xftface_info->xft_fg, &xftface_info->xft_bg);
	401	UNBLOCK_INPUT;
	402
	403	face->extra = xftface_info;
	404	return 0;
	405	}
	406
	407	static void
	408	xftfont_done_face (f, face)
	409	FRAME_PTR f;
	410	struct face *face;
	411	{
e2d0c925 KH	412	struct xftface_info *xftface_info;
e2d0c925 KH	413
a703d27d KH	414	#if 0
a703d27d KH	415	/* This doesn't work if face->ascii_face doesn't use an Xft font. */
e2d0c925 KH	416	if (face != face->ascii_face
	417	\|\| ! face->extra)
	418	return;
a703d27d	419	#endif
c2f5bfd6	420
e2d0c925	421	xftface_info = (struct xftface_info *) face->extra;
773039e8 JD	422	if (xftface_info)
773039e8 JD	423	{
773039e8	424	free (xftface_info);
a92ee6bf	425	face->extra = NULL;
773039e8	426	}
c2f5bfd6 KH	427	}
	428
	429	static unsigned
	430	xftfont_encode_char (font, c)
	431	struct font *font;
	432	int c;
	433	{
	434	struct xftfont_info xftfont_info = (struct xftfont_info ) font;
	435	unsigned code = XftCharIndex (xftfont_info->display, xftfont_info->xftfont,
	436	(FcChar32) c);
	437
b5b2545a	438	return (code ? code : FONT_INVALID_CODE);
c2f5bfd6 KH	439	}
	440
	441	static int
	442	xftfont_text_extents (font, code, nglyphs, metrics)
	443	struct font *font;
	444	unsigned *code;
	445	int nglyphs;
	446	struct font_metrics *metrics;
	447	{
	448	struct xftfont_info xftfont_info = (struct xftfont_info ) font;
	449	XGlyphInfo extents;
	450
	451	BLOCK_INPUT;
	452	XftGlyphExtents (xftfont_info->display, xftfont_info->xftfont, code, nglyphs,
	453	&extents);
	454	UNBLOCK_INPUT;
	455	if (metrics)
	456	{
	457	metrics->lbearing = - extents.x;
	458	metrics->rbearing = - extents.x + extents.width;
	459	metrics->width = extents.xOff;
	460	metrics->ascent = extents.y;
4b848612	461	metrics->descent = extents.height - extents.y;
c2f5bfd6 KH	462	}
	463	return extents.xOff;
	464	}
	465
a92ee6bf KH	466	static XftDraw *
	467	xftfont_get_xft_draw (f)
	468	FRAME_PTR f;
	469	{
	470	XftDraw *xft_draw = font_get_frame_data (f, &xftfont_driver);;
	471
	472	if (! xft_draw)
	473	{
	474	BLOCK_INPUT;
	475	xft_draw= XftDrawCreate (FRAME_X_DISPLAY (f),
	476	FRAME_X_WINDOW (f),
	477	FRAME_X_VISUAL (f),
	478	FRAME_X_COLORMAP (f));
	479	UNBLOCK_INPUT;
	480	if (! xft_draw)
	481	abort ();
	482	font_put_frame_data (f, &xftfont_driver, xft_draw);
	483	}
	484	return xft_draw;
	485	}
	486
c2f5bfd6 KH	487	static int
	488	xftfont_draw (s, from, to, x, y, with_background)
	489	struct glyph_string *s;
	490	int from, to, x, y, with_background;
	491	{
	492	FRAME_PTR f = s->f;
	493	struct face *face = s->face;
c78c1659 KH	494	struct xftfont_info xftfont_info = (struct xftfont_info ) s->font_info;
c78c1659 KH	495	struct xftface_info *xftface_info = NULL;
a92ee6bf	496	XftDraw *xft_draw = xftfont_get_xft_draw (f);
c2f5bfd6 KH	497	FT_UInt *code;
	498	XftColor fg, bg;
	499	XRectangle r;
	500	int len = to - from;
	501	int i;
	502
c78c1659	503	if (s->font_info == face->font_info)
a92ee6bf	504	xftface_info = (struct xftface_info *) face->extra;
c2f5bfd6	505	xftfont_get_colors (f, face, s->gc, xftface_info,
322f8671	506	&fg, with_background ? &bg : NULL);
c2f5bfd6	507	BLOCK_INPUT;
03d198e8 KH	508	if (s->num_clips > 0)
	509	XftDrawSetClipRectangles (xft_draw, 0, 0, s->clip, s->num_clips);
	510	else
	511	XftDrawSetClip (xft_draw, NULL);
	512
c2f5bfd6 KH	513	if (with_background)
	514	{
	515	struct font font = (struct font ) face->font_info;
	516
c78c1659	517	XftDrawRect (xft_draw, &bg,
c2f5bfd6 KH	518	x, y - face->font->ascent, s->width, font->font.height);
	519	}
	520	code = alloca (sizeof (FT_UInt) * len);
	521	for (i = 0; i < len; i++)
	522	code[i] = ((XCHAR2B_BYTE1 (s->char2b + from + i) << 8)
	523	\| XCHAR2B_BYTE2 (s->char2b + from + i));
	524
785543da KH	525	if (s->padding_p)
	526	for (i = 0; i < len; i++)
	527	XftDrawGlyphs (xft_draw, &fg, xftfont_info->xftfont,
	528	x + i, y, code + i, 1);
	529	else
	530	XftDrawGlyphs (xft_draw, &fg, xftfont_info->xftfont,
	531	x, y, code, len);
c2f5bfd6 KH	532	UNBLOCK_INPUT;
	533
	534	return len;
	535	}
	536
	537	static int
	538	xftfont_anchor_point (font, code, index, x, y)
	539	struct font *font;
	540	unsigned code;
	541	int index;
	542	int x, y;
	543	{
	544	struct xftfont_info xftfont_info = (struct xftfont_info ) font;
365131ac KH	545	FT_Face ft_face = XftLockFace (xftfont_info->xftfont);
365131ac KH	546	int result;
c2f5bfd6 KH	547
c2f5bfd6 KH	548	if (FT_Load_Glyph (ft_face, code, FT_LOAD_DEFAULT) != 0)
365131ac KH	549	result = -1;
	550	else if (ft_face->glyph->format != FT_GLYPH_FORMAT_OUTLINE)
	551	result = -1;
	552	else if (index >= ft_face->glyph->outline.n_points)
	553	result = -1;
	554	else
	555	{
	556	*x = ft_face->glyph->outline.points[index].x;
	557	*y = ft_face->glyph->outline.points[index].y;
	558	}
	559	XftUnlockFace (xftfont_info->xftfont);
	560	return result;
c2f5bfd6 KH	561	}
c2f5bfd6 KH	562
a92ee6bf KH	563	static int
	564	xftfont_end_for_frame (f)
	565	FRAME_PTR f;
	566	{
	567	XftDraw *xft_draw = font_get_frame_data (f, &xftfont_driver);
	568
	569	if (xft_draw)
	570	{
	571	BLOCK_INPUT;
	572	XftDrawDestroy (xft_draw);
	573	UNBLOCK_INPUT;
	574	font_put_frame_data (f, &xftfont_driver, NULL);
	575	}
	576	return 0;
	577	}
c2f5bfd6	578
4613015e KH	579	#ifdef HAVE_LIBOTF
	580	#ifdef HAVE_M17N_FLT
	581	static Lisp_Object
	582	xftfont_shape (lgstring)
	583	Lisp_Object lgstring;
	584	{
	585	struct font *font;
	586	struct xftfont_info *xftfont_info;
365131ac KH	587	int result;
365131ac KH	588	FT_Face ft_face;
4613015e KH	589
	590	CHECK_FONT_GET_OBJECT (LGSTRING_FONT (lgstring), font);
	591	xftfont_info = (struct xftfont_info *) font;
	592	if (! xftfont_info->maybe_otf)
	593	return Qnil;
365131ac	594	ft_face = XftLockFace (xftfont_info->xftfont);
4613015e KH	595	if (! xftfont_info->otf)
4613015e KH	596	{
365131ac	597	OTF *otf = OTF_open_ft_face (ft_face);
4613015e KH	598
	599	if (! otf \|\| OTF_get_table (otf, "head") < 0)
	600	{
	601	if (otf)
	602	OTF_close (otf);
	603	xftfont_info->maybe_otf = 0;
365131ac	604	XftUnlockFace (xftfont_info->xftfont);
4613015e KH	605	return 0;
	606	}
	607	xftfont_info->otf = otf;
	608	}
	609
365131ac KH	610	result = ftfont_shape_by_flt (lgstring, font, ft_face, xftfont_info->otf);
	611	XftUnlockFace (xftfont_info->xftfont);
	612	return result;
4613015e KH	613	}
	614	#endif /* HAVE_M17N_FLT */
	615	#endif /* HAVE_LIBOTF */
	616
c2f5bfd6 KH	617	void
	618	syms_of_xftfont ()
	619	{
	620	DEFSYM (Qxft, "xft");
	621
	622	xftfont_driver = ftfont_driver;
	623	xftfont_driver.type = Qxft;
	624	xftfont_driver.get_cache = xfont_driver.get_cache;
	625	xftfont_driver.list = xftfont_list;
10aca0f7	626	xftfont_driver.match = xftfont_match;
c2f5bfd6 KH	627	xftfont_driver.open = xftfont_open;
	628	xftfont_driver.close = xftfont_close;
	629	xftfont_driver.prepare_face = xftfont_prepare_face;
	630	xftfont_driver.done_face = xftfont_done_face;
	631	xftfont_driver.encode_char = xftfont_encode_char;
	632	xftfont_driver.text_extents = xftfont_text_extents;
	633	xftfont_driver.draw = xftfont_draw;
	634	xftfont_driver.anchor_point = xftfont_anchor_point;
a92ee6bf	635	xftfont_driver.end_for_frame = xftfont_end_for_frame;
4613015e KH	636	#ifdef HAVE_LIBOTF
	637	#ifdef HAVE_M17N_FLT
	638	xftfont_driver.shape = xftfont_shape;
	639	#endif /* HAVE_M17N_FLT */
	640	#endif /* HAVE_LIBOTF */
c2f5bfd6 KH	641
	642	register_font_driver (&xftfont_driver, NULL);
	643	}
885b7d09 MB	644
	645	/* arch-tag: 64ec61bf-7c8e-4fe6-b953-c6a85d5e1605
	646	(do not change this comment) */