/* font.h -- Interface definition for font handling.
- Copyright (C) 2006 Free Software Foundation, Inc.
- Copyright (C) 2006
+ Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+ Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
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
+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.
+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
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. */
+along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#ifndef EMACS_FONT_H
#define EMACS_FONT_H
FONT-SPEC
- Vector (length FONT_SPEC_MAX) of font properties. Some
+ Pseudo vector (length FONT_SPEC_MAX) of font properties. Some
properties can be left unspecified (i.e. nil). Emacs asks
font-drivers to find a font by FONT-SPEC. A fontset entry
specifies requisite properties whereas a face specifies just
- preferable properties. This object is fully modifiable by
- Lisp.
+ preferable properties.
FONT-ENTITY
- Vector (length FONT_ENTITY_MAX) of fully specified font
- properties that a font-driver returns upon a request of
+ Pseudo vector (length FONT_ENTITY_MAX) of fully instanciated
+ font properties that a font-driver returns upon a request of
FONT-SPEC.
- Note: Only the method `list' of a font-driver can create this
- object, and should never be modified by Lisp. In that sense,
- it may be cleaner to implement it as a Lisp object of a new
- type (e.g. struct Lisp_Font).
+ Note: Only the method `list' and `match' of a font-driver can
+ create this object, and should never be modified by Lisp.
FONT-OBJECT
- Lisp object of type Lisp_Misc_Save_Value encapsulating a
- pointer to "struct font". This corresponds to an opened font.
+ Pseudo vector (length FONT_OBJECT_MAX) of a opend font.
- Note: The note for FONT-ENTITY also applies to this.
-*/
+ Lisp object encapsulating "struct font". This corresponds to
+ an opened font.
+
+ Note: Only the method `open' of a font-driver can create this
+ object, and should never be modified by Lisp. */
+
+extern Lisp_Object Qfont_spec, Qfont_entity, Qfont_object;
struct font_driver;
struct font;
+struct glyph_string;
/* An enumerator for each font property. This is used as an index to
the vector of FONT-SPEC and FONT-ENTITY.
enum font_property_index
{
/* FONT-TYPE is a symbol indicating a font backend; currently `x',
- `xft', `ftx', `freetype' are available on X and gdi on Windows.
- For Windows, we `bdf' and `uniscribe' backends are in progress.
- For Mac OS X, we need `atm'. */
+ `xft', `ftx' are available on X, `uniscribe' and `gdi' on
+ Windows, and `ns' under Cocoa / GNUstep. */
FONT_TYPE_INDEX,
/* FONT-FOUNDRY is a foundry name (symbol). */
FONT_ADSTYLE_INDEX,
/* FONT-REGISTRY is a combination of a charset-registry and
- charset0encoding name (symbol). */
+ charset-encoding name (symbol). */
FONT_REGISTRY_INDEX,
/* FONT-WEIGHT is a numeric value of weight (e.g. medium, bold) of
- the font. The value is what defined by FC_WEIGHT_* in
- fontconfig. */
+ the font. The lowest 8-bit is an index determining the
+ symbolic name, and the higher bits is the actual numeric value
+ defined in `font-weight-table'. */
FONT_WEIGHT_INDEX,
/* FONT-SLANT is a numeric value of slant (e.g. r, i, o) of the
- font. The value is what defined by FC_SLANT_* in
- fontconfig plus 100. */
+ font. The lowest 8-bit is an index determining the symbolic
+ name, and the higher bits is the actual numeric value defined
+ in `font-slant-table'. */
FONT_SLANT_INDEX,
- /* FONT-WIDTH is a numeric value of setwidth (e.g. normal,
- condensed) of the font. The value is what defined by
- FC_WIDTH_* in fontconfig. */
+ /* FONT-WIDTH is a numeric value of setwidth (e.g. normal) of the
+ font. The lowest 8-bit is an index determining the symbolic
+ name, and the higher bits is the actual numeric value defined
+ `font-width-table'. */
FONT_WIDTH_INDEX,
/* FONT-SIZE is a size of the font. If integer, it is a pixel
size. For a font-spec, the value can be float specifying a
- point size. For a font-entity, the value can be zero meaning
- that the font is scalable. */
+ point size. The value zero means that the font is
+ scalable. */
FONT_SIZE_INDEX,
+ /* FONT-DPI is a resolution (dot per inch) for which the font is
+ designed. */
+ FONT_DPI_INDEX,
+
+ /* FONT-SPACING is a spacing (mono, proportional, charcell) of the
+ font (integer; one of enum font_spacing). */
+ FONT_SPACING_INDEX,
+
+ /* FONT-AVGWIDTH is an average width (1/10 pixel unit) of the
+ font. */
+ FONT_AVGWIDTH_INDEX,
+
+#if 0
+ /* The following two members are to substitute for the above 6
+ members (FONT_WEIGHT_INDEX to FONT_AVGWIDTH_INDEX excluding
+ FONT_SIZE_INDEX) if it is found that font-entities consumes too
+ much memory. */
+
+ /* FONT-STYLE is a 24-bit integer containing indices for
+ style-related properties WEIGHT, SLANT, and WIDTH. The lowest
+ 8-bit is an indice to the weight table AREF (font_style_table,
+ 0), the next 8-bit is an indice to the slant table AREF
+ (font_style_table, 1), the highest 8-bit is an indice to the
+ slant table AREF (font_style_table, 2). The indice 0 indicates
+ that the corresponding style is not specified. This way, we
+ can represent at most 255 different names for each style, which
+ is surely sufficient. */
+ FONT_STYLE_INDEX,
+
+ /* FONT-METRICS is a 27-bit integer containing metrics-related
+ properties DPI, AVGWIDTH, SPACING. The lowest 12-bit is for
+ DPI, the next 12-bit is for AVGWIDTH, the highest 3-bit is for
+ SPACING. In each bit field, the highest bit indicates that the
+ corresponding value is set or not. This way, we can represent
+ DPI by 11-bit (0 to 2047), AVGWIDTH by 11-bit (0 to 2047),
+ SPACING by 3-bit (0 for proportional, 1 for dual, 2 for mono, 3
+ for charcell), which is surely sufficient. */
+ FONT_METRICS_INDEX,
+#endif
+
/* In a font-spec, the value is an alist of extra information of a
font such as name, OpenType features, and language coverage.
- In a font-entity, the value is an extra infomation for
- identifying a font (font-driver dependent). */
+ In addition, in a font-entity, the value may contain a pair
+ (font-entity . INFO) where INFO is extra information to identify
+ a font (font-driver dependent). */
FONT_EXTRA_INDEX, /* alist alist */
/* This value is the length of font-spec vector. */
/* The followings are used only for a font-entity. */
- /* Frame on which the font is found. The value is nil if the font
- can be opend on any frame. */
- FONT_FRAME_INDEX = FONT_SPEC_MAX,
-
- /* List of font-objects opened from the font-entity. The value is
- nil if no font can be opened for this font-entity. */
- FONT_OBJLIST_INDEX,
+ /* List of font-objects opened from the font-entity. */
+ FONT_OBJLIST_INDEX = FONT_SPEC_MAX,
/* This value is the length of font-entity vector. */
- FONT_ENTITY_MAX
+ FONT_ENTITY_MAX,
+
+ /* XLFD name of the font (string). */
+ FONT_NAME_INDEX = FONT_ENTITY_MAX,
+
+ /* Full name of the font (string). It is the name extracted from
+ the opend font, and may be different from the above. It may be
+ nil if the opened font doesn't give a name. */
+ FONT_FULLNAME_INDEX,
+
+ /* File name of the font or nil if a file associated with the font
+ is not available. */
+ FONT_FILE_INDEX,
+
+ /* Format of the font (symbol) or nil if unknown. */
+ FONT_FORMAT_INDEX,
+
+ /* This value is the length of font-object vector. */
+ FONT_OBJECT_MAX
};
-extern Lisp_Object QCspacing, QCdpi, QCscalable, QCotf, QClanguage, QCscript;
+/* Return the numeric weight value of FONT. */
+#define FONT_WEIGHT_NUMERIC(font) \
+ (INTEGERP (AREF ((font), FONT_WEIGHT_INDEX)) \
+ ? (XINT (AREF ((font), FONT_WEIGHT_INDEX)) >> 8) : -1)
+/* Return the numeric slant value of FONT. */
+#define FONT_SLANT_NUMERIC(font) \
+ (INTEGERP (AREF ((font), FONT_SLANT_INDEX)) \
+ ? (XINT (AREF ((font), FONT_SLANT_INDEX)) >> 8) : -1)
+/* Return the numeric width value of FONT. */
+#define FONT_WIDTH_NUMERIC(font) \
+ (INTEGERP (AREF ((font), FONT_WIDTH_INDEX)) \
+ ? (XINT (AREF ((font), FONT_WIDTH_INDEX)) >> 8) : -1)
+/* Return the symbolic weight value of FONT. */
+#define FONT_WEIGHT_SYMBOLIC(font) \
+ font_style_symbolic (font, FONT_WEIGHT_INDEX, 0)
+/* Return the symbolic slant value of FONT. */
+#define FONT_SLANT_SYMBOLIC(font) \
+ font_style_symbolic (font, FONT_SLANT_INDEX, 0)
+/* Return the symbolic width value of FONT. */
+#define FONT_WIDTH_SYMBOLIC(font) \
+ font_style_symbolic (font, FONT_WIDTH_INDEX, 0)
+/* Return the face-weight corresponding to the weight of FONT. */
+#define FONT_WEIGHT_FOR_FACE(font) \
+ font_style_symbolic (font, FONT_WEIGHT_INDEX, 1)
+/* Return the face-slant corresponding to the slant of FONT. */
+#define FONT_SLANT_FOR_FACE(font) \
+ font_style_symbolic (font, FONT_SLANT_INDEX, 1)
+/* Return the face-swidth corresponding to the slant of FONT. */
+#define FONT_WIDTH_FOR_FACE(font) \
+ font_style_symbolic (font, FONT_WIDTH_INDEX, 1)
+
+/* Return the numeric weight value corresponding ot the symbol NAME. */
+#define FONT_WEIGHT_NAME_NUMERIC(name) \
+ (font_style_to_value (FONT_WEIGHT_INDEX, (name), 0) >> 8)
+/* Return the numeric slant value corresponding ot the symbol NAME. */
+#define FONT_SLANT_NAME_NUMERIC(name) \
+ (font_style_to_value (FONT_SLANT_INDEX, (name), 0) >> 8)
+/* Return the numeric width value corresponding ot the symbol NAME. */
+#define FONT_WIDTH_NAME_NUMERIC(name) \
+ (font_style_to_value (FONT_WIDTH_INDEX, (name), 0) >> 8)
+
+/* Set the font property PROP of FONT to VAL. PROP is one of
+ style-related font property index (FONT_WEIGHT/SLANT/WIDTH_INDEX).
+ VAL (integer or symbol) is the numeric or symbolic style value. */
+#define FONT_SET_STYLE(font, prop, val) \
+ ASET ((font), prop, make_number (font_style_to_value (prop, val, 1)))
+
+extern Lisp_Object QCspacing, QCdpi, QCscalable, QCotf, QClang, QCscript;
+extern Lisp_Object QCavgwidth, QCfont_entity, QCfc_unknown_spec;
/* Important character set symbols. */
+extern Lisp_Object Qascii_0;
extern Lisp_Object Qiso8859_1, Qiso10646_1, Qunicode_bmp, Qunicode_sip;
-extern Lisp_Object null_string;
-extern Lisp_Object null_vector;
+/* Special ADSTYLE properties to avoid fonts used for Latin characters. */
+extern Lisp_Object Qja, Qko;
+
+/* Structure for a font-spec. */
+
+struct font_spec
+{
+ EMACS_UINT size;
+ struct Lisp_Vector *next;
+ Lisp_Object props[FONT_SPEC_MAX];
+};
+
+/* Structure for a font-entity. */
+
+struct font_entity
+{
+ EMACS_UINT size;
+ struct Lisp_Vector *next;
+ Lisp_Object props[FONT_ENTITY_MAX];
+};
+
+/* A value which may appear in the member `encoding' of struct font
+ indicating that a font itself doesn't tell which encoding to be
+ used. */
+#define FONT_ENCODING_NOT_DECIDED 255
-/* Structure for an opened font. We can safely cast this structure to
- "struct font_info". */
+/* Structure for a font-object. */
struct font
{
- struct font_info font;
+ EMACS_UINT size;
+ struct Lisp_Vector *next;
- /* From which font-entity the font is opened. */
- Lisp_Object entity;
+ /* All Lisp_Object components must come first.
+ That ensures they are all aligned normally. */
+
+ Lisp_Object props[FONT_OBJECT_MAX];
+
+ /* Beyond here, there should be no more Lisp_Object components. */
+
+ /* Maximum bound width over all existing characters of the font. On
+ X window, this is same as (font->max_bounds.width). */
+ int max_width;
/* By which pixel size the font is opened. */
int pixel_size;
- /* Font-driver for the font. */
- struct font_driver *driver;
+ /* Height of the font. On X window, this is the same as
+ (font->ascent + font->descent). */
+ int height;
- /* Symbol of font font; x, ttf, pcf, etc, */
- Lisp_Object format;
+ /* Width of the space glyph of the font. If the font doesn't have a
+ SPACE glyph, the value is 0. */
+ int space_width;
- /* File name of the font, or NULL if the font is not associated with
- a file. */
- char *file_name;
+ /* Average width of glyphs in the font. If the font itself doesn't
+ have that information but has glyphs of ASCII character, the
+ value is the average with of those glyphs. Otherwise, the value
+ is 0. */
+ int average_width;
+
+ /* Minimum glyph width (in pixels). */
+ int min_width;
+
+ /* Ascent and descent of the font (in pixels). */
+ int ascent, descent;
+
+ /* Vertical pixel width of the underline. If is zero if that
+ information is not in the font. */
+ int underline_thickness;
+
+ /* Vertical pixel position (relative to the baseline) of the
+ underline. If it is positive, it is below the baseline. It is
+ negative if that information is not in the font. */
+ int underline_position;
+
+ /* 1 if `vertical-centering-font-regexp' matches this font name.
+ In this case, we render characters at vartical center positions
+ of lines. */
+ int vertical_centering;
+
+ /* Encoding type of the font. The value is one of
+ 0, 1, 2, or 3:
+ 0: code points 0x20..0x7F or 0x2020..0x7F7F are used
+ 1: code points 0xA0..0xFF or 0xA0A0..0xFFFF are used
+ 2: code points 0x20A0..0x7FFF are used
+ 3: code points 0xA020..0xFF7F are used
+ If the member `font_encoder' is not NULL, this member is ignored. */
+ unsigned char encoding_type;
+
+ /* The baseline position of a font is normally `ascent' value of the
+ font. However, there exists many fonts which don't set `ascent'
+ an appropriate value to be used as baseline position. This is
+ typical in such ASCII fonts which are designed to be used with
+ Chinese, Japanese, Korean characters. When we use mixture of
+ such fonts and normal fonts (having correct `ascent' value), a
+ display line gets very ugly. Since we have no way to fix it
+ automatically, it is users responsibility to supply well designed
+ fonts or correct `ascent' value of fonts. But, the latter
+ requires heavy work (modifying all bitmap data in BDF files).
+ So, Emacs accepts a private font property
+ `_MULE_BASELINE_OFFSET'. If a font has this property, we
+ calculate the baseline position by subtracting the value from
+ `ascent'. In other words, the value indicates how many bits
+ higher we should draw a character of the font than normal ASCII
+ text for a better looking.
+
+ We also have to consider the fact that the concept of `baseline'
+ differs among scripts to which each character belongs. For
+ instance, baseline should be at the bottom most position of all
+ glyphs for Chinese, Japanese, and Korean. But, many of existing
+ fonts for those characters doesn't have correct `ascent' values
+ because they are designed to be used with ASCII fonts. To
+ display characters of different language on the same line, the
+ best way will be to arrange them in the middle of the line. So,
+ in such a case, again, we utilize the font property
+ `_MULE_BASELINE_OFFSET'. If the value is larger than `ascent' we
+ calculate baseline so that a character is arranged in the middle
+ of a line. */
+ int baseline_offset;
+
+ /* Non zero means a character should be composed at a position
+ relative to the height (or depth) of previous glyphs in the
+ following cases:
+ (1) The bottom of the character is higher than this value. In
+ this case, the character is drawn above the previous glyphs.
+ (2) The top of the character is lower than 0 (i.e. baseline
+ height). In this case, the character is drawn beneath the
+ previous glyphs.
+
+ This value is taken from a private font property
+ `_MULE_RELATIVE_COMPOSE' which is introduced by Emacs. */
+ int relative_compose;
+
+ /* Non zero means an ascent value to be used for a character
+ registered in char-table `use-default-ascent'. */
+ int default_ascent;
+
+ /* CCL program to calculate code points of the font. */
+ struct ccl_program *font_encoder;
+
+ /* Font-driver for the font. */
+ struct font_driver *driver;
/* Charset to encode a character code into a glyph code of the font.
-1 means that the font doesn't require this information to encode
determine it. */
int repertory_charset;
- /* Minimum glyph width (in pixels). */
- int min_width;
-
- /* Ascent and descent of the font (in pixels). */
- int ascent, descent;
-
- /* 1 iff the font is scalable. */
- int scalable;
-
/* There will be more to this structure, but they are private to a
font-driver. */
};
/* Predicates to check various font-related objects. */
-#define FONTP(x) \
- (VECTORP (x) && (ASIZE (x) == FONT_SPEC_MAX || ASIZE (x) == FONT_ENTITY_MAX))
+/* 1 iff X is one of font-spec, font-entity, and font-object. */
+#define FONTP(x) PSEUDOVECTORP (x, PVEC_FONT)
+/* 1 iff X is font-spec. */
#define FONT_SPEC_P(x) \
- (VECTORP (x) && ASIZE (x) == FONT_SPEC_MAX)
+ (FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_SPEC_MAX)
+/* 1 iff X is font-entity. */
#define FONT_ENTITY_P(x) \
- (VECTORP (x) && ASIZE (x) == FONT_ENTITY_MAX)
+ (FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_ENTITY_MAX)
+/* 1 iff X is font-object. */
#define FONT_OBJECT_P(x) \
- (XTYPE (x) == Lisp_Misc && XMISCTYPE (x) == Lisp_Misc_Save_Value)
+ (FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_OBJECT_MAX)
+/* 1 iff ENTITY can't be loaded. */
#define FONT_ENTITY_NOT_LOADABLE(entity) \
EQ (AREF (entity, FONT_OBJLIST_INDEX), Qt)
+/* Flag ENTITY not loadable. */
#define FONT_ENTITY_SET_NOT_LOADABLE(entity) \
ASET (entity, FONT_OBJLIST_INDEX, Qt)
/* Check macros for various font-related objects. */
#define CHECK_FONT(x) \
- do { if (! FONTP (x)) x = wrong_type_argument (Qfont, x); } while (0)
+ do { if (! FONTP (x)) wrong_type_argument (Qfont, x); } while (0)
#define CHECK_FONT_SPEC(x) \
- do { if (! FONT_SPEC_P (x)) x = wrong_type_argument (Qfont, x); } while (0)
+ do { if (! FONT_SPEC_P (x)) wrong_type_argument (Qfont_spec, x); } while (0)
#define CHECK_FONT_ENTITY(x) \
- do { if (! FONT_ENTITY_P (x)) x = wrong_type_argument (Qfont, x); } while (0)
+ do { if (! FONT_ENTITY_P (x)) wrong_type_argument (Qfont_entity, x); } while (0)
#define CHECK_FONT_OBJECT(x) \
- do { if (! FONT_OBJECT_P (x)) x = wrong_type_argument (Qfont, x); } while (0)
+ do { if (! FONT_OBJECT_P (x)) wrong_type_argument (Qfont_object, x); } while (0)
-#define CHECK_FONT_GET_OBJECT(x, font) \
- do { \
- if (! FONT_OBJECT_P (x)) x = wrong_type_argument (Qfont, x); \
- if (! XSAVE_VALUE (x)->pointer) error ("Font already closed"); \
- font = XSAVE_VALUE (x)->pointer; \
+#define CHECK_FONT_GET_OBJECT(x, font) \
+ do { \
+ CHECK_FONT_OBJECT (x); \
+ font = XFONT_OBJECT (x); \
} while (0)
+#define XFONT_SPEC(p) \
+ (eassert (FONT_SPEC_P(p)), (struct font_spec *) XPNTR (p))
+#define XFONT_ENTITY(p) \
+ (eassert (FONT_ENTITY_P(p)), (struct font_entity *) XPNTR (p))
+#define XFONT_OBJECT(p) \
+ (eassert (FONT_OBJECT_P(p)), (struct font *) XPNTR (p))
+#define XSETFONT(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_FONT))
+
+/* Number of pt per inch (from the TeXbook). */
+#define PT_PER_INCH 72.27
+
+/* Return a pixel size (integer) corresponding to POINT size (double)
+ on resolution DPI. */
+#define POINT_TO_PIXEL(POINT, DPI) ((POINT) * (DPI) / PT_PER_INCH + 0.5)
+
+/* Return a point size corresponding to POINT size (integer)
+ on resolution DPI. Note that though point size is a double, we expect
+ it to be rounded to an int, so we add 0.5 here. If the desired value
+ is tenths of points (as in xfld specs), then the pixel size should
+ be multiplied BEFORE the conversion to avoid magnifying the error. */
+#define PIXEL_TO_POINT(PIXEL, DPI) ((PIXEL) * PT_PER_INCH / (DPI) + 0.5)
+
/* Ignore the difference of font pixel sizes less than or equal to
this value. */
#define FONT_PIXEL_SIZE_QUANTUM 1
struct face;
-struct composition;
-
-/* Macros for lispy glyph-string. */
-#define LGSTRING_FONT(lgs) AREF (AREF ((lgs), 0), 0)
-#define LGSTRING_WIDTH(lgs) XINT (AREF (AREF ((lgs), 0), 1))
-#define LGSTRING_LBEARING(lgs) XINT (AREF (AREF ((lgs), 0), 2))
-#define LGSTRING_RBEARING(lgs) XINT (AREF (AREF ((lgs), 0), 3))
-#define LGSTRING_ASCENT(lgs) XINT (AREF (AREF ((lgs), 0), 4))
-#define LGSTRING_DESCENT(lgs) XINT (AREF (AREF ((lgs), 0), 5))
-#define LGSTRING_SET_FONT(lgs, val) \
- ASET (AREF ((lgs), 0), 0, (val))
-#define LGSTRING_SET_WIDTH(lgs, val) \
- ASET (AREF ((lgs), 0), 1, make_number (val))
-#define LGSTRING_SET_LBEARING(lgs, val) \
- ASET (AREF ((lgs), 0), 2, make_number (val))
-#define LGSTRING_SET_RBEARING(lgs, val) \
- ASET (AREF ((lgs), 0), 3, make_number (val))
-#define LGSTRING_SET_ASCENT(lgs, val) \
- ASET (AREF ((lgs), 0), 4, make_number (val))
-#define LGSTRING_SET_DESCENT(lgs, val) \
- ASET (AREF ((lgs), 0), 5, make_number (val))
-
-#define LGSTRING_LENGTH(lgs) (ASIZE ((lgs)) - 1)
-#define LGSTRING_GLYPH(lgs, idx) AREF ((lgs), (idx) + 1)
-#define LGSTRING_SET_GLYPH(lgs, idx, val) ASET ((lgs), (idx) + 1, (val))
-
-/* Vector size of Lispy glyph. */
-#define LGLYPH_SIZE 10
-#define LGLYPH_FROM(g) XINT (AREF ((g), 0))
-#define LGLYPH_TO(g) XINT (AREF ((g), 1))
-#define LGLYPH_CHAR(g) XINT (AREF ((g), 2))
-#define LGLYPH_CODE(g) XINT (AREF ((g), 3))
-#define LGLYPH_WIDTH(g) XINT (AREF ((g), 4))
-#define LGLYPH_LBEARING(g) XINT (AREF ((g), 5))
-#define LGLYPH_RBEARING(g) XINT (AREF ((g), 6))
-#define LGLYPH_ASCENT(g) XINT (AREF ((g), 7))
-#define LGLYPH_DESCENT(g) XINT (AREF ((g), 8))
-#define LGLYPH_ADJUSTMENT(g) AREF ((g), 9)
-#define LGLYPH_SET_FROM(g, val) ASET ((g), 0, make_number (val))
-#define LGLYPH_SET_TO(g, val) ASET ((g), 1, make_number (val))
-#define LGLYPH_SET_CHAR(g, val) ASET ((g), 2, make_number (val))
-#define LGLYPH_SET_CODE(g, val) ASET ((g), 3, make_number (val))
-#define LGLYPH_SET_WIDTH(g, val) ASET ((g), 4, make_number (val))
-#define LGLYPH_SET_LBEARING(g, val) ASET ((g), 5, make_number (val))
-#define LGLYPH_SET_RBEARING(g, val) ASET ((g), 6, make_number (val))
-#define LGLYPH_SET_ASCENT(g, val) ASET ((g), 7, make_number (val))
-#define LGLYPH_SET_DESCENT(g, val) ASET ((g), 8, make_number (val))
-#define LGLYPH_SET_ADJUSTMENT(g, val) ASET ((g), 9, (val))
-
-#define LGLYPH_XOFF(g) (VECTORP (LGLYPH_ADJUSTMENT (g)) \
- ? XINT (AREF (LGLYPH_ADJUSTMENT (g), 0)) : 0)
-#define LGLYPH_YOFF(g) (VECTORP (LGLYPH_ADJUSTMENT (g)) \
- ? XINT (AREF (LGLYPH_ADJUSTMENT (g), 1)) : 0)
-#define LGLYPH_WADJUST(g) (VECTORP (LGLYPH_ADJUSTMENT (g)) \
- ? XINT (AREF (LGLYPH_ADJUSTMENT (g), 2)) : 0)
#define FONT_INVALID_CODE 0xFFFFFFFF
/* Symbol indicating the type of the font-driver. */
Lisp_Object type;
+ /* 1 iff the font's foundry, family, and adstyle names are case
+ sensitve. */
+ int case_sensitive;
+
/* Return a cache of font-entities on frame F. The cache must be a
cons whose cdr part is the actual cache area. */
Lisp_Object (*get_cache) P_ ((FRAME_PTR F));
/* List fonts exactly matching with FONT_SPEC on FRAME. The value
- is a vector of font-entities. This is the sole API that
- allocates font-entities. */
+ is a list of font-entities. The font properties to be considered
+ are: :foundry, :family, :adstyle, :registry, :script, :lang, and
+ :otf. See the function `font-spec' for their meanings. Note
+ that the last three properties are stored in FONT_EXTRA_INDEX
+ slot of FONT_SPEC.
+
+ The returned value is a list of font-entities. Each font-entity
+ has :type property whose value is the same as the above `type'.
+ It also has these properties if they are available from the
+ corresponding font; :foundry, :family, :adstyle, :registry,
+ :weight, :slant, :width, :size, :dpi, :spacing, :avgwidth. If
+ the font is scalable, :size and :avgwidth must be 0.
+
+ The `open' method of the same font-backend is called with one of
+ the returned font-entities. If the backend needs additional
+ information to be used in `open' method, this method can add any
+ Lispy value by the property :font-entity to the entities.
+
+ This and the following `match' are the only APIs that allocate
+ font-entities. */
Lisp_Object (*list) P_ ((Lisp_Object frame, Lisp_Object font_spec));
- /* Return a font entity most closely maching with FONT_SPEC on
- FRAME. The closeness is detemined by the font backend, thus
- `face-font-selection-order' is ignored here. */
+ /* Return a font-entity most closely matching with FONT_SPEC on
+ FRAME. Which font property to consider, and how to calculate the
+ closeness is determined by the font backend, thus
+ `face-font-selection-order' is ignored here.
+
+ The properties that the font-entity has is the same as `list'
+ method. */
Lisp_Object (*match) P_ ((Lisp_Object frame, Lisp_Object font_spec));
/* Optional.
/* Open a font specified by FONT_ENTITY on frame F. If the font is
scalable, open it with PIXEL_SIZE. */
- struct font *(*open) P_ ((FRAME_PTR f, Lisp_Object font_entity,
- int pixel_size));
+ Lisp_Object (*open) P_ ((FRAME_PTR f, Lisp_Object font_entity,
+ int pixel_size));
/* Close FONT on frame F. */
void (*close) P_ ((FRAME_PTR f, struct font *font));
void (*done_face) P_ ((FRAME_PTR f, struct face *face));
/* Optional.
- If FONT_ENTITY has a glyph for character C (Unicode code point),
- return 1. If not, return 0. If a font must be opened to check
- it, return -1. */
- int (*has_char) P_ ((Lisp_Object entity, int c));
+ If FONT (FONT-ENTITY or FONT-OBJECT) has a glyph for character C
+ (Unicode code point), return 1. If not, return 0. If FONT is
+ FONT-ENTITY and it must be opened to check it, return -1. */
+ int (*has_char) P_ ((Lisp_Object font, int c));
- /* Return a glyph code of FONT for characer C (Unicode code point).
+ /* Return a glyph code of FONT for character C (Unicode code point).
If FONT doesn't have such a glyph, return FONT_INVALID_CODE. */
unsigned (*encode_char) P_ ((struct font *font, int c));
/* Optional.
Make the font driver ready for frame F. Usually this function
- makes some data specific to F and store it in F by calling
+ makes some data specific to F and stores it in F by calling
font_put_frame_data (). */
int (*start_for_frame) P_ ((FRAME_PTR f));
-
+
/* Optional.
End using the driver for frame F. Usually this function free
some data stored for F. */
int (*end_for_frame) P_ ((FRAME_PTR f));
/* Optional.
- Shape text in LGSTRING. */
+
+ Shape text in GSTRING. See the docstring of
+ `composition-get-gstring' for the format of GSTRING. If the
+ (N+1)th element of GSTRING is nil, input of shaping is from the
+ 1st to (N)th elements. In each input glyph, FROM, TO, CHAR, and
+ CODE are already set.
+
+ This function updates all fields of the input glyphs. If the
+ output glyphs (M) are more than the input glyphs (N), (N+1)th
+ through (M)th elements of GSTRING are updated possibly by making
+ a new glyph object and storing it in GSTRING. If (M) is greater
+ than the length of GSTRING, nil should be return. In that case,
+ this function is called again with the larger GSTRING. */
Lisp_Object (*shape) P_ ((Lisp_Object lgstring));
+
+ /* Optional.
+
+ If FONT is usable on frame F, return 0. Otherwise return -1.
+ This method is used only for debugging. If this method is NULL,
+ Emacs assumes that the font is usable on any frame. */
+ int (*check) P_ ((FRAME_PTR F, struct font *font));
+
+ /* Optional.
+
+ Return the number of variation glyphs of character C supported by
+ FONT. VARIATIONS is an array of 256 elements. If the variation
+ selector N (1..256) defines a glyph, that glyph code is stored in
+ the (N-1)th element of VARIATIONS. */
+ int (*get_variation_glyphs) P_ ((struct font *font,
+ int c, unsigned variations[256]));
+
+ void (*filter_properties) P_ ((Lisp_Object font, Lisp_Object properties));
+
+ /* Optional.
+
+ Return non-zero if FONT_OBJECT can be used as a (cached) font
+ for ENTITY on frame F. */
+ int (*cached_font_ok) P_ ((struct frame *f,
+ Lisp_Object font_object,
+ Lisp_Object entity));
};
struct font_data_list *next;
};
-extern int enable_font_backend;
-
EXFUN (Ffont_spec, MANY);
+EXFUN (Fcopy_font_spec, 1);
+EXFUN (Fmerge_font_spec, 2);
EXFUN (Ffont_get, 2);
+EXFUN (Ffont_put, 3);
EXFUN (Flist_fonts, 4);
+EXFUN (Ffont_family_list, 1);
EXFUN (Fclear_font_cache, 0);
-EXFUN (Ffont_xlfd_name, 1);
+EXFUN (Ffont_xlfd_name, 2);
+
+extern Lisp_Object font_make_spec P_ ((void));
+extern Lisp_Object font_make_entity P_ ((void));
+extern Lisp_Object font_make_object P_ ((int, Lisp_Object, int));
+extern Lisp_Object find_font_encoding P_ ((Lisp_Object));
extern int font_registry_charsets P_ ((Lisp_Object, struct charset **,
struct charset **));
-extern Lisp_Object font_symbolic_weight P_ ((Lisp_Object font));
-extern Lisp_Object font_symbolic_slant P_ ((Lisp_Object font));
-extern Lisp_Object font_symbolic_width P_ ((Lisp_Object font));
+extern int font_style_to_value P_ ((enum font_property_index prop,
+ Lisp_Object name, int noerror));
+extern Lisp_Object font_style_symbolic P_ ((Lisp_Object font,
+ enum font_property_index prop,
+ int for_face));
-extern int font_match_p P_ ((Lisp_Object spec, Lisp_Object entity));
+extern int font_match_p P_ ((Lisp_Object spec, Lisp_Object font));
+extern Lisp_Object font_list_entities P_ ((Lisp_Object frame,
+ Lisp_Object spec));
-extern Lisp_Object font_find_object P_ ((struct font *font));
extern Lisp_Object font_get_name P_ ((Lisp_Object font_object));
-extern Lisp_Object font_get_spec P_ ((Lisp_Object font_object));
+extern Lisp_Object font_spec_from_name P_ ((Lisp_Object font_name));
extern Lisp_Object font_get_frame P_ ((Lisp_Object font_object));
extern int font_has_char P_ ((FRAME_PTR, Lisp_Object, int));
extern unsigned font_encode_char P_ ((Lisp_Object, int));
-extern int font_set_lface_from_name P_ ((FRAME_PTR f,
- Lisp_Object lface,
- Lisp_Object fontname,
- int force_p, int may_fail_p));
+extern void font_clear_prop P_ ((Lisp_Object *attrs,
+ enum font_property_index prop));
+extern void font_update_lface P_ ((FRAME_PTR f, Lisp_Object *attrs));
extern Lisp_Object font_find_for_lface P_ ((FRAME_PTR f, Lisp_Object *lface,
Lisp_Object spec, int c));
extern Lisp_Object font_open_for_lface P_ ((FRAME_PTR f, Lisp_Object entity,
Lisp_Object *lface,
Lisp_Object spec));
-extern void font_load_for_face P_ ((FRAME_PTR f, struct face *face));
+extern Lisp_Object font_load_for_lface P_ ((FRAME_PTR f, Lisp_Object *lface,
+ Lisp_Object spec));
extern void font_prepare_for_face P_ ((FRAME_PTR f, struct face *face));
+extern void font_done_for_face P_ ((FRAME_PTR f, struct face *face));
+
+extern Lisp_Object font_open_by_spec P_ ((FRAME_PTR f, Lisp_Object spec));
extern Lisp_Object font_open_by_name P_ ((FRAME_PTR f, char *name));
extern void font_close_object (FRAME_PTR f, Lisp_Object font_object);
-extern Lisp_Object intern_downcase P_ ((char *str, int len));
+extern Lisp_Object font_intern_prop P_ ((char *str, int len, int force_symbol));
extern void font_update_sort_order P_ ((int *order));
-extern void font_merge_old_spec P_ ((Lisp_Object name, Lisp_Object family,
- Lisp_Object registry, Lisp_Object spec));
-
+extern void font_parse_family_registry P_ ((Lisp_Object family,
+ Lisp_Object registry,
+ Lisp_Object spec));
+extern Lisp_Object font_spec_from_family_registry P_ ((Lisp_Object family,
+ Lisp_Object registry));
extern int font_parse_xlfd P_ ((char *name, Lisp_Object font));
extern int font_unparse_xlfd P_ ((Lisp_Object font, int pixel_size,
extern int font_parse_fcname P_ ((char *name, Lisp_Object font));
extern int font_unparse_fcname P_ ((Lisp_Object font, int pixel_size,
char *name, int bytes));
+extern int font_unparse_gtkname P_ ((Lisp_Object, struct frame *, char *, int));
extern void register_font_driver P_ ((struct font_driver *driver, FRAME_PTR f));
extern void free_font_driver_list P_ ((FRAME_PTR f));
extern Lisp_Object font_update_drivers P_ ((FRAME_PTR f, Lisp_Object list));
extern Lisp_Object font_at P_ ((int c, EMACS_INT pos, struct face *face,
struct window *w, Lisp_Object object));
-
-extern struct font *font_prepare_composition P_ ((struct composition *cmp,
- FRAME_PTR f));
+extern Lisp_Object font_range (EMACS_INT, EMACS_INT *,
+ struct window *, struct face *,
+ Lisp_Object);
+extern void font_fill_lglyph_metrics P_ ((Lisp_Object, Lisp_Object));
extern Lisp_Object font_put_extra P_ ((Lisp_Object font, Lisp_Object prop,
Lisp_Object val));
extern void *font_get_frame_data P_ ((FRAME_PTR f,
struct font_driver *driver));
+extern void font_filter_properties (Lisp_Object font,
+ Lisp_Object alist,
+ const char *boolean_properties[],
+ const char *non_boolean_properties[]);
+
#ifdef HAVE_FREETYPE
extern struct font_driver ftfont_driver;
#endif /* HAVE_FREETYPE */
#endif /* HAVE_X_WINDOWS */
#ifdef WINDOWSNT
extern struct font_driver w32font_driver;
+extern struct font_driver uniscribe_font_driver;
#endif /* WINDOWSNT */
-#ifdef MAC_OS
-extern struct font_driver atmfont_driver;
-#endif /* MAC_OS */
+#ifdef HAVE_NS
+extern struct font_driver nsfont_driver;
+#endif /* HAVE_NS */
+
+#ifndef FONT_DEBUG
+#define FONT_DEBUG
+#endif
+
+extern Lisp_Object Vfont_log;
+extern void font_add_log P_ ((char *, Lisp_Object, Lisp_Object));
+extern void font_deferred_log P_ ((char *, Lisp_Object, Lisp_Object));
+
+#define FONT_ADD_LOG(ACTION, ARG, RESULT) \
+ do { \
+ if (! EQ (Vfont_log, Qt)) \
+ font_add_log ((ACTION), (ARG), (RESULT)); \
+ } while (0)
+
+#define FONT_DEFERRED_LOG(ACTION, ARG, RESULT) \
+ do { \
+ if (! EQ (Vfont_log, Qt)) \
+ font_deferred_log ((ACTION), (ARG), (RESULT)); \
+ } while (0)
+
+#ifdef FONT_DEBUG
+#define font_assert(X) do {if (!(X)) abort ();} while (0)
+#else /* not FONT_DEBUG */
+#define font_assert(X) (void) 0
+#endif /* not FONT_DEBUG */
#endif /* not EMACS_FONT_H */
HCoop / bpt / emacs.git / blobdiff