2 Copyright (C) 1993 Free Software Foundation.
4 This file is part of GNU Emacs.
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
8 the Free Software Foundation; either version 2, or (at your option)
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.
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
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* This is derived from work by Lucid (some parts very loosely so). */
22 #include <sys/types.h>
32 #include "dispextern.h"
34 #include "blockinput.h"
37 /* Compensate for bug in Xos.h on some systems, on which it requires
38 time.h. On some such systems, Xos.h tries to redefine struct
39 timeval and struct timezone if USG is #defined while it is
41 #ifdef XOS_NEEDS_TIME_H
56 /* An explanation of the face data structures. */
58 /* ========================= Face Data Structures =========================
60 Let FACE-NAME be a symbol naming a face.
62 Let FACE-VECTOR be (assq FACE-NAME (frame-face-alist FRAME))
63 FACE-VECTOR is either nil, or a vector of the form
64 [face NAME ID FONT FOREGROUND BACKGROUND BACKGROUND-PIXMAP UNDERLINE-P]
66 face is the symbol `face',
67 NAME is the symbol with which this vector is associated (a backpointer),
68 ID is the face ID, an integer used internally by the C code to identify
70 FONT, FOREGROUND, and BACKGROUND are strings naming the fonts and colors
72 BACKGROUND-PIXMAP is the name of an x bitmap filename, which we don't
74 UNDERLINE-P is non-nil if the face should be underlined.
75 If any of these elements are nil, that parameter is considered
76 unspecified; parameters from faces specified by lower-priority
77 overlays or text properties, or the parameters of the frame itself,
78 can show through. (lisp/faces.el maintains these lists.)
80 (assq FACE-NAME global-face-data) returns a vector describing the
81 global parameters for that face.
83 Let PARAM-FACE be FRAME->display.x->param_faces[Faref (FACE-VECTOR, 2)].
84 PARAM_FACE is a struct face whose members are the Xlib analogues of
85 the parameters in FACE-VECTOR. If an element of FACE-VECTOR is
86 nil, then the corresponding member of PARAM_FACE is FACE_DEFAULT.
87 These faces are called "parameter faces", because they're the ones
88 lisp manipulates to control what gets displayed. Elements 0 and 1
89 of FRAME->display.x->param_faces are special - they describe the
90 default and mode line faces. None of the faces in param_faces have
91 GC's. (See src/dispextern.h for the definiton of struct face.
92 lisp/faces.el maintains the isomorphism between face_alist and
95 The functions compute_char_face and compute_glyph_face find and
96 combine the parameter faces associated with overlays and text
97 properties. The resulting faces are called "computed faces"; none
98 of their members are FACE_DEFAULT; they are completely specified.
99 They then call intern_compute_face to search
100 FRAME->display.x->computed_faces for a matching face, add one if
101 none is found, and return the index into
102 FRAME->display.x->computed_faces. FRAME's glyph matrices use these
103 indices to record the faces of the matrix characters, and the X
104 display hooks consult compute_faces to decide how to display these
105 characters. Elements 0 and 1 of computed_faces always describe the
106 default and mode-line faces.
108 Elements 0 and 1 of computed_faces have GC's; all the other faces
109 in computed_faces do not. The global array face_vector contains
110 faces with their GC's set. Given a computed_face, the function
111 intern_face finds (or adds) an element of face_vector with
112 equivalent parameters, and returns a pointer to that face, whose GC
113 can then be used for display.
117 Symbols naming faces must have associations on all frames; for any
118 FRAME, for all FACE-NAME, if (assq FACE-NAME (frame-face-alist
119 FRAME)) is non-nil, it must be non-nil for all frames.
121 Analogously, indices into param_faces must be valid on all frames;
122 if param_faces[i] is a non-zero face pointer on one frame, then it
123 must be filled in on all frames. Code assumes that face ID's can
124 be used on any frame.
128 Why do we keep param_faces and computed_faces separate?
129 computed_faces contains an element for every combination of facial
130 parameters we have ever displayed. indices into param_faces have
131 to be valid on all frames. If they were the same array, then that
132 array would grow very large on all frames, because any facial
133 combination displayed on any frame would need to be a valid entry
136 Since face_vector is just a cache --- there are no pointers into it
137 from the rest of the code, and everyone accesses it through
138 intern_face --- we could just free its GC's and throw the whole
139 thing away without breaking anything. This gives us a simple way
140 to garbage-collect old GC's nobody's using any more - we can just
141 purge face_vector, and then let subsequent calls to intern_face
142 refill it as needed. The function clear_face_vector performs this
145 We're often applying intern_face to faces in computed_faces -
146 for example, we do this while sending GLYPHs from a struct
147 frame_glyphs to X during redisplay. It would be nice to avoid
148 searching all of face_vector every time we intern a frame's face.
149 So, when intern_face finds a match for FACE in face_vector, it
150 stores the index of the match in FACE's cached_index member, and
151 checks there first next time. */
154 /* Definitions and declarations. */
156 /* A table of display faces. */
157 static struct face
**face_vector
;
158 /* The length in use of the table. */
160 /* The allocated length of the table. */
161 static int nfaces_allocated
;
163 /* The number of face-id's in use (same for all frames). */
166 /* The number of the face to use to indicate the region. */
169 /* This is what appears in a slot in a face to signify that the face
170 does not specify that display aspect. */
171 #define FACE_DEFAULT (~0)
173 Lisp_Object Qface
, Qmouse_face
;
175 static void build_face ( /* FRAME_PTR, struct face * */ );
176 int face_name_id_number ( /* FRAME_PTR, Lisp_Object name */ );
178 struct face
*intern_face ( /* FRAME_PTR, struct face * */ );
179 static int new_computed_face ( /* FRAME_PTR, struct face * */ );
180 static int intern_computed_face ( /* FRAME_PTR, struct face * */ );
181 static void ensure_face_ready ( /* FRAME_PTR, int id */ );
182 void recompute_basic_faces ( /* FRAME_PTR f */ );
184 /* Allocating, copying, and comparing struct faces. */
186 /* Allocate a new face */
190 struct face
*result
= (struct face
*) xmalloc (sizeof (struct face
));
191 bzero (result
, sizeof (struct face
));
192 result
->font
= (XFontStruct
*) FACE_DEFAULT
;
193 result
->foreground
= FACE_DEFAULT
;
194 result
->background
= FACE_DEFAULT
;
195 result
->stipple
= FACE_DEFAULT
;
199 /* Make a new face that's a copy of an existing one. */
204 struct face
*result
= allocate_face ();
206 result
->font
= face
->font
;
207 result
->foreground
= face
->foreground
;
208 result
->background
= face
->background
;
209 result
->stipple
= face
->stipple
;
210 result
->underline
= face
->underline
;
216 face_eql (face1
, face2
)
217 struct face
*face1
, *face2
;
219 return ( face1
->font
== face2
->font
220 && face1
->foreground
== face2
->foreground
221 && face1
->background
== face2
->background
222 && face1
->stipple
== face2
->stipple
223 && face1
->underline
== face2
->underline
);
226 /* Interning faces in the `face_vector' cache, and clearing that cache. */
228 /* Return the unique display face corresponding to the user-level face FACE.
229 If there isn't one, make one, and find a slot in the face_vector to
232 get_cached_face (f
, face
)
239 /* Perhaps FACE->cached_index is valid; this could happen if FACE is
240 in a frame's face list. */
241 if (face
->cached_index
>= 0
242 && face
->cached_index
< nfaces
243 && face_eql (face_vector
[face
->cached_index
], face
))
244 return face_vector
[face
->cached_index
];
246 /* Look for an existing display face that does the job.
247 Also find an empty slot if any. */
248 for (i
= 0; i
< nfaces
; i
++)
250 if (face_eql (face_vector
[i
], face
))
251 return face_vector
[i
];
252 if (face_vector
[i
] == 0)
256 /* If no empty slots, make one. */
257 if (empty
< 0 && nfaces
== nfaces_allocated
)
259 int newsize
= nfaces
+ 20;
261 = (struct face
**) xrealloc (face_vector
,
262 newsize
* sizeof (struct face
*));
263 nfaces_allocated
= newsize
;
269 /* Put a new display face in the empty slot. */
270 result
= copy_face (face
);
271 face_vector
[empty
] = result
;
273 /* Make a graphics context for it. */
274 build_face (f
, result
);
279 /* Given a computed face, return an equivalent display face
280 (one which has a graphics context). */
283 intern_face (f
, face
)
287 /* If it's equivalent to the default face, use that. */
288 if (face_eql (face
, FRAME_DEFAULT_FACE (f
)))
290 if (!FRAME_DEFAULT_FACE (f
)->gc
)
291 build_face (f
, FRAME_DEFAULT_FACE (f
));
292 return FRAME_DEFAULT_FACE (f
);
295 /* If it's equivalent to the mode line face, use that. */
296 if (face_eql (face
, FRAME_MODE_LINE_FACE (f
)))
298 if (!FRAME_MODE_LINE_FACE (f
)->gc
)
299 build_face (f
, FRAME_MODE_LINE_FACE (f
));
300 return FRAME_MODE_LINE_FACE (f
);
303 /* If it's not one of the frame's default faces, it shouldn't have a GC. */
307 /* Get a specialized display face. */
308 return get_cached_face (f
, face
);
311 /* Clear out face_vector and start anew.
312 This should be done from time to time just to avoid
313 keeping too many graphics contexts in face_vector
314 that are no longer needed. */
320 Display
*dpy
= x_current_display
;
324 /* Free the display faces in the face_vector. */
325 for (i
= 0; i
< nfaces
; i
++)
327 struct face
*face
= face_vector
[i
];
329 XFreeGC (dpy
, face
->gc
);
337 /* Allocating and freeing X resources for display faces. */
339 /* Make a graphics context for face FACE, which is on frame F,
340 if that can be done. */
352 if (face
->foreground
!= FACE_DEFAULT
)
353 xgcv
.foreground
= face
->foreground
;
355 xgcv
.foreground
= f
->display
.x
->foreground_pixel
;
357 if (face
->background
!= FACE_DEFAULT
)
358 xgcv
.background
= face
->background
;
360 xgcv
.background
= f
->display
.x
->background_pixel
;
362 if (face
->font
&& (int) face
->font
!= FACE_DEFAULT
)
363 xgcv
.font
= face
->font
->fid
;
365 xgcv
.font
= f
->display
.x
->font
->fid
;
367 xgcv
.graphics_exposures
= 0;
369 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
370 gc
= XCreateGC (x_current_display
, FRAME_X_WINDOW (f
),
374 if (face
->stipple
&& face
->stipple
!= FACE_DEFAULT
)
375 XSetStipple (x_current_display
, gc
, face
->stipple
);
383 /* Allocating, freeing, and duplicating fonts, colors, and pixmaps. */
393 return (XFontStruct
*) FACE_DEFAULT
;
395 CHECK_STRING (name
, 0);
397 font
= XLoadQueryFont (x_current_display
, (char *) XSTRING (name
)->data
);
401 Fsignal (Qerror
, Fcons (build_string ("undefined font"),
402 Fcons (name
, Qnil
)));
407 unload_font (f
, font
)
411 if (!font
|| font
== ((XFontStruct
*) FACE_DEFAULT
))
415 XFreeFont (x_current_display
, font
);
424 Display
*dpy
= x_current_display
;
432 cmap
= DefaultColormapOfScreen (DefaultScreenOfDisplay (x_current_display
));
434 CHECK_STRING (name
, 0);
436 result
= XParseColor (dpy
, cmap
, (char *) XSTRING (name
)->data
, &color
);
439 Fsignal (Qerror
, Fcons (build_string ("undefined color"),
440 Fcons (name
, Qnil
)));
442 result
= XAllocColor (dpy
, cmap
, &color
);
445 Fsignal (Qerror
, Fcons (build_string ("X server cannot allocate color"),
446 Fcons (name
, Qnil
)));
447 return (unsigned long) color
.pixel
;
451 unload_color (f
, pixel
)
455 /* Since faces get built by copying parameters from other faces, the
456 allocation counts for the colors get all screwed up. I don't see
457 any solution that will take less than 10 minutes, and it's better
458 to have a color leak than a crash, so I'm just dyking this out.
459 This isn't really a color leak, anyway - if we ask for it again,
460 we'll get the same pixel. */
463 Display
*dpy
= x_current_display
;
464 if (pixel
== FACE_DEFAULT
465 || pixel
== BLACK_PIX_DEFAULT
466 || pixel
== WHITE_PIX_DEFAULT
)
468 cmap
= DefaultColormapOfScreen (DefaultScreenOfDisplay (x_current_display
));
470 XFreeColors (dpy
, cmap
, &pixel
, 1, 0);
475 /* Managing parameter face arrays for frames. */
481 ensure_face_ready (f
, 0);
482 ensure_face_ready (f
, 1);
484 FRAME_N_COMPUTED_FACES (f
) = 0;
485 FRAME_SIZE_COMPUTED_FACES (f
) = 0;
487 new_computed_face (f
, FRAME_PARAM_FACES (f
)[0]);
488 new_computed_face (f
, FRAME_PARAM_FACES (f
)[1]);
489 recompute_basic_faces (f
);
491 /* Find another X frame. */
493 Lisp_Object tail
, frame
, result
;
496 FOR_EACH_FRAME (tail
, frame
)
497 if (FRAME_X_P (XFRAME (frame
))
498 && XFRAME (frame
) != f
)
504 /* If we didn't find any X frames other than f, then we don't need
505 any faces other than 0 and 1, so we're okay. Otherwise, make
506 sure that all faces valid on the selected frame are also valid
507 on this new frame. */
511 int n_faces
= FRAME_N_PARAM_FACES (XFRAME (result
));
512 struct face
**faces
= FRAME_PARAM_FACES (XFRAME (result
));
514 for (i
= 2; i
< n_faces
; i
++)
516 ensure_face_ready (f
, i
);
522 /* Called from Fdelete_frame. */
527 Display
*dpy
= x_current_display
;
532 for (i
= 0; i
< FRAME_N_PARAM_FACES (f
); i
++)
534 struct face
*face
= FRAME_PARAM_FACES (f
) [i
];
538 XFreeGC (dpy
, face
->gc
);
539 unload_font (f
, face
->font
);
540 unload_color (f
, face
->foreground
);
541 unload_color (f
, face
->background
);
543 unload_pixmap (f
, face
->stipple
);
548 xfree (FRAME_PARAM_FACES (f
));
549 FRAME_PARAM_FACES (f
) = 0;
550 FRAME_N_PARAM_FACES (f
) = 0;
552 /* All faces in FRAME_COMPUTED_FACES use resources copied from
553 FRAME_PARAM_FACES; we can free them without fuss. */
554 xfree (FRAME_COMPUTED_FACES (f
));
555 FRAME_COMPUTED_FACES (f
) = 0;
556 FRAME_N_COMPUTED_FACES (f
) = 0;
561 /* Interning faces in a frame's face array. */
564 new_computed_face (f
, new_face
)
566 struct face
*new_face
;
568 int i
= FRAME_N_COMPUTED_FACES (f
);
570 if (i
>= FRAME_SIZE_COMPUTED_FACES (f
))
572 int new_size
= i
+ 32;
574 FRAME_COMPUTED_FACES (f
)
575 = (struct face
**) (FRAME_SIZE_COMPUTED_FACES (f
) == 0
576 ? xmalloc (new_size
* sizeof (struct face
*))
577 : xrealloc (FRAME_COMPUTED_FACES (f
),
578 new_size
* sizeof (struct face
*)));
579 FRAME_SIZE_COMPUTED_FACES (f
) = new_size
;
582 i
= FRAME_N_COMPUTED_FACES (f
)++;
583 FRAME_COMPUTED_FACES (f
)[i
] = copy_face (new_face
);
588 /* Find a match for NEW_FACE in a FRAME's computed face array, and add
589 it if we don't find one. */
591 intern_computed_face (f
, new_face
)
593 struct face
*new_face
;
595 int len
= FRAME_N_COMPUTED_FACES (f
);
598 /* Search for a computed face already on F equivalent to FACE. */
599 for (i
= 0; i
< len
; i
++)
601 if (! FRAME_COMPUTED_FACES (f
)[i
])
603 if (face_eql (new_face
, FRAME_COMPUTED_FACES (f
)[i
]))
607 /* We didn't find one; add a new one. */
608 return new_computed_face (f
, new_face
);
611 /* Make parameter face id ID valid on frame F. */
614 ensure_face_ready (f
, id
)
618 if (FRAME_N_PARAM_FACES (f
) <= id
)
622 if (!FRAME_N_PARAM_FACES (f
))
623 FRAME_PARAM_FACES (f
)
624 = (struct face
**) xmalloc (sizeof (struct face
*) * n
);
626 FRAME_PARAM_FACES (f
)
627 = (struct face
**) xrealloc (FRAME_PARAM_FACES (f
),
628 sizeof (struct face
*) * n
);
630 bzero (FRAME_PARAM_FACES (f
) + FRAME_N_PARAM_FACES (f
),
631 (n
- FRAME_N_PARAM_FACES (f
)) * sizeof (struct face
*));
632 FRAME_N_PARAM_FACES (f
) = n
;
635 if (FRAME_PARAM_FACES (f
) [id
] == 0)
636 FRAME_PARAM_FACES (f
) [id
] = allocate_face ();
639 /* Return non-zero if FONT1 and FONT2 have the same width.
640 We do not check the height, because we can now deal with
642 We assume that they're both character-cell fonts. */
645 same_size_fonts (font1
, font2
)
646 XFontStruct
*font1
, *font2
;
648 XCharStruct
*bounds1
= &font1
->min_bounds
;
649 XCharStruct
*bounds2
= &font2
->min_bounds
;
651 return (bounds1
->width
== bounds2
->width
);
654 /* Update the line_height of frame F according to the biggest font in
655 any face. Return nonzero if if line_height changes. */
658 frame_update_line_height (f
)
662 int biggest
= FONT_HEIGHT (f
->display
.x
->font
);
664 for (i
= 0; i
< f
->display
.x
->n_param_faces
; i
++)
665 if (f
->display
.x
->param_faces
[i
] != 0
666 && f
->display
.x
->param_faces
[i
]->font
!= (XFontStruct
*) FACE_DEFAULT
)
668 int height
= FONT_HEIGHT (f
->display
.x
->param_faces
[i
]->font
);
669 if (height
> biggest
)
673 if (biggest
== f
->display
.x
->line_height
)
676 f
->display
.x
->line_height
= biggest
;
680 /* Modify face TO by copying from FROM all properties which have
681 nondefault settings. */
684 merge_faces (from
, to
)
685 struct face
*from
, *to
;
687 /* Only merge the font if it's the same width as the base font.
688 Otherwise ignore it, since we can't handle it properly. */
689 if (from
->font
!= (XFontStruct
*) FACE_DEFAULT
690 && same_size_fonts (from
->font
, to
->font
))
691 to
->font
= from
->font
;
692 if (from
->foreground
!= FACE_DEFAULT
)
693 to
->foreground
= from
->foreground
;
694 if (from
->background
!= FACE_DEFAULT
)
695 to
->background
= from
->background
;
696 if (from
->stipple
!= FACE_DEFAULT
)
697 to
->stipple
= from
->stipple
;
699 to
->underline
= from
->underline
;
702 /* Set up the basic set of facial parameters, based on the frame's
703 data; all faces are deltas applied to this. */
706 compute_base_face (f
, face
)
710 struct x_display
*d
= f
->display
.x
;
713 face
->foreground
= d
->foreground_pixel
;
714 face
->background
= d
->background_pixel
;
715 face
->font
= d
->font
;
719 /* Avoid a face comparison by making this invalid. */
720 face
->cached_index
= -1;
723 /* Return the face ID to use to display a special glyph which selects
724 FACE_CODE as the face ID, assuming that ordinarily the face would
725 be CURRENT_FACE. F is the frame. */
728 compute_glyph_face (f
, face_code
, current_face
)
730 int face_code
, current_face
;
734 face
= *FRAME_COMPUTED_FACES (f
)[current_face
];
736 if (face_code
>= 0 && face_code
< FRAME_N_PARAM_FACES (f
)
737 && FRAME_PARAM_FACES (f
) [face_code
] != 0)
738 merge_faces (FRAME_PARAM_FACES (f
) [face_code
], &face
);
740 return intern_computed_face (f
, &face
);
743 /* Return the face ID associated with a buffer position POS.
744 Store into *ENDPTR the position at which a different face is needed.
745 This does not take account of glyphs that specify their own face codes.
746 F is the frame in use for display, and W is a window displaying
749 REGION_BEG, REGION_END delimit the region, so it can be highlighted.
751 LIMIT is a position not to scan beyond. That is to limit
752 the time this function can take.
754 If MOUSE is nonzero, use the character's mouse-face, not its face. */
757 compute_char_face (f
, w
, pos
, region_beg
, region_end
, endptr
, limit
, mouse
)
761 int region_beg
, region_end
;
767 Lisp_Object prop
, position
;
770 Lisp_Object
*overlay_vec
;
773 Lisp_Object propname
;
775 /* W must display the current buffer. We could write this function
776 to use the frame and buffer of W, but right now it doesn't. */
777 if (XBUFFER (w
->buffer
) != current_buffer
)
780 XSET (frame
, Lisp_Frame
, f
);
783 if (pos
< region_beg
&& region_beg
< endpos
)
786 XFASTINT (position
) = pos
;
789 propname
= Qmouse_face
;
793 prop
= Fget_text_property (position
, propname
, w
->buffer
);
796 Lisp_Object limit1
, end
;
798 XFASTINT (limit1
) = (limit
< endpos
? limit
: endpos
);
799 end
= Fnext_single_property_change (position
, propname
, w
->buffer
, limit1
);
808 /* First try with room for 40 overlays. */
810 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
812 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, &next_overlay
);
814 /* If there are more than 40,
815 make enough space for all, and try again. */
819 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
820 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, &next_overlay
);
823 if (next_overlay
< endpos
)
824 endpos
= next_overlay
;
829 /* Optimize the default case. */
830 if (noverlays
== 0 && NILP (prop
)
831 && !(pos
>= region_beg
&& pos
< region_end
))
834 compute_base_face (f
, &face
);
838 facecode
= face_name_id_number (f
, prop
);
839 if (facecode
>= 0 && facecode
< FRAME_N_PARAM_FACES (f
)
840 && FRAME_PARAM_FACES (f
) [facecode
] != 0)
841 merge_faces (FRAME_PARAM_FACES (f
) [facecode
], &face
);
844 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
846 /* Now merge the overlay data in that order. */
847 for (i
= 0; i
< noverlays
; i
++)
849 prop
= Foverlay_get (overlay_vec
[i
], propname
);
855 facecode
= face_name_id_number (f
, prop
);
856 if (facecode
>= 0 && facecode
< FRAME_N_PARAM_FACES (f
)
857 && FRAME_PARAM_FACES (f
) [facecode
] != 0)
858 merge_faces (FRAME_PARAM_FACES (f
)[facecode
], &face
);
860 oend
= OVERLAY_END (overlay_vec
[i
]);
861 oendpos
= OVERLAY_POSITION (oend
);
862 if (oendpos
< endpos
)
867 if (pos
>= region_beg
&& pos
< region_end
)
869 if (region_end
< endpos
)
871 if (region_face
>= 0 && region_face
< next_face_id
)
872 merge_faces (FRAME_PARAM_FACES (f
)[region_face
], &face
);
877 return intern_computed_face (f
, &face
);
880 /* Recompute the GC's for the default and modeline faces.
881 We call this after changing frame parameters on which those GC's
885 recompute_basic_faces (f
)
888 /* If the frame's faces haven't been initialized yet, don't worry about
890 if (FRAME_N_PARAM_FACES (f
) < 2)
895 if (FRAME_DEFAULT_FACE (f
)->gc
)
896 XFreeGC (x_current_display
, FRAME_DEFAULT_FACE (f
)->gc
);
897 if (FRAME_MODE_LINE_FACE (f
)->gc
)
898 XFreeGC (x_current_display
, FRAME_MODE_LINE_FACE (f
)->gc
);
900 compute_base_face (f
, FRAME_DEFAULT_FACE (f
));
901 compute_base_face (f
, FRAME_MODE_LINE_FACE (f
));
903 merge_faces (FRAME_DEFAULT_PARAM_FACE (f
), FRAME_DEFAULT_FACE (f
));
904 merge_faces (FRAME_MODE_LINE_PARAM_FACE (f
), FRAME_MODE_LINE_FACE (f
));
906 build_face (f
, FRAME_DEFAULT_FACE (f
));
907 build_face (f
, FRAME_MODE_LINE_FACE (f
));
914 /* Lisp interface. */
916 DEFUN ("frame-face-alist", Fframe_face_alist
, Sframe_face_alist
, 1, 1, 0,
921 CHECK_FRAME (frame
, 0);
922 return XFRAME (frame
)->face_alist
;
925 DEFUN ("set-frame-face-alist", Fset_frame_face_alist
, Sset_frame_face_alist
,
928 Lisp_Object frame
, value
;
930 CHECK_FRAME (frame
, 0);
931 XFRAME (frame
)->face_alist
= value
;
936 DEFUN ("make-face-internal", Fmake_face_internal
, Smake_face_internal
, 1, 1, 0,
937 "Create face number FACE-ID on all frames.")
942 int id
= XINT (face_id
);
944 CHECK_NUMBER (face_id
, 0);
945 if (id
< 0 || id
>= next_face_id
)
946 error ("Face id out of range");
948 for (rest
= Vframe_list
; !NILP (rest
); rest
= XCONS (rest
)->cdr
)
950 struct frame
*f
= XFRAME (XCONS (rest
)->car
);
952 ensure_face_ready (f
, id
);
958 DEFUN ("set-face-attribute-internal", Fset_face_attribute_internal
,
959 Sset_face_attribute_internal
, 4, 4, 0, "")
960 (face_id
, attr_name
, attr_value
, frame
)
961 Lisp_Object face_id
, attr_name
, attr_value
, frame
;
968 CHECK_FRAME (frame
, 0);
969 CHECK_NUMBER (face_id
, 0);
970 CHECK_SYMBOL (attr_name
, 0);
974 if (id
< 0 || id
>= next_face_id
)
975 error ("Face id out of range");
980 ensure_face_ready (f
, id
);
981 face
= FRAME_PARAM_FACES (f
) [XFASTINT (face_id
)];
983 if (EQ (attr_name
, intern ("font")))
985 XFontStruct
*font
= load_font (f
, attr_value
);
986 if (face
->font
!= f
->display
.x
->font
)
987 unload_font (f
, face
->font
);
989 if (frame_update_line_height (f
))
990 x_set_window_size (f
, 0, f
->width
, f
->height
);
992 else if (EQ (attr_name
, intern ("foreground")))
994 unsigned long new_color
= load_color (f
, attr_value
);
995 unload_color (f
, face
->foreground
);
996 face
->foreground
= new_color
;
998 else if (EQ (attr_name
, intern ("background")))
1000 unsigned long new_color
= load_color (f
, attr_value
);
1001 unload_color (f
, face
->background
);
1002 face
->background
= new_color
;
1005 else if (EQ (attr_name
, intern ("background-pixmap")))
1007 unsigned int w
, h
, d
;
1008 unsigned long new_pixmap
= load_pixmap (f
, attr_value
, &w
, &h
, &d
, 0);
1009 unload_pixmap (f
, face
->stipple
);
1010 if (NILP (attr_value
))
1012 face
->stipple
= new_pixmap
;
1015 /* face->pixmap_depth = d; */
1018 else if (EQ (attr_name
, intern ("underline")))
1020 int new = !NILP (attr_value
);
1021 face
->underline
= new;
1024 error ("unknown face attribute");
1026 if (id
== 0 || id
== 1)
1027 recompute_basic_faces (f
);
1029 /* If we're modifying either of the frame's display faces, that
1030 means that we're changing the parameters of a fixed face code;
1031 since the color/font/whatever is changed but the face ID hasn't,
1032 redisplay won't know to redraw the affected sections. Give it a
1034 if (id
== 0 || id
== 1)
1035 SET_FRAME_GARBAGED (f
);
1037 /* Otherwise, it's enough to tell it to redisplay the text. */
1038 windows_or_buffers_changed
= 1;
1043 DEFUN ("internal-next-face-id", Finternal_next_face_id
, Sinternal_next_face_id
,
1047 return make_number (next_face_id
++);
1050 /* Return the face id for name NAME on frame FRAME.
1051 (It should be the same for all frames,
1052 but it's as easy to use the "right" frame to look it up
1053 as to use any other one.) */
1056 face_name_id_number (f
, name
)
1062 tem
= Fcdr (assq_no_quit (name
, f
->face_alist
));
1065 CHECK_VECTOR (tem
, 0);
1066 tem
= XVECTOR (tem
)->contents
[2];
1067 CHECK_NUMBER (tem
, 0);
1071 /* Emacs initialization. */
1076 Qface
= intern ("face");
1078 Qmouse_face
= intern ("mouse-face");
1079 staticpro (&Qmouse_face
);
1081 DEFVAR_INT ("region-face", ®ion_face
,
1082 "Face number to use to highlight the region\n\
1083 The region is highlighted with this face\n\
1084 when Transient Mark mode is enabled and the mark is active.");
1086 defsubr (&Sframe_face_alist
);
1087 defsubr (&Sset_frame_face_alist
);
1088 defsubr (&Smake_face_internal
);
1089 defsubr (&Sset_face_attribute_internal
);
1090 defsubr (&Sinternal_next_face_id
);
1093 #endif /* HAVE_X_WINDOWS */