/* xfaces.c -- "Face" primitives.
-Copyright (C) 1993-1994, 1998-2015 Free Software Foundation, Inc.
+Copyright (C) 1993-1994, 1998-2016 Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
specs overwrite the font-spec in the 14th attribute.
- Faces are frame-local by nature because Emacs allows to define the
+ Faces are frame-local by nature because Emacs allows you to define the
same named face (face names are symbols) differently for different
frames. Each frame has an alist of face definitions for all named
faces. The value of a named face in such an alist is a Lisp vector
#include "lisp.h"
#include "character.h"
-#include "charset.h"
-#include "keyboard.h"
#include "frame.h"
-#include "termhooks.h"
#ifdef USE_MOTIF
#include <Xm/Xm.h>
#include "dispextern.h"
#include "blockinput.h"
#include "window.h"
-#include "intervals.h"
#include "termchar.h"
#include "font.h"
#endif /* HAVE_WINDOW_SYSTEM */
-/* Non-zero means face attributes have been changed since the last
+/* True means face attributes have been changed since the last
redisplay. Used in redisplay_internal. */
-int face_change_count;
+bool face_change;
/* True means don't display bold text if a face's foreground
and background colors are the inverse of the default colors of the
void
x_free_colors (struct frame *f, unsigned long *pixels, int npixels)
{
- int class = FRAME_DISPLAY_INFO (f)->visual->class;
-
/* If display has an immutable color map, freeing colors is not
necessary and some servers don't allow it. So don't do it. */
- if (class != StaticColor && class != StaticGray && class != TrueColor)
+ if (x_mutable_colormap (FRAME_X_VISUAL (f)))
{
#ifdef DEBUG_X_COLORS
unregister_colors (pixels, npixels);
#ifdef USE_X_TOOLKIT
-/* Free colors used on frame F. PIXELS is an array of NPIXELS pixel
+/* Free colors used on display DPY. PIXELS is an array of NPIXELS pixel
color values. Interrupt input must be blocked when this function
is called. */
unsigned long *pixels, int npixels)
{
struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
- int class = dpyinfo->visual->class;
/* If display has an immutable color map, freeing colors is not
necessary and some servers don't allow it. So don't do it. */
- if (class != StaticColor && class != StaticGray && class != TrueColor)
+ if (x_mutable_colormap (dpyinfo->visual))
{
#ifdef DEBUG_X_COLORS
unregister_colors (pixels, npixels);
/* Clear face caches, and recompute basic faces for frame F. Call
this after changing frame parameters on which those faces depend,
or when realized faces have been freed due to changing attributes
- of named faces. */
+ of named faces. */
void
recompute_basic_faces (struct frame *f)
#endif /* HAVE_WINDOW_SYSTEM */
}
-
DEFUN ("clear-face-cache", Fclear_face_cache, Sclear_face_cache, 0, 1, 0,
doc: /* Clear face caches on all frames.
Optional THOROUGHLY non-nil means try to free unused fonts, too. */)
(Lisp_Object thoroughly)
{
clear_face_cache (!NILP (thoroughly));
- ++face_change_count;
+ face_change = true;
windows_or_buffers_changed = 53;
return Qnil;
}
if (bitmap_id < 0)
{
- add_to_log ("Invalid or undefined bitmap `%s'", name, Qnil);
+ add_to_log ("Invalid or undefined bitmap `%s'", name);
bitmap_id = 0;
}
else
to the values in an existing cell. */
if (!defined_color (f, SSDATA (name), color, true))
{
- add_to_log ("Unable to load color \"%s\"", name, Qnil);
+ add_to_log ("Unable to load color \"%s\"", name);
switch (target_index)
{
|| SYMBOLP (attrs[LFACE_SWIDTH_INDEX]));
eassert (UNSPECIFIEDP (attrs[LFACE_HEIGHT_INDEX])
|| IGNORE_DEFFACE_P (attrs[LFACE_HEIGHT_INDEX])
- || INTEGERP (attrs[LFACE_HEIGHT_INDEX])
- || FLOATP (attrs[LFACE_HEIGHT_INDEX])
+ || NUMBERP (attrs[LFACE_HEIGHT_INDEX])
|| FUNCTIONP (attrs[LFACE_HEIGHT_INDEX]));
eassert (UNSPECIFIEDP (attrs[LFACE_WEIGHT_INDEX])
|| IGNORE_DEFFACE_P (attrs[LFACE_WEIGHT_INDEX])
Lisp_Object tortoise, hare;
if (STRINGP (face_name))
- face_name = intern (SSDATA (face_name));
+ face_name = Fintern (face_name, Qnil);
if (NILP (face_name) || !SYMBOLP (face_name))
return face_name;
face_name, NAMED_MERGE_POINT_NORMAL,
&named_merge_points))
{
- struct gcpro gcpro1;
Lisp_Object from[LFACE_VECTOR_SIZE];
bool ok = get_lface_attributes (f, face_name, from, false,
named_merge_points);
if (ok)
- {
- GCPRO1 (named_merge_point.face_name);
- merge_face_vectors (f, from, to, named_merge_points);
- UNGCPRO;
- }
+ merge_face_vectors (f, from, to, named_merge_points);
return ok;
}
else
{
if (err_msgs)
- add_to_log ("Invalid face color", color_name, Qnil);
+ add_to_log ("Invalid face color %S", color_name);
ok = false;
}
}
/* FACE_REF ought to be a face name. */
ok = merge_named_face (f, face_ref, to, named_merge_points);
if (!ok && err_msgs)
- add_to_log ("Invalid face reference: %s", face_ref, Qnil);
+ add_to_log ("Invalid face reference: %s", face_ref);
}
return ok;
/* Changing a named face means that all realized faces depending on
that face are invalid. Since we cannot tell which realized faces
depend on the face, make sure they are all removed. This is done
- by incrementing face_change_count. The next call to
- init_iterator will then free realized faces. */
+ by setting face_change. The next call to init_iterator will then
+ free realized faces. */
if (NILP (Fget (face, Qface_no_inherit)))
{
- ++face_change_count;
- windows_or_buffers_changed = 54;
+ if (f)
+ {
+ f->face_change = true;
+ fset_redisplay (f);
+ }
+ else
+ {
+ face_change = true;
+ windows_or_buffers_changed = 54;
+ }
}
eassert (LFACEP (lface));
(Lisp_Object from, Lisp_Object to, Lisp_Object frame, Lisp_Object new_frame)
{
Lisp_Object lface, copy;
+ struct frame *f;
CHECK_SYMBOL (from);
CHECK_SYMBOL (to);
strings etc. because 20.2 didn't do it either. */
lface = lface_from_face_name (NULL, from, true);
copy = Finternal_make_lisp_face (to, Qnil);
+ f = NULL;
}
else
{
CHECK_LIVE_FRAME (new_frame);
lface = lface_from_face_name (XFRAME (frame), from, true);
copy = Finternal_make_lisp_face (to, new_frame);
+ f = XFRAME (new_frame);
}
vcopy (copy, 0, XVECTOR (lface)->contents, LFACE_VECTOR_SIZE);
/* Changing a named face means that all realized faces depending on
that face are invalid. Since we cannot tell which realized faces
depend on the face, make sure they are all removed. This is done
- by incrementing face_change_count. The next call to
- init_iterator will then free realized faces. */
+ by setting face_change. The next call to init_iterator will then
+ free realized faces. */
if (NILP (Fget (to, Qface_no_inherit)))
{
- ++face_change_count;
- windows_or_buffers_changed = 55;
+ if (f)
+ {
+ f->face_change = true;
+ fset_redisplay (f);
+ }
+ else
+ {
+ face_change = true;
+ windows_or_buffers_changed = 55;
+ }
}
return to;
/* Set one of enum font_property_index (> 0) if ATTR is one of
font-related attributes other than QCfont and QCfontset. */
enum font_property_index prop_index = 0;
+ struct frame *f;
CHECK_SYMBOL (face);
CHECK_SYMBOL (attr);
/* Set lface to the Lisp attribute vector of FACE. */
if (EQ (frame, Qt))
{
+ f = NULL;
lface = lface_from_face_name (NULL, face, true);
/* When updating face-new-frame-defaults, we put :ignore-defface
{
if (NILP (frame))
frame = selected_frame;
+ f = XFRAME (frame);
CHECK_LIVE_FRAME (frame);
- lface = lface_from_face_name (XFRAME (frame), face, false);
+ lface = lface_from_face_name (f, face, false);
/* If a frame-local face doesn't exist yet, create one. */
if (NILP (lface))
else if (EQ (attr, QCfont))
{
#ifdef HAVE_WINDOW_SYSTEM
- if (EQ (frame, Qt) || FRAME_WINDOW_P (XFRAME (frame)))
+ if (EQ (frame, Qt) || FRAME_WINDOW_P (f))
{
if (!UNSPECIFIEDP (value) && !IGNORE_DEFFACE_P (value))
{
- struct frame *f;
+ struct frame *f1;
old_value = LFACE_FONT (lface);
if (! FONTP (value))
signal_error ("Invalid font or font-spec", value);
}
if (EQ (frame, Qt))
- f = XFRAME (selected_frame);
+ f1 = XFRAME (selected_frame);
else
- f = XFRAME (frame);
+ f1 = XFRAME (frame);
/* FIXME:
If frame is t, and selected frame is a tty frame, the font
can't be realized. An improvement would be to loop over frames
for a non-tty frame and use that. See discussion in Bug#18573.
For a daemon, frame may be an initial frame (Bug#18869). */
- if (FRAME_WINDOW_P (f))
+ if (FRAME_WINDOW_P (f1))
{
if (! FONT_OBJECT_P (value))
{
Lisp_Object *attrs = XVECTOR (lface)->contents;
Lisp_Object font_object;
- font_object = font_load_for_lface (f, attrs, value);
+ font_object = font_load_for_lface (f1, attrs, value);
if (NILP (font_object))
signal_error ("Font not available", value);
value = font_object;
}
- set_lface_from_font (f, lface, value, true);
+ set_lface_from_font (f1, lface, value, true);
+ f1->face_change = 1;
}
}
else
else if (EQ (attr, QCfontset))
{
#ifdef HAVE_WINDOW_SYSTEM
- if (EQ (frame, Qt) || FRAME_WINDOW_P (XFRAME (frame)))
+ if (EQ (frame, Qt) || FRAME_WINDOW_P (f))
{
Lisp_Object tmp;
/* Changing a named face means that all realized faces depending on
that face are invalid. Since we cannot tell which realized faces
depend on the face, make sure they are all removed. This is done
- by incrementing face_change_count. The next call to
- init_iterator will then free realized faces. */
+ by setting face_change. The next call to init_iterator will then
+ free realized faces. */
if (!EQ (frame, Qt)
&& NILP (Fget (face, Qface_no_inherit))
&& NILP (Fequal (old_value, value)))
{
- ++face_change_count;
- windows_or_buffers_changed = 56;
+ f->face_change = true;
+ fset_redisplay (f);
}
if (!UNSPECIFIEDP (value) && !IGNORE_DEFFACE_P (value)
/* Changing a named face means that all realized faces depending on
that face are invalid. Since we cannot tell which realized faces
depend on the face, make sure they are all removed. This is done
- by incrementing face_change_count. The next call to
- init_iterator will then free realized faces. */
+ by setting face_change. The next call to init_iterator will then
+ free realized faces. */
if (!NILP (face)
&& NILP (Fget (face, Qface_no_inherit)))
{
- ++face_change_count;
- windows_or_buffers_changed = 57;
+ f->face_change = true;
+ fset_redisplay (f);
}
}
c->faces_by_id[i] = NULL;
}
+ /* Forget the escape-glyph and glyphless-char faces. */
+ forget_escape_and_glyphless_faces ();
c->used = 0;
size = FACE_CACHE_BUCKETS_SIZE * sizeof *c->buckets;
memset (c->buckets, 0, size);
if (WINDOWP (f->root_window))
{
clear_current_matrices (f);
- windows_or_buffers_changed = 58;
+ fset_redisplay (f);
}
unblock_input ();
Lisp_Object rest;
FOR_EACH_FRAME (rest, frame)
free_realized_faces (FRAME_FACE_CACHE (XFRAME (frame)));
+ windows_or_buffers_changed = 58;
}
else
free_realized_faces (FRAME_FACE_CACHE (XFRAME (frame)));
that a face containing all the attributes in ATTRS, when merged with the
default face for display, can be represented in a way that's
- \(1) different in appearance than the default face, and
- \(2) `close in spirit' to what the attributes specify, if not exact. */
+ (1) different in appearance than the default face, and
+ (2) `close in spirit' to what the attributes specify, if not exact. */
static bool
x_supports_face_attributes_p (struct frame *f,
that a face containing all the attributes in ATTRS, when merged
with the default face for display, can be represented in a way that's
- \(1) different in appearance than the default face, and
- \(2) `close in spirit' to what the attributes specify, if not exact.
+ (1) different in appearance than the default face, and
+ (2) `close in spirit' to what the attributes specify, if not exact.
Point (2) implies that a `:weight black' attribute will be satisfied
by any terminal that can display bold, and a `:foreground "yellow"' as
that a face containing all the attributes in ATTRIBUTES, when merged
with the default face for display, can be represented in a way that's
- \(1) different in appearance than the default face, and
- \(2) `close in spirit' to what the attributes specify, if not exact.
+ (1) different in appearance than the default face, and
+ (2) `close in spirit' to what the attributes specify, if not exact.
Point (2) implies that a `:weight black' attribute will be satisfied by
any display that can display bold, and a `:foreground \"yellow\"' as long
realize_basic_faces (struct frame *f)
{
bool success_p = false;
- ptrdiff_t count = SPECPDL_INDEX ();
/* Block input here so that we won't be surprised by an X expose
event, for instance, without having the faces set up. */
block_input ();
- specbind (Qscalable_fonts_allowed, Qt);
if (realize_default_face (f))
{
success_p = true;
}
- unbind_to (count, Qnil);
unblock_input ();
return success_p;
}
if (STRINGP (color)
&& SCHARS (color)
&& CONSP (Vtty_defined_color_alist)
- && (def = assq_no_quit (color, call1 (Qtty_color_alist, frame)),
+ && (def = assoc_no_quit (color, call1 (Qtty_color_alist, frame)),
CONSP (def)))
{
/* Associations in tty-defined-color-alist are of the form
(Lisp_Object suppress)
{
tty_suppress_bold_inverse_default_colors_p = !NILP (suppress);
- ++face_change_count;
+ face_change = true;
return suppress;
}
abspath = Fexpand_file_name (filename, Qnil);
block_input ();
- fp = emacs_fopen (SSDATA (abspath), "rt");
+ fp = emacs_fopen (SSDATA (abspath), "r" FOPEN_TEXT);
if (fp)
{
char buf[512];
int num;
while (fgets (buf, sizeof (buf), fp) != NULL) {
- if (sscanf (buf, "%u %u %u %n", &red, &green, &blue, &num) == 3)
+ if (sscanf (buf, "%d %d %d %n", &red, &green, &blue, &num) == 3)
{
#ifdef HAVE_NTGUI
int color = RGB (red, green, blue);
/* Names of basic faces. */
DEFSYM (Qdefault, "default");
DEFSYM (Qtool_bar, "tool-bar");
- DEFSYM (Qregion, "region");
DEFSYM (Qfringe, "fringe");
DEFSYM (Qheader_line, "header-line");
DEFSYM (Qscroll_bar, "scroll-bar");
/* The name of the function used to compute colors on TTYs. */
DEFSYM (Qtty_color_alist, "tty-color-alist");
- /* Allowed scalable fonts. A value of nil means don't allow any
- scalable fonts. A value of t means allow the use of any scalable
- font. Otherwise, value must be a list of regular expressions. A
- font may be scaled if its name matches a regular expression in the
- list. */
- DEFSYM (Qscalable_fonts_allowed, "scalable-fonts-allowed");
-
Vparam_value_alist = list1 (Fcons (Qnil, Qnil));
staticpro (&Vparam_value_alist);
Vface_alternative_font_family_alist = Qnil;
only in that buffer. For instance, the mode my-mode could define a
face `my-mode-default', and then in the mode setup function, do:
- (set (make-local-variable 'face-remapping-alist)
- '((default my-mode-default)))).
+ (set (make-local-variable \\='face-remapping-alist)
+ \\='((default my-mode-default)))).
Because Emacs normally only redraws screen areas when the underlying
buffer contents change, you may need to call `redraw-display' after