2 Copyright (C) 1995, 1997, 2000 Electrotechnical Laboratory, JAPAN.
3 Licensed to the Free Software Foundation.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* #define FONTSET_DEBUG */
36 #include "dispextern.h"
48 #include "termhooks.h"
52 #define xassert(X) do {if (!(X)) abort ();} while (0)
60 A fontset is a collection of font related information to give
61 similar appearance (style, size, etc) of characters. There are two
62 kinds of fontsets; base and realized. A base fontset is created by
63 new-fontset from Emacs Lisp explicitly. A realized fontset is
64 created implicitly when a face is realized for ASCII characters. A
65 face is also realized for multibyte characters based on an ASCII
66 face. All of the multibyte faces based on the same ASCII face
67 share the same realized fontset.
69 A fontset object is implemented by a char-table.
71 An element of a base fontset is:
73 (INDEX . (FOUNDRY . REGISTRY ))
74 FONTNAME is a font name pattern for the corresponding character.
75 FOUNDRY and REGISTRY are respectively foundry and registry fields of
76 a font name for the corresponding character. INDEX specifies for
77 which character (or generic character) the element is defined. It
78 may be different from an index to access this element. For
79 instance, if a fontset defines some font for all characters of
80 charset `japanese-jisx0208', INDEX is the generic character of this
81 charset. REGISTRY is the
83 An element of a realized fontset is FACE-ID which is a face to use
84 for displaying the corresponding character.
86 All single byte characters (ASCII and 8bit-unibyte) share the same
87 element in a fontset. The element is stored in the first element
90 To access or set each element, use macros FONTSET_REF and
91 FONTSET_SET respectively for efficiency.
93 A fontset has 3 extra slots.
95 The 1st slot is an ID number of the fontset.
97 The 2nd slot is a name of the fontset. This is nil for a realized
100 The 3rd slot is a frame that the fontset belongs to. This is nil
103 A parent of a base fontset is nil. A parent of a realized fontset
106 All fontsets are recorded in Vfontset_table.
111 There's a special fontset named `default fontset' which defines a
112 default fontname pattern. When a base fontset doesn't specify a
113 font for a specific character, the corresponding value in the
114 default fontset is used. The format is the same as a base fontset.
116 The parent of a realized fontset created for such a face that has
117 no fontset is the default fontset.
120 These structures are hidden from the other codes than this file.
121 The other codes handle fontsets only by their ID numbers. They
122 usually use variable name `fontset' for IDs. But, in this file, we
123 always use variable name `id' for IDs, and name `fontset' for the
124 actual fontset objects.
128 /********** VARIABLES and FUNCTION PROTOTYPES **********/
130 extern Lisp_Object Qfont
;
131 Lisp_Object Qfontset
;
133 /* Vector containing all fontsets. */
134 static Lisp_Object Vfontset_table
;
136 /* Next possibly free fontset ID. Usually this keeps the minimum
137 fontset ID not yet used. */
138 static int next_fontset_id
;
140 /* The default fontset. This gives default FAMILY and REGISTRY of
141 font for each characters. */
142 static Lisp_Object Vdefault_fontset
;
144 /* Alist of font specifications. It override the font specification
145 in the default fontset. */
146 static Lisp_Object Voverriding_fontspec_alist
;
148 Lisp_Object Vfont_encoding_alist
;
149 Lisp_Object Vuse_default_ascent
;
150 Lisp_Object Vignore_relative_composition
;
151 Lisp_Object Valternate_fontname_alist
;
152 Lisp_Object Vfontset_alias_alist
;
153 Lisp_Object Vvertical_centering_font_regexp
;
155 /* The following six are declarations of callback functions depending
156 on window system. See the comments in src/fontset.h for more
159 /* Return a pointer to struct font_info of font FONT_IDX of frame F. */
160 struct font_info
*(*get_font_info_func
) P_ ((FRAME_PTR f
, int font_idx
));
162 /* Return a list of font names which matches PATTERN. See the documentation
163 of `x-list-fonts' for more details. */
164 Lisp_Object (*list_fonts_func
) P_ ((struct frame
*f
,
169 /* Load a font named NAME for frame F and return a pointer to the
170 information of the loaded font. If loading is failed, return 0. */
171 struct font_info
*(*load_font_func
) P_ ((FRAME_PTR f
, char *name
, int));
173 /* Return a pointer to struct font_info of a font named NAME for frame F. */
174 struct font_info
*(*query_font_func
) P_ ((FRAME_PTR f
, char *name
));
176 /* Additional function for setting fontset or changing fontset
177 contents of frame F. */
178 void (*set_frame_fontset_func
) P_ ((FRAME_PTR f
, Lisp_Object arg
,
179 Lisp_Object oldval
));
181 /* To find a CCL program, fs_load_font calls this function.
182 The argument is a pointer to the struct font_info.
183 This function set the member `encoder' of the structure. */
184 void (*find_ccl_program_func
) P_ ((struct font_info
*));
186 /* Check if any window system is used now. */
187 void (*check_window_system_func
) P_ ((void));
190 /* Prototype declarations for static functions. */
191 static Lisp_Object fontset_ref
P_ ((Lisp_Object
, int));
192 static Lisp_Object lookup_overriding_fontspec
P_ ((Lisp_Object
, int));
193 static void fontset_set
P_ ((Lisp_Object
, int, Lisp_Object
));
194 static Lisp_Object make_fontset
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
195 static int fontset_id_valid_p
P_ ((int));
196 static Lisp_Object fontset_pattern_regexp
P_ ((Lisp_Object
));
197 static Lisp_Object font_family_registry
P_ ((Lisp_Object
, int));
198 static Lisp_Object regulalize_fontname
P_ ((Lisp_Object
));
201 /********** MACROS AND FUNCTIONS TO HANDLE FONTSET **********/
203 /* Return the fontset with ID. No check of ID's validness. */
204 #define FONTSET_FROM_ID(id) AREF (Vfontset_table, id)
206 /* Macros to access special values of FONTSET. */
207 #define FONTSET_ID(fontset) XCHAR_TABLE (fontset)->extras[0]
208 #define FONTSET_NAME(fontset) XCHAR_TABLE (fontset)->extras[1]
209 #define FONTSET_FRAME(fontset) XCHAR_TABLE (fontset)->extras[2]
210 #define FONTSET_ASCII(fontset) XCHAR_TABLE (fontset)->contents[0]
211 #define FONTSET_BASE(fontset) XCHAR_TABLE (fontset)->parent
213 #define BASE_FONTSET_P(fontset) NILP (FONTSET_BASE(fontset))
216 /* Return the element of FONTSET (char-table) at index C (character). */
218 #define FONTSET_REF(fontset, c) fontset_ref (fontset, c)
221 fontset_ref (fontset
, c
)
226 Lisp_Object elt
, defalt
;
228 if (SINGLE_BYTE_CHAR_P (c
))
229 return FONTSET_ASCII (fontset
);
231 SPLIT_CHAR (c
, charset
, c1
, c2
);
232 elt
= XCHAR_TABLE (fontset
)->contents
[charset
+ 128];
233 if (!SUB_CHAR_TABLE_P (elt
))
235 defalt
= XCHAR_TABLE (elt
)->defalt
;
237 || (elt
= XCHAR_TABLE (elt
)->contents
[c1
],
240 if (!SUB_CHAR_TABLE_P (elt
))
242 defalt
= XCHAR_TABLE (elt
)->defalt
;
244 || (elt
= XCHAR_TABLE (elt
)->contents
[c2
],
252 lookup_overriding_fontspec (frame
, c
)
258 for (tail
= Voverriding_fontspec_alist
; CONSP (tail
); tail
= XCDR (tail
))
260 Lisp_Object val
, target
, elt
;
265 /* Now VAL is (NO-FRAME-LIST OK-FRAME-LIST CHAR FONTNAME). */
266 if (NILP (Fmemq (frame
, XCAR (val
)))
267 && (CHAR_TABLE_P (target
)
268 ? ! NILP (CHAR_TABLE_REF (target
, c
))
269 : XINT (target
) == CHAR_CHARSET (c
)))
273 if (NILP (Fmemq (frame
, XCAR (val
))))
275 if (! face_font_available_p (XFRAME (frame
), XCDR (elt
)))
277 val
= XCDR (XCAR (tail
));
278 XSETCAR (val
, Fcons (frame
, XCAR (val
)));
281 XSETCAR (val
, Fcons (frame
, XCAR (val
)));
283 if (NILP (XCAR (elt
)))
284 XSETCAR (elt
, make_number (c
));
291 #define FONTSET_REF_VIA_BASE(fontset, c) fontset_ref_via_base (fontset, &c)
294 fontset_ref_via_base (fontset
, c
)
301 if (SINGLE_BYTE_CHAR_P (*c
))
302 return FONTSET_ASCII (fontset
);
305 if (! EQ (FONTSET_BASE (fontset
), Vdefault_fontset
))
306 elt
= FONTSET_REF (FONTSET_BASE (fontset
), *c
);
308 elt
= lookup_overriding_fontspec (FONTSET_FRAME (fontset
), *c
);
310 elt
= FONTSET_REF (Vdefault_fontset
, *c
);
314 *c
= XINT (XCAR (elt
));
315 SPLIT_CHAR (*c
, charset
, c1
, c2
);
316 elt
= XCHAR_TABLE (fontset
)->contents
[charset
+ 128];
318 return (SUB_CHAR_TABLE_P (elt
) ? XCHAR_TABLE (elt
)->defalt
: elt
);
319 if (!SUB_CHAR_TABLE_P (elt
))
321 elt
= XCHAR_TABLE (elt
)->contents
[c1
];
323 return (SUB_CHAR_TABLE_P (elt
) ? XCHAR_TABLE (elt
)->defalt
: elt
);
324 if (!SUB_CHAR_TABLE_P (elt
))
326 elt
= XCHAR_TABLE (elt
)->contents
[c2
];
331 /* Store into the element of FONTSET at index C the value NEWELT. */
332 #define FONTSET_SET(fontset, c, newelt) fontset_set(fontset, c, newelt)
335 fontset_set (fontset
, c
, newelt
)
340 int charset
, code
[3];
344 if (SINGLE_BYTE_CHAR_P (c
))
346 FONTSET_ASCII (fontset
) = newelt
;
350 SPLIT_CHAR (c
, charset
, code
[0], code
[1]);
351 code
[2] = 0; /* anchor */
352 elt
= &XCHAR_TABLE (fontset
)->contents
[charset
+ 128];
353 for (i
= 0; code
[i
] > 0; i
++)
355 if (!SUB_CHAR_TABLE_P (*elt
))
356 *elt
= make_sub_char_table (*elt
);
357 elt
= &XCHAR_TABLE (*elt
)->contents
[code
[i
]];
359 if (SUB_CHAR_TABLE_P (*elt
))
360 XCHAR_TABLE (*elt
)->defalt
= newelt
;
366 /* Return a newly created fontset with NAME. If BASE is nil, make a
367 base fontset. Otherwise make a realized fontset whose parent is
371 make_fontset (frame
, name
, base
)
372 Lisp_Object frame
, name
, base
;
375 int size
= ASIZE (Vfontset_table
);
376 int id
= next_fontset_id
;
378 /* Find a free slot in Vfontset_table. Usually, next_fontset_id is
379 the next available fontset ID. So it is expected that this loop
380 terminates quickly. In addition, as the last element of
381 Vfontset_table is always nil, we don't have to check the range of
383 while (!NILP (AREF (Vfontset_table
, id
))) id
++;
390 tem
= Fmake_vector (make_number (size
+ 8), Qnil
);
391 for (i
= 0; i
< size
; i
++)
392 AREF (tem
, i
) = AREF (Vfontset_table
, i
);
393 Vfontset_table
= tem
;
396 fontset
= Fmake_char_table (Qfontset
, Qnil
);
398 FONTSET_ID (fontset
) = make_number (id
);
399 FONTSET_NAME (fontset
) = name
;
400 FONTSET_FRAME (fontset
) = frame
;
401 FONTSET_BASE (fontset
) = base
;
403 AREF (Vfontset_table
, id
) = fontset
;
404 next_fontset_id
= id
+ 1;
409 /* Return 1 if ID is a valid fontset id, else return 0. */
412 fontset_id_valid_p (id
)
415 return (id
>= 0 && id
< ASIZE (Vfontset_table
) - 1);
419 /* Extract `family' and `registry' string from FONTNAME and a cons of
420 them. Actually, `family' may also contain `foundry', `registry'
421 may also contain `encoding' of FONTNAME. But, if FONTNAME doesn't
422 conform to XLFD nor explicitely specifies the other fields
423 (i.e. not using wildcard `*'), return FONTNAME. If FORCE is
424 nonzero, specifications of the other fields are ignored, and return
425 a cons as far as FONTNAME conform to XLFD. */
428 font_family_registry (fontname
, force
)
429 Lisp_Object fontname
;
432 Lisp_Object family
, registry
;
433 const char *p
= SDATA (fontname
);
440 if (!force
&& i
>= 2 && i
<= 11 && *p
!= '*' && p
[1] != '-')
447 family
= make_unibyte_string (sep
[0], sep
[2] - 1 - sep
[0]);
448 registry
= make_unibyte_string (sep
[12], p
- sep
[12]);
449 return Fcons (family
, registry
);
453 /********** INTERFACES TO xfaces.c and dispextern.h **********/
455 /* Return name of the fontset with ID. */
462 fontset
= FONTSET_FROM_ID (id
);
463 return FONTSET_NAME (fontset
);
467 /* Return ASCII font name of the fontset with ID. */
473 Lisp_Object fontset
, elt
;
474 fontset
= FONTSET_FROM_ID (id
);
475 elt
= FONTSET_ASCII (fontset
);
480 /* Free fontset of FACE. Called from free_realized_face. */
483 free_face_fontset (f
, face
)
487 if (fontset_id_valid_p (face
->fontset
))
489 AREF (Vfontset_table
, face
->fontset
) = Qnil
;
490 if (face
->fontset
< next_fontset_id
)
491 next_fontset_id
= face
->fontset
;
496 /* Return 1 iff FACE is suitable for displaying character C.
497 Otherwise return 0. Called from the macro FACE_SUITABLE_FOR_CHAR_P
498 when C is not a single byte character.. */
501 face_suitable_for_char_p (face
, c
)
505 Lisp_Object fontset
, elt
;
507 if (SINGLE_BYTE_CHAR_P (c
))
508 return (face
== face
->ascii_face
);
510 xassert (fontset_id_valid_p (face
->fontset
));
511 fontset
= FONTSET_FROM_ID (face
->fontset
);
512 xassert (!BASE_FONTSET_P (fontset
));
514 elt
= FONTSET_REF_VIA_BASE (fontset
, c
);
515 return (!NILP (elt
) && face
->id
== XFASTINT (elt
));
519 /* Return ID of face suitable for displaying character C on frame F.
520 The selection of face is done based on the fontset of FACE. FACE
521 should already have been realized for ASCII characters. Called
522 from the macro FACE_FOR_CHAR when C is not a single byte character. */
525 face_for_char (f
, face
, c
)
530 Lisp_Object fontset
, elt
;
533 xassert (fontset_id_valid_p (face
->fontset
));
534 fontset
= FONTSET_FROM_ID (face
->fontset
);
535 xassert (!BASE_FONTSET_P (fontset
));
537 elt
= FONTSET_REF_VIA_BASE (fontset
, c
);
541 /* No face is recorded for C in the fontset of FACE. Make a new
542 realized face for C that has the same fontset. */
543 face_id
= lookup_face (f
, face
->lface
, c
, face
);
545 /* Record the face ID in FONTSET at the same index as the
546 information in the base fontset. */
547 FONTSET_SET (fontset
, c
, make_number (face_id
));
552 /* Make a realized fontset for ASCII face FACE on frame F from the
553 base fontset BASE_FONTSET_ID. If BASE_FONTSET_ID is -1, use the
554 default fontset as the base. Value is the id of the new fontset.
555 Called from realize_x_face. */
558 make_fontset_for_ascii_face (f
, base_fontset_id
)
562 Lisp_Object base_fontset
, fontset
, frame
;
564 XSETFRAME (frame
, f
);
565 if (base_fontset_id
>= 0)
567 base_fontset
= FONTSET_FROM_ID (base_fontset_id
);
568 if (!BASE_FONTSET_P (base_fontset
))
569 base_fontset
= FONTSET_BASE (base_fontset
);
570 xassert (BASE_FONTSET_P (base_fontset
));
573 base_fontset
= Vdefault_fontset
;
575 fontset
= make_fontset (frame
, Qnil
, base_fontset
);
576 return XINT (FONTSET_ID (fontset
));
580 /* Return the font name pattern for C that is recorded in the fontset
581 with ID. If a font name pattern is specified (instead of a cons of
582 family and registry), check if a font can be opened by that pattern
583 to get the fullname. If a font is opened, return that name.
584 Otherwise, return nil. If ID is -1, or the fontset doesn't contain
585 information about C, get the registry and encoding of C from the
586 default fontset. Called from choose_face_font. */
589 fontset_font_pattern (f
, id
, c
)
593 Lisp_Object fontset
, elt
;
594 struct font_info
*fontp
;
597 if (fontset_id_valid_p (id
))
599 fontset
= FONTSET_FROM_ID (id
);
600 xassert (!BASE_FONTSET_P (fontset
));
601 fontset
= FONTSET_BASE (fontset
);
602 if (! EQ (fontset
, Vdefault_fontset
))
603 elt
= FONTSET_REF (fontset
, c
);
609 XSETFRAME (frame
, f
);
610 elt
= lookup_overriding_fontspec (frame
, c
);
613 elt
= FONTSET_REF (Vdefault_fontset
, c
);
617 if (CONSP (XCDR (elt
)))
620 /* The fontset specifies only a font name pattern (not cons of
621 family and registry). If a font can be opened by that pattern,
622 return the name of opened font. Otherwise return nil. The
623 exception is a font for single byte characters. In that case, we
624 return a cons of FAMILY and REGISTRY extracted from the opened
627 xassert (STRINGP (elt
));
628 fontp
= FS_LOAD_FONT (f
, c
, SDATA (elt
), -1);
632 return font_family_registry (build_string (fontp
->full_name
),
633 SINGLE_BYTE_CHAR_P (c
));
637 #if defined(WINDOWSNT) && defined (_MSC_VER)
638 #pragma optimize("", off)
641 /* Load a font named FONTNAME to display character C on frame F.
642 Return a pointer to the struct font_info of the loaded font. If
643 loading fails, return NULL. If FACE is non-zero and a fontset is
644 assigned to it, record FACE->id in the fontset for C. If FONTNAME
645 is NULL, the name is taken from the fontset of FACE or what
649 fs_load_font (f
, c
, fontname
, id
, face
)
657 Lisp_Object list
, elt
;
659 struct font_info
*fontp
;
660 int charset
= CHAR_CHARSET (c
);
667 fontset
= FONTSET_FROM_ID (id
);
670 && !BASE_FONTSET_P (fontset
))
672 elt
= FONTSET_REF_VIA_BASE (fontset
, c
);
675 /* A suitable face for C is already recorded, which means
676 that a proper font is already loaded. */
677 int face_id
= XINT (elt
);
679 xassert (face_id
== face
->id
);
680 face
= FACE_FROM_ID (f
, face_id
);
681 return (*get_font_info_func
) (f
, face
->font_info_id
);
684 if (!fontname
&& charset
== CHARSET_ASCII
)
686 elt
= FONTSET_ASCII (fontset
);
687 fontname
= SDATA (XCDR (elt
));
692 /* No way to get fontname. */
695 fontp
= (*load_font_func
) (f
, fontname
, size
);
699 /* Fill in members (charset, vertical_centering, encoding, etc) of
700 font_info structure that are not set by (*load_font_func). */
701 fontp
->charset
= charset
;
703 fontp
->vertical_centering
704 = (STRINGP (Vvertical_centering_font_regexp
)
705 && (fast_c_string_match_ignore_case
706 (Vvertical_centering_font_regexp
, fontp
->full_name
) >= 0));
708 if (fontp
->encoding
[1] != FONT_ENCODING_NOT_DECIDED
)
710 /* The font itself tells which code points to be used. Use this
711 encoding for all other charsets. */
714 fontp
->encoding
[0] = fontp
->encoding
[1];
715 for (i
= MIN_CHARSET_OFFICIAL_DIMENSION1
; i
<= MAX_CHARSET
; i
++)
716 fontp
->encoding
[i
] = fontp
->encoding
[1];
720 /* The font itself doesn't have information about encoding. */
723 fontname
= fontp
->full_name
;
724 /* By default, encoding of ASCII chars is 0 (i.e. 0x00..0x7F),
725 others is 1 (i.e. 0x80..0xFF). */
726 fontp
->encoding
[0] = 0;
727 for (i
= MIN_CHARSET_OFFICIAL_DIMENSION1
; i
<= MAX_CHARSET
; i
++)
728 fontp
->encoding
[i
] = 1;
729 /* Then override them by a specification in Vfont_encoding_alist. */
730 for (list
= Vfont_encoding_alist
; CONSP (list
); list
= XCDR (list
))
734 && STRINGP (XCAR (elt
)) && CONSP (XCDR (elt
))
735 && (fast_c_string_match_ignore_case (XCAR (elt
), fontname
)
740 for (tmp
= XCDR (elt
); CONSP (tmp
); tmp
= XCDR (tmp
))
741 if (CONSP (XCAR (tmp
))
742 && ((i
= get_charset_id (XCAR (XCAR (tmp
))))
744 && INTEGERP (XCDR (XCAR (tmp
)))
745 && XFASTINT (XCDR (XCAR (tmp
))) < 4)
747 = XFASTINT (XCDR (XCAR (tmp
)));
752 if (! fontp
->font_encoder
&& find_ccl_program_func
)
753 (*find_ccl_program_func
) (fontp
);
755 /* If we loaded a font for a face that has fontset, record the face
756 ID in the fontset for C. */
759 && !BASE_FONTSET_P (fontset
))
760 FONTSET_SET (fontset
, c
, make_number (face
->id
));
764 #if defined(WINDOWSNT) && defined (_MSC_VER)
765 #pragma optimize("", on)
769 /* Cache data used by fontset_pattern_regexp. The car part is a
770 pattern string containing at least one wild card, the cdr part is
771 the corresponding regular expression. */
772 static Lisp_Object Vcached_fontset_data
;
774 #define CACHED_FONTSET_NAME (SDATA (XCAR (Vcached_fontset_data)))
775 #define CACHED_FONTSET_REGEX (XCDR (Vcached_fontset_data))
777 /* If fontset name PATTERN contains any wild card, return regular
778 expression corresponding to PATTERN. */
781 fontset_pattern_regexp (pattern
)
784 if (!index (SDATA (pattern
), '*')
785 && !index (SDATA (pattern
), '?'))
786 /* PATTERN does not contain any wild cards. */
789 if (!CONSP (Vcached_fontset_data
)
790 || strcmp (SDATA (pattern
), CACHED_FONTSET_NAME
))
792 /* We must at first update the cached data. */
793 char *regex
= (char *) alloca (SCHARS (pattern
) * 2 + 3);
794 char *p0
, *p1
= regex
;
796 /* Convert "*" to ".*", "?" to ".". */
798 for (p0
= (char *) SDATA (pattern
); *p0
; p0
++)
813 Vcached_fontset_data
= Fcons (build_string (SDATA (pattern
)),
814 build_string (regex
));
817 return CACHED_FONTSET_REGEX
;
820 /* Return ID of the base fontset named NAME. If there's no such
821 fontset, return -1. */
824 fs_query_fontset (name
, regexpp
)
831 name
= Fdowncase (name
);
834 tem
= Frassoc (name
, Vfontset_alias_alist
);
835 if (CONSP (tem
) && STRINGP (XCAR (tem
)))
839 tem
= fontset_pattern_regexp (name
);
848 for (i
= 0; i
< ASIZE (Vfontset_table
); i
++)
851 const unsigned char *this_name
;
853 fontset
= FONTSET_FROM_ID (i
);
855 || !BASE_FONTSET_P (fontset
))
858 this_name
= SDATA (FONTSET_NAME (fontset
));
860 ? fast_c_string_match_ignore_case (name
, this_name
) >= 0
861 : !strcmp (SDATA (name
), this_name
))
868 DEFUN ("query-fontset", Fquery_fontset
, Squery_fontset
, 1, 2, 0,
869 doc
: /* Return the name of a fontset that matches PATTERN.
870 The value is nil if there is no matching fontset.
871 PATTERN can contain `*' or `?' as a wildcard
872 just as X font name matching algorithm allows.
873 If REGEXPP is non-nil, PATTERN is a regular expression. */)
875 Lisp_Object pattern
, regexpp
;
880 (*check_window_system_func
) ();
882 CHECK_STRING (pattern
);
884 if (SCHARS (pattern
) == 0)
887 id
= fs_query_fontset (pattern
, !NILP (regexpp
));
891 fontset
= FONTSET_FROM_ID (id
);
892 return FONTSET_NAME (fontset
);
895 /* Return a list of base fontset names matching PATTERN on frame F.
896 If SIZE is not 0, it is the size (maximum bound width) of fontsets
900 list_fontsets (f
, pattern
, size
)
905 Lisp_Object frame
, regexp
, val
;
908 XSETFRAME (frame
, f
);
910 regexp
= fontset_pattern_regexp (pattern
);
913 for (id
= 0; id
< ASIZE (Vfontset_table
); id
++)
916 const unsigned char *name
;
918 fontset
= FONTSET_FROM_ID (id
);
920 || !BASE_FONTSET_P (fontset
)
921 || !EQ (frame
, FONTSET_FRAME (fontset
)))
923 name
= SDATA (FONTSET_NAME (fontset
));
926 ? (fast_c_string_match_ignore_case (regexp
, name
) < 0)
927 : strcmp (SDATA (pattern
), name
))
932 struct font_info
*fontp
;
933 fontp
= FS_LOAD_FONT (f
, 0, NULL
, id
);
934 if (!fontp
|| size
!= fontp
->size
)
937 val
= Fcons (Fcopy_sequence (FONTSET_NAME (fontset
)), val
);
943 DEFUN ("new-fontset", Fnew_fontset
, Snew_fontset
, 2, 2, 0,
944 doc
: /* Create a new fontset NAME that contains font information in FONTLIST.
945 FONTLIST is an alist of charsets vs corresponding font name patterns. */)
947 Lisp_Object name
, fontlist
;
949 Lisp_Object fontset
, elements
, ascii_font
;
950 Lisp_Object tem
, tail
, elt
;
952 (*check_window_system_func
) ();
955 CHECK_LIST (fontlist
);
957 name
= Fdowncase (name
);
958 tem
= Fquery_fontset (name
, Qnil
);
960 error ("Fontset `%s' matches the existing fontset `%s'",
961 SDATA (name
), SDATA (tem
));
963 /* Check the validity of FONTLIST while creating a template for
965 elements
= ascii_font
= Qnil
;
966 for (tail
= fontlist
; CONSP (tail
); tail
= XCDR (tail
))
972 || (charset
= get_charset_id (XCAR (tem
))) < 0
973 || (!STRINGP (XCDR (tem
)) && !CONSP (XCDR (tem
))))
974 error ("Elements of fontlist must be a cons of charset and font name pattern");
978 tem
= Fdowncase (tem
);
980 tem
= Fcons (Fdowncase (Fcar (tem
)), Fdowncase (Fcdr (tem
)));
981 if (charset
== CHARSET_ASCII
)
985 c
= MAKE_CHAR (charset
, 0, 0);
986 elements
= Fcons (Fcons (make_number (c
), tem
), elements
);
990 if (NILP (ascii_font
))
991 error ("No ASCII font in the fontlist");
993 fontset
= make_fontset (Qnil
, name
, Qnil
);
994 FONTSET_ASCII (fontset
) = Fcons (make_number (0), ascii_font
);
995 for (; CONSP (elements
); elements
= XCDR (elements
))
997 elt
= XCAR (elements
);
1000 tem
= font_family_registry (tem
, 0);
1001 tem
= Fcons (XCAR (elt
), tem
);
1002 FONTSET_SET (fontset
, XINT (XCAR (elt
)), tem
);
1009 /* Clear all elements of FONTSET for multibyte characters. */
1012 clear_fontset_elements (fontset
)
1013 Lisp_Object fontset
;
1017 for (i
= CHAR_TABLE_SINGLE_BYTE_SLOTS
; i
< CHAR_TABLE_ORDINARY_SLOTS
; i
++)
1018 XCHAR_TABLE (fontset
)->contents
[i
] = Qnil
;
1022 /* Check validity of NAME as a fontset name and return the
1023 corresponding fontset. If not valid, signal an error.
1024 If NAME is nil, return Vdefault_fontset. */
1027 check_fontset_name (name
)
1032 if (EQ (name
, Qnil
))
1033 return Vdefault_fontset
;
1035 CHECK_STRING (name
);
1036 id
= fs_query_fontset (name
, 0);
1038 error ("Fontset `%s' does not exist", SDATA (name
));
1039 return FONTSET_FROM_ID (id
);
1042 /* Downcase FONTNAME or car and cdr of FONTNAME. If FONTNAME is a
1043 string, maybe change FONTNAME to (FAMILY . REGISTRY). */
1046 regulalize_fontname (Lisp_Object fontname
)
1048 Lisp_Object family
, registry
;
1050 if (STRINGP (fontname
))
1051 return font_family_registry (Fdowncase (fontname
), 0);
1053 CHECK_CONS (fontname
);
1054 family
= XCAR (fontname
);
1055 registry
= XCDR (fontname
);
1058 CHECK_STRING (family
);
1059 family
= Fdowncase (family
);
1061 if (!NILP (registry
))
1063 CHECK_STRING (registry
);
1064 registry
= Fdowncase (registry
);
1066 return Fcons (family
, registry
);
1069 DEFUN ("set-fontset-font", Fset_fontset_font
, Sset_fontset_font
, 3, 4, 0,
1070 doc
: /* Modify fontset NAME to use FONTNAME for CHARACTER.
1072 If NAME is nil, modify the default fontset.
1073 CHARACTER may be a cons; (FROM . TO), where FROM and TO are
1074 non-generic characters. In that case, use FONTNAME
1075 for all characters in the range FROM and TO (inclusive).
1076 CHARACTER may be a charset. In that case, use FONTNAME
1077 for all character in the charsets.
1079 FONTNAME may be a cons; (FAMILY . REGISTRY), where FAMILY is a family
1080 name of a font, REGISTRY is a registry name of a font. */)
1081 (name
, character
, fontname
, frame
)
1082 Lisp_Object name
, character
, fontname
, frame
;
1084 Lisp_Object fontset
, elt
;
1085 Lisp_Object realized
;
1088 Lisp_Object family
, registry
;
1090 fontset
= check_fontset_name (name
);
1092 if (CONSP (character
))
1094 /* CH should be (FROM . TO) where FROM and TO are non-generic
1096 CHECK_NUMBER_CAR (character
);
1097 CHECK_NUMBER_CDR (character
);
1098 from
= XINT (XCAR (character
));
1099 to
= XINT (XCDR (character
));
1100 if (!char_valid_p (from
, 0) || !char_valid_p (to
, 0))
1101 error ("Character range should be by non-generic characters");
1103 && (SINGLE_BYTE_CHAR_P (from
) || SINGLE_BYTE_CHAR_P (to
)))
1104 error ("Can't change font for a single byte character");
1106 else if (SYMBOLP (character
))
1108 elt
= Fget (character
, Qcharset
);
1109 if (!VECTORP (elt
) || ASIZE (elt
) < 1 || !NATNUMP (AREF (elt
, 0)))
1110 error ("Invalid charset: %s", SDATA (SYMBOL_NAME (character
)));
1111 from
= MAKE_CHAR (XINT (AREF (elt
, 0)), 0, 0);
1116 CHECK_NUMBER (character
);
1117 from
= XINT (character
);
1120 if (!char_valid_p (from
, 1))
1121 invalid_character (from
);
1122 if (SINGLE_BYTE_CHAR_P (from
))
1123 error ("Can't change font for a single byte character");
1126 if (!char_valid_p (to
, 1))
1127 invalid_character (to
);
1128 if (SINGLE_BYTE_CHAR_P (to
))
1129 error ("Can't change font for a single byte character");
1132 /* The arg FRAME is kept for backward compatibility. We only check
1135 CHECK_LIVE_FRAME (frame
);
1137 elt
= Fcons (make_number (from
), regulalize_fontname (fontname
));
1138 for (; from
<= to
; from
++)
1139 FONTSET_SET (fontset
, from
, elt
);
1140 Foptimize_char_table (fontset
);
1142 /* If there's a realized fontset REALIZED whose parent is FONTSET,
1143 clear all the elements of REALIZED and free all multibyte faces
1144 whose fontset is REALIZED. This way, the specified character(s)
1145 are surely redisplayed by a correct font. */
1146 for (id
= 0; id
< ASIZE (Vfontset_table
); id
++)
1148 realized
= AREF (Vfontset_table
, id
);
1149 if (!NILP (realized
)
1150 && !BASE_FONTSET_P (realized
)
1151 && EQ (FONTSET_BASE (realized
), fontset
))
1153 FRAME_PTR f
= XFRAME (FONTSET_FRAME (realized
));
1154 clear_fontset_elements (realized
);
1155 free_realized_multibyte_face (f
, id
);
1162 DEFUN ("font-info", Ffont_info
, Sfont_info
, 1, 2, 0,
1163 doc
: /* Return information about a font named NAME on frame FRAME.
1164 If FRAME is omitted or nil, use the selected frame.
1165 The returned value is a vector of OPENED-NAME, FULL-NAME, CHARSET, SIZE,
1166 HEIGHT, BASELINE-OFFSET, RELATIVE-COMPOSE, and DEFAULT-ASCENT,
1168 OPENED-NAME is the name used for opening the font,
1169 FULL-NAME is the full name of the font,
1170 SIZE is the maximum bound width of the font,
1171 HEIGHT is the height of the font,
1172 BASELINE-OFFSET is the upward offset pixels from ASCII baseline,
1173 RELATIVE-COMPOSE and DEFAULT-ASCENT are the numbers controlling
1174 how to compose characters.
1175 If the named font is not yet loaded, return nil. */)
1177 Lisp_Object name
, frame
;
1180 struct font_info
*fontp
;
1183 (*check_window_system_func
) ();
1185 CHECK_STRING (name
);
1186 name
= Fdowncase (name
);
1188 frame
= selected_frame
;
1189 CHECK_LIVE_FRAME (frame
);
1192 if (!query_font_func
)
1193 error ("Font query function is not supported");
1195 fontp
= (*query_font_func
) (f
, SDATA (name
));
1199 info
= Fmake_vector (make_number (7), Qnil
);
1201 XVECTOR (info
)->contents
[0] = build_string (fontp
->name
);
1202 XVECTOR (info
)->contents
[1] = build_string (fontp
->full_name
);
1203 XVECTOR (info
)->contents
[2] = make_number (fontp
->size
);
1204 XVECTOR (info
)->contents
[3] = make_number (fontp
->height
);
1205 XVECTOR (info
)->contents
[4] = make_number (fontp
->baseline_offset
);
1206 XVECTOR (info
)->contents
[5] = make_number (fontp
->relative_compose
);
1207 XVECTOR (info
)->contents
[6] = make_number (fontp
->default_ascent
);
1213 /* Return a cons (FONT-NAME . GLYPH-CODE).
1214 FONT-NAME is the font name for the character at POSITION in the current
1215 buffer. This is computed from all the text properties and overlays
1216 that apply to POSITION.
1217 GLYPH-CODE is the glyph code in the font to use for the character.
1219 If the 2nd optional arg CH is non-nil, it is a character to check
1220 the font instead of the character at POSITION.
1222 It returns nil in the following cases:
1224 (1) The window system doesn't have a font for the character (thus
1225 it is displayed by an empty box).
1227 (2) The character code is invalid.
1229 (3) The current buffer is not displayed in any window.
1231 In addition, the returned font name may not take into account of
1232 such redisplay engine hooks as what used in jit-lock-mode if
1233 POSITION is currently not visible. */
1236 DEFUN ("internal-char-font", Finternal_char_font
, Sinternal_char_font
, 1, 2, 0,
1237 doc
: /* For internal use only. */)
1239 Lisp_Object position
, ch
;
1241 int pos
, pos_byte
, dummy
;
1249 CHECK_NUMBER_COERCE_MARKER (position
);
1250 pos
= XINT (position
);
1251 if (pos
< BEGV
|| pos
>= ZV
)
1252 args_out_of_range_3 (position
, make_number (BEGV
), make_number (ZV
));
1253 pos_byte
= CHAR_TO_BYTE (pos
);
1255 c
= FETCH_CHAR (pos_byte
);
1261 if (! CHAR_VALID_P (c
, 0))
1263 window
= Fget_buffer_window (Fcurrent_buffer (), Qnil
);
1266 w
= XWINDOW (window
);
1267 f
= XFRAME (w
->frame
);
1268 face_id
= face_at_buffer_position (w
, pos
, -1, -1, &dummy
, pos
+ 100, 0);
1269 face_id
= FACE_FOR_CHAR (f
, FACE_FROM_ID (f
, face_id
), c
);
1270 face
= FACE_FROM_ID (f
, face_id
);
1271 if (! face
->font
|| ! face
->font_name
)
1275 struct font_info
*fontp
= (*get_font_info_func
) (f
, face
->font_info_id
);
1277 int c1
, c2
, charset
;
1279 SPLIT_CHAR (c
, charset
, c1
, c2
);
1281 STORE_XCHAR2B (&char2b
, c1
, c2
);
1283 STORE_XCHAR2B (&char2b
, 0, c1
);
1284 FRAME_RIF (f
)->encode_char (c
, &char2b
, fontp
, NULL
);
1285 code
= (XCHAR2B_BYTE1 (&char2b
) << 8) | XCHAR2B_BYTE2 (&char2b
);
1287 return Fcons (build_string (face
->font_name
), make_number (code
));
1291 /* Called from Ffontset_info via map_char_table on each leaf of
1292 fontset. ARG is a copy of the default fontset. The current leaf
1293 is indexed by CHARACTER and has value ELT. This function override
1294 the copy by ELT if ELT is not nil. */
1297 override_font_info (fontset
, character
, elt
)
1298 Lisp_Object fontset
, character
, elt
;
1301 Faset (fontset
, character
, elt
);
1304 /* Called from Ffontset_info via map_char_table on each leaf of
1305 fontset. ARG is a list (LAST FONT-INFO ...), where LAST is `(last
1306 ARG)' and FONT-INFOs have this form:
1307 (CHAR FONT-SPEC) or ((FROM . TO) FONT-SPEC)
1308 The current leaf is indexed by CHARACTER and has value ELT. This
1309 function add the information of the current leaf to ARG by
1310 appending a new element or modifying the last element. */
1313 accumulate_font_info (arg
, character
, elt
)
1314 Lisp_Object arg
, character
, elt
;
1316 Lisp_Object last
, last_char
, last_elt
;
1318 if (!CONSP (elt
) && !SINGLE_BYTE_CHAR_P (XINT (character
)))
1319 elt
= FONTSET_REF (Vdefault_fontset
, XINT (character
));
1323 last_char
= XCAR (XCAR (last
));
1324 last_elt
= XCAR (XCDR (XCAR (last
)));
1326 if (!NILP (Fequal (elt
, last_elt
)))
1328 int this_charset
= CHAR_CHARSET (XINT (character
));
1330 if (CONSP (last_char
)) /* LAST_CHAR == (FROM . TO) */
1332 if (this_charset
== CHAR_CHARSET (XINT (XCAR (last_char
))))
1334 XSETCDR (last_char
, character
);
1338 else if (XINT (last_char
) == XINT (character
))
1340 else if (this_charset
== CHAR_CHARSET (XINT (last_char
)))
1342 XSETCAR (XCAR (last
), Fcons (last_char
, character
));
1346 XSETCDR (last
, Fcons (Fcons (character
, Fcons (elt
, Qnil
)), Qnil
));
1347 XSETCAR (arg
, XCDR (last
));
1351 DEFUN ("fontset-info", Ffontset_info
, Sfontset_info
, 1, 2, 0,
1352 doc
: /* Return information about a fontset named NAME on frame FRAME.
1353 If NAME is nil, return information about the default fontset.
1354 The value is a vector:
1355 [ SIZE HEIGHT ((CHARSET-OR-RANGE FONT-SPEC OPENED ...) ...) ],
1357 SIZE is the maximum bound width of ASCII font in the fontset,
1358 HEIGHT is the maximum bound height of ASCII font in the fontset,
1359 CHARSET-OR-RANGE is a charset, a character (may be a generic character)
1360 or a cons of two characters specifying the range of characters.
1361 FONT-SPEC is a fontname pattern string or a cons (FAMILY . REGISTRY),
1362 where FAMILY is a `FAMILY' field of a XLFD font name,
1363 REGISTRY is a `CHARSET_REGISTRY' field of a XLFD font name.
1364 FAMILY may contain a `FOUNDRY' field at the head.
1365 REGISTRY may contain a `CHARSET_ENCODING' field at the tail.
1366 OPENEDs are names of fonts actually opened.
1367 If the ASCII font is not yet opened, SIZE and HEIGHT are 0.
1368 If FRAME is omitted, it defaults to the currently selected frame. */)
1370 Lisp_Object name
, frame
;
1372 Lisp_Object fontset
;
1374 Lisp_Object indices
[3];
1375 Lisp_Object val
, tail
, elt
;
1376 Lisp_Object
*realized
;
1377 struct font_info
*fontp
= NULL
;
1381 (*check_window_system_func
) ();
1383 fontset
= check_fontset_name (name
);
1386 frame
= selected_frame
;
1387 CHECK_LIVE_FRAME (frame
);
1390 /* Recode realized fontsets whose base is FONTSET in the table
1392 realized
= (Lisp_Object
*) alloca (sizeof (Lisp_Object
)
1393 * ASIZE (Vfontset_table
));
1394 for (i
= 0; i
< ASIZE (Vfontset_table
); i
++)
1396 elt
= FONTSET_FROM_ID (i
);
1398 && EQ (FONTSET_BASE (elt
), fontset
))
1399 realized
[n_realized
++] = elt
;
1402 if (! EQ (fontset
, Vdefault_fontset
))
1404 /* Merge FONTSET onto the default fontset. */
1405 val
= Fcopy_sequence (Vdefault_fontset
);
1406 map_char_table (override_font_info
, Qnil
, fontset
, fontset
, val
, 0, indices
);
1410 /* Accumulate information of the fontset in VAL. The format is
1411 (LAST FONT-INFO FONT-INFO ...), where FONT-INFO is (CHAR-OR-RANGE
1412 FONT-SPEC). See the comment for accumulate_font_info for the
1414 val
= Fcons (Fcons (make_number (0),
1415 Fcons (XCDR (FONTSET_ASCII (fontset
)), Qnil
)),
1417 val
= Fcons (val
, val
);
1418 map_char_table (accumulate_font_info
, Qnil
, fontset
, fontset
, val
, 0, indices
);
1421 /* For each FONT-INFO, if CHAR_OR_RANGE (car part) is a generic
1422 character for a charset, replace it with the charset symbol. If
1423 fonts are opened for FONT-SPEC, append the names of the fonts to
1425 for (tail
= val
; CONSP (tail
); tail
= XCDR (tail
))
1429 if (INTEGERP (XCAR (elt
)))
1431 int charset
, c1
, c2
;
1432 c
= XINT (XCAR (elt
));
1433 SPLIT_CHAR (c
, charset
, c1
, c2
);
1435 XSETCAR (elt
, CHARSET_SYMBOL (charset
));
1438 c
= XINT (XCAR (XCAR (elt
)));
1439 for (i
= 0; i
< n_realized
; i
++)
1441 Lisp_Object face_id
, font
;
1444 face_id
= FONTSET_REF_VIA_BASE (realized
[i
], c
);
1445 if (INTEGERP (face_id
))
1447 face
= FACE_FROM_ID (f
, XINT (face_id
));
1448 if (face
&& face
->font
&& face
->font_name
)
1450 font
= build_string (face
->font_name
);
1451 if (NILP (Fmember (font
, XCDR (XCDR (elt
)))))
1452 XSETCDR (XCDR (elt
), Fcons (font
, XCDR (XCDR (elt
))));
1458 elt
= Fcdr (Fcdr (Fassq (CHARSET_SYMBOL (CHARSET_ASCII
), val
)));
1462 fontp
= (*query_font_func
) (f
, SDATA (elt
));
1464 val
= Fmake_vector (make_number (3), val
);
1465 AREF (val
, 0) = fontp
? make_number (fontp
->size
) : make_number (0);
1466 AREF (val
, 1) = fontp
? make_number (fontp
->height
) : make_number (0);
1470 DEFUN ("fontset-font", Ffontset_font
, Sfontset_font
, 2, 2, 0,
1471 doc
: /* Return a font name pattern for character CH in fontset NAME.
1472 If NAME is nil, find a font name pattern in the default fontset. */)
1474 Lisp_Object name
, ch
;
1477 Lisp_Object fontset
, elt
;
1479 fontset
= check_fontset_name (name
);
1483 if (!char_valid_p (c
, 1))
1484 invalid_character (c
);
1486 elt
= FONTSET_REF (fontset
, c
);
1493 DEFUN ("fontset-list", Ffontset_list
, Sfontset_list
, 0, 0, 0,
1494 doc
: /* Return a list of all defined fontset names. */)
1497 Lisp_Object fontset
, list
;
1501 for (i
= 0; i
< ASIZE (Vfontset_table
); i
++)
1503 fontset
= FONTSET_FROM_ID (i
);
1505 && BASE_FONTSET_P (fontset
))
1506 list
= Fcons (FONTSET_NAME (fontset
), list
);
1512 DEFUN ("set-overriding-fontspec-internal", Fset_overriding_fontspec_internal
,
1513 Sset_overriding_fontspec_internal
, 1, 1, 0,
1514 doc
: /* Internal use only.
1516 FONTLIST is an alist of TARGET vs FONTNAME, where TARGET is a charset
1517 or a char-table, FONTNAME have the same meanings as in
1520 It overrides the font specifications for each TARGET in the default
1521 fontset by the corresponding FONTNAME.
1523 If TARGET is a charset, targets are all characters in the charset. If
1524 TARGET is a char-table, targets are characters whose value is non-nil
1527 It is intended that this function is called only from
1528 `set-language-environment'. */)
1530 Lisp_Object fontlist
;
1534 fontlist
= Fcopy_sequence (fontlist
);
1535 /* Now FONTLIST is ((TARGET . FONTNAME) ...). Reform it to ((TARGET
1536 nil nil nil FONTSPEC) ...), where TARGET is a charset-id or a
1538 for (tail
= fontlist
; CONSP (tail
); tail
= XCDR (tail
))
1540 Lisp_Object elt
, target
;
1543 target
= Fcar (elt
);
1544 elt
= Fcons (Qnil
, regulalize_fontname (Fcdr (elt
)));
1545 if (! CHAR_TABLE_P (target
))
1549 CHECK_SYMBOL (target
);
1550 charset
= get_charset_id (target
);
1552 error ("Invalid charset %s", SDATA (SYMBOL_NAME (target
)));
1553 target
= make_number (charset
);
1554 c
= MAKE_CHAR (charset
, 0, 0);
1555 XSETCAR (elt
, make_number (c
));
1557 elt
= Fcons (target
, Fcons (Qnil
, Fcons (Qnil
, elt
)));
1558 XSETCAR (tail
, elt
);
1560 Voverriding_fontspec_alist
= fontlist
;
1561 clear_face_cache (0);
1562 ++windows_or_buffers_changed
;
1569 if (!load_font_func
)
1570 /* Window system initializer should have set proper functions. */
1573 Qfontset
= intern ("fontset");
1574 staticpro (&Qfontset
);
1575 Fput (Qfontset
, Qchar_table_extra_slots
, make_number (3));
1577 Vcached_fontset_data
= Qnil
;
1578 staticpro (&Vcached_fontset_data
);
1580 Vfontset_table
= Fmake_vector (make_number (32), Qnil
);
1581 staticpro (&Vfontset_table
);
1583 Vdefault_fontset
= Fmake_char_table (Qfontset
, Qnil
);
1584 staticpro (&Vdefault_fontset
);
1585 FONTSET_ID (Vdefault_fontset
) = make_number (0);
1586 FONTSET_NAME (Vdefault_fontset
)
1587 = build_string ("-*-*-*-*-*-*-*-*-*-*-*-*-fontset-default");
1588 #if defined (MAC_OS)
1589 FONTSET_ASCII (Vdefault_fontset
)
1590 = Fcons (make_number (0),
1591 build_string ("-apple-monaco-medium-r-*--*-120-*-*-*-*-mac-roman"));
1592 #elif defined (WINDOWSNT)
1593 FONTSET_ASCII (Vdefault_fontset
)
1594 = Fcons (make_number (0),
1595 build_string ("-*-courier new-normal-r-*-*-*-100-*-*-*-*-iso8859-1"));
1597 FONTSET_ASCII (Vdefault_fontset
)
1598 = Fcons (make_number (0),
1599 build_string ("-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1"));
1601 AREF (Vfontset_table
, 0) = Vdefault_fontset
;
1602 next_fontset_id
= 1;
1604 Voverriding_fontspec_alist
= Qnil
;
1605 staticpro (&Voverriding_fontspec_alist
);
1607 DEFVAR_LISP ("font-encoding-alist", &Vfont_encoding_alist
,
1608 doc
: /* Alist of fontname patterns vs corresponding encoding info.
1609 Each element looks like (REGEXP . ENCODING-INFO),
1610 where ENCODING-INFO is an alist of CHARSET vs ENCODING.
1611 ENCODING is one of the following integer values:
1612 0: code points 0x20..0x7F or 0x2020..0x7F7F are used,
1613 1: code points 0xA0..0xFF or 0xA0A0..0xFFFF are used,
1614 2: code points 0x20A0..0x7FFF are used,
1615 3: code points 0xA020..0xFF7F are used. */);
1616 Vfont_encoding_alist
= Qnil
;
1617 Vfont_encoding_alist
1618 = Fcons (Fcons (build_string ("JISX0201"),
1619 Fcons (Fcons (intern ("latin-jisx0201"), make_number (0)),
1621 Vfont_encoding_alist
);
1622 Vfont_encoding_alist
1623 = Fcons (Fcons (build_string ("ISO8859-1"),
1624 Fcons (Fcons (intern ("ascii"), make_number (0)),
1626 Vfont_encoding_alist
);
1628 DEFVAR_LISP ("use-default-ascent", &Vuse_default_ascent
,
1629 doc
: /* Char table of characters whose ascent values should be ignored.
1630 If an entry for a character is non-nil, the ascent value of the glyph
1631 is assumed to be what specified by _MULE_DEFAULT_ASCENT property of a font.
1633 This affects how a composite character which contains
1634 such a character is displayed on screen. */);
1635 Vuse_default_ascent
= Qnil
;
1637 DEFVAR_LISP ("ignore-relative-composition", &Vignore_relative_composition
,
1638 doc
: /* Char table of characters which is not composed relatively.
1639 If an entry for a character is non-nil, a composition sequence
1640 which contains that character is displayed so that
1641 the glyph of that character is put without considering
1642 an ascent and descent value of a previous character. */);
1643 Vignore_relative_composition
= Qnil
;
1645 DEFVAR_LISP ("alternate-fontname-alist", &Valternate_fontname_alist
,
1646 doc
: /* Alist of fontname vs list of the alternate fontnames.
1647 When a specified font name is not found, the corresponding
1648 alternate fontnames (if any) are tried instead. */);
1649 Valternate_fontname_alist
= Qnil
;
1651 DEFVAR_LISP ("fontset-alias-alist", &Vfontset_alias_alist
,
1652 doc
: /* Alist of fontset names vs the aliases. */);
1653 Vfontset_alias_alist
= Fcons (Fcons (FONTSET_NAME (Vdefault_fontset
),
1654 build_string ("fontset-default")),
1657 DEFVAR_LISP ("vertical-centering-font-regexp",
1658 &Vvertical_centering_font_regexp
,
1659 doc
: /* *Regexp matching font names that require vertical centering on display.
1660 When a character is displayed with such fonts, the character is displayed
1661 at the vertical center of lines. */);
1662 Vvertical_centering_font_regexp
= Qnil
;
1664 defsubr (&Squery_fontset
);
1665 defsubr (&Snew_fontset
);
1666 defsubr (&Sset_fontset_font
);
1667 defsubr (&Sfont_info
);
1668 defsubr (&Sinternal_char_font
);
1669 defsubr (&Sfontset_info
);
1670 defsubr (&Sfontset_font
);
1671 defsubr (&Sfontset_list
);
1672 defsubr (&Sset_overriding_fontspec_internal
);
1675 /* arch-tag: ea861585-2f5f-4e5b-9849-d04a9c3a3537
1676 (do not change this comment) */