From 81b39386f6522ac95b329270ba72d733958baa46 Mon Sep 17 00:00:00 2001 From: Kenichi Handa Date: Fri, 1 Mar 2002 01:49:55 +0000 Subject: [PATCH] Include "character.h" instead of "charset.h". (load_face_font): Adjusted for the change of choose_face_font and FS_LOAD_FONT. (generate_ascii_font): New function. (set_lface_from_font_name): Adjusted for the change of FS_LOAD_FONT. (set_font_frame_param): Adjusted for the change of choose_face_font. (free_realized_face): Make it public. (free_realized_faces_for_fontset): Renamed from free_realized_multibyte_face. Free also faces realized for ASCII. (choose_face_font): Argments changed. Adjusted for the change of fontset_font_pattern and FS_LOAD_FONT. --- src/xfaces.c | 138 +++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 107 insertions(+), 31 deletions(-) diff --git a/src/xfaces.c b/src/xfaces.c index c1d736eeb2e..d02602515fe 100644 --- a/src/xfaces.c +++ b/src/xfaces.c @@ -196,7 +196,7 @@ Boston, MA 02111-1307, USA. */ #include #include "lisp.h" -#include "charset.h" +#include "character.h" #include "keyboard.h" #include "frame.h" @@ -550,14 +550,14 @@ static unsigned hash_string_case_insensitive P_ ((Lisp_Object)); static unsigned lface_hash P_ ((Lisp_Object *)); static int lface_same_font_attributes_p P_ ((Lisp_Object *, Lisp_Object *)); static struct face_cache *make_face_cache P_ ((struct frame *)); -static void free_realized_face P_ ((struct frame *, struct face *)); static void clear_face_gcs P_ ((struct face_cache *)); static void free_face_cache P_ ((struct face_cache *)); static int face_numeric_weight P_ ((Lisp_Object)); static int face_numeric_slant P_ ((Lisp_Object)); static int face_numeric_swidth P_ ((Lisp_Object)); static int face_fontset P_ ((Lisp_Object *)); -static char *choose_face_font P_ ((struct frame *, Lisp_Object *, int, int)); +static char *choose_face_font P_ ((struct frame *, Lisp_Object *, + struct face *, int)); static void merge_face_vectors P_ ((struct frame *, Lisp_Object *, Lisp_Object*, Lisp_Object)); static void merge_face_inheritance P_ ((struct frame *f, Lisp_Object, Lisp_Object *, Lisp_Object)); @@ -567,7 +567,6 @@ static int set_lface_from_font_name P_ ((struct frame *, Lisp_Object, Lisp_Object, int, int)); static Lisp_Object lface_from_face_name P_ ((struct frame *, Lisp_Object, int)); static struct face *make_realized_face P_ ((Lisp_Object *)); -static void free_realized_faces P_ ((struct face_cache *)); static char *best_matching_font P_ ((struct frame *, Lisp_Object *, struct font_name *, int, int)); static void cache_face P_ ((struct face_cache *, struct face *, unsigned)); @@ -1268,12 +1267,13 @@ load_face_font (f, face, c) face->font_info_id = -1; face->font = NULL; - font_name = choose_face_font (f, face->lface, face->fontset, c); + font_name = choose_face_font (f, face->lface, face, c); + if (!font_name) return; BLOCK_INPUT; - font_info = FS_LOAD_FACE_FONT (f, c, font_name, face); + font_info = FS_LOAD_FONT (f, font_name); UNBLOCK_INPUT; if (font_info) @@ -2112,6 +2112,61 @@ face_numeric_swidth (width) } +Lisp_Object +generate_ascii_font (name, ascii_spec) + Lisp_Object name; +{ + struct font_name font; + char *p; + + font.name = LSTRDUPA (name); + if (! split_font_name (NULL, &font, 0)) + return Qnil; + + if (STRINGP (AREF (ascii_spec, FONT_SPEC_FAMILY_INDEX))) + { + p = LSTRDUPA (AREF (ascii_spec, FONT_SPEC_FAMILY_INDEX)); + font.fields[XLFD_FOUNDRY] = p; + while (*p != '-') p++; + if (*p) + { + *p++ = 0; + font.fields[XLFD_FAMILY] = p; + } + else + { + font.fields[XLFD_FAMILY] = font.fields[XLFD_FOUNDRY]; + font.fields[XLFD_FOUNDRY] = "*"; + } + } + if (STRINGP (AREF (ascii_spec, FONT_SPEC_WEIGHT_INDEX))) + font.fields[XLFD_WEIGHT] + = XSTRING (AREF (ascii_spec, FONT_SPEC_WEIGHT_INDEX))->data; + if (STRINGP (AREF (ascii_spec, FONT_SPEC_SLANT_INDEX))) + font.fields[XLFD_SLANT] + = XSTRING (AREF (ascii_spec, FONT_SPEC_SLANT_INDEX))->data; + if (STRINGP (AREF (ascii_spec, FONT_SPEC_SWIDTH_INDEX))) + font.fields[XLFD_SWIDTH] + = XSTRING (AREF (ascii_spec, FONT_SPEC_SWIDTH_INDEX))->data; + if (STRINGP (AREF (ascii_spec, FONT_SPEC_ADSTYLE_INDEX))) + font.fields[XLFD_ADSTYLE] + = XSTRING (AREF (ascii_spec, FONT_SPEC_ADSTYLE_INDEX))->data; + p = LSTRDUPA (AREF (ascii_spec, FONT_SPEC_REGISTRY_INDEX)); + font.fields[XLFD_REGISTRY] = p; + while (*p != '-') p++; + if (*p) + *p++ = 0; + else + p = "*"; + font.fields[XLFD_ENCODING] = p; + + p = build_font_name (&font); + name = build_string (p); + xfree (p); + return name; +} + + #ifdef HAVE_WINDOW_SYSTEM /* Return non-zero if FONT is the name of a fixed-pitch font. */ @@ -3149,7 +3204,7 @@ set_lface_from_font_name (f, lface, fontname, force_p, may_fail_p) caching it now is not futail because we anyway load the font later. */ BLOCK_INPUT; - font_info = FS_LOAD_FONT (f, 0, font_name, -1); + font_info = FS_LOAD_FONT (f, font_name); UNBLOCK_INPUT; if (!font_info) @@ -4252,7 +4307,7 @@ set_font_frame_param (frame, lface) /* Choose a font name that reflects LFACE's attributes and has the registry and encoding pattern specified in the default fontset (3rd arg: -1) for ASCII characters (4th arg: 0). */ - font = choose_face_font (f, XVECTOR (lface)->contents, -1, 0); + font = choose_face_font (f, XVECTOR (lface)->contents, NULL, 0); if (!font) error ("No font matches the specified attribute"); font_name = build_string (font); @@ -4938,7 +4993,7 @@ make_realized_face (attr) /* Free realized face FACE, including its X resources. FACE may be null. */ -static void +void free_realized_face (f, face) struct frame *f; struct face *face; @@ -5116,11 +5171,10 @@ free_realized_faces (c) } -/* Free all faces realized for multibyte characters on frame F that - has FONTSET. */ +/* Free all realized faces that are using FONTSET on frame F. */ void -free_realized_multibyte_face (f, fontset) +free_realized_faces_for_fontset (f, fontset) struct frame *f; int fontset; { @@ -5137,7 +5191,6 @@ free_realized_multibyte_face (f, fontset) { face = cache->faces_by_id[i]; if (face - && face != face->ascii_face && face->fontset == fontset) { uncache_face (cache, face); @@ -6064,26 +6117,28 @@ face_fontset (attrs) /* Choose a name of font to use on frame F to display character C with Lisp face attributes specified by ATTRS. The font name is determined by the font-related attributes in ATTRS and the name - pattern for C in FONTSET. Value is the font name which is - allocated from the heap and must be freed by the caller, or NULL if - we can get no information about the font name of C. It is assured - that we always get some information for a single byte - character. */ + pattern for C in FACE->fontset (or Vdefault_fontset if FACE is + null). Value is the font name which is allocated from the heap and + must be freed by the caller, or NULL if we can get no information + about the font name of C. It is assured that we always get some + information for a single byte character. */ static char * -choose_face_font (f, attrs, fontset, c) +choose_face_font (f, attrs, face, c) struct frame *f; Lisp_Object *attrs; - int fontset, c; + struct face *face; + int c; { - Lisp_Object pattern; + Lisp_Object val; + Lisp_Object pattern, family, registry; + Lisp_Object new_attrs[LFACE_VECTOR_SIZE]; char *font_name = NULL; struct font_name *fonts; int nfonts, width_ratio; - /* Get (foundry and) family name and registry (and encoding) name of - a font for C. */ - pattern = fontset_font_pattern (f, fontset, c); + /* Get font spec of a font for C. */ + pattern = fontset_font_pattern (f, face, c); if (NILP (pattern)) { xassert (!SINGLE_BYTE_CHAR_P (c)); @@ -6094,13 +6149,34 @@ choose_face_font (f, attrs, fontset, c) if (STRINGP (pattern)) return xstrdup (XSTRING (pattern)->data); + family = AREF (pattern, FONT_SPEC_FAMILY_INDEX); + registry = AREF (pattern, FONT_SPEC_REGISTRY_INDEX); + + bcopy (attrs, new_attrs, sizeof (Lisp_Object) * LFACE_VECTOR_SIZE); + +#if 0 + /* This doesn't work well for the moment. */ + if (! NILP (AREF (pattern, FONT_SPEC_WEIGHT_INDEX))) + new_attrs[LFACE_WEIGHT_INDEX] = AREF (pattern, FONT_SPEC_WEIGHT_INDEX); + if (! NILP (AREF (pattern, FONT_SPEC_SLANT_INDEX))) + new_attrs[LFACE_SLANT_INDEX] = AREF (pattern, FONT_SPEC_SLANT_INDEX); + if (! NILP (AREF (pattern, FONT_SPEC_SWIDTH_INDEX))) + new_attrs[LFACE_SWIDTH_INDEX] = AREF (pattern, FONT_SPEC_SWIDTH_INDEX); +#endif + + /* If C is an ASCII character, family name in ATTRS has higher + priority than what specified in the fontset. */ + if (STRINGP (attrs[LFACE_FAMILY_INDEX]) + && ASCII_CHAR_P (c)) + family = Qnil; + /* Get a list of fonts matching that pattern and choose the best match for the specified face attributes from it. */ - nfonts = try_font_list (f, attrs, XCAR (pattern), XCDR (pattern), &fonts); - width_ratio = (SINGLE_BYTE_CHAR_P (c) + nfonts = try_font_list (f, new_attrs, family, registry, &fonts); + width_ratio = (ASCII_CHAR_P (c) ? 1 - : CHARSET_WIDTH (CHAR_CHARSET (c))); - font_name = best_matching_font (f, attrs, fonts, nfonts, width_ratio); + : CHAR_WIDTH (c)); + font_name = best_matching_font (f, new_attrs, fonts, nfonts, width_ratio); return font_name; } @@ -6377,10 +6453,10 @@ realize_x_face (cache, attrs, c, base_face) f = cache->f; - /* If C is a multibyte character, we share all face attirbutes with + /* If C is a non-ASCII character, we share all face attirbutes with BASE_FACE including the realized fontset. But, we must load a different font. */ - if (!SINGLE_BYTE_CHAR_P (c)) + if (! ASCII_CHAR_P (c)) { bcopy (base_face, face, sizeof *face); face->gc = 0; @@ -6435,7 +6511,7 @@ realize_x_face (cache, attrs, c, base_face) if (STRINGP (attrs[LFACE_FONT_INDEX])) { struct font_info *font_info = - FS_LOAD_FONT (f, 0, XSTRING (attrs[LFACE_FONT_INDEX])->data, -1); + FS_LOAD_FONT (f, XSTRING (attrs[LFACE_FONT_INDEX])->data); if (font_info) face->font = font_info->font; } -- 2.39.2