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
;
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 regularize_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
;
1089 fontset
= check_fontset_name (name
);
1091 if (CONSP (character
))
1093 /* CH should be (FROM . TO) where FROM and TO are non-generic
1095 CHECK_NUMBER_CAR (character
);
1096 CHECK_NUMBER_CDR (character
);
1097 from
= XINT (XCAR (character
));
1098 to
= XINT (XCDR (character
));
1099 if (!char_valid_p (from
, 0) || !char_valid_p (to
, 0))
1100 error ("Character range should be by non-generic characters");
1102 && (SINGLE_BYTE_CHAR_P (from
) || SINGLE_BYTE_CHAR_P (to
)))
1103 error ("Can't change font for a single byte character");
1105 else if (SYMBOLP (character
))
1107 elt
= Fget (character
, Qcharset
);
1108 if (!VECTORP (elt
) || ASIZE (elt
) < 1 || !NATNUMP (AREF (elt
, 0)))
1109 error ("Invalid charset: %s", SDATA (SYMBOL_NAME (character
)));
1110 from
= MAKE_CHAR (XINT (AREF (elt
, 0)), 0, 0);
1115 CHECK_NUMBER (character
);
1116 from
= XINT (character
);
1119 if (!char_valid_p (from
, 1))
1120 invalid_character (from
);
1121 if (SINGLE_BYTE_CHAR_P (from
))
1122 error ("Can't change font for a single byte character");
1125 if (!char_valid_p (to
, 1))
1126 invalid_character (to
);
1127 if (SINGLE_BYTE_CHAR_P (to
))
1128 error ("Can't change font for a single byte character");
1131 /* The arg FRAME is kept for backward compatibility. We only check
1134 CHECK_LIVE_FRAME (frame
);
1136 elt
= Fcons (make_number (from
), regularize_fontname (fontname
));
1137 for (; from
<= to
; from
++)
1138 FONTSET_SET (fontset
, from
, elt
);
1139 Foptimize_char_table (fontset
);
1141 /* If there's a realized fontset REALIZED whose parent is FONTSET,
1142 clear all the elements of REALIZED and free all multibyte faces
1143 whose fontset is REALIZED. This way, the specified character(s)
1144 are surely redisplayed by a correct font. */
1145 for (id
= 0; id
< ASIZE (Vfontset_table
); id
++)
1147 realized
= AREF (Vfontset_table
, id
);
1148 if (!NILP (realized
)
1149 && !BASE_FONTSET_P (realized
)
1150 && EQ (FONTSET_BASE (realized
), fontset
))
1152 FRAME_PTR f
= XFRAME (FONTSET_FRAME (realized
));
1153 clear_fontset_elements (realized
);
1154 free_realized_multibyte_face (f
, id
);
1161 DEFUN ("font-info", Ffont_info
, Sfont_info
, 1, 2, 0,
1162 doc
: /* Return information about a font named NAME on frame FRAME.
1163 If FRAME is omitted or nil, use the selected frame.
1164 The returned value is a vector of OPENED-NAME, FULL-NAME, CHARSET, SIZE,
1165 HEIGHT, BASELINE-OFFSET, RELATIVE-COMPOSE, and DEFAULT-ASCENT,
1167 OPENED-NAME is the name used for opening the font,
1168 FULL-NAME is the full name of the font,
1169 SIZE is the maximum bound width of the font,
1170 HEIGHT is the height of the font,
1171 BASELINE-OFFSET is the upward offset pixels from ASCII baseline,
1172 RELATIVE-COMPOSE and DEFAULT-ASCENT are the numbers controlling
1173 how to compose characters.
1174 If the named font is not yet loaded, return nil. */)
1176 Lisp_Object name
, frame
;
1179 struct font_info
*fontp
;
1182 (*check_window_system_func
) ();
1184 CHECK_STRING (name
);
1185 name
= Fdowncase (name
);
1187 frame
= selected_frame
;
1188 CHECK_LIVE_FRAME (frame
);
1191 if (!query_font_func
)
1192 error ("Font query function is not supported");
1194 fontp
= (*query_font_func
) (f
, SDATA (name
));
1198 info
= Fmake_vector (make_number (7), Qnil
);
1200 XVECTOR (info
)->contents
[0] = build_string (fontp
->name
);
1201 XVECTOR (info
)->contents
[1] = build_string (fontp
->full_name
);
1202 XVECTOR (info
)->contents
[2] = make_number (fontp
->size
);
1203 XVECTOR (info
)->contents
[3] = make_number (fontp
->height
);
1204 XVECTOR (info
)->contents
[4] = make_number (fontp
->baseline_offset
);
1205 XVECTOR (info
)->contents
[5] = make_number (fontp
->relative_compose
);
1206 XVECTOR (info
)->contents
[6] = make_number (fontp
->default_ascent
);
1212 /* Return a cons (FONT-NAME . GLYPH-CODE).
1213 FONT-NAME is the font name for the character at POSITION in the current
1214 buffer. This is computed from all the text properties and overlays
1215 that apply to POSITION. POSTION may be nil, in which case,
1216 FONT-NAME is the font name for display the character CH with the
1219 GLYPH-CODE is the glyph code in the font to use for the character.
1221 If the 2nd optional arg CH is non-nil, it is a character to check
1222 the font instead of the character at POSITION.
1224 It returns nil in the following cases:
1226 (1) The window system doesn't have a font for the character (thus
1227 it is displayed by an empty box).
1229 (2) The character code is invalid.
1231 (3) If POSITION is not nil, and the current buffer is not displayed
1234 In addition, the returned font name may not take into account of
1235 such redisplay engine hooks as what used in jit-lock-mode if
1236 POSITION is currently not visible. */
1239 DEFUN ("internal-char-font", Finternal_char_font
, Sinternal_char_font
, 1, 2, 0,
1240 doc
: /* For internal use only. */)
1242 Lisp_Object position
, ch
;
1244 int pos
, pos_byte
, dummy
;
1250 if (NILP (position
))
1254 f
= XFRAME (selected_frame
);
1255 face_id
= DEFAULT_FACE_ID
;
1262 CHECK_NUMBER_COERCE_MARKER (position
);
1263 pos
= XINT (position
);
1264 if (pos
< BEGV
|| pos
>= ZV
)
1265 args_out_of_range_3 (position
, make_number (BEGV
), make_number (ZV
));
1266 pos_byte
= CHAR_TO_BYTE (pos
);
1268 c
= FETCH_CHAR (pos_byte
);
1274 window
= Fget_buffer_window (Fcurrent_buffer (), Qnil
);
1277 w
= XWINDOW (window
);
1278 f
= XFRAME (w
->frame
);
1279 face_id
= face_at_buffer_position (w
, pos
, -1, -1, &dummy
, pos
+ 100, 0);
1281 if (! CHAR_VALID_P (c
, 0))
1283 face_id
= FACE_FOR_CHAR (f
, FACE_FROM_ID (f
, face_id
), c
);
1284 face
= FACE_FROM_ID (f
, face_id
);
1285 if (! face
->font
|| ! face
->font_name
)
1289 struct font_info
*fontp
= (*get_font_info_func
) (f
, face
->font_info_id
);
1291 int c1
, c2
, charset
;
1293 SPLIT_CHAR (c
, charset
, c1
, c2
);
1295 STORE_XCHAR2B (&char2b
, c1
, c2
);
1297 STORE_XCHAR2B (&char2b
, 0, c1
);
1298 rif
->encode_char (c
, &char2b
, fontp
, NULL
);
1299 code
= (XCHAR2B_BYTE1 (&char2b
) << 8) | XCHAR2B_BYTE2 (&char2b
);
1301 return Fcons (build_string (face
->font_name
), make_number (code
));
1305 /* Called from Ffontset_info via map_char_table on each leaf of
1306 fontset. ARG is a copy of the default fontset. The current leaf
1307 is indexed by CHARACTER and has value ELT. This function override
1308 the copy by ELT if ELT is not nil. */
1311 override_font_info (fontset
, character
, elt
)
1312 Lisp_Object fontset
, character
, elt
;
1315 Faset (fontset
, character
, elt
);
1318 /* Called from Ffontset_info via map_char_table on each leaf of
1319 fontset. ARG is a list (LAST FONT-INFO ...), where LAST is `(last
1320 ARG)' and FONT-INFOs have this form:
1321 (CHAR FONT-SPEC) or ((FROM . TO) FONT-SPEC)
1322 The current leaf is indexed by CHARACTER and has value ELT. This
1323 function add the information of the current leaf to ARG by
1324 appending a new element or modifying the last element. */
1327 accumulate_font_info (arg
, character
, elt
)
1328 Lisp_Object arg
, character
, elt
;
1330 Lisp_Object last
, last_char
, last_elt
;
1332 if (!CONSP (elt
) && !SINGLE_BYTE_CHAR_P (XINT (character
)))
1333 elt
= FONTSET_REF (Vdefault_fontset
, XINT (character
));
1337 last_char
= XCAR (XCAR (last
));
1338 last_elt
= XCAR (XCDR (XCAR (last
)));
1340 if (!NILP (Fequal (elt
, last_elt
)))
1342 int this_charset
= CHAR_CHARSET (XINT (character
));
1344 if (CONSP (last_char
)) /* LAST_CHAR == (FROM . TO) */
1346 if (this_charset
== CHAR_CHARSET (XINT (XCAR (last_char
))))
1348 XSETCDR (last_char
, character
);
1352 else if (XINT (last_char
) == XINT (character
))
1354 else if (this_charset
== CHAR_CHARSET (XINT (last_char
)))
1356 XSETCAR (XCAR (last
), Fcons (last_char
, character
));
1360 XSETCDR (last
, Fcons (Fcons (character
, Fcons (elt
, Qnil
)), Qnil
));
1361 XSETCAR (arg
, XCDR (last
));
1365 DEFUN ("fontset-info", Ffontset_info
, Sfontset_info
, 1, 2, 0,
1366 doc
: /* Return information about a fontset named NAME on frame FRAME.
1367 If NAME is nil, return information about the default fontset.
1368 The value is a vector:
1369 [ SIZE HEIGHT ((CHARSET-OR-RANGE FONT-SPEC OPENED ...) ...) ],
1371 SIZE is the maximum bound width of ASCII font in the fontset,
1372 HEIGHT is the maximum bound height of ASCII font in the fontset,
1373 CHARSET-OR-RANGE is a charset, a character (may be a generic character)
1374 or a cons of two characters specifying the range of characters.
1375 FONT-SPEC is a fontname pattern string or a cons (FAMILY . REGISTRY),
1376 where FAMILY is a `FAMILY' field of a XLFD font name,
1377 REGISTRY is a `CHARSET_REGISTRY' field of a XLFD font name.
1378 FAMILY may contain a `FOUNDRY' field at the head.
1379 REGISTRY may contain a `CHARSET_ENCODING' field at the tail.
1380 OPENEDs are names of fonts actually opened.
1381 If the ASCII font is not yet opened, SIZE and HEIGHT are 0.
1382 If FRAME is omitted, it defaults to the currently selected frame. */)
1384 Lisp_Object name
, frame
;
1386 Lisp_Object fontset
;
1388 Lisp_Object indices
[3];
1389 Lisp_Object val
, tail
, elt
;
1390 Lisp_Object
*realized
;
1391 struct font_info
*fontp
= NULL
;
1395 (*check_window_system_func
) ();
1397 fontset
= check_fontset_name (name
);
1400 frame
= selected_frame
;
1401 CHECK_LIVE_FRAME (frame
);
1404 /* Recode realized fontsets whose base is FONTSET in the table
1406 realized
= (Lisp_Object
*) alloca (sizeof (Lisp_Object
)
1407 * ASIZE (Vfontset_table
));
1408 for (i
= 0; i
< ASIZE (Vfontset_table
); i
++)
1410 elt
= FONTSET_FROM_ID (i
);
1412 && EQ (FONTSET_BASE (elt
), fontset
))
1413 realized
[n_realized
++] = elt
;
1416 if (! EQ (fontset
, Vdefault_fontset
))
1418 /* Merge FONTSET onto the default fontset. */
1419 val
= Fcopy_sequence (Vdefault_fontset
);
1420 map_char_table (override_font_info
, Qnil
, fontset
, fontset
, val
, 0, indices
);
1424 /* Accumulate information of the fontset in VAL. The format is
1425 (LAST FONT-INFO FONT-INFO ...), where FONT-INFO is (CHAR-OR-RANGE
1426 FONT-SPEC). See the comment for accumulate_font_info for the
1428 val
= Fcons (Fcons (make_number (0),
1429 Fcons (XCDR (FONTSET_ASCII (fontset
)), Qnil
)),
1431 val
= Fcons (val
, val
);
1432 map_char_table (accumulate_font_info
, Qnil
, fontset
, fontset
, val
, 0, indices
);
1435 /* For each FONT-INFO, if CHAR_OR_RANGE (car part) is a generic
1436 character for a charset, replace it with the charset symbol. If
1437 fonts are opened for FONT-SPEC, append the names of the fonts to
1439 for (tail
= val
; CONSP (tail
); tail
= XCDR (tail
))
1443 if (INTEGERP (XCAR (elt
)))
1445 int charset
, c1
, c2
;
1446 c
= XINT (XCAR (elt
));
1447 SPLIT_CHAR (c
, charset
, c1
, c2
);
1449 XSETCAR (elt
, CHARSET_SYMBOL (charset
));
1452 c
= XINT (XCAR (XCAR (elt
)));
1453 for (i
= 0; i
< n_realized
; i
++)
1455 Lisp_Object face_id
, font
;
1458 face_id
= FONTSET_REF_VIA_BASE (realized
[i
], c
);
1459 if (INTEGERP (face_id
))
1461 face
= FACE_FROM_ID (f
, XINT (face_id
));
1462 if (face
&& face
->font
&& face
->font_name
)
1464 font
= build_string (face
->font_name
);
1465 if (NILP (Fmember (font
, XCDR (XCDR (elt
)))))
1466 XSETCDR (XCDR (elt
), Fcons (font
, XCDR (XCDR (elt
))));
1472 elt
= Fcdr (Fcdr (Fassq (CHARSET_SYMBOL (CHARSET_ASCII
), val
)));
1476 fontp
= (*query_font_func
) (f
, SDATA (elt
));
1478 val
= Fmake_vector (make_number (3), val
);
1479 AREF (val
, 0) = fontp
? make_number (fontp
->size
) : make_number (0);
1480 AREF (val
, 1) = fontp
? make_number (fontp
->height
) : make_number (0);
1484 DEFUN ("fontset-font", Ffontset_font
, Sfontset_font
, 2, 2, 0,
1485 doc
: /* Return a font name pattern for character CH in fontset NAME.
1486 If NAME is nil, find a font name pattern in the default fontset. */)
1488 Lisp_Object name
, ch
;
1491 Lisp_Object fontset
, elt
;
1493 fontset
= check_fontset_name (name
);
1497 if (!char_valid_p (c
, 1))
1498 invalid_character (c
);
1500 elt
= FONTSET_REF (fontset
, c
);
1507 DEFUN ("fontset-list", Ffontset_list
, Sfontset_list
, 0, 0, 0,
1508 doc
: /* Return a list of all defined fontset names. */)
1511 Lisp_Object fontset
, list
;
1515 for (i
= 0; i
< ASIZE (Vfontset_table
); i
++)
1517 fontset
= FONTSET_FROM_ID (i
);
1519 && BASE_FONTSET_P (fontset
))
1520 list
= Fcons (FONTSET_NAME (fontset
), list
);
1526 DEFUN ("set-overriding-fontspec-internal", Fset_overriding_fontspec_internal
,
1527 Sset_overriding_fontspec_internal
, 1, 1, 0,
1528 doc
: /* Internal use only.
1530 FONTLIST is an alist of TARGET vs FONTNAME, where TARGET is a charset
1531 or a char-table, FONTNAME have the same meanings as in
1534 It overrides the font specifications for each TARGET in the default
1535 fontset by the corresponding FONTNAME.
1537 If TARGET is a charset, targets are all characters in the charset. If
1538 TARGET is a char-table, targets are characters whose value is non-nil
1541 It is intended that this function is called only from
1542 `set-language-environment'. */)
1544 Lisp_Object fontlist
;
1548 fontlist
= Fcopy_sequence (fontlist
);
1549 /* Now FONTLIST is ((TARGET . FONTNAME) ...). Reform it to ((TARGET
1550 nil nil nil FONTSPEC) ...), where TARGET is a charset-id or a
1552 for (tail
= fontlist
; CONSP (tail
); tail
= XCDR (tail
))
1554 Lisp_Object elt
, target
;
1557 target
= Fcar (elt
);
1558 elt
= Fcons (Qnil
, regularize_fontname (Fcdr (elt
)));
1559 if (! CHAR_TABLE_P (target
))
1563 CHECK_SYMBOL (target
);
1564 charset
= get_charset_id (target
);
1566 error ("Invalid charset %s", SDATA (SYMBOL_NAME (target
)));
1567 target
= make_number (charset
);
1568 c
= MAKE_CHAR (charset
, 0, 0);
1569 XSETCAR (elt
, make_number (c
));
1571 elt
= Fcons (target
, Fcons (Qnil
, Fcons (Qnil
, elt
)));
1572 XSETCAR (tail
, elt
);
1574 Voverriding_fontspec_alist
= fontlist
;
1575 clear_face_cache (0);
1576 ++windows_or_buffers_changed
;
1583 if (!load_font_func
)
1584 /* Window system initializer should have set proper functions. */
1587 Qfontset
= intern ("fontset");
1588 staticpro (&Qfontset
);
1589 Fput (Qfontset
, Qchar_table_extra_slots
, make_number (3));
1591 Vcached_fontset_data
= Qnil
;
1592 staticpro (&Vcached_fontset_data
);
1594 Vfontset_table
= Fmake_vector (make_number (32), Qnil
);
1595 staticpro (&Vfontset_table
);
1597 Vdefault_fontset
= Fmake_char_table (Qfontset
, Qnil
);
1598 staticpro (&Vdefault_fontset
);
1599 FONTSET_ID (Vdefault_fontset
) = make_number (0);
1600 FONTSET_NAME (Vdefault_fontset
)
1601 = build_string ("-*-*-*-*-*-*-*-*-*-*-*-*-fontset-default");
1602 #if defined (MAC_OS)
1603 FONTSET_ASCII (Vdefault_fontset
)
1604 = Fcons (make_number (0),
1605 build_string ("-apple-monaco-medium-r-*--*-120-*-*-*-*-mac-roman"));
1606 #elif defined (WINDOWSNT)
1607 FONTSET_ASCII (Vdefault_fontset
)
1608 = Fcons (make_number (0),
1609 build_string ("-*-courier new-normal-r-*-*-*-100-*-*-*-*-iso8859-1"));
1611 FONTSET_ASCII (Vdefault_fontset
)
1612 = Fcons (make_number (0),
1613 build_string ("-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1"));
1615 AREF (Vfontset_table
, 0) = Vdefault_fontset
;
1616 next_fontset_id
= 1;
1618 Voverriding_fontspec_alist
= Qnil
;
1619 staticpro (&Voverriding_fontspec_alist
);
1621 DEFVAR_LISP ("font-encoding-alist", &Vfont_encoding_alist
,
1622 doc
: /* Alist of fontname patterns vs corresponding encoding info.
1623 Each element looks like (REGEXP . ENCODING-INFO),
1624 where ENCODING-INFO is an alist of CHARSET vs ENCODING.
1625 ENCODING is one of the following integer values:
1626 0: code points 0x20..0x7F or 0x2020..0x7F7F are used,
1627 1: code points 0xA0..0xFF or 0xA0A0..0xFFFF are used,
1628 2: code points 0x20A0..0x7FFF are used,
1629 3: code points 0xA020..0xFF7F are used. */);
1630 Vfont_encoding_alist
= Qnil
;
1631 Vfont_encoding_alist
1632 = Fcons (Fcons (build_string ("JISX0201"),
1633 Fcons (Fcons (intern ("latin-jisx0201"), make_number (0)),
1635 Vfont_encoding_alist
);
1636 Vfont_encoding_alist
1637 = Fcons (Fcons (build_string ("ISO8859-1"),
1638 Fcons (Fcons (intern ("ascii"), make_number (0)),
1640 Vfont_encoding_alist
);
1642 DEFVAR_LISP ("use-default-ascent", &Vuse_default_ascent
,
1643 doc
: /* Char table of characters whose ascent values should be ignored.
1644 If an entry for a character is non-nil, the ascent value of the glyph
1645 is assumed to be what specified by _MULE_DEFAULT_ASCENT property of a font.
1647 This affects how a composite character which contains
1648 such a character is displayed on screen. */);
1649 Vuse_default_ascent
= Qnil
;
1651 DEFVAR_LISP ("ignore-relative-composition", &Vignore_relative_composition
,
1652 doc
: /* Char table of characters which is not composed relatively.
1653 If an entry for a character is non-nil, a composition sequence
1654 which contains that character is displayed so that
1655 the glyph of that character is put without considering
1656 an ascent and descent value of a previous character. */);
1657 Vignore_relative_composition
= Qnil
;
1659 DEFVAR_LISP ("alternate-fontname-alist", &Valternate_fontname_alist
,
1660 doc
: /* Alist of fontname vs list of the alternate fontnames.
1661 When a specified font name is not found, the corresponding
1662 alternate fontnames (if any) are tried instead. */);
1663 Valternate_fontname_alist
= Qnil
;
1665 DEFVAR_LISP ("fontset-alias-alist", &Vfontset_alias_alist
,
1666 doc
: /* Alist of fontset names vs the aliases. */);
1667 Vfontset_alias_alist
= Fcons (Fcons (FONTSET_NAME (Vdefault_fontset
),
1668 build_string ("fontset-default")),
1671 DEFVAR_LISP ("vertical-centering-font-regexp",
1672 &Vvertical_centering_font_regexp
,
1673 doc
: /* *Regexp matching font names that require vertical centering on display.
1674 When a character is displayed with such fonts, the character is displayed
1675 at the vertical center of lines. */);
1676 Vvertical_centering_font_regexp
= Qnil
;
1678 defsubr (&Squery_fontset
);
1679 defsubr (&Snew_fontset
);
1680 defsubr (&Sset_fontset_font
);
1681 defsubr (&Sfont_info
);
1682 defsubr (&Sinternal_char_font
);
1683 defsubr (&Sfontset_info
);
1684 defsubr (&Sfontset_font
);
1685 defsubr (&Sfontset_list
);
1686 defsubr (&Sset_overriding_fontspec_internal
);
1689 /* arch-tag: ea861585-2f5f-4e5b-9849-d04a9c3a3537
1690 (do not change this comment) */