2 Copyright (C) 2004 Free Software Foundation, Inc.
3 Copyright (C) 1995, 1997, 2000 Electrotechnical Laboratory, JAPAN.
4 Licensed to the Free Software Foundation.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* #define FONTSET_DEBUG */
37 #include "dispextern.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 regularize_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
, fullname
;
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 fullname
= build_string (fontp
->full_name
);
704 fontp
->vertical_centering
705 = (STRINGP (Vvertical_centering_font_regexp
)
706 && (fast_string_match_ignore_case
707 (Vvertical_centering_font_regexp
, fullname
) >= 0));
709 if (fontp
->encoding
[1] != FONT_ENCODING_NOT_DECIDED
)
711 /* The font itself tells which code points to be used. Use this
712 encoding for all other charsets. */
715 fontp
->encoding
[0] = fontp
->encoding
[1];
716 for (i
= MIN_CHARSET_OFFICIAL_DIMENSION1
; i
<= MAX_CHARSET
; i
++)
717 fontp
->encoding
[i
] = fontp
->encoding
[1];
721 /* The font itself doesn't have information about encoding. */
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_string_match_ignore_case (XCAR (elt
), fullname
) >= 0))
739 for (tmp
= XCDR (elt
); CONSP (tmp
); tmp
= XCDR (tmp
))
740 if (CONSP (XCAR (tmp
))
741 && ((i
= get_charset_id (XCAR (XCAR (tmp
))))
743 && INTEGERP (XCDR (XCAR (tmp
)))
744 && XFASTINT (XCDR (XCAR (tmp
))) < 4)
746 = XFASTINT (XCDR (XCAR (tmp
)));
751 if (! fontp
->font_encoder
&& find_ccl_program_func
)
752 (*find_ccl_program_func
) (fontp
);
754 /* If we loaded a font for a face that has fontset, record the face
755 ID in the fontset for C. */
758 && !BASE_FONTSET_P (fontset
))
759 FONTSET_SET (fontset
, c
, make_number (face
->id
));
763 #if defined(WINDOWSNT) && defined (_MSC_VER)
764 #pragma optimize("", on)
768 /* Cache data used by fontset_pattern_regexp. The car part is a
769 pattern string containing at least one wild card, the cdr part is
770 the corresponding regular expression. */
771 static Lisp_Object Vcached_fontset_data
;
773 #define CACHED_FONTSET_NAME (SDATA (XCAR (Vcached_fontset_data)))
774 #define CACHED_FONTSET_REGEX (XCDR (Vcached_fontset_data))
776 /* If fontset name PATTERN contains any wild card, return regular
777 expression corresponding to PATTERN. */
780 fontset_pattern_regexp (pattern
)
783 if (!index (SDATA (pattern
), '*')
784 && !index (SDATA (pattern
), '?'))
785 /* PATTERN does not contain any wild cards. */
788 if (!CONSP (Vcached_fontset_data
)
789 || strcmp (SDATA (pattern
), CACHED_FONTSET_NAME
))
791 /* We must at first update the cached data. */
792 char *regex
= (char *) alloca (SCHARS (pattern
) * 2 + 3);
793 char *p0
, *p1
= regex
;
795 /* Convert "*" to ".*", "?" to ".". */
797 for (p0
= (char *) SDATA (pattern
); *p0
; p0
++)
812 Vcached_fontset_data
= Fcons (build_string (SDATA (pattern
)),
813 build_string (regex
));
816 return CACHED_FONTSET_REGEX
;
819 /* Return ID of the base fontset named NAME. If there's no such
820 fontset, return -1. */
823 fs_query_fontset (name
, regexpp
)
830 name
= Fdowncase (name
);
833 tem
= Frassoc (name
, Vfontset_alias_alist
);
834 if (CONSP (tem
) && STRINGP (XCAR (tem
)))
838 tem
= fontset_pattern_regexp (name
);
847 for (i
= 0; i
< ASIZE (Vfontset_table
); i
++)
849 Lisp_Object fontset
, this_name
;
851 fontset
= FONTSET_FROM_ID (i
);
853 || !BASE_FONTSET_P (fontset
))
856 this_name
= FONTSET_NAME (fontset
);
858 ? fast_string_match (name
, this_name
) >= 0
859 : !strcmp (SDATA (name
), SDATA (this_name
)))
866 DEFUN ("query-fontset", Fquery_fontset
, Squery_fontset
, 1, 2, 0,
867 doc
: /* Return the name of a fontset that matches PATTERN.
868 The value is nil if there is no matching fontset.
869 PATTERN can contain `*' or `?' as a wildcard
870 just as X font name matching algorithm allows.
871 If REGEXPP is non-nil, PATTERN is a regular expression. */)
873 Lisp_Object pattern
, regexpp
;
878 (*check_window_system_func
) ();
880 CHECK_STRING (pattern
);
882 if (SCHARS (pattern
) == 0)
885 id
= fs_query_fontset (pattern
, !NILP (regexpp
));
889 fontset
= FONTSET_FROM_ID (id
);
890 return FONTSET_NAME (fontset
);
893 /* Return a list of base fontset names matching PATTERN on frame F.
894 If SIZE is not 0, it is the size (maximum bound width) of fontsets
898 list_fontsets (f
, pattern
, size
)
903 Lisp_Object frame
, regexp
, val
;
906 XSETFRAME (frame
, f
);
908 regexp
= fontset_pattern_regexp (pattern
);
911 for (id
= 0; id
< ASIZE (Vfontset_table
); id
++)
913 Lisp_Object fontset
, name
;
915 fontset
= FONTSET_FROM_ID (id
);
917 || !BASE_FONTSET_P (fontset
)
918 || !EQ (frame
, FONTSET_FRAME (fontset
)))
920 name
= FONTSET_NAME (fontset
);
923 ? (fast_string_match (regexp
, name
) < 0)
924 : strcmp (SDATA (pattern
), SDATA (name
)))
929 struct font_info
*fontp
;
930 fontp
= FS_LOAD_FONT (f
, 0, NULL
, id
);
931 if (!fontp
|| size
!= fontp
->size
)
934 val
= Fcons (Fcopy_sequence (FONTSET_NAME (fontset
)), val
);
940 DEFUN ("new-fontset", Fnew_fontset
, Snew_fontset
, 2, 2, 0,
941 doc
: /* Create a new fontset NAME that contains font information in FONTLIST.
942 FONTLIST is an alist of charsets vs corresponding font name patterns. */)
944 Lisp_Object name
, fontlist
;
946 Lisp_Object fontset
, elements
, ascii_font
;
947 Lisp_Object tem
, tail
, elt
;
949 (*check_window_system_func
) ();
952 CHECK_LIST (fontlist
);
954 name
= Fdowncase (name
);
955 tem
= Fquery_fontset (name
, Qnil
);
957 error ("Fontset `%s' matches the existing fontset `%s'",
958 SDATA (name
), SDATA (tem
));
960 /* Check the validity of FONTLIST while creating a template for
962 elements
= ascii_font
= Qnil
;
963 for (tail
= fontlist
; CONSP (tail
); tail
= XCDR (tail
))
969 || (charset
= get_charset_id (XCAR (tem
))) < 0
970 || (!STRINGP (XCDR (tem
)) && !CONSP (XCDR (tem
))))
971 error ("Elements of fontlist must be a cons of charset and font name pattern");
975 tem
= Fdowncase (tem
);
977 tem
= Fcons (Fdowncase (Fcar (tem
)), Fdowncase (Fcdr (tem
)));
978 if (charset
== CHARSET_ASCII
)
982 c
= MAKE_CHAR (charset
, 0, 0);
983 elements
= Fcons (Fcons (make_number (c
), tem
), elements
);
987 if (NILP (ascii_font
))
988 error ("No ASCII font in the fontlist");
990 fontset
= make_fontset (Qnil
, name
, Qnil
);
991 FONTSET_ASCII (fontset
) = Fcons (make_number (0), ascii_font
);
992 for (; CONSP (elements
); elements
= XCDR (elements
))
994 elt
= XCAR (elements
);
997 tem
= font_family_registry (tem
, 0);
998 tem
= Fcons (XCAR (elt
), tem
);
999 FONTSET_SET (fontset
, XINT (XCAR (elt
)), tem
);
1006 /* Clear all elements of FONTSET for multibyte characters. */
1009 clear_fontset_elements (fontset
)
1010 Lisp_Object fontset
;
1014 for (i
= CHAR_TABLE_SINGLE_BYTE_SLOTS
; i
< CHAR_TABLE_ORDINARY_SLOTS
; i
++)
1015 XCHAR_TABLE (fontset
)->contents
[i
] = Qnil
;
1019 /* Check validity of NAME as a fontset name and return the
1020 corresponding fontset. If not valid, signal an error.
1021 If NAME is nil, return Vdefault_fontset. */
1024 check_fontset_name (name
)
1029 if (EQ (name
, Qnil
))
1030 return Vdefault_fontset
;
1032 CHECK_STRING (name
);
1033 id
= fs_query_fontset (name
, 0);
1035 error ("Fontset `%s' does not exist", SDATA (name
));
1036 return FONTSET_FROM_ID (id
);
1039 /* Downcase FONTNAME or car and cdr of FONTNAME. If FONTNAME is a
1040 string, maybe change FONTNAME to (FAMILY . REGISTRY). */
1043 regularize_fontname (Lisp_Object fontname
)
1045 Lisp_Object family
, registry
;
1047 if (STRINGP (fontname
))
1048 return font_family_registry (Fdowncase (fontname
), 0);
1050 CHECK_CONS (fontname
);
1051 family
= XCAR (fontname
);
1052 registry
= XCDR (fontname
);
1055 CHECK_STRING (family
);
1056 family
= Fdowncase (family
);
1058 if (!NILP (registry
))
1060 CHECK_STRING (registry
);
1061 registry
= Fdowncase (registry
);
1063 return Fcons (family
, registry
);
1066 DEFUN ("set-fontset-font", Fset_fontset_font
, Sset_fontset_font
, 3, 4, 0,
1067 doc
: /* Modify fontset NAME to use FONTNAME for CHARACTER.
1069 If NAME is nil, modify the default fontset.
1070 CHARACTER may be a cons; (FROM . TO), where FROM and TO are
1071 non-generic characters. In that case, use FONTNAME
1072 for all characters in the range FROM and TO (inclusive).
1073 CHARACTER may be a charset. In that case, use FONTNAME
1074 for all character in the charsets.
1076 FONTNAME may be a cons; (FAMILY . REGISTRY), where FAMILY is a family
1077 name of a font, REGISTRY is a registry name of a font. */)
1078 (name
, character
, fontname
, frame
)
1079 Lisp_Object name
, character
, fontname
, frame
;
1081 Lisp_Object fontset
, elt
;
1082 Lisp_Object realized
;
1086 fontset
= check_fontset_name (name
);
1088 if (CONSP (character
))
1090 /* CH should be (FROM . TO) where FROM and TO are non-generic
1092 CHECK_NUMBER_CAR (character
);
1093 CHECK_NUMBER_CDR (character
);
1094 from
= XINT (XCAR (character
));
1095 to
= XINT (XCDR (character
));
1096 if (!char_valid_p (from
, 0) || !char_valid_p (to
, 0))
1097 error ("Character range should be by non-generic characters");
1099 && (SINGLE_BYTE_CHAR_P (from
) || SINGLE_BYTE_CHAR_P (to
)))
1100 error ("Can't change font for a single byte character");
1102 else if (SYMBOLP (character
))
1104 elt
= Fget (character
, Qcharset
);
1105 if (!VECTORP (elt
) || ASIZE (elt
) < 1 || !NATNUMP (AREF (elt
, 0)))
1106 error ("Invalid charset: %s", SDATA (SYMBOL_NAME (character
)));
1107 from
= MAKE_CHAR (XINT (AREF (elt
, 0)), 0, 0);
1112 CHECK_NUMBER (character
);
1113 from
= XINT (character
);
1116 if (!char_valid_p (from
, 1))
1117 invalid_character (from
);
1118 if (SINGLE_BYTE_CHAR_P (from
))
1119 error ("Can't change font for a single byte character");
1122 if (!char_valid_p (to
, 1))
1123 invalid_character (to
);
1124 if (SINGLE_BYTE_CHAR_P (to
))
1125 error ("Can't change font for a single byte character");
1128 /* The arg FRAME is kept for backward compatibility. We only check
1131 CHECK_LIVE_FRAME (frame
);
1133 elt
= Fcons (make_number (from
), regularize_fontname (fontname
));
1134 for (; from
<= to
; from
++)
1135 FONTSET_SET (fontset
, from
, elt
);
1136 Foptimize_char_table (fontset
);
1138 /* If there's a realized fontset REALIZED whose parent is FONTSET,
1139 clear all the elements of REALIZED and free all multibyte faces
1140 whose fontset is REALIZED. This way, the specified character(s)
1141 are surely redisplayed by a correct font. */
1142 for (id
= 0; id
< ASIZE (Vfontset_table
); id
++)
1144 realized
= AREF (Vfontset_table
, id
);
1145 if (!NILP (realized
)
1146 && !BASE_FONTSET_P (realized
)
1147 && EQ (FONTSET_BASE (realized
), fontset
))
1149 FRAME_PTR f
= XFRAME (FONTSET_FRAME (realized
));
1150 clear_fontset_elements (realized
);
1151 free_realized_multibyte_face (f
, id
);
1158 DEFUN ("font-info", Ffont_info
, Sfont_info
, 1, 2, 0,
1159 doc
: /* Return information about a font named NAME on frame FRAME.
1160 If FRAME is omitted or nil, use the selected frame.
1161 The returned value is a vector of OPENED-NAME, FULL-NAME, CHARSET, SIZE,
1162 HEIGHT, BASELINE-OFFSET, RELATIVE-COMPOSE, and DEFAULT-ASCENT,
1164 OPENED-NAME is the name used for opening the font,
1165 FULL-NAME is the full name of the font,
1166 SIZE is the maximum bound width of the font,
1167 HEIGHT is the height of the font,
1168 BASELINE-OFFSET is the upward offset pixels from ASCII baseline,
1169 RELATIVE-COMPOSE and DEFAULT-ASCENT are the numbers controlling
1170 how to compose characters.
1171 If the named font is not yet loaded, return nil. */)
1173 Lisp_Object name
, frame
;
1176 struct font_info
*fontp
;
1179 (*check_window_system_func
) ();
1181 CHECK_STRING (name
);
1182 name
= Fdowncase (name
);
1184 frame
= selected_frame
;
1185 CHECK_LIVE_FRAME (frame
);
1188 if (!query_font_func
)
1189 error ("Font query function is not supported");
1191 fontp
= (*query_font_func
) (f
, SDATA (name
));
1195 info
= Fmake_vector (make_number (7), Qnil
);
1197 XVECTOR (info
)->contents
[0] = build_string (fontp
->name
);
1198 XVECTOR (info
)->contents
[1] = build_string (fontp
->full_name
);
1199 XVECTOR (info
)->contents
[2] = make_number (fontp
->size
);
1200 XVECTOR (info
)->contents
[3] = make_number (fontp
->height
);
1201 XVECTOR (info
)->contents
[4] = make_number (fontp
->baseline_offset
);
1202 XVECTOR (info
)->contents
[5] = make_number (fontp
->relative_compose
);
1203 XVECTOR (info
)->contents
[6] = make_number (fontp
->default_ascent
);
1209 /* Return a cons (FONT-NAME . GLYPH-CODE).
1210 FONT-NAME is the font name for the character at POSITION in the current
1211 buffer. This is computed from all the text properties and overlays
1212 that apply to POSITION. POSTION may be nil, in which case,
1213 FONT-NAME is the font name for display the character CH with the
1216 GLYPH-CODE is the glyph code in the font to use for the character.
1218 If the 2nd optional arg CH is non-nil, it is a character to check
1219 the font instead of the character at POSITION.
1221 It returns nil in the following cases:
1223 (1) The window system doesn't have a font for the character (thus
1224 it is displayed by an empty box).
1226 (2) The character code is invalid.
1228 (3) If POSITION is not nil, and the current buffer is not displayed
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
;
1247 if (NILP (position
))
1251 f
= XFRAME (selected_frame
);
1252 face_id
= DEFAULT_FACE_ID
;
1259 CHECK_NUMBER_COERCE_MARKER (position
);
1260 pos
= XINT (position
);
1261 if (pos
< BEGV
|| pos
>= ZV
)
1262 args_out_of_range_3 (position
, make_number (BEGV
), make_number (ZV
));
1263 pos_byte
= CHAR_TO_BYTE (pos
);
1265 c
= FETCH_CHAR (pos_byte
);
1271 window
= Fget_buffer_window (Fcurrent_buffer (), Qnil
);
1274 w
= XWINDOW (window
);
1275 f
= XFRAME (w
->frame
);
1276 face_id
= face_at_buffer_position (w
, pos
, -1, -1, &dummy
, pos
+ 100, 0);
1278 if (! CHAR_VALID_P (c
, 0))
1280 face_id
= FACE_FOR_CHAR (f
, FACE_FROM_ID (f
, face_id
), c
);
1281 face
= FACE_FROM_ID (f
, face_id
);
1282 if (! face
->font
|| ! face
->font_name
)
1286 struct font_info
*fontp
= (*get_font_info_func
) (f
, face
->font_info_id
);
1288 int c1
, c2
, charset
;
1290 SPLIT_CHAR (c
, charset
, c1
, c2
);
1292 STORE_XCHAR2B (&char2b
, c1
, c2
);
1294 STORE_XCHAR2B (&char2b
, 0, c1
);
1295 rif
->encode_char (c
, &char2b
, fontp
, NULL
);
1296 code
= (XCHAR2B_BYTE1 (&char2b
) << 8) | XCHAR2B_BYTE2 (&char2b
);
1298 return Fcons (build_string (face
->font_name
), make_number (code
));
1302 /* Called from Ffontset_info via map_char_table on each leaf of
1303 fontset. ARG is a copy of the default fontset. The current leaf
1304 is indexed by CHARACTER and has value ELT. This function override
1305 the copy by ELT if ELT is not nil. */
1308 override_font_info (fontset
, character
, elt
)
1309 Lisp_Object fontset
, character
, elt
;
1312 Faset (fontset
, character
, elt
);
1315 /* Called from Ffontset_info via map_char_table on each leaf of
1316 fontset. ARG is a list (LAST FONT-INFO ...), where LAST is `(last
1317 ARG)' and FONT-INFOs have this form:
1318 (CHAR FONT-SPEC) or ((FROM . TO) FONT-SPEC)
1319 The current leaf is indexed by CHARACTER and has value ELT. This
1320 function add the information of the current leaf to ARG by
1321 appending a new element or modifying the last element. */
1324 accumulate_font_info (arg
, character
, elt
)
1325 Lisp_Object arg
, character
, elt
;
1327 Lisp_Object last
, last_char
, last_elt
;
1329 if (!CONSP (elt
) && !SINGLE_BYTE_CHAR_P (XINT (character
)))
1330 elt
= FONTSET_REF (Vdefault_fontset
, XINT (character
));
1334 last_char
= XCAR (XCAR (last
));
1335 last_elt
= XCAR (XCDR (XCAR (last
)));
1337 if (!NILP (Fequal (elt
, last_elt
)))
1339 int this_charset
= CHAR_CHARSET (XINT (character
));
1341 if (CONSP (last_char
)) /* LAST_CHAR == (FROM . TO) */
1343 if (this_charset
== CHAR_CHARSET (XINT (XCAR (last_char
))))
1345 XSETCDR (last_char
, character
);
1349 else if (XINT (last_char
) == XINT (character
))
1351 else if (this_charset
== CHAR_CHARSET (XINT (last_char
)))
1353 XSETCAR (XCAR (last
), Fcons (last_char
, character
));
1357 XSETCDR (last
, Fcons (Fcons (character
, Fcons (elt
, Qnil
)), Qnil
));
1358 XSETCAR (arg
, XCDR (last
));
1362 DEFUN ("fontset-info", Ffontset_info
, Sfontset_info
, 1, 2, 0,
1363 doc
: /* Return information about a fontset named NAME on frame FRAME.
1364 If NAME is nil, return information about the default fontset.
1365 The value is a vector:
1366 [ SIZE HEIGHT ((CHARSET-OR-RANGE FONT-SPEC OPENED ...) ...) ],
1368 SIZE is the maximum bound width of ASCII font in the fontset,
1369 HEIGHT is the maximum bound height of ASCII font in the fontset,
1370 CHARSET-OR-RANGE is a charset, a character (may be a generic character)
1371 or a cons of two characters specifying the range of characters.
1372 FONT-SPEC is a fontname pattern string or a cons (FAMILY . REGISTRY),
1373 where FAMILY is a `FAMILY' field of a XLFD font name,
1374 REGISTRY is a `CHARSET_REGISTRY' field of a XLFD font name.
1375 FAMILY may contain a `FOUNDRY' field at the head.
1376 REGISTRY may contain a `CHARSET_ENCODING' field at the tail.
1377 OPENEDs are names of fonts actually opened.
1378 If the ASCII font is not yet opened, SIZE and HEIGHT are 0.
1379 If FRAME is omitted, it defaults to the currently selected frame. */)
1381 Lisp_Object name
, frame
;
1383 Lisp_Object fontset
;
1385 Lisp_Object indices
[3];
1386 Lisp_Object val
, tail
, elt
;
1387 Lisp_Object
*realized
;
1388 struct font_info
*fontp
= NULL
;
1392 (*check_window_system_func
) ();
1394 fontset
= check_fontset_name (name
);
1397 frame
= selected_frame
;
1398 CHECK_LIVE_FRAME (frame
);
1401 /* Recode realized fontsets whose base is FONTSET in the table
1403 realized
= (Lisp_Object
*) alloca (sizeof (Lisp_Object
)
1404 * ASIZE (Vfontset_table
));
1405 for (i
= 0; i
< ASIZE (Vfontset_table
); i
++)
1407 elt
= FONTSET_FROM_ID (i
);
1409 && EQ (FONTSET_BASE (elt
), fontset
))
1410 realized
[n_realized
++] = elt
;
1413 if (! EQ (fontset
, Vdefault_fontset
))
1415 /* Merge FONTSET onto the default fontset. */
1416 val
= Fcopy_sequence (Vdefault_fontset
);
1417 map_char_table (override_font_info
, Qnil
, fontset
, fontset
, val
, 0, indices
);
1421 /* Accumulate information of the fontset in VAL. The format is
1422 (LAST FONT-INFO FONT-INFO ...), where FONT-INFO is (CHAR-OR-RANGE
1423 FONT-SPEC). See the comment for accumulate_font_info for the
1425 val
= Fcons (Fcons (make_number (0),
1426 Fcons (XCDR (FONTSET_ASCII (fontset
)), Qnil
)),
1428 val
= Fcons (val
, val
);
1429 map_char_table (accumulate_font_info
, Qnil
, fontset
, fontset
, val
, 0, indices
);
1432 /* For each FONT-INFO, if CHAR_OR_RANGE (car part) is a generic
1433 character for a charset, replace it with the charset symbol. If
1434 fonts are opened for FONT-SPEC, append the names of the fonts to
1436 for (tail
= val
; CONSP (tail
); tail
= XCDR (tail
))
1440 if (INTEGERP (XCAR (elt
)))
1442 int charset
, c1
, c2
;
1443 c
= XINT (XCAR (elt
));
1444 SPLIT_CHAR (c
, charset
, c1
, c2
);
1446 XSETCAR (elt
, CHARSET_SYMBOL (charset
));
1449 c
= XINT (XCAR (XCAR (elt
)));
1450 for (i
= 0; i
< n_realized
; i
++)
1452 Lisp_Object face_id
, font
;
1455 face_id
= FONTSET_REF_VIA_BASE (realized
[i
], c
);
1456 if (INTEGERP (face_id
))
1458 face
= FACE_FROM_ID (f
, XINT (face_id
));
1459 if (face
&& face
->font
&& face
->font_name
)
1461 font
= build_string (face
->font_name
);
1462 if (NILP (Fmember (font
, XCDR (XCDR (elt
)))))
1463 XSETCDR (XCDR (elt
), Fcons (font
, XCDR (XCDR (elt
))));
1469 elt
= Fcdr (Fcdr (Fassq (CHARSET_SYMBOL (CHARSET_ASCII
), val
)));
1473 fontp
= (*query_font_func
) (f
, SDATA (elt
));
1475 val
= Fmake_vector (make_number (3), val
);
1476 AREF (val
, 0) = fontp
? make_number (fontp
->size
) : make_number (0);
1477 AREF (val
, 1) = fontp
? make_number (fontp
->height
) : make_number (0);
1481 DEFUN ("fontset-font", Ffontset_font
, Sfontset_font
, 2, 2, 0,
1482 doc
: /* Return a font name pattern for character CH in fontset NAME.
1483 If NAME is nil, find a font name pattern in the default fontset. */)
1485 Lisp_Object name
, ch
;
1488 Lisp_Object fontset
, elt
;
1490 fontset
= check_fontset_name (name
);
1494 if (!char_valid_p (c
, 1))
1495 invalid_character (c
);
1497 elt
= FONTSET_REF (fontset
, c
);
1504 DEFUN ("fontset-list", Ffontset_list
, Sfontset_list
, 0, 0, 0,
1505 doc
: /* Return a list of all defined fontset names. */)
1508 Lisp_Object fontset
, list
;
1512 for (i
= 0; i
< ASIZE (Vfontset_table
); i
++)
1514 fontset
= FONTSET_FROM_ID (i
);
1516 && BASE_FONTSET_P (fontset
))
1517 list
= Fcons (FONTSET_NAME (fontset
), list
);
1523 DEFUN ("set-overriding-fontspec-internal", Fset_overriding_fontspec_internal
,
1524 Sset_overriding_fontspec_internal
, 1, 1, 0,
1525 doc
: /* Internal use only.
1527 FONTLIST is an alist of TARGET vs FONTNAME, where TARGET is a charset
1528 or a char-table, FONTNAME have the same meanings as in
1531 It overrides the font specifications for each TARGET in the default
1532 fontset by the corresponding FONTNAME.
1534 If TARGET is a charset, targets are all characters in the charset. If
1535 TARGET is a char-table, targets are characters whose value is non-nil
1538 It is intended that this function is called only from
1539 `set-language-environment'. */)
1541 Lisp_Object fontlist
;
1545 fontlist
= Fcopy_sequence (fontlist
);
1546 /* Now FONTLIST is ((TARGET . FONTNAME) ...). Reform it to ((TARGET
1547 nil nil nil FONTSPEC) ...), where TARGET is a charset-id or a
1549 for (tail
= fontlist
; CONSP (tail
); tail
= XCDR (tail
))
1551 Lisp_Object elt
, target
;
1554 target
= Fcar (elt
);
1555 elt
= Fcons (Qnil
, regularize_fontname (Fcdr (elt
)));
1556 if (! CHAR_TABLE_P (target
))
1560 CHECK_SYMBOL (target
);
1561 charset
= get_charset_id (target
);
1563 error ("Invalid charset %s", SDATA (SYMBOL_NAME (target
)));
1564 target
= make_number (charset
);
1565 c
= MAKE_CHAR (charset
, 0, 0);
1566 XSETCAR (elt
, make_number (c
));
1568 elt
= Fcons (target
, Fcons (Qnil
, Fcons (Qnil
, elt
)));
1569 XSETCAR (tail
, elt
);
1571 Voverriding_fontspec_alist
= fontlist
;
1572 clear_face_cache (0);
1573 ++windows_or_buffers_changed
;
1580 if (!load_font_func
)
1581 /* Window system initializer should have set proper functions. */
1584 Qfontset
= intern ("fontset");
1585 staticpro (&Qfontset
);
1586 Fput (Qfontset
, Qchar_table_extra_slots
, make_number (3));
1588 Vcached_fontset_data
= Qnil
;
1589 staticpro (&Vcached_fontset_data
);
1591 Vfontset_table
= Fmake_vector (make_number (32), Qnil
);
1592 staticpro (&Vfontset_table
);
1594 Vdefault_fontset
= Fmake_char_table (Qfontset
, Qnil
);
1595 staticpro (&Vdefault_fontset
);
1596 FONTSET_ID (Vdefault_fontset
) = make_number (0);
1597 FONTSET_NAME (Vdefault_fontset
)
1598 = build_string ("-*-*-*-*-*-*-*-*-*-*-*-*-fontset-default");
1599 #if defined (MAC_OS)
1600 FONTSET_ASCII (Vdefault_fontset
)
1601 = Fcons (make_number (0),
1602 build_string ("-apple-monaco-medium-r-*--*-120-*-*-*-*-mac-roman"));
1603 #elif defined (WINDOWSNT)
1604 FONTSET_ASCII (Vdefault_fontset
)
1605 = Fcons (make_number (0),
1606 build_string ("-*-courier new-normal-r-*-*-*-100-*-*-*-*-iso8859-1"));
1608 FONTSET_ASCII (Vdefault_fontset
)
1609 = Fcons (make_number (0),
1610 build_string ("-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1"));
1612 AREF (Vfontset_table
, 0) = Vdefault_fontset
;
1613 next_fontset_id
= 1;
1615 Voverriding_fontspec_alist
= Qnil
;
1616 staticpro (&Voverriding_fontspec_alist
);
1618 DEFVAR_LISP ("font-encoding-alist", &Vfont_encoding_alist
,
1619 doc
: /* Alist of fontname patterns vs corresponding encoding info.
1620 Each element looks like (REGEXP . ENCODING-INFO),
1621 where ENCODING-INFO is an alist of CHARSET vs ENCODING.
1622 ENCODING is one of the following integer values:
1623 0: code points 0x20..0x7F or 0x2020..0x7F7F are used,
1624 1: code points 0xA0..0xFF or 0xA0A0..0xFFFF are used,
1625 2: code points 0x20A0..0x7FFF are used,
1626 3: code points 0xA020..0xFF7F are used. */);
1627 Vfont_encoding_alist
= Qnil
;
1628 Vfont_encoding_alist
1629 = Fcons (Fcons (build_string ("JISX0201"),
1630 Fcons (Fcons (intern ("latin-jisx0201"), make_number (0)),
1632 Vfont_encoding_alist
);
1633 Vfont_encoding_alist
1634 = Fcons (Fcons (build_string ("ISO8859-1"),
1635 Fcons (Fcons (intern ("ascii"), make_number (0)),
1637 Vfont_encoding_alist
);
1639 DEFVAR_LISP ("use-default-ascent", &Vuse_default_ascent
,
1640 doc
: /* Char table of characters whose ascent values should be ignored.
1641 If an entry for a character is non-nil, the ascent value of the glyph
1642 is assumed to be what specified by _MULE_DEFAULT_ASCENT property of a font.
1644 This affects how a composite character which contains
1645 such a character is displayed on screen. */);
1646 Vuse_default_ascent
= Qnil
;
1648 DEFVAR_LISP ("ignore-relative-composition", &Vignore_relative_composition
,
1649 doc
: /* Char table of characters which is not composed relatively.
1650 If an entry for a character is non-nil, a composition sequence
1651 which contains that character is displayed so that
1652 the glyph of that character is put without considering
1653 an ascent and descent value of a previous character. */);
1654 Vignore_relative_composition
= Qnil
;
1656 DEFVAR_LISP ("alternate-fontname-alist", &Valternate_fontname_alist
,
1657 doc
: /* Alist of fontname vs list of the alternate fontnames.
1658 When a specified font name is not found, the corresponding
1659 alternate fontnames (if any) are tried instead. */);
1660 Valternate_fontname_alist
= Qnil
;
1662 DEFVAR_LISP ("fontset-alias-alist", &Vfontset_alias_alist
,
1663 doc
: /* Alist of fontset names vs the aliases. */);
1664 Vfontset_alias_alist
= Fcons (Fcons (FONTSET_NAME (Vdefault_fontset
),
1665 build_string ("fontset-default")),
1668 DEFVAR_LISP ("vertical-centering-font-regexp",
1669 &Vvertical_centering_font_regexp
,
1670 doc
: /* *Regexp matching font names that require vertical centering on display.
1671 When a character is displayed with such fonts, the character is displayed
1672 at the vertical center of lines. */);
1673 Vvertical_centering_font_regexp
= Qnil
;
1675 defsubr (&Squery_fontset
);
1676 defsubr (&Snew_fontset
);
1677 defsubr (&Sset_fontset_font
);
1678 defsubr (&Sfont_info
);
1679 defsubr (&Sinternal_char_font
);
1680 defsubr (&Sfontset_info
);
1681 defsubr (&Sfontset_font
);
1682 defsubr (&Sfontset_list
);
1683 defsubr (&Sset_overriding_fontspec_internal
);
1686 /* arch-tag: ea861585-2f5f-4e5b-9849-d04a9c3a3537
1687 (do not change this comment) */