|
428
|
1 ;; font-menu.el --- Managing menus of fonts.
|
|
|
2
|
|
|
3 ;; Copyright (C) 1994 Free Software Foundation, Inc.
|
|
|
4 ;; Copyright (C) 1995 Tinker Systems and INS Engineering Corp.
|
|
|
5 ;; Copyright (C) 1997 Sun Microsystems
|
|
|
6
|
|
|
7 ;; Adapted from x-font-menu.el by Andy Piper <andy@xemacs.org>
|
|
|
8
|
|
|
9 ;; This file is part of XEmacs.
|
|
|
10
|
|
|
11 ;; XEmacs is free software; you can redistribute it and/or modify it
|
|
|
12 ;; under the terms of the GNU General Public License as published by
|
|
|
13 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
|
14 ;; any later version.
|
|
|
15
|
|
|
16 ;; XEmacs is distributed in the hope that it will be useful, but
|
|
|
17 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
19 ;; General Public License for more details.
|
|
|
20
|
|
|
21 ;; You should have received a copy of the GNU General Public License
|
|
444
|
22 ;; along with XEmacs; see the file COPYING. If not, write to the
|
|
428
|
23 ;; Free Software Foundation, 59 Temple Place - Suite 330,
|
|
|
24 ;; Boston, MA 02111-1307, USA.
|
|
|
25
|
|
|
26 ;; This file contains the device-nospecific font menu stuff
|
|
|
27
|
|
|
28 ;;; Commentary:
|
|
|
29 ;;;
|
|
|
30 ;;; Creates three menus, "Font", "Size", and "Weight", and puts them on the
|
|
|
31 ;;; "Options" menu. The contents of these menus are the superset of those
|
|
|
32 ;;; properties available on any fonts, but only the intersection of the three
|
|
|
33 ;;; sets is selectable at one time.
|
|
|
34 ;;;
|
|
|
35 ;;; Known Problems:
|
|
|
36 ;;; ===============
|
|
|
37 ;;; Items on the Font menu are selectable if and only if that font exists in
|
|
|
38 ;;; the same size and weight as the current font. This means that some fonts
|
|
|
39 ;;; are simply not reachable from some other fonts - if only one font comes
|
|
|
40 ;;; in only one point size (like "Nil", which comes only in 2), you will never
|
|
|
41 ;;; be able to select it. It would be better if the items on the Fonts menu
|
|
|
42 ;;; were always selectable, and selecting them would set the size to be the
|
|
|
43 ;;; closest size to the current font's size.
|
|
|
44 ;;;
|
|
440
|
45 ;;; This attempts to change all other faces in an analogous way to the change
|
|
428
|
46 ;;; that was made to the default face; if it can't, it will skip over the face.
|
|
|
47 ;;; However, this could leave incongruous font sizes around, which may cause
|
|
|
48 ;;; some nonreversibility problems if further changes are made. Perhaps it
|
|
|
49 ;;; should remember the initial fonts of all faces, and derive all subsequent
|
|
|
50 ;;; fonts from that initial state.
|
|
|
51 ;;;
|
|
|
52 ;;; xfontsel(1) is a lot more flexible (but probably harder to understand).
|
|
|
53 ;;;
|
|
|
54 ;;; The code to construct menus from all of the x11 fonts available from the
|
|
|
55 ;;; server is autoloaded and executed the very first time that one of the Font
|
|
|
56 ;;; menus is selected on each device. That is, if XEmacs has frames on two
|
|
|
57 ;;; different devices, then separate font menu information will be maintained
|
|
|
58 ;;; for each X display. If the font path changes after emacs has already
|
|
|
59 ;;; asked the X server on a particular display for its list of fonts, this
|
|
|
60 ;;; won't notice. Also, the first time that a font menu is posted on each
|
|
|
61 ;;; display will entail a lengthy delay, but that's better than slowing down
|
|
|
62 ;;; XEmacs startup. At any time (i.e.: after a font-path change or
|
|
|
63 ;;; immediately after device creation), you can call
|
|
|
64 ;;; `reset-device-font-menus' to rebuild the menus from all currently
|
|
|
65 ;;; available fonts.
|
|
|
66 ;;;
|
|
|
67 ;;; There are at least three kinds of fonts under X11r5:
|
|
|
68 ;;;
|
|
|
69 ;;; - bitmap fonts, which can be assumed to look as good as possible;
|
|
|
70 ;;; - bitmap fonts which have been (or can be) automatically scaled to
|
|
|
71 ;;; a new size, and which almost always look awful;
|
|
|
72 ;;; - and true outline fonts, which should look ok at any size, but in
|
|
|
73 ;;; practice (on at least some systems) look awful at any size, and
|
|
|
74 ;;; even in theory are unlikely ever to look as good as non-scaled
|
|
|
75 ;;; bitmap fonts.
|
|
|
76 ;;;
|
|
|
77 ;;; It would be nice to get this code to look for non-scaled bitmap fonts
|
|
|
78 ;;; first, then outline fonts, then scaled bitmap fonts as a last resort.
|
|
|
79 ;;; But it's not clear to me how to tell them apart based on their truenames
|
|
|
80 ;;; and/or the result of XListFonts(). I welcome any and all explanations
|
|
|
81 ;;; of the subtleties involved...
|
|
|
82 ;;;
|
|
|
83 ;;;
|
|
|
84 ;;; If You Think You'Re Seeing A Bug:
|
|
|
85 ;;; =================================
|
|
|
86 ;;; When reporting problems, send the following information:
|
|
|
87 ;;;
|
|
|
88 ;;; - Exactly what behavior you're seeing;
|
|
|
89 ;;; - The output of the `xlsfonts' program;
|
|
|
90 ;;; - The value of the variable `device-fonts-cache';
|
|
|
91 ;;; - The values of the following expressions, both before and after
|
|
|
92 ;;; making a selection from any of the fonts-related menus:
|
|
|
93 ;;; (face-font 'default)
|
|
|
94 ;;; (font-truename (face-font 'default))
|
|
|
95 ;;; (font-properties (face-font 'default))
|
|
|
96 ;;; - The values of the following variables after making a selection:
|
|
|
97 ;;; font-menu-preferred-resolution
|
|
|
98 ;;; font-menu-registry-encoding
|
|
|
99 ;;;
|
|
|
100 ;;; There is a common misconception that "*-courier-medium-r-*-11-*", also
|
|
|
101 ;;; known as "-adobe-courier-medium-r-normal--11-80-100-100-m-60-iso8859-1",
|
|
|
102 ;;; is an 11-point font. It is not -- it is an 11-pixel font at 100dpi,
|
|
|
103 ;;; which is an 8-point font (the number after -11- is the size in tenths
|
|
|
104 ;;; of points). So if you expect to be seeing an "11" entry in the "Size"
|
|
|
105 ;;; menu and are not, this may be why.
|
|
|
106 ;;;
|
|
|
107 ;;; In the real world (aka Solaris), one has to deal with fonts that
|
|
|
108 ;;; appear to be medium-i but are really light-r, and fonts that
|
|
|
109 ;;; resolve to different resolutions depending on the charset:
|
|
|
110 ;;;
|
|
|
111 ;;; (font-instance-truename
|
|
|
112 ;;; (make-font-instance "-*-mincho-medium-i-normal-*-*-*-*-*-*-*-jisx0201*-*"))
|
|
|
113 ;;; ==>
|
|
|
114 ;;; "-morisawa-ryumin light kl-light-r-normal--10-100-72-72-m-50-jisx0201.1976-0"
|
|
|
115 ;;;
|
|
2527
|
116 ;;; (font-list "-dt-interface user-medium-r-normal-s*-*-*-*-*-*-*-*-*")
|
|
428
|
117 ;;; ==>
|
|
|
118 ;;; ("-dt-interface user-medium-r-normal-s sans-12-120-72-72-m-70-iso8859-1"
|
|
|
119 ;;; "-dt-interface user-medium-r-normal-s-14-120-75-75-m-120-jisx0208.1983-0"
|
|
|
120 ;;; "-dt-interface user-medium-r-normal-s-14-120-75-75-m-60-jisx0201.1976-0")
|
|
|
121
|
|
|
122 ;;;###autoload
|
|
|
123 (defcustom font-menu-ignore-scaled-fonts nil
|
|
2297
|
124 "*If non-nil, the font menu shows only bitmap fonts.
|
|
|
125
|
|
|
126 Bitmap fonts at their design size are generally noticably higher quality than
|
|
|
127 scaled fonts, unless the device is capable of interpreting antialiasing hints.
|
|
|
128 In general, setting this option non-`nil' is useful mostly on older X servers.
|
|
|
129
|
|
|
130 Not all devices make the distinction between bitmap and scaled fonts."
|
|
428
|
131 :type 'boolean
|
|
|
132 :group 'font-menu)
|
|
|
133
|
|
|
134 ;;;###autoload
|
|
|
135 (defcustom font-menu-this-frame-only-p nil
|
|
2297
|
136 "*If non-nil, the menu affects the default font only on the selected frame."
|
|
428
|
137 :type 'boolean
|
|
|
138 :group 'font-menu)
|
|
|
139
|
|
1701
|
140 (defcustom font-menu-max-number nil
|
|
2297
|
141 "The maximum number of fonts retrieved from the display."
|
|
1701
|
142 :type 'integer
|
|
|
143 :group 'font-menu)
|
|
|
144
|
|
771
|
145 (defvaralias 'font-menu-max-items 'menu-max-items)
|
|
|
146 (defvaralias 'font-menu-submenu-name-format 'menu-submenu-name-format)
|
|
428
|
147
|
|
2297
|
148 ;; #### Need to update for fontconfig/Xft? Document form for MS Windows.
|
|
444
|
149 (defvar font-menu-preferred-resolution
|
|
428
|
150 (make-specifier-and-init 'generic '((global ((mswindows) . ":")
|
|
1102
|
151 ((gtk) . "*-*")
|
|
428
|
152 ((x) . "*-*"))) t)
|
|
2297
|
153 "Generic specifier containing preferred resolution as a string.
|
|
|
154 Do not `setq' this variable; use `set-specifier'.
|
|
|
155
|
|
|
156 For X11 and GTK devices, the instance value will be interpolated into an
|
|
|
157 XLFD, and looks like \"75-75\").")
|
|
428
|
158
|
|
|
159 (defvar font-menu-size-scaling
|
|
|
160 (make-specifier-and-init 'integer '((global ((mswindows) . 1)
|
|
1102
|
161 ((gtk) . 10)
|
|
428
|
162 ((x) . 10))) t)
|
|
2297
|
163 "Generic specifier containing scale factor for font sizes. Don't touch.
|
|
|
164
|
|
|
165 This is really a device type constant. Some devices specify size in points
|
|
|
166 \(MS Windows), others in decipoints (X11).")
|
|
428
|
167
|
|
2297
|
168 (defvar device-fonts-cache nil
|
|
|
169 "Alist mapping devices to font lists and font menus. Don't use this.
|
|
|
170
|
|
|
171 Instead, use the function `device-fonts-cache' which lazily updates this
|
|
|
172 variable, and returns the value for the selected device.
|
|
|
173
|
|
|
174 Each element has the form (DEVICE . [FONT-LIST FAMILY SIZE WEIGHT]) where
|
|
|
175 FAMILY, SIZE, and WEIGHT denote menus.")
|
|
428
|
176
|
|
|
177 (defsubst device-fonts-cache ()
|
|
|
178 (or (cdr (assq (selected-device) device-fonts-cache))
|
|
|
179 (and (reset-device-font-menus (selected-device))
|
|
|
180 (cdr (assq (selected-device) device-fonts-cache)))))
|
|
|
181
|
|
|
182 ;;;###autoload
|
|
|
183 (fset 'install-font-menus 'reset-device-font-menus)
|
|
|
184 (make-obsolete 'install-font-menus 'reset-device-font-menus)
|
|
|
185
|
|
|
186 ;;;###autoload
|
|
|
187 (defun reset-device-font-menus (&optional device debug)
|
|
|
188 "Generates the `Font', `Size', and `Weight' submenus for the Options menu.
|
|
|
189 This is run the first time that a font-menu is needed for each device.
|
|
2297
|
190
|
|
428
|
191 If you don't like the lazy invocation of this function, you can add it to
|
|
|
192 `create-device-hook' and that will make the font menus respond more quickly
|
|
444
|
193 when they are selected for the first time. If you add fonts to your system,
|
|
428
|
194 or if you change your font path, you can call this to re-initialize the menus."
|
|
|
195 (if (or noninteractive
|
|
|
196 (not (or device (setq device (selected-device)))))
|
|
|
197 nil
|
|
2297
|
198 (message "Getting list of fonts from server... ")
|
|
428
|
199 (call-device-method 'reset-device-font-menus device device debug)
|
|
|
200 (message "Getting list of fonts from server... done.")))
|
|
|
201
|
|
|
202 ;;;###autoload
|
|
|
203 (defun font-menu-family-constructor (ignored)
|
|
|
204 (catch 'menu
|
|
|
205 (unless (console-on-window-system-p)
|
|
|
206 (throw 'menu '(["Cannot parse current font" ding nil])))
|
|
|
207 (let* ((dcache (device-fonts-cache))
|
|
|
208 (font-data (font-menu-font-data 'default dcache))
|
|
|
209 (entry (aref font-data 0))
|
|
|
210 (family (aref font-data 1))
|
|
|
211 (size (aref font-data 2))
|
|
|
212 (weight (aref font-data 3))
|
|
|
213 f)
|
|
|
214 (unless family
|
|
|
215 (throw 'menu '(["Cannot parse current font" ding nil])))
|
|
|
216 ;; Items on the Font menu are enabled iff that font exists in
|
|
|
217 ;; the same size and weight as the current font (scalable fonts
|
|
|
218 ;; exist in every size). Only the current font is marked as
|
|
|
219 ;; selected.
|
|
771
|
220 (menu-split-long-menu
|
|
428
|
221 (mapcar
|
|
|
222 (lambda (item)
|
|
442
|
223 (setq f (menu-item-strip-accelerator-spec (aref item 0))
|
|
428
|
224 entry (vassoc f (aref dcache 0)))
|
|
|
225 (if (and (or (member weight (aref entry 1))
|
|
|
226 ;; mswindows often allows any weight
|
|
|
227 (member "" (aref entry 1)))
|
|
|
228 (or (member size (aref entry 2))
|
|
|
229 (and (not font-menu-ignore-scaled-fonts)
|
|
|
230 (member 0 (aref entry 2)))))
|
|
|
231 (enable-menu-item item)
|
|
|
232 (disable-menu-item item))
|
|
|
233 (if (string-equal family f)
|
|
|
234 (select-toggle-menu-item item)
|
|
|
235 (deselect-toggle-menu-item item))
|
|
|
236 item)
|
|
|
237 (aref dcache 1))))))
|
|
|
238
|
|
|
239 (define-device-method* font-menu-font-data)
|
|
|
240
|
|
|
241 ;;;###autoload
|
|
|
242 (defun font-menu-size-constructor (ignored)
|
|
|
243 (catch 'menu
|
|
|
244 (unless (console-on-window-system-p)
|
|
|
245 (throw 'menu '(["Cannot parse current font" ding nil])))
|
|
|
246 (let* ((dcache (device-fonts-cache))
|
|
|
247 (font-data (font-menu-font-data 'default dcache))
|
|
|
248 (entry (aref font-data 0))
|
|
|
249 (family (aref font-data 1))
|
|
|
250 (size (aref font-data 2))
|
|
|
251 ;;(weight (aref font-data 3))
|
|
|
252 s)
|
|
|
253 (unless family
|
|
|
254 (throw 'menu '(["Cannot parse current font" ding nil])))
|
|
|
255 ;; Items on the Size menu are enabled iff current font has
|
|
|
256 ;; that size. Only the size of the current font is selected.
|
|
|
257 ;; (If the current font comes in size 0, it is scalable, and
|
|
|
258 ;; thus has every size.)
|
|
|
259 (mapcar
|
|
|
260 (lambda (item)
|
|
|
261 (setq s (nth 3 (aref item 1)))
|
|
|
262 (if (or (member s (aref entry 2))
|
|
|
263 (and (not font-menu-ignore-scaled-fonts)
|
|
|
264 (member 0 (aref entry 2))))
|
|
|
265 (enable-menu-item item)
|
|
|
266 (disable-menu-item item))
|
|
3094
|
267 ;; #### God save the Queen!
|
|
|
268 ;; well, if this fails because s or size is non-numeric, fuck 'em
|
|
|
269 (if (= size (if (featurep 'xft-fonts) (float s) s))
|
|
428
|
270 (select-toggle-menu-item item)
|
|
|
271 (deselect-toggle-menu-item item))
|
|
|
272 item)
|
|
442
|
273 (submenu-generate-accelerator-spec (aref dcache 2))))))
|
|
428
|
274
|
|
|
275 ;;;###autoload
|
|
|
276 (defun font-menu-weight-constructor (ignored)
|
|
|
277 (catch 'menu
|
|
|
278 (unless (console-on-window-system-p)
|
|
|
279 (throw 'menu '(["Cannot parse current font" ding nil])))
|
|
|
280 (let* ((dcache (device-fonts-cache))
|
|
|
281 (font-data (font-menu-font-data 'default dcache))
|
|
|
282 (entry (aref font-data 0))
|
|
|
283 (family (aref font-data 1))
|
|
|
284 ;;(size (aref font-data 2))
|
|
|
285 (weight (aref font-data 3))
|
|
|
286 w)
|
|
|
287 (unless family
|
|
|
288 (throw 'menu '(["Cannot parse current font" ding nil])))
|
|
|
289 ;; Items on the Weight menu are enabled iff current font
|
|
|
290 ;; has that weight. Only the weight of the current font
|
|
|
291 ;; is selected.
|
|
|
292 (mapcar
|
|
|
293 (lambda (item)
|
|
|
294 (setq w (aref item 0))
|
|
|
295 (if (member w (aref entry 1))
|
|
|
296 (enable-menu-item item)
|
|
|
297 (disable-menu-item item))
|
|
|
298 (if (string-equal weight w)
|
|
|
299 (select-toggle-menu-item item)
|
|
|
300 (deselect-toggle-menu-item item))
|
|
|
301 item)
|
|
442
|
302 (submenu-generate-accelerator-spec (aref dcache 3))))))
|
|
428
|
303
|
|
|
304
|
|
|
305 ;;; Changing font sizes
|
|
|
306
|
|
|
307 (defun font-menu-set-font (family weight size)
|
|
|
308 ;; This is what gets run when an item is selected from any of the three
|
|
|
309 ;; fonts menus. It needs to be rather clever.
|
|
|
310 ;; (size is measured in 10ths of points.)
|
|
|
311 (let* ((dcache (device-fonts-cache))
|
|
|
312 (font-data (font-menu-font-data 'default dcache))
|
|
|
313 (from-family (aref font-data 1))
|
|
|
314 (from-size (aref font-data 2))
|
|
1102
|
315 (from-weight (aref font-data 3))
|
|
428
|
316 (from-slant (aref font-data 4))
|
|
442
|
317 (face-list-to-change (delq 'default (face-list)))
|
|
|
318 new-default-face-font)
|
|
428
|
319 (unless from-family
|
|
|
320 (signal 'error '("couldn't parse font name for default face")))
|
|
|
321 (when weight
|
|
|
322 (signal 'error '("Setting weight currently not supported")))
|
|
|
323 (setq new-default-face-font
|
|
872
|
324 (font-instance-name
|
|
|
325 (font-menu-load-font
|
|
|
326 (or family from-family)
|
|
|
327 (or weight from-weight)
|
|
|
328 (or size from-size)
|
|
|
329 from-slant
|
|
|
330 (specifier-instance
|
|
|
331 font-menu-preferred-resolution (selected-device)))))
|
|
|
332 ;; #### This is such a gross hack. The border-glyph face under
|
|
428
|
333 ;; mswindows is in a symbol font. Thus it will not appear in the
|
|
|
334 ;; cache - being a junk family. What we should do is change the
|
|
|
335 ;; size but not the family, but this is more work than I care to
|
|
|
336 ;; invest at the moment.
|
|
|
337 (when (eq (device-type) 'mswindows)
|
|
|
338 (setq face-list-to-change
|
|
|
339 (delq 'border-glyph face-list-to-change)))
|
|
|
340 (dolist (face face-list-to-change)
|
|
|
341 (when (face-font-instance face)
|
|
|
342 (message "Changing font of `%s'..." face)
|
|
|
343 (condition-case c
|
|
|
344 (font-menu-change-face face
|
|
|
345 from-family from-weight from-size
|
|
1102
|
346 (or family from-family)
|
|
|
347 (or weight from-weight)
|
|
|
348 (or size from-size))
|
|
428
|
349 (error
|
|
3094
|
350 (message "Error updating font of `%s'" face)
|
|
428
|
351 (display-error c nil)
|
|
|
352 (sit-for 1)))))
|
|
|
353 ;; Set the default face's font after hacking the other faces, so that
|
|
|
354 ;; the frame size doesn't change until we are all done.
|
|
|
355
|
|
|
356 ;; If we need to be frame local we do the changes ourselves.
|
|
|
357 (if font-menu-this-frame-only-p
|
|
|
358 ;;; WMP - we need to honor font-menu-this-frame-only-p here!
|
|
|
359 (set-face-font 'default new-default-face-font
|
|
|
360 (and font-menu-this-frame-only-p (selected-frame)))
|
|
|
361 ;; OK Let Customize do it.
|
|
3094
|
362 (let ((fsize (if (featurep 'xft-fonts)
|
|
|
363 (int-to-string (or size from-size))
|
|
|
364 (concat (int-to-string
|
|
|
365 (/ (or size from-size)
|
|
|
366 (specifier-instance font-menu-size-scaling
|
|
|
367 (selected-device))))
|
|
3918
|
368 "pt")))
|
|
|
369 new-spec-list)
|
|
|
370 ;; If the font was initialised from X resources (the tag-set
|
|
|
371 ;; contains 'x-resource) pretend to Custom that it has
|
|
|
372 ;; responsibility for those settings.
|
|
|
373 (map-specifier (face-font 'default)
|
|
|
374 (lambda (spec locale inst-list arg)
|
|
|
375 (loop
|
|
|
376 for (tag-set . inst)
|
|
|
377 in inst-list
|
|
|
378 do (setq tag-set (delq 'x-resource tag-set)
|
|
|
379 tag-set (delq 'custom tag-set)
|
|
|
380 tag-set (cons 'custom tag-set))
|
|
|
381 (push (cons tag-set inst) new-spec-list)
|
|
|
382 ;; Need to return nil, else map-specifier stops
|
|
|
383 finally return nil))
|
|
|
384 nil nil '(x-resource))
|
|
|
385 (remove-specifier (face-font 'default) nil '(x-resource))
|
|
|
386 (when new-spec-list
|
|
|
387 (add-spec-list-to-specifier (face-font 'default)
|
|
|
388 (list (cons 'global new-spec-list))))
|
|
3094
|
389 (custom-set-face-update-spec 'default
|
|
|
390 (list (list 'type (device-type)))
|
|
|
391 (list :family (or family from-family)
|
|
|
392 :size fsize))))
|
|
|
393 (message "Font %s" (face-font-name 'default))))
|
|
428
|
394
|
|
2297
|
395 ;; #### This should be called `font-menu-maybe-change-face'
|
|
|
396 ;; I wonder if a better API wouldn't (face attribute from to)
|
|
428
|
397 (defun font-menu-change-face (face
|
|
|
398 from-family from-weight from-size
|
|
|
399 to-family to-weight to-size)
|
|
2297
|
400 "Maybe update the font of FACE per TO-FAMILY, TO-WEIGHT, and TO-SIZE."
|
|
446
|
401 (check-type face symbol)
|
|
428
|
402 (let* ((dcache (device-fonts-cache))
|
|
|
403 (font-data (font-menu-font-data face dcache))
|
|
|
404 (face-family (aref font-data 1))
|
|
|
405 (face-size (aref font-data 2))
|
|
|
406 (face-weight (aref font-data 3))
|
|
|
407 (face-slant (aref font-data 4)))
|
|
|
408
|
|
2297
|
409 (or face-family
|
|
|
410 (signal 'error (list "couldn't parse font name for face" face)))
|
|
428
|
411
|
|
|
412 ;; If this face matches the old default face in the attribute we
|
|
|
413 ;; are changing, then change it to the new attribute along that
|
|
|
414 ;; dimension. Also, the face must have its own global attribute.
|
|
|
415 ;; If its value is inherited, we don't touch it. If any of this
|
|
|
416 ;; is not true, we leave it alone.
|
|
|
417 (when (and (face-font face 'global)
|
|
444
|
418 (cond
|
|
428
|
419 (to-family (string-equal face-family from-family))
|
|
|
420 (to-weight (string-equal face-weight from-weight))
|
|
|
421 (to-size (= face-size from-size))))
|
|
|
422 (set-face-font face
|
|
872
|
423 (font-instance-name
|
|
|
424 (font-menu-load-font (or to-family face-family)
|
|
|
425 (or to-weight face-weight)
|
|
|
426 (or to-size face-size)
|
|
|
427 face-slant
|
|
|
428 (specifier-instance
|
|
|
429 font-menu-preferred-resolution
|
|
|
430 (selected-device))))
|
|
428
|
431 (and font-menu-this-frame-only-p
|
|
|
432 (selected-frame))))))
|
|
|
433
|
|
|
434 (define-device-method font-menu-load-font)
|
|
|
435
|
|
|
436 (defun flush-device-fonts-cache (device)
|
|
|
437 ;; by Stig@hackvan.com
|
|
|
438 (let ((elt (assq device device-fonts-cache)))
|
|
|
439 (and elt
|
|
|
440 (setq device-fonts-cache (delq elt device-fonts-cache)))))
|
|
|
441
|
|
|
442 (add-hook 'delete-device-hook 'flush-device-fonts-cache)
|
|
|
443
|
|
|
444 (provide 'font-menu)
|
|
|
445
|
|
|
446 ;; font-menu ends here
|
