1 /* font.c -- "Font" primitives.
2 Copyright (C) 2006 Free Software Foundation, Inc.
4 National Institute of Advanced Industrial Science and Technology (AIST)
5 Registration Number H13PRO009
7 This file is part of GNU Emacs.
9 GNU Emacs is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GNU Emacs is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GNU Emacs; see the file COPYING. If not, write to
21 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
32 #include "dispextern.h"
34 #include "character.h"
35 #include "composite.h"
43 #define xassert(X) do {if (!(X)) abort ();} while (0)
45 #define xassert(X) (void) 0
48 int enable_font_backend
;
52 /* Like CHECK_FONT_SPEC but also validate properties of the font-spec,
53 and set X to the validated result. */
55 #define CHECK_VALIDATE_FONT_SPEC(x) \
57 if (! FONT_SPEC_P (x)) x = wrong_type_argument (Qfont, x); \
58 x = font_prop_validate (x); \
61 /* Number of pt per inch (from the TeXbook). */
62 #define PT_PER_INCH 72.27
64 /* Return a pixel size corresponding to POINT size (1/10 pt unit) on
66 #define POINT_TO_PIXEL(POINT, RESY) ((POINT) * (RESY) / PT_PER_INCH / 10 + 0.5)
68 #define PIXEL_TO_POINT(PIXEL, RESY) ((PIXEL) * PT_PER_INCH * 10 / (RESY) + 0.5)
70 /* Special string of zero length. It is used to specify a NULL name
71 in a font properties (e.g. adstyle). We don't use the symbol of
72 NULL name because it's confusing (Lisp printer prints nothing for
74 Lisp_Object null_string
;
76 /* Special vector of zero length. This is repeatedly used by (struct
77 font_driver *)->list when a specified font is not found. */
78 Lisp_Object null_vector
;
80 /* Vector of 3 elements. Each element is an alist for one of font
81 style properties (weight, slant, width). The alist contains a
82 mapping between symbolic property values (e.g. `medium' for weight)
83 and numeric property values (e.g. 100). So, it looks like this:
84 [((thin . 0) ... (heavy . 210))
85 ((ro . 0) ... (ot . 210))
86 ((ultracondensed . 50) ... (wide . 200))] */
87 static Lisp_Object font_style_table
;
89 /* Alist of font family vs the corresponding aliases.
90 Each element has this form:
91 (FAMILY ALIAS1 ALIAS2 ...) */
93 static Lisp_Object font_family_alist
;
95 /* Symbols representing keys of normal font properties. */
96 extern Lisp_Object QCtype
, QCfamily
, QCweight
, QCslant
, QCwidth
, QCsize
, QCname
;
97 Lisp_Object QCfoundry
, QCadstyle
, QCregistry
, QCextra
;
98 /* Symbols representing keys of font extra info. */
99 Lisp_Object QCotf
, QClanguage
, QCscript
;
101 /* List of all font drivers. All font-backends (XXXfont.c) call
102 add_font_driver in syms_of_XXXfont to register the font-driver
104 static struct font_driver_list
*font_driver_list
;
106 static Lisp_Object prop_name_to_numeric
P_ ((enum font_property_index
,
108 static Lisp_Object prop_numeric_to_name
P_ ((enum font_property_index
, int));
109 static Lisp_Object font_open_entity
P_ ((FRAME_PTR
, Lisp_Object
, int));
111 /* Number of registered font drivers. */
112 static int num_font_drivers
;
114 /* Return a numeric value corresponding to PROP's NAME (symbol). If
115 NAME is not registered in font_style_table, return Qnil. PROP must
116 be one of FONT_{WEIGHT|SLANT|SWIDTH}_INDEX. */
119 prop_name_to_numeric (prop
, name
)
120 enum font_property_index prop
;
123 int table_index
= prop
- FONT_WEIGHT_INDEX
;
126 val
= assq_no_quit (name
, AREF (font_style_table
, table_index
));
127 return (NILP (val
) ? Qnil
: XCDR (val
));
131 /* Return a name (symbol) corresponding to PROP's NUMERIC value. If
132 no name is registered for NUMERIC in font_style_table, return a
133 symbol of integer name (e.g. `123'). PROP must be one of
134 FONT_{WEIGHT|SLANT|SWIDTH}_INDEX. */
137 prop_numeric_to_name (prop
, numeric
)
138 enum font_property_index prop
;
141 int table_index
= prop
- FONT_WEIGHT_INDEX
;
142 Lisp_Object table
= AREF (font_style_table
, table_index
);
145 while (! NILP (table
))
147 if (XINT (XCDR (XCAR (table
))) >= numeric
)
149 if (XINT (XCDR (XCAR (table
))) == numeric
)
150 return XCAR (XCAR (table
));
154 table
= XCDR (table
);
156 sprintf (buf
, "%d", numeric
);
161 /* Return a symbol whose name is STR (length LEN). If STR contains
162 uppercase letters, downcase them in advance. */
165 intern_downcase (str
, len
)
172 for (i
= 0; i
< len
; i
++)
173 if (isupper (str
[i
]))
176 return Fintern (make_unibyte_string (str
, len
), Qnil
);
179 return Fintern (null_string
, Qnil
);
180 bcopy (str
, buf
, len
);
182 if (isascii (buf
[i
]))
183 buf
[i
] = tolower (buf
[i
]);
184 return Fintern (make_unibyte_string (buf
, len
), Qnil
);
187 extern Lisp_Object Vface_alternative_font_family_alist
;
190 build_font_family_alist ()
192 Lisp_Object alist
= Vface_alternative_font_family_alist
;
194 for (; CONSP (alist
); alist
= XCDR (alist
))
196 Lisp_Object tail
, elt
;
198 for (tail
= XCAR (alist
), elt
= Qnil
; CONSP (tail
); tail
= XCDR (tail
))
199 elt
= nconc2 (elt
, Fcons (Fintern (XCAR (tail
), Qnil
), Qnil
));
200 font_family_alist
= Fcons (elt
, font_family_alist
);
205 /* Font property validater. */
208 font_prop_validate_type (prop
, val
)
209 enum font_property_index prop
;
212 return (SYMBOLP (val
) ? val
: Qerror
);
216 font_prop_validate_symbol (prop
, val
)
217 enum font_property_index prop
;
221 val
= (SCHARS (val
) == 0 ? null_string
222 : intern_downcase ((char *) SDATA (val
), SBYTES (val
)));
223 else if (SYMBOLP (val
))
225 if (SCHARS (SYMBOL_NAME (val
)) == 0)
234 font_prop_validate_style (prop
, val
)
235 enum font_property_index prop
;
238 if (! INTEGERP (val
))
241 val
= intern_downcase ((char *) SDATA (val
), SBYTES (val
));
246 val
= prop_name_to_numeric (prop
, val
);
255 font_prop_validate_size (prop
, val
)
256 enum font_property_index prop
;
259 return (NATNUMP (val
) || (FLOATP (val
) && XFLOAT_DATA (val
) >= 0)
264 font_prop_validate_extra (prop
, val
)
265 enum font_property_index prop
;
270 for (tail
= val
; CONSP (tail
); tail
= XCDR (tail
))
272 Lisp_Object key
= Fcar (XCAR (tail
)), this_val
= Fcdr (XCAR (tail
));
276 if (EQ (key
, QClanguage
))
277 if (! SYMBOLP (this_val
))
279 for (; CONSP (this_val
); this_val
= XCDR (this_val
))
280 if (! SYMBOLP (XCAR (this_val
)))
282 if (! NILP (this_val
))
286 if (! STRINGP (this_val
))
289 return (NILP (tail
) ? val
: Qerror
);
296 Lisp_Object (*validater
) P_ ((enum font_property_index prop
,
298 } font_property_table
[FONT_SPEC_MAX
] =
299 { { &QCtype
, font_prop_validate_type
},
300 { &QCfoundry
, font_prop_validate_symbol
},
301 { &QCfamily
, font_prop_validate_symbol
},
302 { &QCadstyle
, font_prop_validate_symbol
},
303 { &QCregistry
, font_prop_validate_symbol
},
304 { &QCweight
, font_prop_validate_style
},
305 { &QCslant
, font_prop_validate_style
},
306 { &QCwidth
, font_prop_validate_style
},
307 { &QCsize
, font_prop_validate_size
},
308 { &QCextra
, font_prop_validate_extra
}
311 static enum font_property_index
312 check_font_prop_name (key
)
315 enum font_property_index i
;
317 for (i
= FONT_TYPE_INDEX
; i
< FONT_SPEC_MAX
; i
++)
318 if (EQ (key
, *font_property_table
[i
].key
))
324 font_prop_validate (spec
)
327 enum font_property_index i
;
330 for (i
= FONT_TYPE_INDEX
; i
<= FONT_EXTRA_INDEX
; i
++)
332 if (! NILP (AREF (spec
, i
)))
334 val
= (font_property_table
[i
].validater
) (i
, AREF (spec
, i
));
335 if (EQ (val
, Qerror
))
336 Fsignal (Qerror
, list3 (build_string ("invalid font property"),
337 *font_property_table
[i
].key
,
346 /* Font name parser and unparser */
348 /* An enumerator for each field of an XLFD font name. */
350 enum xlfd_field_index
358 XLFD_PIXEL_SIZE_INDEX
,
359 XLFD_POINT_SIZE_INDEX
,
369 /* Return a symbol interned by string at STR and bytes LEN.
370 If LEN == 0, return a null string.
371 If the string is "*", return Qnil.
372 It is assured that LEN < 256. */
375 intern_font_field (f
, xlfd
)
376 char *f
[XLFD_LAST_INDEX
+ 1];
379 char *str
= f
[xlfd
] + 1;
382 if (xlfd
!= XLFD_RESY_INDEX
)
383 len
= f
[xlfd
+ 1] - f
[xlfd
] - 1;
385 len
= f
[XLFD_REGISTRY_INDEX
] - f
[xlfd
] - 1;
389 if (*str
== '*' && len
== 1)
391 return intern_downcase (str
, len
);
394 /* Parse P pointing the pixel/point size field of the form
395 `[A B C D]' which specifies a transformation matrix:
401 by which all glyphs of the font are transformed. The spec says
402 that scalar value N for the pixel/point size is equivalent to:
403 A = N * resx/resy, B = C = 0, D = N.
405 Return the scalar value N if the form is valid. Otherwise return
416 for (i
= 0, p
++; i
< 4 && *p
&& *p
!= ']'; i
++)
419 matrix
[i
] = - strtod (p
+ 1, &end
);
421 matrix
[i
] = strtod (p
, &end
);
424 return (i
== 4 ? (int) matrix
[3] : -1);
427 /* Parse NAME (null terminated) as XLFD format, and store information
428 in FONT (font-spec or font-entity). If NAME is successfully
429 parsed, return 2 (non-scalable font), 1 (scalable vector font), or
430 0 (auto-scaled font). Otherwise return -1.
432 If FONT is a font-entity, store RESY-SPACING-AVWIDTH information as
433 a symbol in FONT_EXTRA_INDEX.
435 If MERGE is nonzero, set a property of FONT only when it's nil. */
438 font_parse_xlfd (name
, font
, merge
)
443 int len
= strlen (name
);
445 int pixel_size
, resy
, avwidth
;
447 char *f
[XLFD_LAST_INDEX
+ 1];
449 int first_wildcard_field
= -1, last_wildcard_field
= XLFD_LAST_INDEX
;
452 /* Maximum XLFD name length is 255. */
454 for (i
= 0; *name
; name
++)
456 && i
< XLFD_LAST_INDEX
)
459 if (name
[1] == '*' && (! name
[2] || name
[2] == '-'))
461 if (first_wildcard_field
< 0)
462 first_wildcard_field
= i
;
463 last_wildcard_field
= i
;
468 f
[XLFD_LAST_INDEX
] = name
;
469 if (i
< XLFD_LAST_INDEX
)
471 /* Not a fully specified XLFD. */
472 if (first_wildcard_field
< 0 )
476 if (last_wildcard_field
< i
)
478 /* Shift fields after the last wildcard field. */
479 for (j
= XLFD_LAST_INDEX
- 1; j
> last_wildcard_field
; j
--, i
--)
481 /* Make all fields between the first and last wildcard fieled
482 also wildcard fields. */
483 for (j
--; j
> first_wildcard_field
; j
--)
487 f
[XLFD_ENCODING_INDEX
] = f
[XLFD_LAST_INDEX
];
489 if (! merge
|| NILP (AREF (font
, FONT_FOUNDRY_INDEX
)))
490 ASET (font
, FONT_FOUNDRY_INDEX
, intern_font_field (f
, XLFD_FOUNDRY_INDEX
));
491 if (! merge
|| NILP (AREF (font
, FONT_FAMILY_INDEX
)))
492 ASET (font
, FONT_FAMILY_INDEX
, intern_font_field (f
, XLFD_FAMILY_INDEX
));
493 if (! merge
|| NILP (AREF (font
, FONT_ADSTYLE_INDEX
)))
494 ASET (font
, FONT_ADSTYLE_INDEX
, intern_font_field (f
, XLFD_ADSTYLE_INDEX
));
495 if (! merge
|| NILP (AREF (font
, FONT_REGISTRY_INDEX
)))
496 ASET (font
, FONT_REGISTRY_INDEX
, intern_font_field (f
, XLFD_REGISTRY_INDEX
));
498 for (i
= FONT_WEIGHT_INDEX
, j
= XLFD_WEIGHT_INDEX
;
499 j
<= XLFD_SWIDTH_INDEX
; i
++, j
++)
500 if (! merge
|| NILP (AREF (font
, i
)))
502 if (isdigit(f
[j
][1]))
503 val
= make_number (atoi (f
[j
] + 1));
506 Lisp_Object sym
= intern_font_field (f
, j
);
508 val
= prop_name_to_numeric (i
, sym
);
515 if (f
[XLFD_PIXEL_SIZE_INDEX
][1] == '*')
516 pixel_size
= -1; /* indicates "unspecified" */
517 else if (f
[XLFD_PIXEL_SIZE_INDEX
][1] == '[')
518 pixel_size
= parse_matrix (f
[XLFD_PIXEL_SIZE_INDEX
] + 1);
519 else if (isdigit (f
[XLFD_PIXEL_SIZE_INDEX
][1]))
520 pixel_size
= strtod (f
[XLFD_PIXEL_SIZE_INDEX
] + 1, NULL
);
524 if (pixel_size
< 0 && FONT_ENTITY_P (font
))
527 if (f
[XLFD_POINT_SIZE_INDEX
][1] == '*')
528 point_size
= -1; /* indicates "unspecified" */
529 else if (f
[XLFD_POINT_SIZE_INDEX
][1] == '[')
530 point_size
= parse_matrix (f
[XLFD_POINT_SIZE_INDEX
] + 1);
531 else if (isdigit (f
[XLFD_POINT_SIZE_INDEX
][1]))
532 point_size
= strtod (f
[XLFD_POINT_SIZE_INDEX
] + 1, NULL
);
536 if (f
[XLFD_RESY_INDEX
][1] == '*')
537 resy
= -1; /* indicates "unspecified" */
539 resy
= strtod (f
[XLFD_RESY_INDEX
] + 1, NULL
);
541 if (f
[XLFD_AVGWIDTH_INDEX
][1] == '*')
542 avwidth
= -1; /* indicates "unspecified" */
543 else if (f
[XLFD_AVGWIDTH_INDEX
][1] == '~')
544 avwidth
= - strtod (f
[XLFD_AVGWIDTH_INDEX
] + 2, NULL
);
546 avwidth
= strtod (f
[XLFD_AVGWIDTH_INDEX
] + 1, NULL
);
548 if (! merge
|| NILP (AREF (font
, FONT_SIZE_INDEX
)))
551 ASET (font
, FONT_SIZE_INDEX
, make_number (pixel_size
));
558 pixel_size
= POINT_TO_PIXEL (point_size
, resy
);
559 ASET (font
, FONT_SIZE_INDEX
, make_number (pixel_size
));
563 ASET (font
, FONT_SIZE_INDEX
, make_float (point_size
/ 10));
567 ASET (font
, FONT_SIZE_INDEX
, Qnil
);
571 if (FONT_ENTITY_P (font
)
572 && EQ (AREF (font
, FONT_TYPE_INDEX
), Qx
))
573 ASET (font
, FONT_EXTRA_INDEX
, intern_font_field (f
, XLFD_RESY_INDEX
));
575 return (avwidth
> 0 ? 2 : resy
== 0);
578 /* Store XLFD name of FONT (font-spec or font-entity) in NAME (NBYTES
579 length), and return the name length. If FONT_SIZE_INDEX of FONT is
580 0, use PIXEL_SIZE instead. */
583 font_unparse_xlfd (font
, pixel_size
, name
, nbytes
)
588 char *f
[XLFD_REGISTRY_INDEX
+ 1], *pixel_point
;
593 xassert (FONTP (font
));
595 for (i
= FONT_FOUNDRY_INDEX
, j
= XLFD_FOUNDRY_INDEX
; i
<= FONT_REGISTRY_INDEX
;
598 if (i
== FONT_ADSTYLE_INDEX
)
599 j
= XLFD_ADSTYLE_INDEX
;
600 else if (i
== FONT_REGISTRY_INDEX
)
601 j
= XLFD_REGISTRY_INDEX
;
602 val
= AREF (font
, i
);
604 f
[j
] = "*", len
+= 2;
608 val
= SYMBOL_NAME (val
);
609 f
[j
] = (char *) SDATA (val
), len
+= SBYTES (val
) + 1;
613 for (i
= FONT_WEIGHT_INDEX
, j
= XLFD_WEIGHT_INDEX
; i
<= FONT_WIDTH_INDEX
;
616 val
= AREF (font
, i
);
618 f
[j
] = "*", len
+= 2;
622 val
= prop_numeric_to_name (i
, XINT (val
));
624 val
= SYMBOL_NAME (val
);
625 xassert (STRINGP (val
));
626 f
[j
] = (char *) SDATA (val
), len
+= SBYTES (val
) + 1;
630 val
= AREF (font
, FONT_SIZE_INDEX
);
631 xassert (NUMBERP (val
) || NILP (val
));
636 len
+= sprintf (work
, "%d", i
) + 1;
638 len
+= sprintf (work
, "%d-*", pixel_size
) + 1;
641 else if (FLOATP (val
))
643 i
= XFLOAT_DATA (val
) * 10;
644 len
+= sprintf (work
, "*-%d", i
) + 1;
648 pixel_point
= "*-*", len
+= 4;
650 if (FONT_ENTITY_P (font
)
651 && EQ (AREF (font
, FONT_TYPE_INDEX
), Qx
))
653 /* Setup names for RESY-SPACING-AVWIDTH. */
654 val
= AREF (font
, FONT_EXTRA_INDEX
);
655 if (SYMBOLP (val
) && ! NILP (val
))
657 val
= SYMBOL_NAME (val
);
658 f
[XLFD_RESY_INDEX
] = (char *) SDATA (val
), len
+= SBYTES (val
) + 1;
661 f
[XLFD_RESY_INDEX
] = "*-*-*", len
+= 6;
664 f
[XLFD_RESY_INDEX
] = "*-*-*", len
+= 6;
666 len
+= 3; /* for "-*" of resx, and terminating '\0'. */
669 return sprintf (name
, "-%s-%s-%s-%s-%s-%s-%s-*-%s-%s",
670 f
[XLFD_FOUNDRY_INDEX
], f
[XLFD_FAMILY_INDEX
],
671 f
[XLFD_WEIGHT_INDEX
], f
[XLFD_SLANT_INDEX
],
672 f
[XLFD_SWIDTH_INDEX
],
673 f
[XLFD_ADSTYLE_INDEX
], pixel_point
,
674 f
[XLFD_RESY_INDEX
], f
[XLFD_REGISTRY_INDEX
]);
678 font_merge_old_spec (name
, family
, registry
, spec
)
679 Lisp_Object name
, family
, registry
, spec
;
683 if (font_parse_xlfd ((char *) SDATA (name
), spec
, 1) < 0)
685 Lisp_Object extra
= Fcons (Fcons (QCname
, name
), Qnil
);
687 ASET (spec
, FONT_EXTRA_INDEX
, extra
);
697 xassert (STRINGP (family
));
698 len
= SBYTES (family
);
699 p0
= (char *) SDATA (family
);
700 p1
= index (p0
, '-');
703 if (NILP (AREF (spec
, FONT_FOUNDRY_INDEX
)))
704 ASET (spec
, FONT_FOUNDRY_INDEX
,
705 intern_downcase (p0
, p1
- p0
));
706 if (NILP (AREF (spec
, FONT_FAMILY_INDEX
)))
707 ASET (spec
, FONT_FAMILY_INDEX
,
708 intern_downcase (p1
+ 1, len
- (p1
+ 1 - p0
)));
710 else if (NILP (AREF (spec
, FONT_FAMILY_INDEX
)))
711 ASET (spec
, FONT_FAMILY_INDEX
, intern_downcase (p0
, len
));
713 if (! NILP (registry
)
714 && NILP (AREF (spec
, FONT_REGISTRY_INDEX
)))
715 ASET (spec
, FONT_REGISTRY_INDEX
,
716 intern_downcase ((char *) SDATA (registry
), SBYTES (registry
)));
730 struct otf_list
*next
;
733 static struct otf_list
*otf_list
;
741 OTF_tag_name (tag
, name
);
742 return Fintern (make_unibyte_string (name
, 4), Qnil
);
746 otf_open (entity
, file
)
750 struct otf_list
*list
= otf_list
;
752 while (list
&& ! EQ (list
->entity
, entity
))
756 list
= malloc (sizeof (struct otf_list
));
757 list
->entity
= entity
;
758 list
->otf
= file
? OTF_open (file
) : NULL
;
759 list
->next
= otf_list
;
766 /* Return a list describing which scripts/languages FONT supports by
767 which GSUB/GPOS features of OpenType tables. See the comment of
768 (sturct font_driver).otf_capability. */
771 font_otf_capability (font
)
775 Lisp_Object capability
= Fcons (Qnil
, Qnil
);
778 otf
= otf_open (font
->entity
, font
->file_name
);
781 for (i
= 0; i
< 2; i
++)
783 OTF_GSUB_GPOS
*gsub_gpos
;
784 Lisp_Object script_list
= Qnil
;
787 if (OTF_get_features (otf
, i
== 0) < 0)
789 gsub_gpos
= i
== 0 ? otf
->gsub
: otf
->gpos
;
790 for (j
= gsub_gpos
->ScriptList
.ScriptCount
- 1; j
>= 0; j
--)
792 OTF_Script
*script
= gsub_gpos
->ScriptList
.Script
+ j
;
793 Lisp_Object langsys_list
= Qnil
;
794 Lisp_Object script_tag
= otf_tag_symbol (script
->ScriptTag
);
797 for (k
= script
->LangSysCount
; k
>= 0; k
--)
799 OTF_LangSys
*langsys
;
800 Lisp_Object feature_list
= Qnil
;
801 Lisp_Object langsys_tag
;
804 if (j
== script
->LangSysCount
)
806 langsys
= &script
->DefaultLangSys
;
811 langsys
= script
->LangSys
+ k
;
813 = otf_tag_symbol (script
->LangSysRecord
[k
].LangSysTag
);
815 for (l
= langsys
->FeatureCount
-1; l
>= 0; l
--)
818 = gsub_gpos
->FeatureList
.Feature
+ langsys
->FeatureIndex
[l
];
819 Lisp_Object feature_tag
820 = otf_tag_symbol (feature
->FeatureTag
);
822 feature_list
= Fcons (feature_tag
, feature_list
);
824 langsys_list
= Fcons (Fcons (langsys_tag
, feature_list
),
827 script_list
= Fcons (Fcons (script_tag
, langsys_list
),
832 XSETCAR (capability
, script_list
);
834 XSETCDR (capability
, script_list
);
841 parse_gsub_gpos_spec (spec
, script
, langsys
, features
)
843 char **script
, **langsys
, **features
;
851 *script
= (char *) SDATA (SYMBOL_NAME (val
));
854 *langsys
= NILP (val
) ? NULL
: (char *) SDATA (SYMBOL_NAME (val
));
856 len
= XINT (Flength (spec
));
857 *features
= p
= malloc (6 * len
);
861 for (asterisk
= 0; CONSP (spec
); spec
= XCDR (spec
))
864 if (SREF (SYMBOL_NAME (val
), 0) == '*')
867 p
+= sprintf (p
, ",*");
870 p
+= sprintf (p
, ",%s", SDATA (SYMBOL_NAME (val
)));
872 p
+= sprintf (p
, ",~%s", SDATA (SYMBOL_NAME (val
)));
877 #define DEVICE_DELTA(table, size) \
878 (((size) >= (table).StartSize && (size) <= (table).EndSize) \
879 ? (table).DeltaValue[(size) >= (table).StartSize] \
883 adjust_anchor (struct font
*font
, OTF_Anchor
*anchor
,
884 unsigned code
, int size
, int *x
, int *y
)
886 if (anchor
->AnchorFormat
== 2)
890 if (font
->driver
->anchor_point (font
, code
, anchor
->f
.f1
.AnchorPoint
,
894 else if (anchor
->AnchorFormat
== 3)
896 if (anchor
->f
.f2
.XDeviceTable
.offset
)
897 *x
+= DEVICE_DELTA (anchor
->f
.f2
.XDeviceTable
, size
);
898 if (anchor
->f
.f2
.YDeviceTable
.offset
)
899 *y
+= DEVICE_DELTA (anchor
->f
.f2
.YDeviceTable
, size
);
904 /* Drive FONT's OTF GSUB features according to GSUB_SPEC. See the
905 comment of (sturct font_driver).otf_gsub. */
908 font_otf_gsub (font
, gsub_spec
, gstring_in
, from
, to
, gstring_out
, idx
)
910 Lisp_Object gsub_spec
;
911 Lisp_Object gstring_in
;
913 Lisp_Object gstring_out
;
919 OTF_GlyphString otf_gstring
;
921 char *script
, *langsys
, *features
;
923 otf
= otf_open (font
->entity
, font
->file_name
);
926 if (OTF_get_table (otf
, "head") < 0)
928 if (OTF_check_table (otf
, "GSUB") < 0)
930 if (parse_gsub_gpos_spec (gsub_spec
, &script
, &langsys
, &features
) < 0)
933 otf_gstring
.size
= otf_gstring
.used
= len
;
934 otf_gstring
.glyphs
= (OTF_Glyph
*) malloc (sizeof (OTF_Glyph
) * len
);
935 memset (otf_gstring
.glyphs
, 0, sizeof (OTF_Glyph
) * len
);
936 for (i
= 0; i
< len
; i
++)
938 Lisp_Object g
= LGSTRING_GLYPH (gstring_in
, from
+ i
);
940 otf_gstring
.glyphs
[i
].c
= XINT (LGLYPH_CHAR (g
));
941 otf_gstring
.glyphs
[i
].glyph_id
= XINT (LGLYPH_CODE (g
));
944 OTF_drive_gdef (otf
, &otf_gstring
);
945 if (OTF_drive_gsub (otf
, &otf_gstring
, script
, langsys
, features
) < 0)
947 free (otf_gstring
.glyphs
);
950 if (ASIZE (gstring_out
) < idx
+ otf_gstring
.used
)
952 free (otf_gstring
.glyphs
);
956 for (i
= 0, g
= otf_gstring
.glyphs
; i
< otf_gstring
.used
;)
958 int i0
= g
->f
.index
.from
, i1
= g
->f
.index
.to
;
959 Lisp_Object glyph
= LGSTRING_GLYPH (gstring_in
, from
+ i0
);
960 Lisp_Object min_idx
= AREF (glyph
, 0);
961 Lisp_Object max_idx
= AREF (glyph
, 1);
965 int min_idx_i
= XINT (min_idx
), max_idx_i
= XINT (max_idx
);
967 for (i0
++; i0
<= i1
; i0
++)
969 glyph
= LGSTRING_GLYPH (gstring_in
, from
+ i0
);
970 if (min_idx_i
> XINT (AREF (glyph
, 0)))
971 min_idx_i
= XINT (AREF (glyph
, 0));
972 if (max_idx_i
< XINT (AREF (glyph
, 1)))
973 max_idx_i
= XINT (AREF (glyph
, 1));
975 min_idx
= make_number (min_idx_i
);
976 max_idx
= make_number (max_idx_i
);
977 i0
= g
->f
.index
.from
;
979 for (; i
< otf_gstring
.used
&& g
->f
.index
.from
== i0
; i
++, g
++)
981 glyph
= LGSTRING_GLYPH (gstring_out
, idx
+ i
);
982 ASET (glyph
, 0, min_idx
);
983 ASET (glyph
, 1, max_idx
);
984 LGLYPH_SET_CHAR (glyph
, make_number (g
->c
));
985 LGLYPH_SET_CODE (glyph
, make_number (g
->glyph_id
));
989 free (otf_gstring
.glyphs
);
993 /* Drive FONT's OTF GPOS features according to GPOS_SPEC. See the
994 comment of (sturct font_driver).otf_gpos. */
997 font_otf_gpos (font
, gpos_spec
, gstring
, from
, to
)
999 Lisp_Object gpos_spec
;
1000 Lisp_Object gstring
;
1006 OTF_GlyphString otf_gstring
;
1008 char *script
, *langsys
, *features
;
1011 Lisp_Object base
, mark
;
1013 otf
= otf_open (font
->entity
, font
->file_name
);
1016 if (OTF_get_table (otf
, "head") < 0)
1018 if (OTF_check_table (otf
, "GPOS") < 0)
1020 if (parse_gsub_gpos_spec (gpos_spec
, &script
, &langsys
, &features
) < 0)
1023 otf_gstring
.size
= otf_gstring
.used
= len
;
1024 otf_gstring
.glyphs
= (OTF_Glyph
*) malloc (sizeof (OTF_Glyph
) * len
);
1025 memset (otf_gstring
.glyphs
, 0, sizeof (OTF_Glyph
) * len
);
1026 for (i
= 0; i
< len
; i
++)
1028 glyph
= LGSTRING_GLYPH (gstring
, from
+ i
);
1029 otf_gstring
.glyphs
[i
].glyph_id
= XINT (LGLYPH_CODE (glyph
));
1032 OTF_drive_gdef (otf
, &otf_gstring
);
1034 if (OTF_drive_gpos (otf
, &otf_gstring
, script
, langsys
, features
) < 0)
1036 free (otf_gstring
.glyphs
);
1040 u
= otf
->head
->unitsPerEm
;
1041 size
= font
->pixel_size
;
1043 for (i
= 0, g
= otf_gstring
.glyphs
; i
< otf_gstring
.used
; i
++, g
++)
1046 int xoff
= 0, yoff
= 0, width_adjust
= 0;
1051 glyph
= LGSTRING_GLYPH (gstring
, from
+ i
);
1052 switch (g
->positioning_type
)
1058 int format
= g
->f
.f1
.format
;
1060 if (format
& OTF_XPlacement
)
1061 xoff
= g
->f
.f1
.value
->XPlacement
* size
/ u
;
1062 if (format
& OTF_XPlaDevice
)
1063 xoff
+= DEVICE_DELTA (g
->f
.f1
.value
->XPlaDevice
, size
);
1064 if (format
& OTF_YPlacement
)
1065 yoff
= - (g
->f
.f1
.value
->YPlacement
* size
/ u
);
1066 if (format
& OTF_YPlaDevice
)
1067 yoff
-= DEVICE_DELTA (g
->f
.f1
.value
->YPlaDevice
, size
);
1068 if (format
& OTF_XAdvance
)
1069 width_adjust
+= g
->f
.f1
.value
->XAdvance
* size
/ u
;
1070 if (format
& OTF_XAdvDevice
)
1071 width_adjust
+= DEVICE_DELTA (g
->f
.f1
.value
->XAdvDevice
, size
);
1075 /* Not yet supported. */
1081 goto label_adjust_anchor
;
1082 default: /* i.e. case 6 */
1087 label_adjust_anchor
:
1089 int base_x
, base_y
, mark_x
, mark_y
, width
;
1092 base_x
= g
->f
.f4
.base_anchor
->XCoordinate
* size
/ u
;
1093 base_y
= g
->f
.f4
.base_anchor
->YCoordinate
* size
/ u
;
1094 mark_x
= g
->f
.f4
.mark_anchor
->XCoordinate
* size
/ u
;
1095 mark_y
= g
->f
.f4
.mark_anchor
->YCoordinate
* size
/ u
;
1097 code
= XINT (LGLYPH_CODE (prev
));
1098 if (g
->f
.f4
.base_anchor
->AnchorFormat
!= 1)
1099 adjust_anchor (font
, g
->f
.f4
.base_anchor
,
1100 code
, size
, &base_x
, &base_y
);
1101 if (g
->f
.f4
.mark_anchor
->AnchorFormat
!= 1)
1102 adjust_anchor (font
, g
->f
.f4
.mark_anchor
,
1103 code
, size
, &mark_x
, &mark_y
);
1105 if (NILP (LGLYPH_WIDTH (prev
)))
1107 width
= font
->driver
->text_extents (font
, &code
, 1, NULL
);
1108 LGLYPH_SET_WIDTH (prev
, make_number (width
));
1110 xoff
= XINT (LGLYPH_XOFF (prev
)) + (base_x
- width
) - mark_x
;
1111 yoff
= XINT (LGLYPH_YOFF (prev
)) + mark_y
- base_y
;
1114 if (g
->GlyphClass
== OTF_GlyphClass0
)
1115 base
= mark
= glyph
;
1116 else if (g
->GlyphClass
== OTF_GlyphClassMark
)
1121 LGLYPH_SET_XOFF (glyph
, make_number (xoff
));
1122 LGLYPH_SET_YOFF (glyph
, make_number (yoff
));
1123 LGLYPH_SET_WADJUST (glyph
, make_number (width_adjust
));
1126 free (otf_gstring
.glyphs
);
1130 #endif /* HAVE_LIBOTF */
1133 /* glyph-string handler */
1135 /* GSTRING is a vector of this form:
1136 [ [FONT-OBJECT LBEARING RBEARING WITH ASCENT DESCENT] GLYPH ... ]
1137 and GLYPH is a vector of this form:
1138 [ FROM-IDX TO-IDX C CODE X-OFF Y-OFF WIDTH WADJUST ]
1140 FROM-IDX and TO-IDX are used internally and should not be touched.
1141 C is a character of the glyph.
1142 CODE is a glyph-code of C in FONT-OBJECT.
1143 X-OFF and Y-OFF are offests to the base position for the glyph.
1144 WIDTH is a normal width of the glyph.
1145 WADJUST is an adjustment to the normal width of the glyph. */
1148 font_prepare_composition (cmp
)
1149 struct composition
*cmp
;
1152 = AREF (XHASH_TABLE (composition_hash_table
)->key_and_value
,
1153 cmp
->hash_index
* 2);
1154 struct font
*font
= XSAVE_VALUE (LGSTRING_FONT (gstring
))->pointer
;
1155 int len
= LGSTRING_LENGTH (gstring
);
1159 cmp
->lbearing
= cmp
->rbearing
= cmp
->pixel_width
= 0;
1160 cmp
->ascent
= font
->ascent
;
1161 cmp
->descent
= font
->descent
;
1163 for (i
= 0; i
< len
; i
++)
1165 Lisp_Object g
= LGSTRING_GLYPH (gstring
, i
);
1166 unsigned code
= XINT (LGLYPH_CODE (g
));
1167 struct font_metrics metrics
;
1169 font
->driver
->text_extents (font
, &code
, 1, &metrics
);
1170 LGLYPH_SET_WIDTH (g
, make_number (metrics
.width
));
1171 metrics
.lbearing
+= XINT (LGLYPH_XOFF (g
));
1172 metrics
.rbearing
+= XINT (LGLYPH_XOFF (g
));
1173 metrics
.ascent
+= XINT (LGLYPH_YOFF (g
));
1174 metrics
.descent
+= XINT (LGLYPH_YOFF (g
));
1176 if (cmp
->lbearing
> cmp
->pixel_width
+ metrics
.lbearing
)
1177 cmp
->lbearing
= cmp
->pixel_width
+ metrics
.lbearing
;
1178 if (cmp
->rbearing
< cmp
->pixel_width
+ metrics
.rbearing
)
1179 cmp
->rbearing
= cmp
->pixel_width
+ metrics
.rbearing
;
1180 if (cmp
->ascent
< metrics
.ascent
)
1181 cmp
->ascent
= metrics
.ascent
;
1182 if (cmp
->descent
< metrics
.descent
)
1183 cmp
->descent
= metrics
.descent
;
1184 cmp
->pixel_width
+= metrics
.width
+ XINT (LGLYPH_WADJUST (g
));
1186 LGSTRING_SET_LBEARING (gstring
, make_number (cmp
->lbearing
));
1187 LGSTRING_SET_RBEARING (gstring
, make_number (cmp
->rbearing
));
1188 LGSTRING_SET_WIDTH (gstring
, make_number (cmp
->pixel_width
));
1189 LGSTRING_SET_ASCENT (gstring
, make_number (cmp
->ascent
));
1190 LGSTRING_SET_DESCENT (gstring
, make_number (cmp
->descent
));
1196 font_gstring_produce (old
, from
, to
, new, idx
, code
, n
)
1204 Lisp_Object min_idx
, max_idx
;
1207 if (idx
+ n
> ASIZE (new))
1213 min_idx
= make_number (0);
1214 max_idx
= make_number (1);
1218 min_idx
= AREF (AREF (old
, from
- 1), 0);
1219 max_idx
= AREF (AREF (old
, from
- 1), 1);
1222 else if (from
+ 1 == to
)
1224 min_idx
= AREF (AREF (old
, from
), 0);
1225 max_idx
= AREF (AREF (old
, from
), 1);
1229 int min_idx_i
= XINT (AREF (AREF (old
, from
), 0));
1230 int max_idx_i
= XINT (AREF (AREF (old
, from
), 1));
1232 for (i
= from
+ 1; i
< to
; i
++)
1234 if (min_idx_i
> XINT (AREF (AREF (old
, i
), 0)))
1235 min_idx_i
= XINT (AREF (AREF (old
, i
), 0));
1236 if (max_idx_i
< XINT (AREF (AREF (old
, i
), 1)))
1237 max_idx_i
= XINT (AREF (AREF (old
, i
), 1));
1239 min_idx
= make_number (min_idx_i
);
1240 max_idx
= make_number (max_idx_i
);
1243 for (i
= 0; i
< n
; i
++)
1245 ASET (AREF (new, idx
+ i
), 0, min_idx
);
1246 ASET (AREF (new, idx
+ i
), 1, max_idx
);
1247 ASET (AREF (new, idx
+ i
), 2, make_number (code
[i
]));
1255 static unsigned font_score
P_ ((Lisp_Object
, Lisp_Object
));
1256 static int font_compare
P_ ((const void *, const void *));
1257 static Lisp_Object font_sort_entites
P_ ((Lisp_Object
, Lisp_Object
,
1258 Lisp_Object
, Lisp_Object
));
1260 /* We sort fonts by scoring each of them against a specified
1261 font-spec. The score value is 32 bit (`unsigned'), and the smaller
1262 the value is, the closer the font is to the font-spec.
1264 Each 1-bit in the highest 4 bits of the score is used for atomic
1265 properties FOUNDRY, FAMILY, ADSTYLE, and REGISTRY.
1267 Each 7-bit in the lowest 28 bits are used for numeric properties
1268 WEIGHT, SLANT, WIDTH, and SIZE. */
1270 /* How many bits to shift to store the difference value of each font
1271 property in a score. */
1272 static int sort_shift_bits
[FONT_SIZE_INDEX
+ 1];
1274 /* Score font-entity ENTITY against font-spec SPEC. The return value
1275 indicates how different ENTITY is compared with SPEC. */
1278 font_score (entity
, spec
)
1279 Lisp_Object entity
, spec
;
1283 /* Score atomic fields. Maximum difference is 1. */
1284 for (i
= FONT_FOUNDRY_INDEX
; i
<= FONT_REGISTRY_INDEX
; i
++)
1286 Lisp_Object val
= AREF (spec
, i
);
1289 && ! EQ (val
, AREF (entity
, i
)))
1290 score
|= 1 << sort_shift_bits
[i
];
1293 /* Score numeric fields. Maximum difference is 127. */
1294 for (i
= FONT_WEIGHT_INDEX
; i
<= FONT_SIZE_INDEX
; i
++)
1296 Lisp_Object spec_val
= AREF (spec
, i
);
1297 Lisp_Object entity_val
= AREF (entity
, i
);
1299 if (! NILP (spec_val
) && ! EQ (spec_val
, entity_val
))
1301 if (! INTEGERP (entity_val
))
1302 score
|= 127 << sort_shift_bits
[i
];
1303 else if (i
< FONT_SIZE_INDEX
1304 || XINT (entity_val
) != 0)
1306 int diff
= XINT (entity_val
) - XINT (spec_val
);
1310 score
|= min (diff
, 127) << sort_shift_bits
[i
];
1319 /* The comparison function for qsort. */
1322 font_compare (d1
, d2
)
1323 const void *d1
, *d2
;
1325 return (*(unsigned *) d1
< *(unsigned *) d2
1326 ? -1 : *(unsigned *) d1
> *(unsigned *) d2
);
1330 /* The structure for elements being sorted by qsort. */
1331 struct font_sort_data
1338 /* Sort font-entities in vector VEC by closeness to font-spec PREFER.
1339 If PREFER specifies a point-size, calculate the corresponding
1340 pixel-size from the Y-resolution of FRAME before sorting. If SPEC
1341 is not nil, it is a font-spec to get the font-entities in VEC. */
1344 font_sort_entites (vec
, prefer
, frame
, spec
)
1345 Lisp_Object vec
, prefer
, frame
, spec
;
1349 struct font_sort_data
*data
;
1350 int prefer_is_copy
= 0;
1357 size
= AREF (spec
, FONT_SIZE_INDEX
);
1360 double point_size
= XFLOAT_DATA (size
) * 10;
1361 int pixel_size
= POINT_TO_PIXEL (point_size
, XFRAME (frame
)->resy
);
1363 prefer
= Fcopy_sequence (prefer
);
1364 ASET (prefer
, FONT_SIZE_INDEX
, make_number (pixel_size
));
1370 /* As it is assured that all fonts in VEC match with SPEC, we
1371 should ignore properties specified in SPEC. So, set the
1372 corresponding properties in PREFER nil. */
1373 for (i
= FONT_WEIGHT_INDEX
; i
<= FONT_SIZE_INDEX
; i
++)
1374 if (! NILP (AREF (spec
, i
)) && ! NILP (AREF (prefer
, i
)))
1376 if (i
<= FONT_SIZE_INDEX
)
1378 if (! prefer_is_copy
)
1379 prefer
= Fcopy_sequence (prefer
);
1380 for (; i
<= FONT_SIZE_INDEX
; i
++)
1381 if (! NILP (AREF (spec
, i
)) && ! NILP (AREF (prefer
, i
)))
1382 ASET (prefer
, i
, Qnil
);
1386 /* Scoring and sorting. */
1387 SAFE_ALLOCA (data
, struct font_sort_data
*, (sizeof *data
) * len
);
1388 for (i
= 0; i
< len
; i
++)
1390 data
[i
].entity
= AREF (vec
, i
);
1391 data
[i
].score
= font_score (data
[i
].entity
, prefer
);
1393 qsort (data
, len
, sizeof *data
, font_compare
);
1394 for (i
= 0; i
< len
; i
++)
1395 ASET (vec
, i
, data
[i
].entity
);
1402 /* API of Font Service Layer. */
1405 font_update_sort_order (order
)
1408 int i
, shift_bits
= 21;
1410 for (i
= 0; i
< 4; i
++, shift_bits
-= 7)
1412 int xlfd_idx
= order
[i
];
1414 if (xlfd_idx
== XLFD_WEIGHT_INDEX
)
1415 sort_shift_bits
[FONT_WEIGHT_INDEX
] = shift_bits
;
1416 else if (xlfd_idx
== XLFD_SLANT_INDEX
)
1417 sort_shift_bits
[FONT_SLANT_INDEX
] = shift_bits
;
1418 else if (xlfd_idx
== XLFD_SWIDTH_INDEX
)
1419 sort_shift_bits
[FONT_WIDTH_INDEX
] = shift_bits
;
1421 sort_shift_bits
[FONT_SIZE_INDEX
] = shift_bits
;
1426 font_symbolic_weight (font
)
1429 Lisp_Object weight
= AREF (font
, FONT_WEIGHT_INDEX
);
1431 if (INTEGERP (weight
))
1432 weight
= prop_numeric_to_name (FONT_WEIGHT_INDEX
, XINT (weight
));
1437 font_symbolic_slant (font
)
1440 Lisp_Object slant
= AREF (font
, FONT_SLANT_INDEX
);
1442 if (INTEGERP (slant
))
1443 slant
= prop_numeric_to_name (FONT_SLANT_INDEX
, XINT (slant
));
1448 font_symbolic_width (font
)
1451 Lisp_Object width
= AREF (font
, FONT_WIDTH_INDEX
);
1453 if (INTEGERP (width
))
1454 width
= prop_numeric_to_name (FONT_WIDTH_INDEX
, XINT (width
));
1459 font_find_object (font
)
1462 Lisp_Object tail
, elt
;
1464 for (tail
= AREF (font
->entity
, FONT_OBJLIST_INDEX
); CONSP (tail
);
1468 if (font
== XSAVE_VALUE (elt
)->pointer
1469 && XSAVE_VALUE (elt
)->integer
> 0)
1476 static Lisp_Object scratch_font_spec
, scratch_font_prefer
;
1478 /* Return a vector of font-entities matching with SPEC on frame F. */
1481 font_list_entities (frame
, spec
)
1482 Lisp_Object frame
, spec
;
1484 FRAME_PTR f
= XFRAME (frame
);
1485 struct font_driver_list
*driver_list
= f
->font_driver_list
;
1486 Lisp_Object ftype
, family
, alternate_familes
;
1487 Lisp_Object
*vec
= alloca (sizeof (Lisp_Object
) * num_font_drivers
);
1493 family
= AREF (spec
, FONT_FAMILY_INDEX
);
1495 alternate_familes
= Qnil
;
1498 if (NILP (font_family_alist
)
1499 && !NILP (Vface_alternative_font_family_alist
))
1500 build_font_family_alist ();
1501 alternate_familes
= assq_no_quit (family
, font_family_alist
);
1502 if (! NILP (alternate_familes
))
1503 alternate_familes
= XCDR (alternate_familes
);
1505 xassert (ASIZE (spec
) == FONT_SPEC_MAX
);
1506 ftype
= AREF (spec
, FONT_TYPE_INDEX
);
1508 for (i
= 0; driver_list
; driver_list
= driver_list
->next
)
1509 if (NILP (ftype
) || EQ (driver_list
->driver
->type
, ftype
))
1511 Lisp_Object cache
= driver_list
->driver
->get_cache (frame
);
1512 Lisp_Object tail
= alternate_familes
;
1515 xassert (CONSP (cache
));
1516 ASET (spec
, FONT_TYPE_INDEX
, driver_list
->driver
->type
);
1517 ASET (spec
, FONT_FAMILY_INDEX
, family
);
1521 val
= assoc_no_quit (spec
, XCDR (cache
));
1526 val
= driver_list
->driver
->list (frame
, spec
);
1528 XSETCDR (cache
, Fcons (Fcons (Fcopy_sequence (spec
), val
),
1531 if (VECTORP (val
) && ASIZE (val
) > 0)
1538 ASET (spec
, FONT_FAMILY_INDEX
, XCAR (tail
));
1542 ASET (spec
, FONT_TYPE_INDEX
, ftype
);
1543 ASET (spec
, FONT_FAMILY_INDEX
, family
);
1544 return (i
> 0 ? Fvconcat (i
, vec
) : null_vector
);
1547 static int num_fonts
;
1550 font_open_entity (f
, entity
, pixel_size
)
1555 struct font_driver_list
*driver_list
;
1556 Lisp_Object objlist
, size
, val
;
1559 size
= AREF (entity
, FONT_SIZE_INDEX
);
1560 xassert (NATNUMP (size
));
1561 if (XINT (size
) != 0)
1562 pixel_size
= XINT (size
);
1564 for (objlist
= AREF (entity
, FONT_OBJLIST_INDEX
); CONSP (objlist
);
1565 objlist
= XCDR (objlist
))
1567 font
= XSAVE_VALUE (XCAR (objlist
))->pointer
;
1568 if (font
->pixel_size
== pixel_size
)
1570 XSAVE_VALUE (XCAR (objlist
))->integer
++;
1571 return XCAR (objlist
);
1575 xassert (FONT_ENTITY_P (entity
));
1576 val
= AREF (entity
, FONT_TYPE_INDEX
);
1577 for (driver_list
= f
->font_driver_list
;
1578 driver_list
&& ! EQ (driver_list
->driver
->type
, val
);
1579 driver_list
= driver_list
->next
);
1583 font
= driver_list
->driver
->open (f
, entity
, pixel_size
);
1586 val
= make_save_value (font
, 1);
1587 ASET (entity
, FONT_OBJLIST_INDEX
,
1588 Fcons (val
, AREF (entity
, FONT_OBJLIST_INDEX
)));
1594 font_close_object (f
, font_object
)
1596 Lisp_Object font_object
;
1599 Lisp_Object objlist
= AREF (font
->entity
, FONT_OBJLIST_INDEX
);
1600 Lisp_Object tail
, prev
= Qnil
;
1602 for (prev
= Qnil
, tail
= objlist
; CONSP (tail
);
1603 prev
= tail
, tail
= XCDR (tail
))
1604 if (EQ (font_object
, XCAR (tail
)))
1606 struct Lisp_Save_Value
*p
= XSAVE_VALUE (font_object
);
1608 xassert (p
->integer
> 0);
1610 if (p
->integer
== 0)
1612 if (font
->driver
->close
)
1613 font
->driver
->close (f
, p
->pointer
);
1616 ASET (font
->entity
, FONT_OBJLIST_INDEX
, XCDR (objlist
));
1618 XSETCDR (prev
, XCDR (objlist
));
1625 font_has_char (f
, font_entity
, c
)
1627 Lisp_Object font_entity
;
1630 Lisp_Object type
= AREF (font_entity
, FONT_TYPE_INDEX
);
1631 struct font_driver_list
*driver_list
;
1633 for (driver_list
= f
->font_driver_list
;
1634 driver_list
&& ! EQ (driver_list
->driver
->type
, type
);
1635 driver_list
= driver_list
->next
);
1638 return driver_list
->driver
->has_char (font_entity
, c
);
1642 font_encode_char (font_object
, c
)
1643 Lisp_Object font_object
;
1646 struct font
*font
= XSAVE_VALUE (font_object
)->pointer
;
1648 return font
->driver
->encode_char (font
, c
);
1652 font_get_name (font_object
)
1653 Lisp_Object font_object
;
1655 struct font
*font
= XSAVE_VALUE (font_object
)->pointer
;
1657 return (font
->font
.full_name
? font
->font
.full_name
1658 : font
->file_name
? font
->file_name
1663 font_get_frame (font
)
1666 if (FONT_OBJECT_P (font
))
1667 font
= ((struct font
*) XSAVE_VALUE (font
)->pointer
)->entity
;
1668 xassert (FONT_ENTITY_P (font
));
1669 return AREF (font
, FONT_FRAME_INDEX
);
1672 extern Lisp_Object Qunspecified
, Qignore_defface
;
1675 font_find_for_lface (f
, lface
, spec
)
1680 Lisp_Object attrs
[LFACE_SLANT_INDEX
+ 1];
1681 Lisp_Object frame
, val
, entities
;
1683 unsigned char try_unspecified
[FONT_SPEC_MAX
];
1685 for (i
= 0; i
<= LFACE_SLANT_INDEX
; i
++)
1688 if (EQ (val
, Qunspecified
) || EQ (val
, Qignore_defface
))
1693 for (i
= 0; i
< FONT_SPEC_MAX
; i
++)
1694 ASET (scratch_font_spec
, i
, Qnil
);
1696 for (i
= 0; i
< FONT_SPEC_MAX
; i
++)
1697 ASET (scratch_font_spec
, i
, AREF (spec
, i
));
1699 /* If SPEC doesn't specify a specific property, it can be tried with
1700 nil even if FACE specifies it. */
1701 for (i
= FONT_FOUNDRY_INDEX
; i
<= FONT_SIZE_INDEX
; i
++)
1702 try_unspecified
[i
] = NILP (AREF (scratch_font_spec
, i
));
1704 if (STRINGP (attrs
[LFACE_FONT_INDEX
]))
1705 font_merge_old_spec (attrs
[LFACE_FONT_INDEX
], Qnil
, Qnil
,
1707 if (NILP (AREF (scratch_font_spec
, FONT_FAMILY_INDEX
))
1708 && ! NILP (attrs
[LFACE_FAMILY_INDEX
]))
1709 font_merge_old_spec (Qnil
, attrs
[LFACE_FAMILY_INDEX
], Qnil
,
1711 if (NILP (AREF (scratch_font_spec
, FONT_REGISTRY_INDEX
)))
1713 ASET (scratch_font_spec
, FONT_REGISTRY_INDEX
, intern ("iso8859-1"));
1714 try_unspecified
[FONT_REGISTRY_INDEX
] = 0;
1717 for (i
= FONT_FAMILY_INDEX
; i
<= FONT_SIZE_INDEX
; i
++)
1718 if (try_unspecified
[i
]
1719 && NILP (AREF (scratch_font_spec
, i
)))
1720 try_unspecified
[i
] = 0;
1722 XSETFRAME (frame
, f
);
1723 entities
= font_list_entities (frame
, scratch_font_spec
);
1724 while (ASIZE (entities
) == 0)
1726 if (try_unspecified
[FONT_WEIGHT_INDEX
]
1727 || try_unspecified
[FONT_SLANT_INDEX
]
1728 || try_unspecified
[FONT_WIDTH_INDEX
]
1729 || try_unspecified
[FONT_SIZE_INDEX
])
1731 for (i
= FONT_WEIGHT_INDEX
; i
<= FONT_SIZE_INDEX
; i
++)
1733 try_unspecified
[i
] = 0;
1734 ASET (scratch_font_spec
, i
, Qnil
);
1736 entities
= font_list_entities (frame
, scratch_font_spec
);
1738 else if (try_unspecified
[FONT_FOUNDRY_INDEX
])
1740 try_unspecified
[FONT_FOUNDRY_INDEX
] = 0;
1741 ASET (scratch_font_spec
, FONT_FOUNDRY_INDEX
, Qnil
);
1742 entities
= font_list_entities (frame
, scratch_font_spec
);
1744 else if (try_unspecified
[FONT_FAMILY_INDEX
])
1746 try_unspecified
[FONT_FAMILY_INDEX
] = 0;
1747 ASET (scratch_font_spec
, FONT_FAMILY_INDEX
, Qnil
);
1748 entities
= font_list_entities (frame
, scratch_font_spec
);
1754 if (ASIZE (entities
) > 1)
1756 Lisp_Object prefer
= scratch_font_prefer
;
1758 for (i
= 0; i
< FONT_WEIGHT_INDEX
; i
++)
1759 ASET (prefer
, i
, Qnil
);
1760 if (! NILP (attrs
[LFACE_WEIGHT_INDEX
]))
1761 ASET (prefer
, FONT_WEIGHT_INDEX
,
1762 font_prop_validate_style (FONT_WEIGHT_INDEX
,
1763 attrs
[LFACE_WEIGHT_INDEX
]));
1764 if (! NILP (attrs
[LFACE_SLANT_INDEX
]))
1765 ASET (prefer
, FONT_SLANT_INDEX
,
1766 font_prop_validate_style (FONT_SLANT_INDEX
,
1767 attrs
[LFACE_SLANT_INDEX
]));
1768 if (! NILP (attrs
[LFACE_SWIDTH_INDEX
]))
1769 ASET (prefer
, FONT_WIDTH_INDEX
,
1770 font_prop_validate_style (FONT_WIDTH_INDEX
,
1771 attrs
[LFACE_SWIDTH_INDEX
]));
1772 if (! NILP (attrs
[LFACE_HEIGHT_INDEX
]))
1776 val
= attrs
[LFACE_HEIGHT_INDEX
];
1777 size
= POINT_TO_PIXEL (XINT (val
), f
->resy
);
1778 ASET (prefer
, FONT_SIZE_INDEX
, make_number (size
));
1780 font_sort_entites (entities
, prefer
, frame
, spec
);
1783 return AREF (entities
, 0);
1787 font_open_for_lface (f
, lface
, entity
)
1792 int pt
= XINT (lface
[LFACE_HEIGHT_INDEX
]);
1793 int size
= POINT_TO_PIXEL (pt
, f
->resy
);
1795 return font_open_entity (f
, entity
, size
);
1799 font_load_for_face (f
, face
)
1805 face
->font_info_id
= -1;
1806 face
->font_info
= NULL
;
1808 face
->font_name
= NULL
;
1810 entity
= font_find_for_lface (f
, face
->lface
, Qnil
);
1811 if (! NILP (entity
))
1813 Lisp_Object font_object
= font_open_for_lface (f
, face
->lface
, entity
);
1815 if (! NILP (font_object
))
1817 struct font
*font
= XSAVE_VALUE (font_object
)->pointer
;
1819 face
->font
= font
->font
.font
;
1820 face
->font_info
= (struct font_info
*) font
;
1821 face
->font_info_id
= 0;
1822 face
->font_name
= font
->font
.full_name
;
1826 add_to_log ("Unable to load font for a face%s", null_string
, Qnil
);
1830 font_prepare_for_face (f
, face
)
1834 struct font
*font
= (struct font
*) face
->font_info
;
1836 if (font
->driver
->prepare_face
)
1837 font
->driver
->prepare_face (f
, face
);
1841 font_done_for_face (f
, face
)
1845 struct font
*font
= (struct font
*) face
->font_info
;
1847 if (font
->driver
->done_face
)
1848 font
->driver
->done_face (f
, face
);
1853 font_open_by_name (f
, name
)
1857 Lisp_Object spec
= Ffont_spec (0, NULL
);
1858 Lisp_Object entities
= Qnil
;
1862 XSETFRAME (frame
, f
);
1864 ASET (spec
, FONT_EXTRA_INDEX
,
1865 Fcons (Fcons (QCname
, make_unibyte_string (name
, strlen (name
))),
1867 entities
= font_list_entities (frame
, spec
);
1868 if (ASIZE (entities
) == 0)
1870 pixel_size
= XINT (AREF (AREF (entities
, 0), FONT_SIZE_INDEX
));
1871 if (pixel_size
== 0)
1873 return font_open_entity (f
, AREF (entities
, 0), pixel_size
);
1877 /* Register font-driver DRIVER. This function is used in two ways.
1879 The first is with frame F non-NULL. In this case, DRIVER is
1880 registered to be used for drawing characters on F. All frame
1881 creaters (e.g. Fx_create_frame) must call this function at least
1882 once with an available font-driver.
1884 The second is with frame F NULL. In this case, DRIVER is globally
1885 registered in the variable `font_driver_list'. All font-driver
1886 implementations must call this function in its syms_of_XXXX
1887 (e.g. syms_of_xfont). */
1890 register_font_driver (driver
, f
)
1891 struct font_driver
*driver
;
1894 struct font_driver_list
*root
= f
? f
->font_driver_list
: font_driver_list
;
1895 struct font_driver_list
*prev
, *list
;
1897 if (f
&& ! driver
->draw
)
1898 error ("Unsable font driver for a frame: %s",
1899 SDATA (SYMBOL_NAME (driver
->type
)));
1901 for (prev
= NULL
, list
= root
; list
; prev
= list
, list
= list
->next
)
1902 if (list
->driver
->type
== driver
->type
)
1903 error ("Duplicated font driver: %s", SDATA (SYMBOL_NAME (driver
->type
)));
1905 list
= malloc (sizeof (struct font_driver_list
));
1906 list
->driver
= driver
;
1911 f
->font_driver_list
= list
;
1913 font_driver_list
= list
;
1917 /* Free font-driver list on frame F. It doesn't free font-drivers
1921 free_font_driver_list (f
)
1924 while (f
->font_driver_list
)
1926 struct font_driver_list
*next
= f
->font_driver_list
->next
;
1928 free (f
->font_driver_list
);
1929 f
->font_driver_list
= next
;
1936 DEFUN ("fontp", Ffontp
, Sfontp
, 1, 1, 0,
1937 doc
: /* Return t if object is a font-spec or font-entity. */)
1941 return (FONTP (object
) ? Qt
: Qnil
);
1944 DEFUN ("font-spec", Ffont_spec
, Sfont_spec
, 0, MANY
, 0,
1945 doc
: /* Return a newly created font-spec with specified arguments as properties.
1946 usage: (font-spec &rest properties) */)
1951 Lisp_Object spec
= Fmake_vector (make_number (FONT_SPEC_MAX
), Qnil
);
1952 Lisp_Object extra
= Qnil
;
1955 for (i
= 0; i
< nargs
; i
+= 2)
1957 enum font_property_index prop
;
1958 Lisp_Object key
= args
[i
], val
= args
[i
+ 1];
1960 prop
= check_font_prop_name (key
);
1961 if (prop
< FONT_EXTRA_INDEX
)
1962 ASET (spec
, prop
, (font_property_table
[prop
].validater
) (prop
, val
));
1964 extra
= Fcons (Fcons (key
, val
), extra
);
1966 ASET (spec
, FONT_EXTRA_INDEX
, extra
);
1971 DEFUN ("font-get", Ffont_get
, Sfont_get
, 2, 2, 0,
1972 doc
: /* Return the value of FONT's PROP property.
1973 FONT may be a font-spec or font-entity.
1974 If FONT is font-entity and PROP is :extra, always nil is returned. */)
1976 Lisp_Object font
, prop
;
1978 enum font_property_index idx
;
1981 idx
= check_font_prop_name (prop
);
1982 if (idx
< FONT_EXTRA_INDEX
)
1983 return AREF (font
, idx
);
1984 if (FONT_ENTITY_P (font
))
1986 return Fcdr (Fassoc (AREF (font
, FONT_EXTRA_INDEX
), prop
));
1990 DEFUN ("font-put", Ffont_put
, Sfont_put
, 3, 3, 0,
1991 doc
: /* Set one property of FONT-SPEC: give property PROP value VALUE. */)
1992 (font_spec
, prop
, val
)
1993 Lisp_Object font_spec
, prop
, val
;
1995 enum font_property_index idx
;
1996 Lisp_Object extra
, slot
;
1998 CHECK_FONT_SPEC (font_spec
);
1999 idx
= check_font_prop_name (prop
);
2000 if (idx
< FONT_EXTRA_INDEX
)
2001 return ASET (font_spec
, idx
, val
);
2002 extra
= AREF (font_spec
, FONT_EXTRA_INDEX
);
2003 slot
= Fassoc (extra
, prop
);
2005 extra
= Fcons (Fcons (prop
, val
), extra
);
2007 Fsetcdr (slot
, val
);
2011 DEFUN ("list-fonts", Flist_fonts
, Slist_fonts
, 1, 4, 0,
2012 doc
: /* List available fonts matching FONT-SPEC on the current frame.
2013 Optional 2nd argument FRAME specifies the target frame.
2014 Optional 3rd argument NUM, if non-nil, limits the number of returned fonts.
2015 Optional 4th argument PREFER, if non-nil, is a font-spec to sort fonts
2016 by closeness to PREFER. */)
2017 (font_spec
, frame
, num
, prefer
)
2018 Lisp_Object font_spec
, frame
, num
, prefer
;
2020 Lisp_Object vec
, list
, tail
;
2024 frame
= selected_frame
;
2025 CHECK_LIVE_FRAME (frame
);
2026 CHECK_VALIDATE_FONT_SPEC (font_spec
);
2034 if (! NILP (prefer
))
2035 CHECK_FONT (prefer
);
2037 vec
= font_list_entities (frame
, font_spec
);
2042 return Fcons (AREF (vec
, 0), Qnil
);
2044 if (! NILP (prefer
))
2045 vec
= font_sort_entites (vec
, prefer
, frame
, font_spec
);
2047 list
= tail
= Fcons (AREF (vec
, 0), Qnil
);
2048 if (n
== 0 || n
> len
)
2050 for (i
= 1; i
< n
; i
++)
2052 Lisp_Object val
= Fcons (AREF (vec
, i
), Qnil
);
2054 XSETCDR (tail
, val
);
2060 DEFUN ("list-families", Flist_families
, Slist_families
, 0, 1, 0,
2061 doc
: /* List available font families on the current frame.
2062 Optional 2nd argument FRAME specifies the target frame. */)
2067 struct font_driver_list
*driver_list
;
2071 frame
= selected_frame
;
2072 CHECK_LIVE_FRAME (frame
);
2075 for (driver_list
= f
->font_driver_list
; driver_list
;
2076 driver_list
= driver_list
->next
)
2077 if (driver_list
->driver
->list_family
)
2079 Lisp_Object val
= driver_list
->driver
->list_family (frame
);
2085 Lisp_Object tail
= list
;
2087 for (; CONSP (val
); val
= XCDR (val
))
2088 if (NILP (Fmemq (XCAR (val
), tail
)))
2089 list
= Fcons (XCAR (val
), list
);
2095 DEFUN ("find-font", Ffind_font
, Sfind_font
, 1, 2, 0,
2096 doc
: /* Return a font-entity matching with FONT-SPEC on the current frame.
2097 Optional 2nd argument FRAME, if non-nil, specifies the target frame. */)
2099 Lisp_Object font_spec
, frame
;
2101 Lisp_Object val
= Flist_fonts (font_spec
, frame
, make_number (1), Qnil
);
2108 DEFUN ("font-xlfd-name", Ffont_xlfd_name
, Sfont_xlfd_name
, 1, 1, 0,
2109 doc
: /* Return XLFD name of FONT.
2110 FONT is a font-spec, font-entity, or font-object.
2111 If the name is too long for XLFD (maximum 255 chars), return nil. */)
2118 if (FONT_SPEC_P (font
))
2119 CHECK_VALIDATE_FONT_SPEC (font
);
2120 else if (FONT_ENTITY_P (font
))
2126 CHECK_FONT_GET_OBJECT (font
, fontp
);
2127 font
= fontp
->entity
;
2128 pixel_size
= fontp
->pixel_size
;
2131 if (font_unparse_xlfd (font
, pixel_size
, name
, 256) < 0)
2133 return build_string (name
);
2136 DEFUN ("clear-font-cache", Fclear_font_cache
, Sclear_font_cache
, 0, 0, 0,
2137 doc
: /* Clear font cache. */)
2140 Lisp_Object list
, frame
;
2142 FOR_EACH_FRAME (list
, frame
)
2144 FRAME_PTR f
= XFRAME (frame
);
2145 struct font_driver_list
*driver_list
= f
->font_driver_list
;
2147 for (; driver_list
; driver_list
= driver_list
->next
)
2149 Lisp_Object cache
= driver_list
->driver
->get_cache (frame
);
2150 Lisp_Object tail
, elt
;
2152 for (tail
= XCDR (cache
); CONSP (tail
); tail
= XCDR (tail
))
2155 if (CONSP (elt
) && FONT_SPEC_P (XCAR (elt
)))
2157 Lisp_Object vec
= XCDR (elt
);
2160 for (i
= 0; i
< ASIZE (vec
); i
++)
2162 Lisp_Object entity
= AREF (vec
, i
);
2163 Lisp_Object objlist
= AREF (entity
, FONT_OBJLIST_INDEX
);
2165 for (; CONSP (objlist
); objlist
= XCDR (objlist
))
2167 Lisp_Object val
= XCAR (objlist
);
2168 struct Lisp_Save_Value
*p
= XSAVE_VALUE (val
);
2169 struct font
*font
= p
->pointer
;
2172 && driver_list
->driver
== font
->driver
);
2173 driver_list
->driver
->close (f
, font
);
2177 if (driver_list
->driver
->free_entity
)
2178 driver_list
->driver
->free_entity (entity
);
2182 XSETCDR (cache
, Qnil
);
2189 DEFUN ("internal-set-font-style-table", Finternal_set_font_style_table
,
2190 Sinternal_set_font_style_table
, 2, 2, 0,
2191 doc
: /* Set font style table for PROP to TABLE.
2192 PROP must be `:weight', `:slant', or `:width'.
2193 TABLE must be an alist of symbols vs the corresponding numeric values
2194 sorted by numeric values. */)
2196 Lisp_Object prop
, table
;
2200 Lisp_Object tail
, val
;
2202 CHECK_SYMBOL (prop
);
2203 table_index
= (EQ (prop
, QCweight
) ? 0
2204 : EQ (prop
, QCslant
) ? 1
2205 : EQ (prop
, QCwidth
) ? 2
2207 if (table_index
>= ASIZE (font_style_table
))
2208 error ("Invalid font style property: %s", SDATA (SYMBOL_NAME (prop
)));
2209 table
= Fcopy_sequence (table
);
2211 for (tail
= table
; ! NILP (tail
); tail
= Fcdr (tail
))
2213 prop
= Fcar (Fcar (tail
));
2214 val
= Fcdr (Fcar (tail
));
2215 CHECK_SYMBOL (prop
);
2217 if (numeric
> XINT (val
))
2218 error ("Numeric values not sorted for %s", SDATA (SYMBOL_NAME (prop
)));
2219 numeric
= XINT (val
);
2220 XSETCAR (tail
, Fcons (prop
, val
));
2222 ASET (font_style_table
, table_index
, table
);
2226 DEFUN ("font-make-gstring", Ffont_make_gstring
, Sfont_make_gstring
, 2, 2, 0,
2227 doc
: /* Return a newly created glyph-string for FONT-OBJECT with NUM glyphs.
2228 FONT-OBJECT may be nil if it is not yet known. */)
2230 Lisp_Object font_object
, num
;
2232 Lisp_Object gstring
, g
;
2236 if (! NILP (font_object
))
2237 CHECK_FONT_OBJECT (font_object
);
2240 len
= XINT (num
) + 1;
2241 gstring
= Fmake_vector (make_number (len
), Qnil
);
2242 g
= Fmake_vector (make_number (6), Qnil
);
2243 ASET (g
, 0, font_object
);
2244 ASET (gstring
, 0, g
);
2245 for (i
= 1; i
< len
; i
++)
2246 ASET (gstring
, i
, Fmake_vector (make_number (8), make_number (0)));
2250 DEFUN ("font-fill-gstring", Ffont_fill_gstring
, Sfont_fill_gstring
, 4, 5, 0,
2251 doc
: /* Fillin glyph-string GSTRING by characters for FONT-OBJECT.
2252 START and END specifies the region to extract characters.
2253 If optional 3rd argument OBJECT is non-nil, it is a buffer or a string from
2254 where to extract characters.
2255 FONT-OBJECT may be nil if GSTRING already already contains one. */)
2256 (gstring
, font_object
, start
, end
, object
)
2257 Lisp_Object gstring
, font_object
, start
, end
, object
;
2263 CHECK_VECTOR (gstring
);
2264 if (NILP (font_object
))
2265 font_object
= Faref (Faref (gstring
, make_number (0)), make_number (0));
2266 CHECK_FONT_GET_OBJECT (font_object
, font
);
2268 if (STRINGP (object
))
2270 const unsigned char *p
;
2272 CHECK_NATNUM (start
);
2274 if (XINT (start
) > XINT (end
)
2275 || XINT (end
) > ASIZE (object
)
2276 || XINT (end
) - XINT (start
) >= XINT (Flength (gstring
)))
2277 args_out_of_range (start
, end
);
2279 len
= XINT (end
) - XINT (start
);
2280 p
= SDATA (object
) + string_char_to_byte (object
, XINT (start
));
2281 for (i
= 0; i
< len
; i
++)
2283 Lisp_Object g
= LGSTRING_GLYPH (gstring
, i
);
2285 c
= STRING_CHAR_ADVANCE (p
);
2286 code
= font
->driver
->encode_char (font
, c
);
2287 if (code
> MOST_POSITIVE_FIXNUM
)
2288 error ("Glyph code 0x%X is too large", code
);
2289 ASET (g
, 0, make_number (i
));
2290 ASET (g
, 1, make_number (i
+ 1));
2291 LGLYPH_SET_CHAR (g
, make_number (c
));
2292 LGLYPH_SET_CODE (g
, make_number (code
));
2299 if (! NILP (object
))
2300 Fset_buffer (object
);
2301 validate_region (&start
, &end
);
2302 if (XINT (end
) - XINT (start
) > len
)
2303 args_out_of_range (start
, end
);
2304 len
= XINT (end
) - XINT (start
);
2306 pos_byte
= CHAR_TO_BYTE (pos
);
2307 for (i
= 0; i
< len
; i
++)
2309 Lisp_Object g
= LGSTRING_GLYPH (gstring
, i
);
2311 FETCH_CHAR_ADVANCE (c
, pos
, pos_byte
);
2312 code
= font
->driver
->encode_char (font
, c
);
2313 if (code
> MOST_POSITIVE_FIXNUM
)
2314 error ("Glyph code 0x%X is too large", code
);
2315 ASET (g
, 0, make_number (i
));
2316 ASET (g
, 1, make_number (i
+ 1));
2317 LGLYPH_SET_CHAR (g
, make_number (c
));
2318 LGLYPH_SET_CODE (g
, make_number (code
));
2327 DEFUN ("open-font", Fopen_font
, Sopen_font
, 1, 3, 0,
2328 doc
: /* Open FONT-ENTITY. */)
2329 (font_entity
, size
, frame
)
2330 Lisp_Object font_entity
;
2336 CHECK_FONT_ENTITY (font_entity
);
2338 size
= AREF (font_entity
, FONT_SIZE_INDEX
);
2339 CHECK_NUMBER (size
);
2341 frame
= selected_frame
;
2342 CHECK_LIVE_FRAME (frame
);
2344 isize
= XINT (size
);
2346 isize
= POINT_TO_PIXEL (- isize
, XFRAME (frame
)->resy
);
2348 return font_open_entity (XFRAME (frame
), font_entity
, isize
);
2351 DEFUN ("close-font", Fclose_font
, Sclose_font
, 1, 2, 0,
2352 doc
: /* Close FONT-OBJECT. */)
2353 (font_object
, frame
)
2354 Lisp_Object font_object
, frame
;
2356 CHECK_FONT_OBJECT (font_object
);
2358 frame
= selected_frame
;
2359 CHECK_LIVE_FRAME (frame
);
2360 font_close_object (XFRAME (frame
), font_object
);
2364 DEFUN ("query-font", Fquery_font
, Squery_font
, 1, 1, 0,
2365 doc
: /* Return information about FONT-OBJECT. */)
2367 Lisp_Object font_object
;
2372 CHECK_FONT_GET_OBJECT (font_object
, font
);
2374 val
= Fmake_vector (make_number (9), Qnil
);
2375 ASET (val
, 0, Ffont_xlfd_name (font_object
));
2376 if (font
->file_name
)
2377 ASET (val
, 1, make_unibyte_string (font
->file_name
,
2378 strlen (font
->file_name
)));
2379 ASET (val
, 2, make_number (font
->pixel_size
));
2380 ASET (val
, 3, make_number (font
->font
.size
));
2381 ASET (val
, 4, make_number (font
->ascent
));
2382 ASET (val
, 5, make_number (font
->descent
));
2383 ASET (val
, 6, make_number (font
->font
.space_width
));
2384 ASET (val
, 7, make_number (font
->font
.average_width
));
2385 if (font
->driver
->otf_capability
)
2386 ASET (val
, 8, font
->driver
->otf_capability (font
));
2390 DEFUN ("get-font-glyphs", Fget_font_glyphs
, Sget_font_glyphs
, 2, 2, 0,
2391 doc
: /* Return a vector of glyphs of FONT-OBJECT for drawing STRING.
2392 Each element is a vector [GLYPH-CODE LBEARING RBEARING WIDTH ASCENT DESCENT]. */)
2393 (font_object
, string
)
2394 Lisp_Object font_object
, string
;
2400 CHECK_FONT_GET_OBJECT (font_object
, font
);
2401 CHECK_STRING (string
);
2402 len
= SCHARS (string
);
2403 vec
= Fmake_vector (make_number (len
), Qnil
);
2404 for (i
= 0; i
< len
; i
++)
2406 Lisp_Object ch
= Faref (string
, make_number (i
));
2410 struct font_metrics metrics
;
2412 code
= font
->driver
->encode_char (font
, c
);
2413 if (code
== FONT_INVALID_CODE
)
2415 val
= Fmake_vector (make_number (6), Qnil
);
2416 if (code
<= MOST_POSITIVE_FIXNUM
)
2417 ASET (val
, 0, make_number (code
));
2419 ASET (val
, 0, Fcons (make_number (code
>> 16),
2420 make_number (code
& 0xFFFF)));
2421 font
->driver
->text_extents (font
, &code
, 1, &metrics
);
2422 ASET (val
, 1, make_number (metrics
.lbearing
));
2423 ASET (val
, 2, make_number (metrics
.rbearing
));
2424 ASET (val
, 3, make_number (metrics
.width
));
2425 ASET (val
, 4, make_number (metrics
.ascent
));
2426 ASET (val
, 5, make_number (metrics
.descent
));
2433 DEFUN ("draw-string", Fdraw_string
, Sdraw_string
, 2, 2, 0,
2434 doc
: /* Draw STRING by FONT-OBJECT on the top left corner of the current frame.
2435 The value is a number of glyphs drawn.
2436 Type C-l to recover what previously shown. */)
2437 (font_object
, string
)
2438 Lisp_Object font_object
, string
;
2440 Lisp_Object frame
= selected_frame
;
2441 FRAME_PTR f
= XFRAME (frame
);
2447 CHECK_FONT_GET_OBJECT (font_object
, font
);
2448 CHECK_STRING (string
);
2449 len
= SCHARS (string
);
2450 code
= alloca (sizeof (unsigned) * len
);
2451 for (i
= 0; i
< len
; i
++)
2453 Lisp_Object ch
= Faref (string
, make_number (i
));
2457 code
[i
] = font
->driver
->encode_char (font
, c
);
2458 if (code
[i
] == FONT_INVALID_CODE
)
2461 face
= FACE_FROM_ID (f
, DEFAULT_FACE_ID
);
2463 if (font
->driver
->prepare_face
)
2464 font
->driver
->prepare_face (f
, face
);
2465 width
= font
->driver
->text_extents (font
, code
, i
, NULL
);
2466 len
= font
->driver
->draw_text (f
, face
, 0, font
->ascent
, code
, i
, width
);
2467 if (font
->driver
->done_face
)
2468 font
->driver
->done_face (f
, face
);
2470 return make_number (len
);
2474 #endif /* FONT_DEBUG */
2477 extern void syms_of_ftfont
P_ (());
2478 extern void syms_of_xfont
P_ (());
2479 extern void syms_of_xftfont
P_ (());
2480 extern void syms_of_ftxfont
P_ (());
2481 extern void syms_of_bdffont
P_ (());
2482 extern void syms_of_w32font
P_ (());
2483 extern void syms_of_atmfont
P_ (());
2488 sort_shift_bits
[FONT_SLANT_INDEX
] = 0;
2489 sort_shift_bits
[FONT_WEIGHT_INDEX
] = 7;
2490 sort_shift_bits
[FONT_SIZE_INDEX
] = 14;
2491 sort_shift_bits
[FONT_WIDTH_INDEX
] = 21;
2492 sort_shift_bits
[FONT_ADSTYLE_INDEX
] = 28;
2493 sort_shift_bits
[FONT_FOUNDRY_INDEX
] = 29;
2494 sort_shift_bits
[FONT_FAMILY_INDEX
] = 30;
2495 sort_shift_bits
[FONT_REGISTRY_INDEX
] = 31;
2496 /* Note that sort_shift_bits[FONT_SLANT_TYPE] is never used. */
2498 staticpro (&font_style_table
);
2499 font_style_table
= Fmake_vector (make_number (3), Qnil
);
2501 staticpro (&font_family_alist
);
2502 font_family_alist
= Qnil
;
2504 DEFSYM (Qfontp
, "fontp");
2506 DEFSYM (QCotf
, ":otf");
2507 DEFSYM (QClanguage
, ":language");
2508 DEFSYM (QCscript
, ":script");
2510 DEFSYM (QCfoundry
, ":foundry");
2511 DEFSYM (QCadstyle
, ":adstyle");
2512 DEFSYM (QCregistry
, ":registry");
2513 DEFSYM (QCextra
, ":extra");
2515 staticpro (&null_string
);
2516 null_string
= build_string ("");
2517 staticpro (&null_vector
);
2518 null_vector
= Fmake_vector (make_number (0), Qnil
);
2520 staticpro (&scratch_font_spec
);
2521 scratch_font_spec
= Ffont_spec (0, NULL
);
2522 staticpro (&scratch_font_prefer
);
2523 scratch_font_prefer
= Ffont_spec (0, NULL
);
2526 defsubr (&Sfont_spec
);
2527 defsubr (&Sfont_get
);
2528 defsubr (&Sfont_put
);
2529 defsubr (&Slist_fonts
);
2530 defsubr (&Slist_families
);
2531 defsubr (&Sfind_font
);
2532 defsubr (&Sfont_xlfd_name
);
2533 defsubr (&Sclear_font_cache
);
2534 defsubr (&Sinternal_set_font_style_table
);
2535 defsubr (&Sfont_make_gstring
);
2536 defsubr (&Sfont_fill_gstring
);
2539 defsubr (&Sopen_font
);
2540 defsubr (&Sclose_font
);
2541 defsubr (&Squery_font
);
2542 defsubr (&Sget_font_glyphs
);
2544 defsubr (&Sdraw_string
);
2546 #endif /* FONT_DEBUG */
2548 #ifdef HAVE_FREETYPE
2550 #ifdef HAVE_X_WINDOWS
2555 #endif /* HAVE_XFT */
2556 #endif /* HAVE_X_WINDOWS */
2557 #else /* not HAVE_FREETYPE */
2558 #ifdef HAVE_X_WINDOWS
2560 #endif /* HAVE_X_WINDOWS */
2561 #endif /* not HAVE_FREETYPE */
2564 #endif /* HAVE_BDFFONT */
2567 #endif /* WINDOWSNT */