|
0
|
1 @c -*-texinfo-*-
|
|
|
2 @c This is part of the XEmacs Lisp Reference Manual.
|
|
|
3 @c Copyright (C) 1995 Ben Wing.
|
|
|
4 @c See the file lispref.texi for copying conditions.
|
|
|
5 @setfilename ../../info/faces.info
|
|
|
6 @node Faces and Window-System Objects, Glyphs, Specifiers, top
|
|
|
7 @chapter Faces and Window-System Objects
|
|
|
8 @cindex faces
|
|
|
9 @cindex window-system objects
|
|
|
10
|
|
|
11 @menu
|
|
|
12 * Faces:: Controlling the way text looks.
|
|
|
13 * Fonts:: Controlling the typeface of text.
|
|
|
14 * Colors:: Controlling the color of text and pixmaps.
|
|
|
15 @end menu
|
|
|
16
|
|
|
17 @node Faces
|
|
|
18 @section Faces
|
|
|
19
|
|
|
20 A @dfn{face} is a named collection of graphical properties: font,
|
|
|
21 foreground color, background color, background pixmap, optional
|
|
|
22 underlining, and (on TTY devices) whether the text is to be highlighted,
|
|
|
23 dimmed, blinking, or displayed in reverse video. Faces control the
|
|
|
24 display of text on the screen. Every face has a name, which is a symbol
|
|
|
25 such as @code{default} or @code{modeline}.
|
|
|
26
|
|
|
27 Each built-in property of a face is controlled using a specifier,
|
|
|
28 which allows it to have separate values in particular buffers, frames,
|
|
|
29 windows, and devices and to further vary according to device type
|
|
|
30 (X or TTY) and device class (color, mono, or grayscale).
|
|
|
31 @xref{Specifiers} for more information.
|
|
|
32
|
|
|
33 The face named @code{default} is used for ordinary text. The face named
|
|
|
34 @code{modeline} is used for displaying the modeline. The face named
|
|
|
35 @code{highlight} is used for highlighted extents (@pxref{Extents}). The
|
|
|
36 faces named @code{left-margin} and @code{right-margin} are used for the
|
|
|
37 left and right margin areas, respectively (@pxref{Annotations}). The
|
|
|
38 face named @code{zmacs-region} is used for the highlighted region
|
|
|
39 between point and mark.
|
|
|
40
|
|
|
41
|
|
|
42 @menu
|
|
|
43 * Merging Faces:: How XEmacs decides which face to use
|
|
|
44 for a character.
|
|
|
45 * Basic Face Functions:: How to define and examine faces.
|
|
|
46 * Face Properties:: How to access and modify a face's properties.
|
|
|
47 * Face Convenience Functions:: Convenience functions for accessing
|
|
|
48 particular properties of a face.
|
|
|
49 * Other Face Display Functions:: Other functions pertaining to how a
|
|
|
50 a face appears.
|
|
|
51 @end menu
|
|
|
52
|
|
|
53 @node Merging Faces
|
|
|
54 @subsection Merging Faces for Display
|
|
|
55
|
|
|
56 Here are all the ways to specify which face to use for display of text:
|
|
|
57
|
|
|
58 @itemize @bullet
|
|
|
59 @item
|
|
|
60 With defaults. Each frame has a @dfn{default face}, which is used for
|
|
|
61 all text that doesn't somehow specify another face. The face named
|
|
|
62 @code{default} applies to the text area, while the faces
|
|
|
63 @code{left-margin} and @code{right-margin} apply to the left and right
|
|
|
64 margin areas.
|
|
|
65
|
|
|
66 @item
|
|
|
67 With text properties. A character may have a @code{face} property; if so,
|
|
|
68 it's displayed with that face. (Text properties are actually implemented
|
|
|
69 in terms of extents.) @xref{Text Properties}.
|
|
|
70
|
|
|
71 @item
|
|
|
72 With extents. An extent may have a @code{face} property, which applies
|
|
|
73 to all the text covered by the extent; in addition, if the
|
|
|
74 @code{highlight} property is set, the @code{highlight} property applies
|
|
|
75 when the mouse moves over the extent or if the extent is explicitly
|
|
|
76 highlighted. @xref{Extents}.
|
|
|
77
|
|
|
78 @item
|
|
|
79 With annotations. Annotations that are inserted into a buffer can specify
|
|
|
80 their own face. (Annotations are actually implemented in terms of extents.)
|
|
|
81 @xref{Annotations}.
|
|
|
82 @end itemize
|
|
|
83
|
|
|
84 If these various sources together specify more than one face for a
|
|
|
85 particular character, XEmacs merges the properties of the various faces
|
|
|
86 specified. Extents, text properties, and annotations all use the same
|
|
|
87 underlying representation (as extents). When multiple extents cover one
|
|
|
88 character, an extent with higher priority overrides those with lower
|
|
|
89 priority. @xref{Extents}. If no extent covers a particular character,
|
|
|
90 the @code{default} face is used.
|
|
|
91
|
|
|
92 @cindex background pixmap
|
|
|
93 If a background pixmap is specified, it determines what will be
|
|
|
94 displayed in the background of text characters. If the background
|
|
|
95 pixmap is actually a pixmap, with its colors specified, those colors are
|
|
|
96 used; if it is a bitmap, the face's foreground and background colors are
|
|
|
97 used to color it.
|
|
|
98
|
|
|
99 @node Basic Face Functions
|
|
|
100 @subsection Basic Functions for Working with Faces
|
|
|
101
|
|
|
102 The properties a face can specify include the font, the foreground
|
|
|
103 color, the background color, the background pixmap, the underlining,
|
|
|
104 the display table, and (for TTY devices) whether the text is to be
|
|
|
105 highlighted, dimmed, blinking, or displayed in reverse video.
|
|
|
106 The face can also leave these unspecified, causing them to assume the
|
|
|
107 value of the corresponding property of the @code{default} face.
|
|
|
108
|
|
|
109 Here are the basic primitives for working with faces.
|
|
|
110
|
|
|
111 @defun make-face name &optional doc-string temporary
|
|
|
112 This function defines and returns a new face named @var{name}, initially
|
|
|
113 with all properties unspecified. It does nothing if there is already a
|
|
|
114 face named @var{name}. Optional argument @var{doc-string} specifies
|
|
|
115 an explanatory string used for descriptive purposes. If optional
|
|
|
116 argument @var{temporary} is non-@code{nil}, the face will automatically
|
|
|
117 disappear when there are no more references to it anywhere in text or
|
|
|
118 Lisp code (otherwise, the face will continue to exist indefinitely
|
|
|
119 even if it is not used).
|
|
|
120 @end defun
|
|
|
121
|
|
|
122 @defun face-list &optional temporary
|
|
|
123 This function returns a list of the names of all defined faces. If
|
|
|
124 @var{temporary} is @code{nil}, only the permanent faces are included.
|
|
|
125 If it is @code{t}, only the temporary faces are included. If it is any
|
|
|
126 other non-@code{nil} value both permanent and temporary are included.
|
|
|
127 @end defun
|
|
|
128
|
|
|
129 @defun facep object
|
|
|
130 This function returns whether the given object is a face.
|
|
|
131 @end defun
|
|
|
132
|
|
|
133 @defun copy-face old-face new-name &optional locale how-to-add
|
|
|
134 This function defines a new face named @var{new-name} which is a copy of
|
|
|
135 the existing face named @var{old-face}. If there is already a face
|
|
|
136 named @var{new-name}, then it alters the face to have the same
|
|
|
137 properties as @var{old-face}. @var{locale} and @var{how-to-add}
|
|
|
138 let you copy just parts of the old face rather than the whole face,
|
|
|
139 and are as in @code{copy-specifier} (@pxref{Specifiers}).
|
|
|
140 @end defun
|
|
|
141
|
|
|
142 @node Face Properties
|
|
|
143 @subsection Face Properties
|
|
|
144
|
|
|
145 You can examine and modify the properties of an existing face with the
|
|
|
146 following functions.
|
|
|
147
|
|
|
148 The following symbols have predefined meanings:
|
|
|
149
|
|
|
150 @table @code
|
|
|
151 @item foreground
|
|
|
152 The foreground color of the face.
|
|
|
153
|
|
|
154 @item background
|
|
|
155 The background color of the face.
|
|
|
156
|
|
|
157 @item font
|
|
|
158 The font used to display text covered by this face.
|
|
|
159
|
|
|
160 @item display-table
|
|
|
161 The display table of the face.
|
|
|
162
|
|
|
163 @item background-pixmap
|
|
|
164 The pixmap displayed in the background of the face. Only used by faces
|
|
|
165 on X devices.
|
|
|
166
|
|
|
167 @item underline
|
|
|
168 Underline all text covered by this face.
|
|
|
169
|
|
|
170 @item highlight
|
|
|
171 Highlight all text covered by this face. Only used by faces on TTY
|
|
|
172 devices.
|
|
|
173
|
|
|
174 @item dim
|
|
|
175 Dim all text covered by this face. Only used by faces on TTY devices.
|
|
|
176
|
|
|
177 @item blinking
|
|
|
178 Blink all text covered by this face. Only used by faces on TTY devices.
|
|
|
179
|
|
|
180 @item reverse
|
|
|
181 Reverse the foreground and background colors. Only used by faces on TTY
|
|
|
182 devices.
|
|
|
183
|
|
|
184 @item doc-string
|
|
|
185 Description of what the face's normal use is. NOTE: This is not a
|
|
|
186 specifier, unlike all the other built-in properties, and cannot contain
|
|
|
187 locale-specific values.
|
|
|
188 @end table
|
|
|
189
|
|
|
190 @defun set-face-property face property value &optional locale tag how-to-add
|
|
|
191 This function changes a property of a @var{face}.
|
|
|
192
|
|
|
193 For built-in properties, the actual value of the property is a specifier
|
|
|
194 and you cannot change this; but you can change the specifications within
|
|
|
195 the specifier, and that is what this function will do. For user-defined
|
|
|
196 properties, you can use this function to either change the actual value
|
|
|
197 of the property or, if this value is a specifier, change the
|
|
|
198 specifications within it.
|
|
|
199
|
|
|
200 If @var{property} is a built-in property, the specifications to be added
|
|
|
201 to this property can be supplied in many different ways:
|
|
|
202
|
|
|
203 @itemize @bullet
|
|
|
204 If @var{value} is a simple instantiator (e.g. a string naming a font or
|
|
|
205 color) or a list of instantiators, then the instantiator(s) will be
|
|
|
206 added as a specification of the property for the given @var{locale}
|
|
|
207 (which defaults to @code{global} if omitted).
|
|
|
208
|
|
|
209 If @var{value} is a list of specifications (each of which is a cons of a
|
|
|
210 locale and a list of instantiators), then @var{locale} must be
|
|
|
211 @code{nil} (it does not make sense to explicitly specify a locale in
|
|
|
212 this case), and specifications will be added as given.
|
|
|
213
|
|
|
214 If @var{value} is a specifier (as would be returned by
|
|
|
215 @code{face-property} if no @var{locale} argument is given), then some or
|
|
|
216 all of the specifications in the specifier will be added to the
|
|
|
217 property. In this case, the function is really equivalent to
|
|
|
218 @code{copy-specifier} and @var{locale} has the same semantics (if it is
|
|
|
219 a particular locale, the specification for the locale will be copied; if
|
|
|
220 a locale type, specifications for all locales of that type will be
|
|
|
221 copied; if @code{nil} or @code{all}, then all specifications will be
|
|
|
222 copied).
|
|
|
223 @end itemize
|
|
|
224
|
|
|
225 @var{how-to-add} should be either @code{nil} or one of the symbols
|
|
|
226 @code{prepend}, @code{append}, @code{remove-tag-set-prepend},
|
|
|
227 @code{remove-tag-set-append}, @code{remove-locale},
|
|
|
228 @code{remove-locale-type}, or @code{remove-all}. See
|
|
|
229 @code{copy-specifier} and @code{add-spec-to-specifier} for a description
|
|
|
230 of what each of these means. Most of the time, you do not need to worry
|
|
|
231 about this argument; the default behavior usually is fine.
|
|
|
232
|
|
|
233 In general, it is OK to pass an instance object (e.g. as returned by
|
|
|
234 @code{face-property-instance}) as an instantiator in place of an actual
|
|
|
235 instantiator. In such a case, the instantiator used to create that
|
|
|
236 instance object will be used (for example, if you set a font-instance
|
|
|
237 object as the value of the @code{font} property, then the font name used
|
|
|
238 to create that object will be used instead). If some cases, however,
|
|
|
239 doing this conversion does not make sense, and this will be noted in the
|
|
|
240 documentation for particular types of instance objects.
|
|
|
241
|
|
|
242 If @var{property} is not a built-in property, then this function will
|
|
|
243 simply set its value if @var{locale} is @code{nil}. However, if
|
|
|
244 @var{locale} is given, then this function will attempt to add
|
|
|
245 @var{value} as the instantiator for the given @var{locale}, using
|
|
|
246 @code{add-spec-to-specifier}. If the value of the property is not a
|
|
|
247 specifier, it will automatically be converted into a @code{generic}
|
|
|
248 specifier.
|
|
|
249 @end defun
|
|
|
250
|
|
|
251 @defun face-property face property &optional locale
|
|
|
252 This function returns @var{face}'s value of the given @var{property}.
|
|
|
253
|
|
|
254 If @var{locale} is omitted, the @var{face}'s actual value for
|
|
|
255 @var{property} will be returned. For built-in properties, this will be
|
|
|
256 a specifier object of a type appropriate to the property (e.g. a font or
|
|
|
257 color specifier). For other properties, this could be anything.
|
|
|
258
|
|
|
259 If @var{locale} is supplied, then instead of returning the actual value,
|
|
|
260 the specification(s) for the given locale or locale type will be
|
|
|
261 returned. This will only work if the actual value of @var{property} is
|
|
|
262 a specifier (this will always be the case for built-in properties, but
|
|
|
263 not or not may apply to user-defined properties). If the actual value
|
|
|
264 of @var{property} is not a specifier, this value will simply be returned
|
|
|
265 regardless of @var{locale}.
|
|
|
266
|
|
|
267 The return value will be a list of instantiators (e.g. strings
|
|
|
268 specifying a font or color name), or a list of specifications, each of
|
|
|
269 which is a cons of a locale and a list of instantiators. Specifically,
|
|
|
270 if @var{locale} is a particular locale (a buffer, window, frame, device,
|
|
|
271 or @code{global}), a list of instantiators for that locale will be
|
|
|
272 returned. Otherwise, if @var{locale} is a locale type (one of the
|
|
|
273 symbols @code{buffer}, @code{window}, @code{frame}, or @code{device}),
|
|
|
274 the specifications for all locales of that type will be returned.
|
|
|
275 Finally, if @var{locale} is @code{all}, the specifications for all
|
|
|
276 locales of all types will be returned.
|
|
|
277
|
|
|
278 The specifications in a specifier determine what the value of
|
|
|
279 @var{property} will be in a particular @dfn{domain} or set of
|
|
|
280 circumstances, which is typically a particular Emacs window along with
|
|
|
281 the buffer it contains and the frame and device it lies within. The
|
|
|
282 value is derived from the instantiator associated with the most specific
|
|
|
283 locale (in the order buffer, window, frame, device, and @code{global})
|
|
|
284 that matches the domain in question. In other words, given a domain
|
|
|
285 (i.e. an Emacs window, usually), the specifier for @var{property} will
|
|
|
286 first be searched for a specification whose locale is the buffer
|
|
|
287 contained within that window; then for a specification whose locale is
|
|
|
288 the window itself; then for a specification whose locale is the frame
|
|
|
289 that the window is contained within; etc. The first instantiator that
|
|
|
290 is valid for the domain (usually this means that the instantiator is
|
|
|
291 recognized by the device [i.e. the X server or TTY device] that the
|
|
|
292 domain is on). The function @code{face-property-instance} actually does
|
|
|
293 all this, and is used to determine how to display the face.
|
|
|
294 @end defun
|
|
|
295
|
|
|
296 @defun face-property-instance face property &optional domain default no-fallback
|
|
|
297 This function returns the instance of @var{face}'s @var{property} in the
|
|
|
298 specified @var{domain}.
|
|
|
299
|
|
|
300 Under most circumstances, @var{domain} will be a particular window, and
|
|
|
301 the returned instance describes how the specified property actually is
|
|
|
302 displayed for that window and the particular buffer in it. Note that
|
|
|
303 this may not be the same as how the property appears when the buffer is
|
|
|
304 displayed in a different window or frame, or how the property appears in
|
|
|
305 the same window if you switch to another buffer in that window; and in
|
|
|
306 those cases, the returned instance would be different.
|
|
|
307
|
|
|
308 The returned instance will typically be a color-instance, font-instance,
|
|
|
309 or pixmap-instance object, and you can query it using the appropriate
|
|
|
310 object-specific functions. For example, you could use
|
|
|
311 @code{color-instance-rgb-components} to find out the RGB (red, green,
|
|
|
312 and blue) components of how the @code{background} property of the
|
|
|
313 @code{highlight} face is displayed in a particular window. The results
|
|
|
314 might be different from the results you would get for another window
|
|
|
315 (perhaps the user specified a different color for the frame that window
|
|
|
316 is on; or perhaps the same color was specified but the window is on a
|
|
|
317 different X server, and that X server has different RGB values for the
|
|
|
318 color from this one).
|
|
|
319
|
|
|
320 @var{domain} defaults to the selected window if omitted.
|
|
|
321
|
|
|
322 @var{domain} can be a frame or device, instead of a window. The value
|
|
|
323 returned for a such a domain is used in special circumstances when a
|
|
|
324 more specific domain does not apply; for example, a frame value might be
|
|
|
325 used for coloring a toolbar, which is conceptually attached to a frame
|
|
|
326 rather than a particular window. The value is also useful in
|
|
|
327 determining what the value would be for a particular window within the
|
|
|
328 frame or device, if it is not overridden by a more specific
|
|
|
329 specification.
|
|
|
330
|
|
|
331 If @var{property} does not name a built-in property, its value will
|
|
|
332 simply be returned unless it is a specifier object, in which case it
|
|
|
333 will be instanced using @code{specifier-instance}.
|
|
|
334
|
|
|
335 Optional arguments @var{default} and @var{no-fallback} are the same as
|
|
|
336 in @code{specifier-instance}. @xref{Specifiers}.
|
|
|
337 @end defun
|
|
|
338
|
|
|
339 @node Face Convenience Functions
|
|
|
340 @subsection Face Convenience Functions
|
|
|
341
|
|
|
342 @defun set-face-foreground face color &optional locale tag how-to-add
|
|
|
343 @defunx set-face-background face color &optional locale tag how-to-add
|
|
|
344 These functions set the foreground (respectively, background) color of
|
|
|
345 face @var{face} to @var{color}. The argument @var{color} should be a
|
|
|
346 string (the name of a color) or a color object as returned by
|
|
|
347 @code{make-color} (@pxref{Colors}).
|
|
|
348 @end defun
|
|
|
349
|
|
|
350 @defun set-face-background-pixmap face pixmap &optional locale tag how-to-add
|
|
|
351 This function sets the background pixmap of face @var{face} to
|
|
|
352 @var{pixmap}. The argument @var{pixmap} should be a string (the name of
|
|
|
353 a bitmap or pixmap file; the directories listed in the variable
|
|
|
354 @code{x-bitmap-file-path} will be searched) or a glyph object as
|
|
|
355 returned by @code{make-glyph} (@pxref{Glyphs}). The argument may also
|
|
|
356 be a list of the form @code{(@var{width} @var{height} @var{data})} where
|
|
|
357 @var{width} and @var{height} are the size in pixels, and @var{data} is a
|
|
|
358 string, containing the raw bits of the bitmap.
|
|
|
359 @end defun
|
|
|
360
|
|
|
361 @defun set-face-font face font &optional locale tag how-to-add
|
|
|
362 This function sets the font of face @var{face}. The argument @var{font}
|
|
|
363 should be a string or a font object as returned by @code{make-font}
|
|
|
364 (@pxref{Fonts}).
|
|
|
365 @end defun
|
|
|
366
|
|
|
367 @defun set-face-underline-p face underline-p &optional locale tag how-to-add
|
|
|
368 This function sets the underline property of face @var{face}.
|
|
|
369 @end defun
|
|
|
370
|
|
|
371 @defun face-foreground face &optional locale
|
|
|
372 @defunx face-background face &optional locale
|
|
|
373 These functions return the foreground (respectively, background) color
|
|
|
374 specifier of face @var{face}.
|
|
|
375 @xref{Colors}.
|
|
|
376 @end defun
|
|
|
377
|
|
|
378 @defun face-background-pixmap face &optional locale
|
|
|
379 This function return the background-pixmap glyph object of face
|
|
|
380 @var{face}.
|
|
|
381 @end defun
|
|
|
382
|
|
|
383 @defun face-font face &optional locale
|
|
|
384 This function returns the font specifier of face @var{face}. (Note:
|
|
|
385 This is not the same as the function @code{face-font} in FSF Emacs.)
|
|
|
386 @xref{Fonts}.
|
|
|
387 @end defun
|
|
|
388
|
|
|
389 @defun face-font-name face &optional domain
|
|
|
390 This function returns the name of the font of face @var{face}, or
|
|
|
391 @code{nil} if it is unspecified. This is basically equivalent to
|
|
|
392 @code{(font-name (face-font @var{face}) @var{domain})} except that
|
|
|
393 it does not cause an error if @var{face}'s font is @code{nil}. (This
|
|
|
394 function is named @code{face-font} in FSF Emacs.)
|
|
|
395 @end defun
|
|
|
396
|
|
|
397 @defun face-underline-p face &optional locale
|
|
|
398 This function returns the underline property of face @var{face}.
|
|
|
399 @end defun
|
|
|
400
|
|
|
401 @defun face-foreground-instance face &optional domain
|
|
|
402 @defunx face-background-instance face &optional domain
|
|
|
403 These functions return the foreground (respectively, background) color
|
|
|
404 specifier of face @var{face}.
|
|
|
405 @xref{Colors}.
|
|
|
406 @end defun
|
|
|
407
|
|
|
408 @defun face-background-pixmap-instance face &optional domain
|
|
|
409 This function return the background-pixmap glyph object of face
|
|
|
410 @var{face}.
|
|
|
411 @end defun
|
|
|
412
|
|
|
413 @defun face-font-instance face &optional domain
|
|
|
414 This function returns the font specifier of face @var{face}.
|
|
|
415 @xref{Fonts}.
|
|
|
416 @end defun
|
|
|
417
|
|
|
418 @node Other Face Display Functions
|
|
|
419 @subsection Other Face Display Functions
|
|
|
420
|
|
|
421 @defun invert-face face &optional locale
|
|
|
422 Swap the foreground and background colors of face @var{face}. If the
|
|
|
423 face doesn't specify both foreground and background, then its foreground
|
|
|
424 and background are set to the default background and foreground.
|
|
|
425 @end defun
|
|
|
426
|
|
|
427 @defun face-equal face1 face2 &optional domain
|
|
|
428 This returns @code{t} if the faces @var{face1} and @var{face2} will
|
|
|
429 display in the same way. @var{domain} is as in
|
|
|
430 @code{face-property-instance}.
|
|
|
431 @end defun
|
|
|
432
|
|
|
433 @defun face-differs-from-default-p face &optional domain
|
|
|
434 This returns @code{t} if the face @var{face} displays differently from
|
|
|
435 the default face. @var{domain} is as in @code{face-property-instance}.
|
|
|
436 @end defun
|
|
|
437
|
|
|
438 @node Fonts
|
|
|
439 @section Fonts
|
|
|
440 @cindex fonts
|
|
|
441
|
|
|
442 This section describes how to work with font specifier and
|
|
|
443 font instance objects, which encapsulate fonts in the window system.
|
|
|
444
|
|
|
445 @menu
|
|
|
446 * Font Specifiers:: Specifying how a font will appear.
|
|
|
447 * Font Instances:: What a font specifier gets instanced as.
|
|
|
448 * Font Instance Names:: The name of a font instance.
|
|
|
449 * Font Instance Size:: The size of a font instance.
|
|
|
450 * Font Instance Characteristics:: Display characteristics of font instances.
|
|
|
451 * Font Convenience Functions:: Convenience functions that automatically
|
|
|
452 instance and retrieve the properties
|
|
|
453 of a font specifier.
|
|
|
454 @end menu
|
|
|
455
|
|
|
456 @node Font Specifiers
|
|
|
457 @subsection Font Specifiers
|
|
|
458
|
|
|
459 @defun font-specifier-p object
|
|
|
460 This predicate returns @code{t} if @var{object} is a font specifier, and
|
|
|
461 @code{nil} otherwise.
|
|
|
462 @end defun
|
|
|
463
|
|
|
464 @node Font Instances
|
|
|
465 @subsection Font Instances
|
|
|
466
|
|
|
467 @defun font-instance-p object
|
|
|
468 This predicate returns @code{t} if @var{object} is a font instance, and
|
|
|
469 @code{nil} otherwise.
|
|
|
470 @end defun
|
|
|
471
|
|
|
472 @defun make-font-instance name &optional device noerror
|
|
|
473 This function creates a new font-instance object of the specified name.
|
|
|
474 @var{device} specifies the device this object applies to and defaults to
|
|
|
475 the selected device. An error is signalled if the font is unknown or
|
|
|
476 cannot be allocated; however, if @var{noerror} is non-@code{nil},
|
|
|
477 @code{nil} is simply returned in this case.
|
|
|
478
|
|
|
479 The returned object is a normal, first-class lisp object. The way you
|
|
|
480 ``deallocate'' the font is the way you deallocate any other lisp object:
|
|
|
481 you drop all pointers to it and allow it to be garbage collected. When
|
|
|
482 these objects are GCed, the underlying X data is deallocated as well.
|
|
|
483 @end defun
|
|
|
484
|
|
|
485 @node Font Instance Names
|
|
|
486 @subsection Font Instance Names
|
|
|
487 @cindex font instance name
|
|
|
488 @cindex available fonts
|
|
|
489 @cindex fonts available
|
|
|
490
|
|
|
491 @defun list-fonts pattern &optional device
|
|
|
492 This function returns a list of font names matching the given pattern.
|
|
|
493 @var{device} specifies which device to search for names, and defaults to
|
|
|
494 the currently selected device.
|
|
|
495 @end defun
|
|
|
496
|
|
|
497 @defun font-instance-name font-instance
|
|
|
498 This function returns the name used to allocate @var{font-instance}.
|
|
|
499 @end defun
|
|
|
500
|
|
|
501 @defun font-instance-truename font-instance
|
|
|
502 This function returns the canonical name of the given font instance.
|
|
|
503 Font names are patterns which may match any number of fonts, of which
|
|
|
504 the first found is used. This returns an unambiguous name for that font
|
|
|
505 (but not necessarily its only unambiguous name).
|
|
|
506 @end defun
|
|
|
507
|
|
|
508 @node Font Instance Size
|
|
|
509 @subsection Font Instance Size
|
|
|
510 @cindex font instance size
|
|
|
511
|
|
|
512 @defun x-font-size font
|
|
|
513 This function returns the nominal size of the given font. This is done
|
|
|
514 by parsing its name, so it's likely to lose. X fonts can be specified
|
|
|
515 (by the user) in either pixels or 10ths of points, and this returns the
|
|
|
516 first one it finds, so you have to decide which units the returned value
|
|
|
517 is measured in yourself ...
|
|
|
518 @end defun
|
|
|
519
|
|
|
520 @defun x-find-larger-font font &optional device
|
|
|
521 This function loads a new, slightly larger version of the given font (or
|
|
|
522 font name). Returns the font if it succeeds, @code{nil} otherwise. If
|
|
|
523 scalable fonts are available, this returns a font which is 1 point
|
|
|
524 larger. Otherwise, it returns the next larger version of this font that
|
|
|
525 is defined.
|
|
|
526 @end defun
|
|
|
527
|
|
|
528 @defun x-find-smaller-font font &optional device
|
|
|
529 This function loads a new, slightly smaller version of the given font
|
|
|
530 (or font name). Returns the font if it succeeds, @code{nil} otherwise.
|
|
|
531 If scalable fonts are available, this returns a font which is 1 point
|
|
|
532 smaller. Otherwise, it returns the next smaller version of this font
|
|
|
533 that is defined.
|
|
|
534 @end defun
|
|
|
535
|
|
|
536 @node Font Instance Characteristics
|
|
|
537 @subsection Font Instance Characteristics
|
|
|
538 @cindex font instance characteristics
|
|
|
539 @cindex characteristics of font instances
|
|
|
540 @cindex bold
|
|
|
541 @cindex demibold
|
|
|
542 @cindex italic
|
|
|
543 @cindex oblique
|
|
|
544
|
|
|
545 @defun font-instance-properties font
|
|
|
546 This function returns the properties (an alist or @code{nil}) of
|
|
|
547 @var{font-instance}.
|
|
|
548 @end defun
|
|
|
549
|
|
|
550 @defun x-make-font-bold font &optional device
|
|
|
551 Given an X font specification, this attempts to make a ``bold'' font.
|
|
|
552 If it fails, it returns @code{nil}.
|
|
|
553 @end defun
|
|
|
554
|
|
|
555 @defun x-make-font-unbold font &optional device
|
|
|
556 Given an X font specification, this attempts to make a non-bold font.
|
|
|
557 If it fails, it returns @code{nil}.
|
|
|
558 @end defun
|
|
|
559
|
|
|
560 @defun x-make-font-italic font &optional device
|
|
|
561 Given an X font specification, this attempts to make an ``italic'' font.
|
|
|
562 If it fails, it returns @code{nil}.
|
|
|
563 @end defun
|
|
|
564
|
|
|
565 @defun x-make-font-unitalic font &optional device
|
|
|
566 Given an X font specification, this attempts to make a non-italic font.
|
|
|
567 If it fails, it returns @code{nil}.
|
|
|
568 @end defun
|
|
|
569
|
|
|
570 @defun x-make-font-bold-italic font &optional device
|
|
|
571 Given an X font specification, this attempts to make a ``bold-italic''
|
|
|
572 font. If it fails, it returns @code{nil}.
|
|
|
573 @end defun
|
|
|
574
|
|
|
575 @node Font Convenience Functions
|
|
|
576 @subsection Font Convenience Functions
|
|
|
577
|
|
|
578 @defun font-name font &optional domain
|
|
|
579 This function returns the name of the @var{font} in the specified
|
|
|
580 @var{domain}, if any. @var{font} should be a font specifier object and
|
|
|
581 @var{domain} is normally a window and defaults to the selected window if
|
|
|
582 omitted. This is equivalent to using @code{specifier-instance} and
|
|
|
583 applying @code{font-instance-name} to the result.
|
|
|
584 @end defun
|
|
|
585
|
|
|
586 @defun font-truename font &optional domain
|
|
|
587 This function returns the truename of the @var{font} in the specified
|
|
|
588 @var{domain}, if any. @var{font} should be a font specifier object and
|
|
|
589 @var{domain} is normally a window and defaults to the selected window if
|
|
|
590 omitted. This is equivalent to using @code{specifier-instance} and
|
|
|
591 applying @code{font-instance-truename} to the result.
|
|
|
592 @end defun
|
|
|
593
|
|
|
594 @defun font-properties font &optional domain
|
|
|
595 This function returns the properties of the @var{font} in the specified
|
|
|
596 @var{domain}, if any. @var{font} should be a font specifier object and
|
|
|
597 @var{domain} is normally a window and defaults to the selected window if
|
|
|
598 omitted. This is equivalent to using @code{specifier-instance} and
|
|
|
599 applying @code{font-instance-properties} to the result.
|
|
|
600 @end defun
|
|
|
601
|
|
|
602 @node Colors
|
|
|
603 @section Colors
|
|
|
604 @cindex colors
|
|
|
605
|
|
|
606 @menu
|
|
|
607 * Color Specifiers:: Specifying how a color will appear.
|
|
|
608 * Color Instances:: What a color specifier gets instanced as.
|
|
|
609 * Color Instance Properties:: Properties of color instances.
|
|
|
610 * Color Convenience Functions:: Convenience functions that automatically
|
|
|
611 instance and retrieve the properties
|
|
|
612 of a color specifier.
|
|
|
613 @end menu
|
|
|
614
|
|
|
615 @node Color Specifiers
|
|
|
616 @subsection Color Specifiers
|
|
|
617
|
|
|
618 @defun color-specifier-p object
|
|
|
619 This function returns non-@code{nil} if @var{object} is a color specifier.
|
|
|
620 @end defun
|
|
|
621
|
|
|
622 @node Color Instances
|
|
|
623 @subsection Color Instances
|
|
|
624 @cindex color instances
|
|
|
625
|
|
|
626 A @dfn{color-instance object} is an object describing the way a color
|
|
|
627 specifier is instanced in a particular domain. Functions such as
|
|
|
628 @code{face-background-instance} return a color-instance object. For
|
|
|
629 example,
|
|
|
630
|
|
|
631 @example
|
|
|
632 (face-background-instance 'default (next-window))
|
|
|
633 @result{} #<color-instance moccasin 47=(FFFF,E4E4,B5B5) 0x678d>
|
|
|
634 @end example
|
|
|
635
|
|
|
636 The color-instance object returned describes the way the background
|
|
|
637 color of the @code{default} face is displayed in the next window after
|
|
|
638 the selected one.
|
|
|
639
|
|
|
640 @defun color-instance-p object
|
|
|
641 This function returns non-@code{nil} if @var{object} is a color-instance.
|
|
|
642 @end defun
|
|
|
643
|
|
|
644 @node Color Instance Properties
|
|
|
645 @subsection Color Instance Properties
|
|
|
646
|
|
|
647 @defun color-instance-name color-instance
|
|
|
648 This function returns the name used to allocate @var{color-instance}.
|
|
|
649 @end defun
|
|
|
650
|
|
|
651 @defun color-instance-rgb-components color-instance
|
|
|
652 This function returns a three element list containing the red, green,
|
|
|
653 and blue color components of @var{color-instance}.
|
|
|
654
|
|
|
655 @example
|
|
|
656 (color-instance-rgb-components
|
|
|
657 (face-background-instance 'default (next-window)))
|
|
|
658 @result{} (65535 58596 46517)
|
|
|
659 @end example
|
|
|
660 @end defun
|
|
|
661
|
|
|
662 @node Color Convenience Functions
|
|
|
663 @subsection Color Convenience Functions
|
|
|
664
|
|
|
665 @defun color-name color &optional domain
|
|
|
666 This function returns the name of the @var{color} in the specified
|
|
|
667 @var{domain}, if any. @var{color} should be a color specifier object
|
|
|
668 and @var{domain} is normally a window and defaults to the selected
|
|
|
669 window if omitted. This is equivalent to using
|
|
|
670 @code{specifier-instance} and applying @code{color-instance-name} to the
|
|
|
671 result.
|
|
|
672 @end defun
|
|
|
673
|
|
|
674 @defun color-rgb-components color &optional domain
|
|
|
675 This function returns the @sc{RGB} components of the @var{color} in the
|
|
|
676 specified @var{domain}, if any. @var{color} should be a color specifier
|
|
|
677 object and @var{domain} is normally a window and defaults to the
|
|
|
678 selected window if omitted. This is equivalent to using
|
|
|
679 @code{specifier-instance} and applying
|
|
|
680 @code{color-instance-rgb-components} to the result.
|
|
|
681
|
|
|
682 @example
|
|
|
683 (color-rgb-components (face-background 'default (next-window)))
|
|
|
684 @result{} (65535 58596 46517)
|
|
|
685 @end example
|
|
|
686 @end defun
|
