mirror of
git://git.sv.gnu.org/emacs.git
synced 2026-01-10 21:50:37 -08:00
307 lines
8.4 KiB
C
307 lines
8.4 KiB
C
/* ftcrfont.c -- FreeType font driver on cairo.
|
||
Copyright (C) 2015 Free Software Foundation, Inc.
|
||
|
||
This file is part of GNU Emacs.
|
||
|
||
GNU Emacs is free software: you can redistribute it and/or modify
|
||
it under the terms of the GNU General Public License as published by
|
||
the Free Software Foundation, either version 3 of the License, or
|
||
(at your option) any later version.
|
||
|
||
GNU Emacs is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
|
||
|
||
|
||
#include <config.h>
|
||
#include <stdio.h>
|
||
#include <cairo-ft.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"
|
||
|
||
/* FTCR font driver. */
|
||
|
||
/* The actual structure for FTCR font. A pointer to this structure
|
||
can be cast to struct font *. */
|
||
|
||
struct ftcrfont_info
|
||
{
|
||
struct font font;
|
||
/* The following six members must be here in this order to be
|
||
compatible with struct ftfont_info (in ftfont.c). */
|
||
#ifdef HAVE_LIBOTF
|
||
bool maybe_otf; /* Flag to tell if this may be OTF or not. */
|
||
OTF *otf;
|
||
#endif /* HAVE_LIBOTF */
|
||
FT_Size ft_size;
|
||
int index;
|
||
FT_Matrix matrix;
|
||
|
||
cairo_font_face_t *cr_font_face;
|
||
/* To prevent cairo from cluttering the activated FT_Size maintained
|
||
in ftfont.c, we activate this special FT_Size before drawing. */
|
||
FT_Size ft_size_draw;
|
||
/* Font metrics cache. */
|
||
struct font_metrics **metrics;
|
||
short metrics_nrows;
|
||
};
|
||
|
||
#define METRICS_NCOLS_PER_ROW (128)
|
||
|
||
enum metrics_status
|
||
{
|
||
METRICS_INVALID = -1, /* metrics entry is invalid */
|
||
};
|
||
|
||
#define METRICS_STATUS(metrics) ((metrics)->ascent + (metrics)->descent)
|
||
#define METRICS_SET_STATUS(metrics, status) \
|
||
((metrics)->ascent = 0, (metrics)->descent = (status))
|
||
|
||
struct font_driver ftcrfont_driver;
|
||
|
||
static int
|
||
ftcrfont_glyph_extents (struct font *font,
|
||
unsigned glyph,
|
||
struct font_metrics *metrics)
|
||
{
|
||
struct ftcrfont_info *ftcrfont_info = (struct ftcrfont_info *) font;
|
||
int row, col;
|
||
struct font_metrics *cache;
|
||
|
||
row = glyph / METRICS_NCOLS_PER_ROW;
|
||
col = glyph % METRICS_NCOLS_PER_ROW;
|
||
if (row >= ftcrfont_info->metrics_nrows)
|
||
{
|
||
ftcrfont_info->metrics =
|
||
xrealloc (ftcrfont_info->metrics,
|
||
sizeof (struct font_metrics *) * (row + 1));
|
||
bzero (ftcrfont_info->metrics + ftcrfont_info->metrics_nrows,
|
||
(sizeof (struct font_metrics *)
|
||
* (row + 1 - ftcrfont_info->metrics_nrows)));
|
||
ftcrfont_info->metrics_nrows = row + 1;
|
||
}
|
||
if (ftcrfont_info->metrics[row] == NULL)
|
||
{
|
||
struct font_metrics *new;
|
||
int i;
|
||
|
||
new = xmalloc (sizeof (struct font_metrics) * METRICS_NCOLS_PER_ROW);
|
||
for (i = 0; i < METRICS_NCOLS_PER_ROW; i++)
|
||
METRICS_SET_STATUS (new + i, METRICS_INVALID);
|
||
ftcrfont_info->metrics[row] = new;
|
||
}
|
||
cache = ftcrfont_info->metrics[row] + col;
|
||
|
||
if (METRICS_STATUS (cache) == METRICS_INVALID)
|
||
ftfont_driver.text_extents (font, &glyph, 1, cache);
|
||
|
||
if (metrics)
|
||
*metrics = *cache;
|
||
|
||
return cache->width;
|
||
}
|
||
|
||
static Lisp_Object
|
||
ftcrfont_list (struct frame *f, Lisp_Object spec)
|
||
{
|
||
Lisp_Object list = ftfont_driver.list (f, spec), tail;
|
||
|
||
for (tail = list; CONSP (tail); tail = XCDR (tail))
|
||
ASET (XCAR (tail), FONT_TYPE_INDEX, Qftcr);
|
||
return list;
|
||
}
|
||
|
||
static Lisp_Object
|
||
ftcrfont_match (struct frame *f, Lisp_Object spec)
|
||
{
|
||
Lisp_Object entity = ftfont_driver.match (f, spec);
|
||
|
||
if (VECTORP (entity))
|
||
ASET (entity, FONT_TYPE_INDEX, Qftcr);
|
||
return entity;
|
||
}
|
||
|
||
extern FT_Face ftfont_get_ft_face (Lisp_Object);
|
||
|
||
static Lisp_Object
|
||
ftcrfont_open (struct frame *f, Lisp_Object entity, int pixel_size)
|
||
{
|
||
Lisp_Object font_object;
|
||
struct font *font;
|
||
struct ftcrfont_info *ftcrfont_info;
|
||
FT_Face ft_face;
|
||
FT_UInt size;
|
||
|
||
block_input ();
|
||
size = XINT (AREF (entity, FONT_SIZE_INDEX));
|
||
if (size == 0)
|
||
size = pixel_size;
|
||
font_object = font_build_object (VECSIZE (struct ftcrfont_info),
|
||
Qftcr, entity, size);
|
||
font_object = ftfont_open2 (f, entity, pixel_size, font_object);
|
||
if (NILP (font_object)) return Qnil;
|
||
|
||
font = XFONT_OBJECT (font_object);
|
||
font->driver = &ftcrfont_driver;
|
||
ftcrfont_info = (struct ftcrfont_info *) font;
|
||
ft_face = ftcrfont_info->ft_size->face;
|
||
FT_New_Size (ft_face, &ftcrfont_info->ft_size_draw);
|
||
FT_Activate_Size (ftcrfont_info->ft_size_draw);
|
||
FT_Set_Pixel_Sizes (ft_face, 0, font->pixel_size);
|
||
ftcrfont_info->cr_font_face =
|
||
cairo_ft_font_face_create_for_ft_face (ft_face, 0);
|
||
ftcrfont_info->metrics = NULL;
|
||
ftcrfont_info->metrics_nrows = 0;
|
||
unblock_input ();
|
||
|
||
return font_object;
|
||
}
|
||
|
||
static void
|
||
ftcrfont_close (struct font *font)
|
||
{
|
||
struct ftcrfont_info *ftcrfont_info = (struct ftcrfont_info *) font;
|
||
int i;
|
||
|
||
block_input ();
|
||
for (i = 0; i < ftcrfont_info->metrics_nrows; i++)
|
||
if (ftcrfont_info->metrics[i])
|
||
xfree (ftcrfont_info->metrics[i]);
|
||
if (ftcrfont_info->metrics)
|
||
xfree (ftcrfont_info->metrics);
|
||
FT_Done_Size (ftcrfont_info->ft_size_draw);
|
||
cairo_font_face_destroy (ftcrfont_info->cr_font_face);
|
||
unblock_input ();
|
||
|
||
ftfont_driver.close (font);
|
||
}
|
||
|
||
static void
|
||
ftcrfont_text_extents (struct font *font,
|
||
unsigned *code,
|
||
int nglyphs,
|
||
struct font_metrics *metrics)
|
||
{
|
||
int width, i;
|
||
|
||
block_input ();
|
||
width = ftcrfont_glyph_extents (font, code[0], metrics);
|
||
for (i = 1; i < nglyphs; i++)
|
||
{
|
||
struct font_metrics m;
|
||
int w = ftcrfont_glyph_extents (font, code[i], metrics ? &m : NULL);
|
||
|
||
if (metrics)
|
||
{
|
||
if (width + m.lbearing < metrics->lbearing)
|
||
metrics->lbearing = width + m.lbearing;
|
||
if (width + m.rbearing > metrics->rbearing)
|
||
metrics->rbearing = width + m.rbearing;
|
||
if (m.ascent > metrics->ascent)
|
||
metrics->ascent = m.ascent;
|
||
if (m.descent > metrics->descent)
|
||
metrics->descent = m.descent;
|
||
}
|
||
width += w;
|
||
}
|
||
unblock_input ();
|
||
|
||
if (metrics)
|
||
metrics->width = width;
|
||
}
|
||
|
||
static int
|
||
ftcrfont_draw (struct glyph_string *s,
|
||
int from, int to, int x, int y, bool with_background)
|
||
{
|
||
struct frame *f = s->f;
|
||
struct face *face = s->face;
|
||
struct ftcrfont_info *ftcrfont_info = (struct ftcrfont_info *) s->font;
|
||
cairo_t *cr;
|
||
cairo_glyph_t *glyphs;
|
||
cairo_surface_t *surface;
|
||
cairo_surface_type_t surface_type;
|
||
int len = to - from;
|
||
int i;
|
||
|
||
block_input ();
|
||
|
||
cr = x_begin_cr_clip (f, s->gc);
|
||
|
||
if (with_background)
|
||
{
|
||
x_set_cr_source_with_gc_background (f, s->gc);
|
||
cairo_rectangle (cr, x, y - FONT_BASE (face->font),
|
||
s->width, FONT_HEIGHT (face->font));
|
||
cairo_fill (cr);
|
||
}
|
||
|
||
glyphs = alloca (sizeof (cairo_glyph_t) * len);
|
||
for (i = 0; i < len; i++)
|
||
{
|
||
unsigned code = ((XCHAR2B_BYTE1 (s->char2b + from + i) << 8)
|
||
| XCHAR2B_BYTE2 (s->char2b + from + i));
|
||
|
||
glyphs[i].index = code;
|
||
glyphs[i].x = x;
|
||
glyphs[i].y = y;
|
||
x += (s->padding_p ? 1 : ftcrfont_glyph_extents (s->font, code, NULL));
|
||
}
|
||
|
||
x_set_cr_source_with_gc_foreground (f, s->gc);
|
||
cairo_set_font_face (cr, ftcrfont_info->cr_font_face);
|
||
cairo_set_font_size (cr, s->font->pixel_size);
|
||
/* cairo_set_font_matrix */
|
||
/* cairo_set_font_options */
|
||
|
||
FT_Activate_Size (ftcrfont_info->ft_size_draw);
|
||
cairo_show_glyphs (cr, glyphs, len);
|
||
surface = cairo_get_target (cr);
|
||
/* XXX: It used to be necessary to flush when exporting. It might
|
||
be the case that this is no longer necessary. */
|
||
surface_type = cairo_surface_get_type (surface);
|
||
if (surface_type != CAIRO_SURFACE_TYPE_XLIB
|
||
&& (surface_type != CAIRO_SURFACE_TYPE_IMAGE
|
||
|| cairo_image_surface_get_format (surface) != CAIRO_FORMAT_ARGB32))
|
||
cairo_surface_flush (surface);
|
||
|
||
x_end_cr_clip (f);
|
||
|
||
unblock_input ();
|
||
|
||
return len;
|
||
}
|
||
|
||
|
||
|
||
void
|
||
syms_of_ftcrfont (void)
|
||
{
|
||
if (ftfont_info_size != offsetof (struct ftcrfont_info, cr_font_face))
|
||
abort ();
|
||
|
||
DEFSYM (Qftcr, "ftcr");
|
||
|
||
ftcrfont_driver = ftfont_driver;
|
||
ftcrfont_driver.type = Qftcr;
|
||
ftcrfont_driver.list = ftcrfont_list;
|
||
ftcrfont_driver.match = ftcrfont_match;
|
||
ftcrfont_driver.open = ftcrfont_open;
|
||
ftcrfont_driver.close = ftcrfont_close;
|
||
ftcrfont_driver.text_extents = ftcrfont_text_extents;
|
||
ftcrfont_driver.draw = ftcrfont_draw;
|
||
register_font_driver (&ftcrfont_driver, NULL);
|
||
}
|