2730
|
1 /* "Face" primitives.
|
7307
|
2 Copyright (C) 1993, 1994 Free Software Foundation.
|
2342
|
3
|
2336
|
4 This file is part of GNU Emacs.
|
|
5
|
|
6 GNU Emacs is free software; you can redistribute it and/or modify
|
|
7 it under the terms of the GNU General Public License as published by
|
2342
|
8 the Free Software Foundation; either version 2, or (at your option)
|
2336
|
9 any later version.
|
|
10
|
|
11 GNU Emacs is distributed in the hope that it will be useful,
|
|
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
14 GNU General Public License for more details.
|
|
15
|
|
16 You should have received a copy of the GNU General Public License
|
|
17 along with GNU Emacs; see the file COPYING. If not, write to
|
14186
|
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
19 Boston, MA 02111-1307, USA. */
|
2336
|
20
|
2438
|
21 /* This is derived from work by Lucid (some parts very loosely so). */
|
2342
|
22
|
2336
|
23 #include <sys/types.h>
|
|
24 #include <sys/stat.h>
|
|
25
|
4696
|
26 #include <config.h>
|
2336
|
27 #include "lisp.h"
|
|
28
|
9572
|
29 #ifdef HAVE_FACES
|
2730
|
30
|
9572
|
31 #ifdef HAVE_X_WINDOWS
|
2336
|
32 #include "xterm.h"
|
9572
|
33 #endif
|
|
34 #ifdef MSDOS
|
|
35 #include "dosfns.h"
|
|
36 #endif
|
2336
|
37 #include "buffer.h"
|
2391
|
38 #include "dispextern.h"
|
2342
|
39 #include "frame.h"
|
2438
|
40 #include "blockinput.h"
|
2767
|
41 #include "window.h"
|
8848
|
42 #include "intervals.h"
|
2336
|
43
|
9572
|
44 #ifdef HAVE_X_WINDOWS
|
3997
|
45 /* Compensate for bug in Xos.h on some systems, on which it requires
|
|
46 time.h. On some such systems, Xos.h tries to redefine struct
|
|
47 timeval and struct timezone if USG is #defined while it is
|
|
48 #included. */
|
3436
|
49 #ifdef XOS_NEEDS_TIME_H
|
3277
|
50
|
3997
|
51 #include <time.h>
|
|
52 #undef USG
|
|
53 #include <X11/Xos.h>
|
|
54 #define USG
|
|
55 #define __TIMEVAL__
|
|
56
|
|
57 #else
|
3316
|
58
|
2336
|
59 #include <X11/Xos.h>
|
|
60
|
3997
|
61 #endif
|
9572
|
62 #endif /* HAVE_X_WINDOWS */
|
2730
|
63
|
|
64 /* An explanation of the face data structures. */
|
|
65
|
|
66 /* ========================= Face Data Structures =========================
|
|
67
|
3882
|
68 Let FACE-NAME be a symbol naming a face.
|
2730
|
69
|
3882
|
70 Let FACE-VECTOR be (assq FACE-NAME (frame-face-alist FRAME))
|
|
71 FACE-VECTOR is either nil, or a vector of the form
|
2730
|
72 [face NAME ID FONT FOREGROUND BACKGROUND BACKGROUND-PIXMAP UNDERLINE-P]
|
|
73 where
|
|
74 face is the symbol `face',
|
|
75 NAME is the symbol with which this vector is associated (a backpointer),
|
|
76 ID is the face ID, an integer used internally by the C code to identify
|
|
77 the face,
|
|
78 FONT, FOREGROUND, and BACKGROUND are strings naming the fonts and colors
|
|
79 to use with the face,
|
|
80 BACKGROUND-PIXMAP is the name of an x bitmap filename, which we don't
|
|
81 use right now, and
|
|
82 UNDERLINE-P is non-nil if the face should be underlined.
|
3882
|
83 If any of these elements are nil, that parameter is considered
|
|
84 unspecified; parameters from faces specified by lower-priority
|
|
85 overlays or text properties, or the parameters of the frame itself,
|
|
86 can show through. (lisp/faces.el maintains these lists.)
|
2730
|
87
|
3882
|
88 (assq FACE-NAME global-face-data) returns a vector describing the
|
|
89 global parameters for that face.
|
2730
|
90
|
12667
a3466dad7d6d
Renamings: frame->display => frame->output, struct x_display -> sruct x_output.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
91 Let PARAM-FACE be FRAME->output_data.x->param_faces[Faref (FACE-VECTOR, 2)].
|
3882
|
92 PARAM_FACE is a struct face whose members are the Xlib analogues of
|
|
93 the parameters in FACE-VECTOR. If an element of FACE-VECTOR is
|
|
94 nil, then the corresponding member of PARAM_FACE is FACE_DEFAULT.
|
|
95 These faces are called "parameter faces", because they're the ones
|
|
96 lisp manipulates to control what gets displayed. Elements 0 and 1
|
12667
a3466dad7d6d
Renamings: frame->display => frame->output, struct x_display -> sruct x_output.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
97 of FRAME->output_data.x->param_faces are special - they describe the
|
3882
|
98 default and mode line faces. None of the faces in param_faces have
|
14036
|
99 GC's. (See src/dispextern.h for the definition of struct face.
|
3882
|
100 lisp/faces.el maintains the isomorphism between face_alist and
|
|
101 param_faces.)
|
2342
|
102
|
3882
|
103 The functions compute_char_face and compute_glyph_face find and
|
|
104 combine the parameter faces associated with overlays and text
|
|
105 properties. The resulting faces are called "computed faces"; none
|
|
106 of their members are FACE_DEFAULT; they are completely specified.
|
|
107 They then call intern_compute_face to search
|
12667
a3466dad7d6d
Renamings: frame->display => frame->output, struct x_display -> sruct x_output.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
108 FRAME->output_data.x->computed_faces for a matching face, add one if
|
3882
|
109 none is found, and return the index into
|
12667
a3466dad7d6d
Renamings: frame->display => frame->output, struct x_display -> sruct x_output.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
110 FRAME->output_data.x->computed_faces. FRAME's glyph matrices use these
|
3882
|
111 indices to record the faces of the matrix characters, and the X
|
|
112 display hooks consult compute_faces to decide how to display these
|
|
113 characters. Elements 0 and 1 of computed_faces always describe the
|
|
114 default and mode-line faces.
|
2730
|
115
|
9564
|
116 Each computed face belongs to a particular frame.
|
|
117
|
9529
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
118 Computed faces have graphics contexts some of the time.
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
119 intern_face builds a GC for a specified computed face
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
120 if it doesn't have one already.
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
121 clear_face_cache clears out the GCs of all computed faces.
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
122 This is done from time to time so that we don't hold on to
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
123 lots of GCs that are no longer needed.
|
3882
|
124
|
13460
|
125 If a computed face has 0 as its font,
|
|
126 it is unused, and can be reused by new_computed_face.
|
|
127
|
3882
|
128 Constraints:
|
2342
|
129
|
3882
|
130 Symbols naming faces must have associations on all frames; for any
|
|
131 FRAME, for all FACE-NAME, if (assq FACE-NAME (frame-face-alist
|
|
132 FRAME)) is non-nil, it must be non-nil for all frames.
|
|
133
|
|
134 Analogously, indices into param_faces must be valid on all frames;
|
|
135 if param_faces[i] is a non-zero face pointer on one frame, then it
|
|
136 must be filled in on all frames. Code assumes that face ID's can
|
|
137 be used on any frame.
|
2342
|
138
|
2730
|
139 Some subtleties:
|
2342
|
140
|
3882
|
141 Why do we keep param_faces and computed_faces separate?
|
|
142 computed_faces contains an element for every combination of facial
|
|
143 parameters we have ever displayed. indices into param_faces have
|
|
144 to be valid on all frames. If they were the same array, then that
|
|
145 array would grow very large on all frames, because any facial
|
|
146 combination displayed on any frame would need to be a valid entry
|
9529
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
147 on all frames. */
|
2730
|
148
|
|
149 /* Definitions and declarations. */
|
|
150
|
2336
|
151 /* The number of face-id's in use (same for all frames). */
|
11737
|
152 static int next_face_id;
|
2336
|
153
|
2795
|
154 /* The number of the face to use to indicate the region. */
|
11737
|
155 static int region_face;
|
2795
|
156
|
2838
|
157 /* This is what appears in a slot in a face to signify that the face
|
|
158 does not specify that display aspect. */
|
2342
|
159 #define FACE_DEFAULT (~0)
|
|
160
|
6615
|
161 Lisp_Object Qface, Qmouse_face;
|
9564
|
162 Lisp_Object Qpixmap_spec_p;
|
2391
|
163
|
3830
|
164 int face_name_id_number ( /* FRAME_PTR, Lisp_Object name */ );
|
2730
|
165
|
3830
|
166 struct face *intern_face ( /* FRAME_PTR, struct face * */ );
|
3882
|
167 static int new_computed_face ( /* FRAME_PTR, struct face * */ );
|
|
168 static int intern_computed_face ( /* FRAME_PTR, struct face * */ );
|
3830
|
169 static void ensure_face_ready ( /* FRAME_PTR, int id */ );
|
3843
18892e151d53
* xfaces.c (recompute_basic_faces): This shouldn't be declared static.
Jim Blandy <jimb@redhat.com>
diff
changeset
|
170 void recompute_basic_faces ( /* FRAME_PTR f */ );
|
2336
|
171
|
2730
|
172 /* Allocating, copying, and comparing struct faces. */
|
|
173
|
|
174 /* Allocate a new face */
|
|
175 static struct face *
|
|
176 allocate_face ()
|
|
177 {
|
|
178 struct face *result = (struct face *) xmalloc (sizeof (struct face));
|
|
179 bzero (result, sizeof (struct face));
|
|
180 result->font = (XFontStruct *) FACE_DEFAULT;
|
|
181 result->foreground = FACE_DEFAULT;
|
|
182 result->background = FACE_DEFAULT;
|
|
183 result->stipple = FACE_DEFAULT;
|
|
184 return result;
|
|
185 }
|
|
186
|
2336
|
187 /* Make a new face that's a copy of an existing one. */
|
|
188 static struct face *
|
|
189 copy_face (face)
|
|
190 struct face *face;
|
|
191 {
|
|
192 struct face *result = allocate_face ();
|
|
193
|
|
194 result->font = face->font;
|
|
195 result->foreground = face->foreground;
|
|
196 result->background = face->background;
|
2391
|
197 result->stipple = face->stipple;
|
2336
|
198 result->underline = face->underline;
|
9564
|
199 result->pixmap_h = face->pixmap_h;
|
|
200 result->pixmap_w = face->pixmap_w;
|
2336
|
201
|
|
202 return result;
|
|
203 }
|
|
204
|
|
205 static int
|
|
206 face_eql (face1, face2)
|
|
207 struct face *face1, *face2;
|
|
208 {
|
2730
|
209 return ( face1->font == face2->font
|
2336
|
210 && face1->foreground == face2->foreground
|
|
211 && face1->background == face2->background
|
2730
|
212 && face1->stipple == face2->stipple
|
|
213 && face1->underline == face2->underline);
|
2336
|
214 }
|
2730
|
215
|
9529
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
216 /* Managing graphics contexts of faces. */
|
2730
|
217
|
9572
|
218 #ifdef HAVE_X_WINDOWS
|
9529
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
219 /* Given a computed face, construct its graphics context if necessary. */
|
2730
|
220
|
|
221 struct face *
|
|
222 intern_face (f, face)
|
|
223 struct frame *f;
|
|
224 struct face *face;
|
|
225 {
|
2336
|
226 GC gc;
|
|
227 XGCValues xgcv;
|
|
228 unsigned long mask;
|
|
229
|
9529
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
230 if (face->gc)
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
231 return face;
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
232
|
3074
|
233 BLOCK_INPUT;
|
|
234
|
2391
|
235 if (face->foreground != FACE_DEFAULT)
|
|
236 xgcv.foreground = face->foreground;
|
|
237 else
|
12667
a3466dad7d6d
Renamings: frame->display => frame->output, struct x_display -> sruct x_output.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
238 xgcv.foreground = f->output_data.x->foreground_pixel;
|
3074
|
239
|
2391
|
240 if (face->background != FACE_DEFAULT)
|
|
241 xgcv.background = face->background;
|
|
242 else
|
12667
a3466dad7d6d
Renamings: frame->display => frame->output, struct x_display -> sruct x_output.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
243 xgcv.background = f->output_data.x->background_pixel;
|
3074
|
244
|
11238
|
245 if (face->font && face->font != (XFontStruct *) FACE_DEFAULT)
|
2391
|
246 xgcv.font = face->font->fid;
|
|
247 else
|
12667
a3466dad7d6d
Renamings: frame->display => frame->output, struct x_display -> sruct x_output.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
248 xgcv.font = f->output_data.x->font->fid;
|
3074
|
249
|
2336
|
250 xgcv.graphics_exposures = 0;
|
3074
|
251
|
2336
|
252 mask = GCForeground | GCBackground | GCFont | GCGraphicsExposures;
|
9564
|
253 if (face->stipple && face->stipple != FACE_DEFAULT)
|
9566
|
254 {
|
|
255 xgcv.fill_style = FillStippled;
|
|
256 xgcv.stipple = x_bitmap_pixmap (f, face->stipple);
|
|
257 mask |= GCFillStyle | GCStipple;
|
|
258 }
|
9564
|
259
|
9529
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
260 gc = XCreateGC (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
|
2336
|
261 mask, &xgcv);
|
3074
|
262
|
2391
|
263 face->gc = gc;
|
3074
|
264
|
|
265 UNBLOCK_INPUT;
|
9529
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
266
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
267 return face;
|
2336
|
268 }
|
2730
|
269
|
9529
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
270 /* Clear out all graphics contexts for all computed faces
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
271 except for the default and mode line faces.
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
272 This should be done from time to time just to avoid
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
273 keeping too many graphics contexts that are no longer needed. */
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
274
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
275 void
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
276 clear_face_cache ()
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
277 {
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
278 Lisp_Object tail, frame;
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
279
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
280 BLOCK_INPUT;
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
281 FOR_EACH_FRAME (tail, frame)
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
282 {
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
283 FRAME_PTR f = XFRAME (frame);
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
284 if (FRAME_X_P (f))
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
285 {
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
286 int i;
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
287 Display *dpy = FRAME_X_DISPLAY (f);
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
288
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
289 for (i = 2; i < FRAME_N_COMPUTED_FACES (f); i++)
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
290 {
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
291 struct face *face = FRAME_COMPUTED_FACES (f) [i];
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
292 if (face->gc)
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
293 XFreeGC (dpy, face->gc);
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
294 face->gc = 0;
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
295 }
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
296 }
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
297 }
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
298
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
299 UNBLOCK_INPUT;
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
300 }
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
301
|
9564
|
302 /* Allocating, freeing, and duplicating fonts, colors, and pixmaps.
|
|
303
|
|
304 These functions operate on param faces only.
|
|
305 Computed faces get their fonts, colors and pixmaps
|
|
306 by merging param faces. */
|
2730
|
307
|
|
308 static XFontStruct *
|
|
309 load_font (f, name)
|
|
310 struct frame *f;
|
|
311 Lisp_Object name;
|
|
312 {
|
|
313 XFontStruct *font;
|
|
314
|
|
315 if (NILP (name))
|
|
316 return (XFontStruct *) FACE_DEFAULT;
|
|
317
|
|
318 CHECK_STRING (name, 0);
|
|
319 BLOCK_INPUT;
|
9529
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
320 font = XLoadQueryFont (FRAME_X_DISPLAY (f), (char *) XSTRING (name)->data);
|
2730
|
321 UNBLOCK_INPUT;
|
|
322
|
|
323 if (! font)
|
|
324 Fsignal (Qerror, Fcons (build_string ("undefined font"),
|
|
325 Fcons (name, Qnil)));
|
|
326 return font;
|
|
327 }
|
|
328
|
|
329 static void
|
|
330 unload_font (f, font)
|
|
331 struct frame *f;
|
|
332 XFontStruct *font;
|
|
333 {
|
13460
|
334 int len = FRAME_N_COMPUTED_FACES (f);
|
|
335 int i;
|
|
336
|
2730
|
337 if (!font || font == ((XFontStruct *) FACE_DEFAULT))
|
|
338 return;
|
3074
|
339
|
|
340 BLOCK_INPUT;
|
13460
|
341 /* Invalidate any computed faces which use this font,
|
|
342 and free their GC's if they have any. */
|
13622
67c2ba47a729
(unload_color, unload_font): Never invalidate computed faces 0 and 1.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
343 for (i = 2; i < len; i++)
|
13460
|
344 {
|
|
345 struct face *face = FRAME_COMPUTED_FACES (f)[i];
|
|
346 if (face->font == font)
|
|
347 {
|
|
348 Display *dpy = FRAME_X_DISPLAY (f);
|
|
349 if (face->gc)
|
|
350 XFreeGC (dpy, face->gc);
|
|
351 face->gc = 0;
|
13622
67c2ba47a729
(unload_color, unload_font): Never invalidate computed faces 0 and 1.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
352 /* This marks the computed face as available to reuse. */
|
13460
|
353 face->font = 0;
|
|
354 }
|
|
355 }
|
|
356
|
9529
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
357 XFreeFont (FRAME_X_DISPLAY (f), font);
|
3074
|
358 UNBLOCK_INPUT;
|
2730
|
359 }
|
|
360
|
|
361 static unsigned long
|
|
362 load_color (f, name)
|
|
363 struct frame *f;
|
|
364 Lisp_Object name;
|
|
365 {
|
|
366 XColor color;
|
|
367 int result;
|
|
368
|
|
369 if (NILP (name))
|
|
370 return FACE_DEFAULT;
|
|
371
|
|
372 CHECK_STRING (name, 0);
|
12077
|
373 /* if the colormap is full, defined_color will return a best match
|
|
374 to the values in an an existing cell. */
|
10919
|
375 result = defined_color(f, (char *) XSTRING (name)->data, &color, 1);
|
2730
|
376 if (! result)
|
|
377 Fsignal (Qerror, Fcons (build_string ("undefined color"),
|
|
378 Fcons (name, Qnil)));
|
|
379 return (unsigned long) color.pixel;
|
|
380 }
|
|
381
|
|
382 static void
|
|
383 unload_color (f, pixel)
|
|
384 struct frame *f;
|
3316
|
385 unsigned long pixel;
|
2730
|
386 {
|
|
387 Colormap cmap;
|
9529
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
388 Display *dpy = FRAME_X_DISPLAY (f);
|
12608
|
389 int class = FRAME_X_DISPLAY_INFO (f)->visual->class;
|
|
390
|
2818
|
391 if (pixel == FACE_DEFAULT
|
9671
5c7a3709e81a
(unload_color): Pass arg f to WHITE_PIX_DEFAULT and BLACK_PIX_DEFAULT.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
392 || pixel == BLACK_PIX_DEFAULT (f)
|
5c7a3709e81a
(unload_color): Pass arg f to WHITE_PIX_DEFAULT and BLACK_PIX_DEFAULT.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
393 || pixel == WHITE_PIX_DEFAULT (f))
|
2730
|
394 return;
|
9529
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
395 cmap = DefaultColormapOfScreen (DefaultScreenOfDisplay (dpy));
|
12608
|
396
|
|
397 /* If display has an immutable color map, freeing colors is not
|
|
398 necessary and some servers don't allow it. So don't do it. */
|
|
399 if (! (class == StaticColor || class == StaticGray || class == TrueColor))
|
|
400 {
|
13460
|
401 int len = FRAME_N_COMPUTED_FACES (f);
|
|
402 int i;
|
|
403
|
12608
|
404 BLOCK_INPUT;
|
13460
|
405 /* Invalidate any computed faces which use this color,
|
|
406 and free their GC's if they have any. */
|
13622
67c2ba47a729
(unload_color, unload_font): Never invalidate computed faces 0 and 1.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
407 for (i = 2; i < len; i++)
|
13460
|
408 {
|
|
409 struct face *face = FRAME_COMPUTED_FACES (f)[i];
|
|
410 if (face->foreground == pixel
|
|
411 || face->background == pixel)
|
|
412 {
|
|
413 Display *dpy = FRAME_X_DISPLAY (f);
|
|
414 if (face->gc)
|
|
415 XFreeGC (dpy, face->gc);
|
|
416 face->gc = 0;
|
13622
67c2ba47a729
(unload_color, unload_font): Never invalidate computed faces 0 and 1.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
417 /* This marks the computed face as available to reuse. */
|
13460
|
418 face->font = 0;
|
|
419 }
|
|
420 }
|
|
421
|
12608
|
422 XFreeColors (dpy, cmap, &pixel, 1, (unsigned long)0);
|
|
423 UNBLOCK_INPUT;
|
|
424 }
|
9564
|
425 }
|
|
426
|
|
427 DEFUN ("pixmap-spec-p", Fpixmap_spec_p, Spixmap_spec_p, 1, 1, 0,
|
14090
|
428 "Return t if OBJECT is a valid pixmap specification.")
|
|
429 (object)
|
|
430 Lisp_Object object;
|
9564
|
431 {
|
|
432 Lisp_Object height, width;
|
|
433
|
14090
|
434 return ((STRINGP (object)
|
|
435 || (CONSP (object)
|
|
436 && CONSP (XCONS (object)->cdr)
|
|
437 && CONSP (XCONS (XCONS (object)->cdr)->cdr)
|
|
438 && NILP (XCONS (XCONS (XCONS (object)->cdr)->cdr)->cdr)
|
|
439 && (width = XCONS (object)->car, INTEGERP (width))
|
|
440 && (height = XCONS (XCONS (object)->cdr)->car, INTEGERP (height))
|
|
441 && STRINGP (XCONS (XCONS (XCONS (object)->cdr)->cdr)->car)
|
9564
|
442 && XINT (width) > 0
|
|
443 && XINT (height) > 0
|
|
444 /* The string must have enough bits for width * height. */
|
14090
|
445 && ((XSTRING (XCONS (XCONS (XCONS (object)->cdr)->cdr)->car)->size
|
13363
|
446 * (BITS_PER_INT / sizeof (int)))
|
9944
dd9afae74baf
(Fpixmap_spec_p): Avoid function calls and assignments as arguments to a
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
447 >= XFASTINT (width) * XFASTINT (height))))
|
9564
|
448 ? Qt : Qnil);
|
|
449 }
|
|
450
|
|
451 /* Load a bitmap according to NAME (which is either a file name
|
|
452 or a pixmap spec). Return the bitmap_id (see xfns.c)
|
|
453 or get an error if NAME is invalid.
|
|
454
|
|
455 Store the bitmap width in *W_PTR and height in *H_PTR. */
|
|
456
|
|
457 static long
|
|
458 load_pixmap (f, name, w_ptr, h_ptr)
|
9902
|
459 FRAME_PTR f;
|
9564
|
460 Lisp_Object name;
|
|
461 unsigned int *w_ptr, *h_ptr;
|
|
462 {
|
|
463 int bitmap_id;
|
|
464 Lisp_Object tem;
|
|
465
|
|
466 if (NILP (name))
|
|
467 return FACE_DEFAULT;
|
|
468
|
|
469 tem = Fpixmap_spec_p (name);
|
|
470 if (NILP (tem))
|
|
471 wrong_type_argument (Qpixmap_spec_p, name);
|
|
472
|
|
473 BLOCK_INPUT;
|
|
474
|
|
475 if (CONSP (name))
|
|
476 {
|
|
477 /* Decode a bitmap spec into a bitmap. */
|
|
478
|
|
479 int h, w;
|
|
480 Lisp_Object bits;
|
|
481
|
|
482 w = XINT (Fcar (name));
|
|
483 h = XINT (Fcar (Fcdr (name)));
|
|
484 bits = Fcar (Fcdr (Fcdr (name)));
|
|
485
|
|
486 bitmap_id = x_create_bitmap_from_data (f, XSTRING (bits)->data,
|
|
487 w, h);
|
|
488 }
|
|
489 else
|
|
490 {
|
|
491 /* It must be a string -- a file name. */
|
|
492 bitmap_id = x_create_bitmap_from_file (f, name);
|
|
493 }
|
|
494 UNBLOCK_INPUT;
|
|
495
|
9902
|
496 if (bitmap_id < 0)
|
|
497 Fsignal (Qerror, Fcons (build_string ("invalid or undefined bitmap"),
|
9564
|
498 Fcons (name, Qnil)));
|
|
499
|
|
500 *w_ptr = x_bitmap_width (f, bitmap_id);
|
|
501 *h_ptr = x_bitmap_height (f, bitmap_id);
|
|
502
|
|
503 return bitmap_id;
|
2730
|
504 }
|
9572
|
505
|
|
506 #else /* !HAVE_X_WINDOWS */
|
|
507
|
|
508 /* Stubs for MSDOS when not under X. */
|
|
509
|
|
510 struct face *
|
|
511 intern_face (f, face)
|
|
512 struct frame *f;
|
|
513 struct face *face;
|
|
514 {
|
|
515 return face;
|
|
516 }
|
|
517
|
|
518 void
|
|
519 clear_face_cache ()
|
|
520 {
|
|
521 /* No action. */
|
|
522 }
|
|
523
|
|
524 #ifdef MSDOS
|
|
525 unsigned long
|
|
526 load_color (f, name)
|
|
527 FRAME_PTR f;
|
|
528 Lisp_Object name;
|
|
529 {
|
|
530 Lisp_Object result;
|
|
531
|
|
532 if (NILP (name))
|
|
533 return FACE_DEFAULT;
|
|
534
|
|
535 CHECK_STRING (name, 0);
|
|
536 result = call1 (Qmsdos_color_translate, name);
|
|
537 if (INTEGERP (result))
|
|
538 return XINT (result);
|
|
539 else
|
|
540 Fsignal (Qerror, Fcons (build_string ("undefined color"),
|
|
541 Fcons (name, Qnil)));
|
|
542 }
|
|
543 #endif
|
|
544 #endif /* !HAVE_X_WINDOWS */
|
|
545
|
2336
|
546
|
3882
|
547 /* Managing parameter face arrays for frames. */
|
2730
|
548
|
|
549 void
|
|
550 init_frame_faces (f)
|
3074
|
551 FRAME_PTR f;
|
2730
|
552 {
|
|
553 ensure_face_ready (f, 0);
|
3074
|
554 ensure_face_ready (f, 1);
|
2730
|
555
|
5801
|
556 FRAME_N_COMPUTED_FACES (f) = 0;
|
|
557 FRAME_SIZE_COMPUTED_FACES (f) = 0;
|
|
558
|
3882
|
559 new_computed_face (f, FRAME_PARAM_FACES (f)[0]);
|
|
560 new_computed_face (f, FRAME_PARAM_FACES (f)[1]);
|
3074
|
561 recompute_basic_faces (f);
|
3299
|
562
|
9572
|
563 #ifdef MULTI_FRAME
|
3583
|
564 /* Find another X frame. */
|
|
565 {
|
|
566 Lisp_Object tail, frame, result;
|
|
567
|
|
568 result = Qnil;
|
|
569 FOR_EACH_FRAME (tail, frame)
|
|
570 if (FRAME_X_P (XFRAME (frame))
|
|
571 && XFRAME (frame) != f)
|
|
572 {
|
|
573 result = frame;
|
|
574 break;
|
|
575 }
|
3299
|
576
|
3583
|
577 /* If we didn't find any X frames other than f, then we don't need
|
|
578 any faces other than 0 and 1, so we're okay. Otherwise, make
|
|
579 sure that all faces valid on the selected frame are also valid
|
|
580 on this new frame. */
|
|
581 if (FRAMEP (result))
|
|
582 {
|
|
583 int i;
|
3882
|
584 int n_faces = FRAME_N_PARAM_FACES (XFRAME (result));
|
|
585 struct face **faces = FRAME_PARAM_FACES (XFRAME (result));
|
3299
|
586
|
3583
|
587 for (i = 2; i < n_faces; i++)
|
|
588 if (faces[i])
|
|
589 ensure_face_ready (f, i);
|
|
590 }
|
|
591 }
|
9572
|
592 #endif /* MULTI_FRAME */
|
3074
|
593 }
|
2730
|
594
|
|
595
|
|
596 /* Called from Fdelete_frame. */
|
9564
|
597
|
2730
|
598 void
|
|
599 free_frame_faces (f)
|
|
600 struct frame *f;
|
|
601 {
|
9529
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
602 Display *dpy = FRAME_X_DISPLAY (f);
|
2730
|
603 int i;
|
|
604
|
3074
|
605 BLOCK_INPUT;
|
|
606
|
3882
|
607 for (i = 0; i < FRAME_N_PARAM_FACES (f); i++)
|
2730
|
608 {
|
3882
|
609 struct face *face = FRAME_PARAM_FACES (f) [i];
|
3074
|
610 if (face)
|
|
611 {
|
3882
|
612 unload_font (f, face->font);
|
|
613 unload_color (f, face->foreground);
|
|
614 unload_color (f, face->background);
|
9564
|
615 x_destroy_bitmap (f, face->stipple);
|
3074
|
616 xfree (face);
|
|
617 }
|
2730
|
618 }
|
3882
|
619 xfree (FRAME_PARAM_FACES (f));
|
|
620 FRAME_PARAM_FACES (f) = 0;
|
|
621 FRAME_N_PARAM_FACES (f) = 0;
|
|
622
|
|
623 /* All faces in FRAME_COMPUTED_FACES use resources copied from
|
9529
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
624 FRAME_PARAM_FACES; we can free them without fuss.
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
625 But we do free the GCs and the face objects themselves. */
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
626 for (i = 0; i < FRAME_N_COMPUTED_FACES (f); i++)
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
627 {
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
628 struct face *face = FRAME_COMPUTED_FACES (f) [i];
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
629 if (face)
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
630 {
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
631 if (face->gc)
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
632 XFreeGC (dpy, face->gc);
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
633 xfree (face);
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
634 }
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
635 }
|
3882
|
636 xfree (FRAME_COMPUTED_FACES (f));
|
|
637 FRAME_COMPUTED_FACES (f) = 0;
|
|
638 FRAME_N_COMPUTED_FACES (f) = 0;
|
3074
|
639
|
|
640 UNBLOCK_INPUT;
|
2730
|
641 }
|
|
642
|
|
643 /* Interning faces in a frame's face array. */
|
|
644
|
3074
|
645 static int
|
3882
|
646 new_computed_face (f, new_face)
|
|
647 struct frame *f;
|
2730
|
648 struct face *new_face;
|
|
649 {
|
13460
|
650 int len = FRAME_N_COMPUTED_FACES (f);
|
|
651 int i;
|
|
652
|
|
653 /* Search for an unused computed face in the middle of the table. */
|
|
654 for (i = 0; i < len; i++)
|
|
655 {
|
|
656 struct face *face = FRAME_COMPUTED_FACES (f)[i];
|
|
657 if (face->font == 0)
|
|
658 {
|
|
659 FRAME_COMPUTED_FACES (f)[i] = copy_face (new_face);
|
|
660 return i;
|
|
661 }
|
|
662 }
|
3882
|
663
|
|
664 if (i >= FRAME_SIZE_COMPUTED_FACES (f))
|
|
665 {
|
|
666 int new_size = i + 32;
|
|
667
|
|
668 FRAME_COMPUTED_FACES (f)
|
5801
|
669 = (struct face **) (FRAME_SIZE_COMPUTED_FACES (f) == 0
|
|
670 ? xmalloc (new_size * sizeof (struct face *))
|
|
671 : xrealloc (FRAME_COMPUTED_FACES (f),
|
|
672 new_size * sizeof (struct face *)));
|
3882
|
673 FRAME_SIZE_COMPUTED_FACES (f) = new_size;
|
|
674 }
|
|
675
|
|
676 i = FRAME_N_COMPUTED_FACES (f)++;
|
|
677 FRAME_COMPUTED_FACES (f)[i] = copy_face (new_face);
|
|
678 return i;
|
|
679 }
|
|
680
|
|
681
|
|
682 /* Find a match for NEW_FACE in a FRAME's computed face array, and add
|
|
683 it if we don't find one. */
|
|
684 static int
|
|
685 intern_computed_face (f, new_face)
|
|
686 struct frame *f;
|
|
687 struct face *new_face;
|
|
688 {
|
|
689 int len = FRAME_N_COMPUTED_FACES (f);
|
2730
|
690 int i;
|
|
691
|
3882
|
692 /* Search for a computed face already on F equivalent to FACE. */
|
2730
|
693 for (i = 0; i < len; i++)
|
|
694 {
|
3882
|
695 if (! FRAME_COMPUTED_FACES (f)[i])
|
|
696 abort ();
|
|
697 if (face_eql (new_face, FRAME_COMPUTED_FACES (f)[i]))
|
2730
|
698 return i;
|
|
699 }
|
|
700
|
|
701 /* We didn't find one; add a new one. */
|
3882
|
702 return new_computed_face (f, new_face);
|
2730
|
703 }
|
|
704
|
3882
|
705 /* Make parameter face id ID valid on frame F. */
|
2730
|
706
|
|
707 static void
|
|
708 ensure_face_ready (f, id)
|
|
709 struct frame *f;
|
|
710 int id;
|
|
711 {
|
3882
|
712 if (FRAME_N_PARAM_FACES (f) <= id)
|
2730
|
713 {
|
|
714 int n = id + 10;
|
|
715 int i;
|
3882
|
716 if (!FRAME_N_PARAM_FACES (f))
|
|
717 FRAME_PARAM_FACES (f)
|
2730
|
718 = (struct face **) xmalloc (sizeof (struct face *) * n);
|
|
719 else
|
3882
|
720 FRAME_PARAM_FACES (f)
|
|
721 = (struct face **) xrealloc (FRAME_PARAM_FACES (f),
|
2730
|
722 sizeof (struct face *) * n);
|
|
723
|
3882
|
724 bzero (FRAME_PARAM_FACES (f) + FRAME_N_PARAM_FACES (f),
|
|
725 (n - FRAME_N_PARAM_FACES (f)) * sizeof (struct face *));
|
|
726 FRAME_N_PARAM_FACES (f) = n;
|
2730
|
727 }
|
|
728
|
3882
|
729 if (FRAME_PARAM_FACES (f) [id] == 0)
|
|
730 FRAME_PARAM_FACES (f) [id] = allocate_face ();
|
2730
|
731 }
|
|
732
|
9572
|
733 #ifdef HAVE_X_WINDOWS
|
6784
|
734 /* Return non-zero if FONT1 and FONT2 have the same width.
|
|
735 We do not check the height, because we can now deal with
|
|
736 different heights.
|
|
737 We assume that they're both character-cell fonts. */
|
2730
|
738
|
3074
|
739 int
|
|
740 same_size_fonts (font1, font2)
|
|
741 XFontStruct *font1, *font2;
|
|
742 {
|
|
743 XCharStruct *bounds1 = &font1->min_bounds;
|
|
744 XCharStruct *bounds2 = &font2->min_bounds;
|
|
745
|
3528
|
746 return (bounds1->width == bounds2->width);
|
3074
|
747 }
|
|
748
|
6768
|
749 /* Update the line_height of frame F according to the biggest font in
|
6879
|
750 any face. Return nonzero if if line_height changes. */
|
6768
|
751
|
6879
|
752 int
|
6768
|
753 frame_update_line_height (f)
|
|
754 FRAME_PTR f;
|
|
755 {
|
|
756 int i;
|
12667
a3466dad7d6d
Renamings: frame->display => frame->output, struct x_display -> sruct x_output.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
757 int biggest = FONT_HEIGHT (f->output_data.x->font);
|
6768
|
758
|
12667
a3466dad7d6d
Renamings: frame->display => frame->output, struct x_display -> sruct x_output.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
759 for (i = 0; i < f->output_data.x->n_param_faces; i++)
|
a3466dad7d6d
Renamings: frame->display => frame->output, struct x_display -> sruct x_output.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
760 if (f->output_data.x->param_faces[i] != 0
|
a3466dad7d6d
Renamings: frame->display => frame->output, struct x_display -> sruct x_output.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
761 && f->output_data.x->param_faces[i]->font != (XFontStruct *) FACE_DEFAULT)
|
6768
|
762 {
|
12667
a3466dad7d6d
Renamings: frame->display => frame->output, struct x_display -> sruct x_output.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
763 int height = FONT_HEIGHT (f->output_data.x->param_faces[i]->font);
|
6768
|
764 if (height > biggest)
|
|
765 biggest = height;
|
|
766 }
|
|
767
|
12667
a3466dad7d6d
Renamings: frame->display => frame->output, struct x_display -> sruct x_output.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
768 if (biggest == f->output_data.x->line_height)
|
6879
|
769 return 0;
|
6768
|
770
|
12667
a3466dad7d6d
Renamings: frame->display => frame->output, struct x_display -> sruct x_output.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
771 f->output_data.x->line_height = biggest;
|
6879
|
772 return 1;
|
6768
|
773 }
|
9572
|
774 #endif /* not HAVE_X_WINDOWS */
|
6784
|
775
|
2342
|
776 /* Modify face TO by copying from FROM all properties which have
|
|
777 nondefault settings. */
|
6784
|
778
|
2342
|
779 static void
|
|
780 merge_faces (from, to)
|
|
781 struct face *from, *to;
|
|
782 {
|
6784
|
783 /* Only merge the font if it's the same width as the base font.
|
|
784 Otherwise ignore it, since we can't handle it properly. */
|
2883
|
785 if (from->font != (XFontStruct *) FACE_DEFAULT
|
|
786 && same_size_fonts (from->font, to->font))
|
|
787 to->font = from->font;
|
2342
|
788 if (from->foreground != FACE_DEFAULT)
|
|
789 to->foreground = from->foreground;
|
|
790 if (from->background != FACE_DEFAULT)
|
|
791 to->background = from->background;
|
2391
|
792 if (from->stipple != FACE_DEFAULT)
|
9564
|
793 {
|
|
794 to->stipple = from->stipple;
|
|
795 to->pixmap_h = from->pixmap_h;
|
|
796 to->pixmap_w = from->pixmap_w;
|
|
797 }
|
2342
|
798 if (from->underline)
|
|
799 to->underline = from->underline;
|
|
800 }
|
|
801
|
3074
|
802 /* Set up the basic set of facial parameters, based on the frame's
|
|
803 data; all faces are deltas applied to this. */
|
6784
|
804
|
3074
|
805 static void
|
|
806 compute_base_face (f, face)
|
|
807 FRAME_PTR f;
|
|
808 struct face *face;
|
|
809 {
|
|
810 face->gc = 0;
|
9564
|
811 face->foreground = FRAME_FOREGROUND_PIXEL (f);
|
|
812 face->background = FRAME_BACKGROUND_PIXEL (f);
|
|
813 face->font = FRAME_FONT (f);
|
3811
|
814 face->stipple = 0;
|
3074
|
815 face->underline = 0;
|
|
816 }
|
|
817
|
6784
|
818 /* Return the face ID to use to display a special glyph which selects
|
|
819 FACE_CODE as the face ID, assuming that ordinarily the face would
|
|
820 be CURRENT_FACE. F is the frame. */
|
3074
|
821
|
6784
|
822 int
|
|
823 compute_glyph_face (f, face_code, current_face)
|
|
824 struct frame *f;
|
|
825 int face_code, current_face;
|
|
826 {
|
|
827 struct face face;
|
|
828
|
|
829 face = *FRAME_COMPUTED_FACES (f)[current_face];
|
|
830
|
|
831 if (face_code >= 0 && face_code < FRAME_N_PARAM_FACES (f)
|
|
832 && FRAME_PARAM_FACES (f) [face_code] != 0)
|
|
833 merge_faces (FRAME_PARAM_FACES (f) [face_code], &face);
|
|
834
|
|
835 return intern_computed_face (f, &face);
|
|
836 }
|
8472
|
837
|
|
838 /* Return the face ID to use to display a special glyph which selects
|
|
839 FACE_CODE as the face ID, assuming that ordinarily the face would
|
|
840 be CURRENT_FACE. F is the frame. */
|
|
841
|
|
842 int
|
|
843 compute_glyph_face_1 (f, face_name, current_face)
|
|
844 struct frame *f;
|
|
845 Lisp_Object face_name;
|
|
846 int current_face;
|
|
847 {
|
|
848 struct face face;
|
|
849
|
|
850 face = *FRAME_COMPUTED_FACES (f)[current_face];
|
|
851
|
|
852 if (!NILP (face_name))
|
|
853 {
|
|
854 int facecode = face_name_id_number (f, face_name);
|
|
855 if (facecode >= 0 && facecode < FRAME_N_PARAM_FACES (f)
|
|
856 && FRAME_PARAM_FACES (f) [facecode] != 0)
|
|
857 merge_faces (FRAME_PARAM_FACES (f) [facecode], &face);
|
|
858 }
|
|
859
|
|
860 return intern_computed_face (f, &face);
|
|
861 }
|
6784
|
862
|
2730
|
863 /* Return the face ID associated with a buffer position POS.
|
2342
|
864 Store into *ENDPTR the position at which a different face is needed.
|
|
865 This does not take account of glyphs that specify their own face codes.
|
2784
|
866 F is the frame in use for display, and W is a window displaying
|
2795
|
867 the current buffer.
|
|
868
|
5084
|
869 REGION_BEG, REGION_END delimit the region, so it can be highlighted.
|
|
870
|
|
871 LIMIT is a position not to scan beyond. That is to limit
|
6615
|
872 the time this function can take.
|
|
873
|
|
874 If MOUSE is nonzero, use the character's mouse-face, not its face. */
|
2795
|
875
|
2730
|
876 int
|
6615
|
877 compute_char_face (f, w, pos, region_beg, region_end, endptr, limit, mouse)
|
2342
|
878 struct frame *f;
|
2391
|
879 struct window *w;
|
2342
|
880 int pos;
|
2795
|
881 int region_beg, region_end;
|
2342
|
882 int *endptr;
|
5084
|
883 int limit;
|
6615
|
884 int mouse;
|
2342
|
885 {
|
|
886 struct face face;
|
2767
|
887 Lisp_Object prop, position;
|
2342
|
888 int i, j, noverlays;
|
|
889 int facecode;
|
|
890 Lisp_Object *overlay_vec;
|
2391
|
891 Lisp_Object frame;
|
2784
|
892 int endpos;
|
6615
|
893 Lisp_Object propname;
|
2784
|
894
|
|
895 /* W must display the current buffer. We could write this function
|
|
896 to use the frame and buffer of W, but right now it doesn't. */
|
|
897 if (XBUFFER (w->buffer) != current_buffer)
|
|
898 abort ();
|
2391
|
899
|
9284
a969e0eefaf5
(compute_char_face): Use new accessor macros instead of calling XSET directly.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
900 XSETFRAME (frame, f);
|
2342
|
901
|
2784
|
902 endpos = ZV;
|
2795
|
903 if (pos < region_beg && region_beg < endpos)
|
|
904 endpos = region_beg;
|
2784
|
905
|
9326
|
906 XSETFASTINT (position, pos);
|
6615
|
907
|
|
908 if (mouse)
|
|
909 propname = Qmouse_face;
|
|
910 else
|
|
911 propname = Qface;
|
|
912
|
|
913 prop = Fget_text_property (position, propname, w->buffer);
|
|
914
|
2767
|
915 {
|
5084
|
916 Lisp_Object limit1, end;
|
2767
|
917
|
9326
|
918 XSETFASTINT (limit1, (limit < endpos ? limit : endpos));
|
6615
|
919 end = Fnext_single_property_change (position, propname, w->buffer, limit1);
|
2767
|
920 if (INTEGERP (end))
|
|
921 endpos = XINT (end);
|
|
922 }
|
2342
|
923
|
2767
|
924 {
|
2784
|
925 int next_overlay;
|
2838
|
926 int len;
|
2767
|
927
|
2838
|
928 /* First try with room for 40 overlays. */
|
|
929 len = 40;
|
|
930 overlay_vec = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
|
|
931
|
11420
|
932 noverlays = overlays_at (pos, 0, &overlay_vec, &len,
|
|
933 &next_overlay, (int *) 0);
|
2838
|
934
|
|
935 /* If there are more than 40,
|
|
936 make enough space for all, and try again. */
|
|
937 if (noverlays > len)
|
|
938 {
|
|
939 len = noverlays;
|
|
940 overlay_vec = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
|
8965
|
941 noverlays = overlays_at (pos, 0, &overlay_vec, &len,
|
11420
|
942 &next_overlay, (int *) 0);
|
2838
|
943 }
|
|
944
|
2784
|
945 if (next_overlay < endpos)
|
|
946 endpos = next_overlay;
|
2767
|
947 }
|
|
948
|
|
949 *endptr = endpos;
|
2342
|
950
|
|
951 /* Optimize the default case. */
|
2795
|
952 if (noverlays == 0 && NILP (prop)
|
|
953 && !(pos >= region_beg && pos < region_end))
|
2730
|
954 return 0;
|
2342
|
955
|
3074
|
956 compute_base_face (f, &face);
|
2342
|
957
|
9186
|
958 if (CONSP (prop))
|
|
959 {
|
|
960 /* We have a list of faces, merge them in reverse order */
|
12468
|
961 Lisp_Object length;
|
|
962 int len;
|
9186
|
963 Lisp_Object *faces;
|
|
964
|
12468
|
965 length = Fsafe_length (prop);
|
|
966 len = XFASTINT (length);
|
|
967
|
9186
|
968 /* Put them into an array */
|
|
969 faces = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
|
|
970 for (j = 0; j < len; j++)
|
|
971 {
|
|
972 faces[j] = Fcar (prop);
|
|
973 prop = Fcdr (prop);
|
|
974 }
|
|
975 /* So that we can merge them in the reverse order */
|
|
976 for (j = len - 1; j >= 0; j--)
|
|
977 {
|
|
978 facecode = face_name_id_number (f, faces[j]);
|
|
979 if (facecode >= 0 && facecode < FRAME_N_PARAM_FACES (f)
|
|
980 && FRAME_PARAM_FACES (f) [facecode] != 0)
|
|
981 merge_faces (FRAME_PARAM_FACES (f) [facecode], &face);
|
|
982 }
|
|
983 }
|
|
984 else if (!NILP (prop))
|
2342
|
985 {
|
3065
|
986 facecode = face_name_id_number (f, prop);
|
3882
|
987 if (facecode >= 0 && facecode < FRAME_N_PARAM_FACES (f)
|
|
988 && FRAME_PARAM_FACES (f) [facecode] != 0)
|
|
989 merge_faces (FRAME_PARAM_FACES (f) [facecode], &face);
|
2342
|
990 }
|
|
991
|
5858
021e58905963
(compute_char_face): Extract overlay-sorting code as a separate function,
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
992 noverlays = sort_overlays (overlay_vec, noverlays, w);
|
2342
|
993
|
|
994 /* Now merge the overlay data in that order. */
|
|
995 for (i = 0; i < noverlays; i++)
|
|
996 {
|
6615
|
997 prop = Foverlay_get (overlay_vec[i], propname);
|
9186
|
998 if (CONSP (prop))
|
|
999 {
|
|
1000 /* We have a list of faces, merge them in reverse order */
|
12468
|
1001 Lisp_Object length;
|
|
1002 int len;
|
9186
|
1003 Lisp_Object *faces;
|
12468
|
1004
|
|
1005 length = Fsafe_length (prop);
|
|
1006 len = XFASTINT (length);
|
9186
|
1007
|
|
1008 /* Put them into an array */
|
|
1009 faces = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
|
|
1010 for (j = 0; j < len; j++)
|
|
1011 {
|
|
1012 faces[j] = Fcar (prop);
|
|
1013 prop = Fcdr (prop);
|
|
1014 }
|
|
1015 /* So that we can merge them in the reverse order */
|
|
1016 for (j = len - 1; j >= 0; j--)
|
|
1017 {
|
|
1018 facecode = face_name_id_number (f, faces[j]);
|
|
1019 if (facecode >= 0 && facecode < FRAME_N_PARAM_FACES (f)
|
|
1020 && FRAME_PARAM_FACES (f) [facecode] != 0)
|
|
1021 merge_faces (FRAME_PARAM_FACES (f) [facecode], &face);
|
|
1022 }
|
|
1023 }
|
|
1024 else if (!NILP (prop))
|
2342
|
1025 {
|
|
1026 Lisp_Object oend;
|
|
1027 int oendpos;
|
|
1028
|
3065
|
1029 facecode = face_name_id_number (f, prop);
|
3882
|
1030 if (facecode >= 0 && facecode < FRAME_N_PARAM_FACES (f)
|
|
1031 && FRAME_PARAM_FACES (f) [facecode] != 0)
|
6615
|
1032 merge_faces (FRAME_PARAM_FACES (f)[facecode], &face);
|
2342
|
1033
|
5858
021e58905963
(compute_char_face): Extract overlay-sorting code as a separate function,
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1034 oend = OVERLAY_END (overlay_vec[i]);
|
2342
|
1035 oendpos = OVERLAY_POSITION (oend);
|
2784
|
1036 if (oendpos < endpos)
|
2342
|
1037 endpos = oendpos;
|
|
1038 }
|
|
1039 }
|
|
1040
|
2795
|
1041 if (pos >= region_beg && pos < region_end)
|
|
1042 {
|
|
1043 if (region_end < endpos)
|
|
1044 endpos = region_end;
|
|
1045 if (region_face >= 0 && region_face < next_face_id)
|
6615
|
1046 merge_faces (FRAME_PARAM_FACES (f)[region_face], &face);
|
2795
|
1047 }
|
|
1048
|
2342
|
1049 *endptr = endpos;
|
|
1050
|
3882
|
1051 return intern_computed_face (f, &face);
|
2342
|
1052 }
|
6784
|
1053
|
3074
|
1054 /* Recompute the GC's for the default and modeline faces.
|
|
1055 We call this after changing frame parameters on which those GC's
|
|
1056 depend. */
|
5801
|
1057
|
3074
|
1058 void
|
|
1059 recompute_basic_faces (f)
|
|
1060 FRAME_PTR f;
|
|
1061 {
|
|
1062 /* If the frame's faces haven't been initialized yet, don't worry about
|
|
1063 this stuff. */
|
3882
|
1064 if (FRAME_N_PARAM_FACES (f) < 2)
|
3074
|
1065 return;
|
|
1066
|
|
1067 BLOCK_INPUT;
|
|
1068
|
|
1069 if (FRAME_DEFAULT_FACE (f)->gc)
|
9529
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1070 XFreeGC (FRAME_X_DISPLAY (f), FRAME_DEFAULT_FACE (f)->gc);
|
3074
|
1071 if (FRAME_MODE_LINE_FACE (f)->gc)
|
9529
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1072 XFreeGC (FRAME_X_DISPLAY (f), FRAME_MODE_LINE_FACE (f)->gc);
|
3882
|
1073
|
|
1074 compute_base_face (f, FRAME_DEFAULT_FACE (f));
|
|
1075 compute_base_face (f, FRAME_MODE_LINE_FACE (f));
|
|
1076
|
|
1077 merge_faces (FRAME_DEFAULT_PARAM_FACE (f), FRAME_DEFAULT_FACE (f));
|
|
1078 merge_faces (FRAME_MODE_LINE_PARAM_FACE (f), FRAME_MODE_LINE_FACE (f));
|
|
1079
|
9529
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1080 intern_face (f, FRAME_DEFAULT_FACE (f));
|
8e610355cb29
Eliminate the "display faces"; store GCs in the "computed faces".
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1081 intern_face (f, FRAME_MODE_LINE_FACE (f));
|
3074
|
1082
|
|
1083 UNBLOCK_INPUT;
|
|
1084 }
|
|
1085
|
|
1086
|
2336
|
1087
|
2730
|
1088 /* Lisp interface. */
|
2336
|
1089
|
|
1090 DEFUN ("frame-face-alist", Fframe_face_alist, Sframe_face_alist, 1, 1, 0,
|
|
1091 "")
|
|
1092 (frame)
|
|
1093 Lisp_Object frame;
|
|
1094 {
|
|
1095 CHECK_FRAME (frame, 0);
|
|
1096 return XFRAME (frame)->face_alist;
|
|
1097 }
|
|
1098
|
|
1099 DEFUN ("set-frame-face-alist", Fset_frame_face_alist, Sset_frame_face_alist,
|
|
1100 2, 2, 0, "")
|
|
1101 (frame, value)
|
|
1102 Lisp_Object frame, value;
|
|
1103 {
|
|
1104 CHECK_FRAME (frame, 0);
|
|
1105 XFRAME (frame)->face_alist = value;
|
|
1106 return value;
|
|
1107 }
|
|
1108
|
|
1109
|
|
1110 DEFUN ("make-face-internal", Fmake_face_internal, Smake_face_internal, 1, 1, 0,
|
|
1111 "Create face number FACE-ID on all frames.")
|
|
1112 (face_id)
|
|
1113 Lisp_Object face_id;
|
|
1114 {
|
9572
|
1115 Lisp_Object rest, frame;
|
2336
|
1116 int id = XINT (face_id);
|
|
1117
|
2391
|
1118 CHECK_NUMBER (face_id, 0);
|
|
1119 if (id < 0 || id >= next_face_id)
|
|
1120 error ("Face id out of range");
|
2336
|
1121
|
9572
|
1122 FOR_EACH_FRAME (rest, frame)
|
2336
|
1123 {
|
9572
|
1124 if (FRAME_X_P (XFRAME (frame)))
|
|
1125 ensure_face_ready (XFRAME (frame), id);
|
2336
|
1126 }
|
|
1127 return Qnil;
|
|
1128 }
|
|
1129
|
|
1130
|
|
1131 DEFUN ("set-face-attribute-internal", Fset_face_attribute_internal,
|
|
1132 Sset_face_attribute_internal, 4, 4, 0, "")
|
|
1133 (face_id, attr_name, attr_value, frame)
|
|
1134 Lisp_Object face_id, attr_name, attr_value, frame;
|
|
1135 {
|
|
1136 struct face *face;
|
|
1137 struct frame *f;
|
|
1138 int magic_p;
|
|
1139 int id;
|
9184
|
1140 int garbaged = 0;
|
2336
|
1141
|
|
1142 CHECK_FRAME (frame, 0);
|
2391
|
1143 CHECK_NUMBER (face_id, 0);
|
2336
|
1144 CHECK_SYMBOL (attr_name, 0);
|
|
1145
|
|
1146 f = XFRAME (frame);
|
|
1147 id = XINT (face_id);
|
2391
|
1148 if (id < 0 || id >= next_face_id)
|
|
1149 error ("Face id out of range");
|
2336
|
1150
|
2767
|
1151 if (! FRAME_X_P (f))
|
7583
|
1152 return Qnil;
|
2767
|
1153
|
2336
|
1154 ensure_face_ready (f, id);
|
3882
|
1155 face = FRAME_PARAM_FACES (f) [XFASTINT (face_id)];
|
2336
|
1156
|
|
1157 if (EQ (attr_name, intern ("font")))
|
|
1158 {
|
9572
|
1159 #if defined (MSDOS) && !defined (HAVE_X_WINDOWS)
|
13626
|
1160 /* The one and only font. Must *not* be zero (which
|
|
1161 is taken to mean an unused face nowadays). */
|
|
1162 face->font = (XFontStruct *)1 ;
|
9572
|
1163 #else
|
2391
|
1164 XFontStruct *font = load_font (f, attr_value);
|
12667
a3466dad7d6d
Renamings: frame->display => frame->output, struct x_display -> sruct x_output.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1165 if (face->font != f->output_data.x->font)
|
2998
|
1166 unload_font (f, face->font);
|
2336
|
1167 face->font = font;
|
6879
|
1168 if (frame_update_line_height (f))
|
|
1169 x_set_window_size (f, 0, f->width, f->height);
|
9184
|
1170 /* Must clear cache, since it might contain the font
|
|
1171 we just got rid of. */
|
|
1172 garbaged = 1;
|
9572
|
1173 #endif
|
2336
|
1174 }
|
|
1175 else if (EQ (attr_name, intern ("foreground")))
|
|
1176 {
|
2391
|
1177 unsigned long new_color = load_color (f, attr_value);
|
2336
|
1178 unload_color (f, face->foreground);
|
|
1179 face->foreground = new_color;
|
9184
|
1180 garbaged = 1;
|
2336
|
1181 }
|
|
1182 else if (EQ (attr_name, intern ("background")))
|
|
1183 {
|
2391
|
1184 unsigned long new_color = load_color (f, attr_value);
|
2336
|
1185 unload_color (f, face->background);
|
9572
|
1186 #if defined (MSDOS) && !defined (HAVE_X_WINDOWS)
|
|
1187 new_color &= ~8; /* Bright would give blinking characters. */
|
|
1188 #endif
|
2336
|
1189 face->background = new_color;
|
9184
|
1190 garbaged = 1;
|
2336
|
1191 }
|
|
1192 else if (EQ (attr_name, intern ("background-pixmap")))
|
|
1193 {
|
9564
|
1194 unsigned int w, h;
|
|
1195 unsigned long new_pixmap = load_pixmap (f, attr_value, &w, &h);
|
|
1196 x_destroy_bitmap (f, face->stipple);
|
2391
|
1197 face->stipple = new_pixmap;
|
2336
|
1198 face->pixmap_w = w;
|
|
1199 face->pixmap_h = h;
|
9564
|
1200 garbaged = 1;
|
2336
|
1201 }
|
|
1202 else if (EQ (attr_name, intern ("underline")))
|
|
1203 {
|
|
1204 int new = !NILP (attr_value);
|
|
1205 face->underline = new;
|
|
1206 }
|
|
1207 else
|
|
1208 error ("unknown face attribute");
|
|
1209
|
3882
|
1210 if (id == 0 || id == 1)
|
|
1211 recompute_basic_faces (f);
|
2336
|
1212
|
9184
|
1213 /* We must redraw the frame whenever any face font or color changes,
|
|
1214 because it's possible that a merged (display) face
|
|
1215 contains the font or color we just replaced.
|
|
1216 And we must inhibit any Expose events until the redraw is done,
|
|
1217 since they would try to use the invalid display faces. */
|
|
1218 if (garbaged)
|
2821
|
1219 SET_FRAME_GARBAGED (f);
|
|
1220
|
2336
|
1221 return Qnil;
|
|
1222 }
|
|
1223
|
|
1224 DEFUN ("internal-next-face-id", Finternal_next_face_id, Sinternal_next_face_id,
|
|
1225 0, 0, 0, "")
|
|
1226 ()
|
|
1227 {
|
|
1228 return make_number (next_face_id++);
|
|
1229 }
|
2391
|
1230
|
|
1231 /* Return the face id for name NAME on frame FRAME.
|
|
1232 (It should be the same for all frames,
|
|
1233 but it's as easy to use the "right" frame to look it up
|
|
1234 as to use any other one.) */
|
|
1235
|
3065
|
1236 int
|
|
1237 face_name_id_number (f, name)
|
|
1238 FRAME_PTR f;
|
|
1239 Lisp_Object name;
|
2391
|
1240 {
|
|
1241 Lisp_Object tem;
|
|
1242
|
4258
|
1243 tem = Fcdr (assq_no_quit (name, f->face_alist));
|
2767
|
1244 if (NILP (tem))
|
|
1245 return 0;
|
2391
|
1246 CHECK_VECTOR (tem, 0);
|
|
1247 tem = XVECTOR (tem)->contents[2];
|
|
1248 CHECK_NUMBER (tem, 0);
|
|
1249 return XINT (tem);
|
|
1250 }
|
2336
|
1251
|
2730
|
1252 /* Emacs initialization. */
|
|
1253
|
2336
|
1254 void
|
2391
|
1255 syms_of_xfaces ()
|
2336
|
1256 {
|
2391
|
1257 Qface = intern ("face");
|
|
1258 staticpro (&Qface);
|
6615
|
1259 Qmouse_face = intern ("mouse-face");
|
|
1260 staticpro (&Qmouse_face);
|
9564
|
1261 Qpixmap_spec_p = intern ("pixmap-spec-p");
|
|
1262 staticpro (&Qpixmap_spec_p);
|
2391
|
1263
|
2795
|
1264 DEFVAR_INT ("region-face", ®ion_face,
|
|
1265 "Face number to use to highlight the region\n\
|
|
1266 The region is highlighted with this face\n\
|
|
1267 when Transient Mark mode is enabled and the mark is active.");
|
|
1268
|
9572
|
1269 #ifdef HAVE_X_WINDOWS
|
9564
|
1270 defsubr (&Spixmap_spec_p);
|
9572
|
1271 #endif
|
2336
|
1272 defsubr (&Sframe_face_alist);
|
|
1273 defsubr (&Sset_frame_face_alist);
|
|
1274 defsubr (&Smake_face_internal);
|
|
1275 defsubr (&Sset_face_attribute_internal);
|
|
1276 defsubr (&Sinternal_next_face_id);
|
|
1277 }
|
2730
|
1278
|
9572
|
1279 #endif /* HAVE_FACES */
|