/* xfaces.c -- "Face" primitives.
-Copyright (C) 1993, 1994, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
- 2005, 2006, 2007, 2008, 2009, 2010
- Free Software Foundation, Inc.
+Copyright (C) 1993-1994, 1998-2011 Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include <X11/Xos.h>
#define USG
#define __TIMEVAL__
+#if defined USG || defined __TIMEVAL__ /* Don't warn about unused macros. */
+#endif
#else /* not XOS_NEEDS_TIME_H */
#include <X11/Xos.h>
#endif /* not XOS_NEEDS_TIME_H */
#define DIM(VECTOR) (sizeof (VECTOR) / sizeof *(VECTOR))
-/* Make a copy of string S on the stack using alloca. Value is a pointer
- to the copy. */
-
-#define STRDUPA(S) strcpy ((char *) alloca (strlen ((S)) + 1), (S))
-
-/* Make a copy of the contents of Lisp string S on the stack using
- alloca. Value is a pointer to the copy. */
-
-#define LSTRDUPA(S) STRDUPA (SDATA ((S)))
-
/* Size of hash table of realized faces in face caches (should be a
prime number). */
/* Keyword symbols used for face attribute names. */
-Lisp_Object QCfamily, QCheight, QCweight, QCslant, QCunderline;
-Lisp_Object QCinverse_video, QCforeground, QCbackground, QCstipple;
-Lisp_Object QCwidth, QCfont, QCbold, QCitalic;
-Lisp_Object QCreverse_video;
-Lisp_Object QCoverline, QCstrike_through, QCbox, QCinherit;
-Lisp_Object QCfontset;
+Lisp_Object QCfamily, QCheight, QCweight, QCslant;
+static Lisp_Object QCunderline;
+static Lisp_Object QCinverse_video, QCstipple;
+Lisp_Object QCforeground, QCbackground;
+Lisp_Object QCwidth;
+static Lisp_Object QCfont, QCbold, QCitalic;
+static Lisp_Object QCreverse_video;
+static Lisp_Object QCoverline, QCstrike_through, QCbox, QCinherit;
+static Lisp_Object QCfontset;
/* Symbols used for attribute values. */
-Lisp_Object Qnormal, Qbold, Qultra_light, Qextra_light, Qlight;
-Lisp_Object Qsemi_light, Qsemi_bold, Qextra_bold, Qultra_bold;
-Lisp_Object Qoblique, Qitalic, Qreverse_oblique, Qreverse_italic;
-Lisp_Object Qultra_condensed, Qextra_condensed, Qcondensed;
-Lisp_Object Qsemi_condensed, Qsemi_expanded, Qexpanded, Qextra_expanded;
-Lisp_Object Qultra_expanded;
-Lisp_Object Qreleased_button, Qpressed_button;
-Lisp_Object QCstyle, QCcolor, QCline_width;
-Lisp_Object Qunspecified;
-Lisp_Object Qignore_defface;
+Lisp_Object Qnormal;
+Lisp_Object Qbold;
+static Lisp_Object Qultra_light, Qextra_light, Qlight;
+static Lisp_Object Qsemi_light, Qsemi_bold, Qextra_bold, Qultra_bold;
+static Lisp_Object Qoblique, Qreverse_oblique, Qreverse_italic;
+Lisp_Object Qitalic;
+static Lisp_Object Qultra_condensed, Qextra_condensed;
+Lisp_Object Qcondensed;
+static Lisp_Object Qsemi_condensed, Qsemi_expanded, Qextra_expanded;
+Lisp_Object Qexpanded;
+static Lisp_Object Qultra_expanded;
+static Lisp_Object Qreleased_button, Qpressed_button;
+static Lisp_Object QCstyle, QCcolor, QCline_width;
+Lisp_Object Qunspecified; /* used in dosfns.c */
+static Lisp_Object Qignore_defface;
char unspecified_fg[] = "unspecified-fg", unspecified_bg[] = "unspecified-bg";
/* Names of basic faces. */
-Lisp_Object Qdefault, Qtool_bar, Qregion, Qfringe;
-Lisp_Object Qheader_line, Qscroll_bar, Qcursor, Qborder, Qmouse, Qmenu;
-Lisp_Object Qmode_line_inactive, Qvertical_border;
+Lisp_Object Qdefault, Qtool_bar, Qfringe;
+static Lisp_Object Qregion;
+Lisp_Object Qheader_line, Qscroll_bar, Qcursor;
+static Lisp_Object Qborder, Qmouse, Qmenu;
+Lisp_Object Qmode_line_inactive;
+static Lisp_Object Qvertical_border;
/* The symbol `face-alias'. A symbols having that property is an
alias for another face. Value of the property is the name of
the aliased face. */
-Lisp_Object Qface_alias;
-
-/* Default stipple pattern used on monochrome displays. This stipple
- pattern is used on monochrome displays instead of shades of gray
- for a face background color. See `set-face-stipple' for possible
- values for this variable. */
-
-Lisp_Object Vface_default_stipple;
+static Lisp_Object Qface_alias;
/* Alist of alternative font families. Each element is of the form
(FAMILY FAMILY1 FAMILY2 ...). If fonts of FAMILY can't be loaded,
font may be scaled if its name matches a regular expression in the
list. */
-Lisp_Object Vscalable_fonts_allowed, Qscalable_fonts_allowed;
-
-/* List of regular expressions that matches names of fonts to ignore. */
-
-Lisp_Object Vface_ignored_fonts;
-
-/* Alist of font name patterns vs the rescaling factor. */
-
-Lisp_Object Vface_font_rescale_alist;
+static Lisp_Object Qscalable_fonts_allowed;
-/* Maximum number of fonts to consider in font_list. If not an
- integer > 0, DEFAULT_FONT_LIST_LIMIT is used instead. */
-
-Lisp_Object Vfont_list_limit;
#define DEFAULT_FONT_LIST_LIMIT 100
/* The symbols `foreground-color' and `background-color' which can be
/* Property for basic faces which other faces cannot inherit. */
-Lisp_Object Qface_no_inherit;
+static Lisp_Object Qface_no_inherit;
/* Error symbol for wrong_type_argument in load_pixmap. */
-Lisp_Object Qbitmap_spec_p;
-
-/* Alist of global face definitions. Each element is of the form
- (FACE . LFACE) where FACE is a symbol naming a face and LFACE
- is a Lisp vector of face attributes. These faces are used
- to initialize faces for new frames. */
-
-Lisp_Object Vface_new_frame_defaults;
-
-/* Alist of face remappings. Each element is of the form:
- (FACE REPLACEMENT...) which causes display of the face FACE to use
- REPLACEMENT... instead. REPLACEMENT... is interpreted the same way
- the value of a `face' text property is: it may be (1) A face name,
- (2) A list of face names, (3) A property-list of face attribute/value
- pairs, or (4) A list of face names intermixed with lists containing
- face attribute/value pairs.
-
- Multiple entries in REPLACEMENT... are merged together to form the final
- result, with faces or attributes earlier in the list taking precedence
- over those that are later.
-
- Face-name remapping cycles are suppressed; recursive references use
- the underlying face instead of the remapped face. */
-
-Lisp_Object Vface_remapping_alist;
+static Lisp_Object Qbitmap_spec_p;
/* The next ID to assign to Lisp faces. */
/* TTY color-related functions (defined in tty-colors.el). */
-Lisp_Object Qtty_color_desc, Qtty_color_by_index, Qtty_color_standard_values;
+static Lisp_Object Qtty_color_desc, Qtty_color_by_index, Qtty_color_standard_values;
/* The name of the function used to compute colors on TTYs. */
-Lisp_Object Qtty_color_alist;
-
-/* An alist of defined terminal colors and their RGB values. */
-
-Lisp_Object Vtty_defined_color_alist;
+static Lisp_Object Qtty_color_alist;
/* Counter for calls to clear_face_cache. If this counter reaches
CLEAR_FONT_TABLE_COUNT, and a frame has more than
display. This is a kluge to suppress `bold black' foreground text
which is hard to read on an LCD monitor. */
-int tty_suppress_bold_inverse_default_colors_p;
+static int tty_suppress_bold_inverse_default_colors_p;
/* A list of the form `((x . y))' used to avoid consing in
Finternal_set_lisp_face_attribute. */
/* Non-zero means the definition of the `menu' face for new frames has
been changed. */
-int menu_face_changed_default;
+static int menu_face_changed_default;
\f
/* Function prototypes. */
}
+#ifdef USE_X_TOOLKIT
+
/* Free colors used on frame F. PIXELS is an array of NPIXELS pixel
color values. Interrupt input must be blocked when this function
is called. */
XFreeColors (dpy, cmap, pixels, npixels, 0);
}
}
-
+#endif /* USE_X_TOOLKIT */
/* Create and return a GC for use on frame F. GC values and mask
are given by XGCV and MASK. */
are in ISO8859-1. */
int
-xstrcasecmp (const unsigned char *s1, const unsigned char *s2)
+xstrcasecmp (const char *s1, const char *s2)
{
while (*s1 && *s2)
{
- unsigned char c1 = tolower (*s1);
- unsigned char c2 = tolower (*s2);
+ unsigned char b1 = *s1;
+ unsigned char b2 = *s2;
+ unsigned char c1 = tolower (b1);
+ unsigned char c2 = tolower (b2);
if (c1 != c2)
return c1 < c2 ? -1 : 1;
++s1, ++s2;
{
#ifdef HAVE_WINDOW_SYSTEM
Lisp_Object tail, frame;
- struct frame *f;
if (clear_fonts_p
|| ++clear_font_table_count == CLEAR_FONT_TABLE_COUNT)
/* Clear GCs of realized faces. */
FOR_EACH_FRAME (tail, frame)
{
- f = XFRAME (frame);
+ struct frame *f = XFRAME (frame);
if (FRAME_WINDOW_P (f))
clear_face_gcs (FRAME_FACE_CACHE (f));
}
h = XINT (Fcar (Fcdr (name)));
bits = Fcar (Fcdr (Fcdr (name)));
- bitmap_id = x_create_bitmap_from_data (f, SDATA (bits),
+ bitmap_id = x_create_bitmap_from_data (f, SSDATA (bits),
w, h);
}
else
/* A version of defined_color for non-X frames. */
-int
+static int
tty_defined_color (struct frame *f, const char *color_name,
XColor *color_def, int alloc)
{
This does the right thing for any type of frame. */
-int
+static int
defined_color (struct frame *f, const char *color_name, XColor *color_def, int alloc)
{
if (!FRAME_WINDOW_P (f))
else
CHECK_FRAME (frame);
f = XFRAME (frame);
- return face_color_gray_p (f, SDATA (color)) ? Qt : Qnil;
+ return face_color_gray_p (f, SSDATA (color)) ? Qt : Qnil;
}
else
CHECK_FRAME (frame);
f = XFRAME (frame);
- if (face_color_supported_p (f, SDATA (color), !NILP (background_p)))
+ if (face_color_supported_p (f, SSDATA (color), !NILP (background_p)))
return Qt;
return Qnil;
}
/* if the color map is full, defined_color will return a best match
to the values in an existing cell. */
- if (!defined_color (f, SDATA (name), &color, 1))
+ if (!defined_color (f, SSDATA (name), &color, 1))
{
add_to_log ("Unable to load color \"%s\"", name, Qnil);
face_color_supported_p is smart enough to know that grays are
"supported" as background because we are supposed to use stipple
for them. */
- if (!face_color_supported_p (f, SDATA (bg), 0)
+ if (!face_color_supported_p (f, SSDATA (bg), 0)
&& !NILP (Fbitmap_spec_p (Vface_default_stipple)))
{
x_destroy_bitmap (f, face->stipple);
if (idx <= FONT_REGISTRY_INDEX)
{
if (STRINGP (val1))
- result = STRINGP (val2) ? strcmp (SDATA (val1), SDATA (val2)) : -1;
+ result = STRINGP (val2) ? strcmp (SSDATA (val1), SSDATA (val2)) : -1;
else
result = STRINGP (val2) ? 1 : 0;
}
(Lisp_Object pattern, Lisp_Object face, Lisp_Object frame, Lisp_Object maximum, Lisp_Object width)
{
struct frame *f;
- int size, avgwidth;
+ int size, avgwidth IF_LINT (= 0);
check_x ();
CHECK_STRING (pattern);
/* This is of limited utility since it works with character
widths. Keep it for compatibility. --gerd. */
int face_id = lookup_named_face (f, face, 0);
- struct face *face = (face_id < 0
- ? NULL
- : FACE_FROM_ID (f, face_id));
+ struct face *width_face = (face_id < 0
+ ? NULL
+ : FACE_FROM_ID (f, face_id));
- if (face && face->font)
+ if (width_face && width_face->font)
{
- size = face->font->pixel_size;
- avgwidth = face->font->average_width;
+ size = width_face->font->pixel_size;
+ avgwidth = width_face->font->average_width;
}
else
{
{
/* This is a scalable font. For backward compatibility,
we set the specified size. */
- font_entity = Fcopy_font_spec (font_entity);
+ font_entity = copy_font_spec (font_entity);
ASET (font_entity, FONT_SIZE_INDEX,
AREF (font_spec, FONT_SIZE_INDEX));
}
#define LFACE_INHERIT(LFACE) AREF ((LFACE), LFACE_INHERIT_INDEX)
#define LFACE_FONTSET(LFACE) AREF ((LFACE), LFACE_FONTSET_INDEX)
+#if XASSERTS
/* Non-zero if LFACE is a Lisp face. A Lisp face is a vector of size
LFACE_VECTOR_SIZE which has the symbol `face' in slot 0. */
#define LFACEP(LFACE) \
(VECTORP (LFACE) \
- && XVECTOR (LFACE)->size == LFACE_VECTOR_SIZE \
+ && ASIZE (LFACE) == LFACE_VECTOR_SIZE \
&& EQ (AREF (LFACE, 0), Qface))
+#endif
#if GLYPH_DEBUG
Lisp_Object tortoise, hare;
if (STRINGP (face_name))
- face_name = intern (SDATA (face_name));
+ face_name = intern (SSDATA (face_name));
if (NILP (face_name) || !SYMBOLP (face_name))
return face_name;
`relative' heights; the returned value is always an absolute height
unless both FROM and TO are relative. */
-Lisp_Object
+static Lisp_Object
merge_face_heights (Lisp_Object from, Lisp_Object to, Lisp_Object invalid)
{
Lisp_Object result = invalid;
if (!UNSPECIFIEDP (from[i]))
{
if (!UNSPECIFIEDP (to[i]))
- to[i] = Fmerge_font_spec (from[i], to[i]);
+ to[i] = merge_font_spec (from[i], to[i]);
else
- to[i] = Fcopy_font_spec (from[i]);
+ to[i] = copy_font_spec (from[i]);
if (! NILP (AREF (to[i], FONT_FOUNDRY_INDEX)))
to[LFACE_FOUNDRY_INDEX] = SYMBOL_NAME (AREF (to[i], FONT_FOUNDRY_INDEX));
if (! NILP (AREF (to[i], FONT_FAMILY_INDEX)))
{
/* The default face must have an absolute size. */
if (!INTEGERP (value) || XINT (value) <= 0)
- signal_error ("Invalid default face height", value);
+ signal_error ("Default face height not absolute and positive", value);
}
else
{
make_number (10),
Qnil);
if (!INTEGERP (test) || XINT (test) <= 0)
- signal_error ("Invalid face height", value);
+ signal_error ("Face height does not produce a positive integer", value);
}
}
xassert (STRINGP (value));
- if (xstrcasecmp (SDATA (value), "on") == 0
- || xstrcasecmp (SDATA (value), "true") == 0)
+ if (xstrcasecmp (SSDATA (value), "on") == 0
+ || xstrcasecmp (SSDATA (value), "true") == 0)
result = Qt;
- else if (xstrcasecmp (SDATA (value), "off") == 0
- || xstrcasecmp (SDATA (value), "false") == 0)
+ else if (xstrcasecmp (SSDATA (value), "off") == 0
+ || xstrcasecmp (SSDATA (value), "false") == 0)
result = Qnil;
- else if (xstrcasecmp (SDATA (value), "unspecified") == 0)
+ else if (xstrcasecmp (SSDATA (value), "unspecified") == 0)
result = Qunspecified;
else if (signal_p)
signal_error ("Invalid face attribute value from X resource", value);
CHECK_SYMBOL (attr);
CHECK_STRING (value);
- if (xstrcasecmp (SDATA (value), "unspecified") == 0)
+ if (xstrcasecmp (SSDATA (value), "unspecified") == 0)
value = Qunspecified;
else if (EQ (attr, QCheight))
{
else if (EQ (attr, QCbold) || EQ (attr, QCitalic))
value = face_boolean_x_resource_value (value, 1);
else if (EQ (attr, QCweight) || EQ (attr, QCslant) || EQ (attr, QCwidth))
- value = intern (SDATA (value));
+ value = intern (SSDATA (value));
else if (EQ (attr, QCreverse_video) || EQ (attr, QCinverse_video))
value = face_boolean_x_resource_value (value, 1);
else if (EQ (attr, QCunderline)
char line[512];
Lisp_Object lface = lface_from_face_name (f, Qmenu, 1);
struct face *face = FACE_FROM_ID (f, MENU_FACE_ID);
- const char *myname = SDATA (Vx_resource_name);
+ const char *myname = SSDATA (Vx_resource_name);
int changed_p = 0;
#ifdef USE_MOTIF
const char *popup_path = "popup_menu";
if (! NILP (xlfd))
{
#if defined HAVE_X_I18N
- char *fontsetname = xic_create_fontsetname (SDATA (xlfd), motif);
+ char *fontsetname = xic_create_fontsetname (SSDATA (xlfd), motif);
#else
- char *fontsetname = (char *) SDATA (xlfd);
+ char *fontsetname = SSDATA (xlfd);
#endif
sprintf (line, "%s.pane.menubar*font%s: %s",
myname, suffix, fontsetname);
myname, popup_path, suffix, fontsetname);
XrmPutLineResource (&rdb, line);
changed_p = 1;
- if (fontsetname != (char *) SDATA (xlfd))
+ if (fontsetname != SSDATA (xlfd))
xfree (fontsetname);
}
}
{
struct frame *f = frame_or_selected_frame (frame, 1);
int face_id = lookup_named_face (f, face, 1);
- struct face *face = FACE_FROM_ID (f, face_id);
+ struct face *fface = FACE_FROM_ID (f, face_id);
- if (! face)
+ if (! fface)
return Qnil;
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f) && !NILP (character))
{
CHECK_CHARACTER (character);
- face_id = FACE_FOR_CHAR (f, face, XINT (character), -1, Qnil);
- face = FACE_FROM_ID (f, face_id);
+ face_id = FACE_FOR_CHAR (f, fface, XINT (character), -1, Qnil);
+ fface = FACE_FROM_ID (f, face_id);
}
- return (face->font
- ? face->font->props[FONT_NAME_INDEX]
+ return (fface->font
+ ? fface->font->props[FONT_NAME_INDEX]
: Qnil);
#else /* !HAVE_WINDOW_SYSTEM */
return build_string (FRAME_MSDOS_P (f)
{
xassert (lface_fully_specified_p (lface1)
&& lface_fully_specified_p (lface2));
- return (xstrcasecmp (SDATA (lface1[LFACE_FAMILY_INDEX]),
- SDATA (lface2[LFACE_FAMILY_INDEX])) == 0
- && xstrcasecmp (SDATA (lface1[LFACE_FOUNDRY_INDEX]),
- SDATA (lface2[LFACE_FOUNDRY_INDEX])) == 0
+ return (xstrcasecmp (SSDATA (lface1[LFACE_FAMILY_INDEX]),
+ SSDATA (lface2[LFACE_FAMILY_INDEX])) == 0
+ && xstrcasecmp (SSDATA (lface1[LFACE_FOUNDRY_INDEX]),
+ SSDATA (lface2[LFACE_FOUNDRY_INDEX])) == 0
&& EQ (lface1[LFACE_HEIGHT_INDEX], lface2[LFACE_HEIGHT_INDEX])
&& EQ (lface1[LFACE_SWIDTH_INDEX], lface2[LFACE_SWIDTH_INDEX])
&& EQ (lface1[LFACE_WEIGHT_INDEX], lface2[LFACE_WEIGHT_INDEX])
&& (EQ (lface1[LFACE_FONTSET_INDEX], lface2[LFACE_FONTSET_INDEX])
|| (STRINGP (lface1[LFACE_FONTSET_INDEX])
&& STRINGP (lface2[LFACE_FONTSET_INDEX])
- && ! xstrcasecmp (SDATA (lface1[LFACE_FONTSET_INDEX]),
- SDATA (lface2[LFACE_FONTSET_INDEX]))))
+ && ! xstrcasecmp (SSDATA (lface1[LFACE_FONTSET_INDEX]),
+ SSDATA (lface2[LFACE_FONTSET_INDEX]))))
);
}
/* Free realized face FACE, including its X resources. FACE may
be null. */
-void
+static void
free_realized_face (struct frame *f, struct face *face)
{
if (face)
f = XFRAME (frame);
if (!(CONSP (color1) && parse_rgb_list (color1, &cdef1))
- && !(STRINGP (color1) && defined_color (f, SDATA (color1), &cdef1, 0)))
+ && !(STRINGP (color1) && defined_color (f, SSDATA (color1), &cdef1, 0)))
signal_error ("Invalid color", color1);
if (!(CONSP (color2) && parse_rgb_list (color2, &cdef2))
- && !(STRINGP (color2) && defined_color (f, SDATA (color2), &cdef2, 0)))
+ && !(STRINGP (color2) && defined_color (f, SSDATA (color2), &cdef2, 0)))
signal_error ("Invalid color", color2);
return make_number (color_distance (&cdef1, &cdef2));
}
-/* Free all realized faces that are using FONTSET on frame F. */
-
-void
-free_realized_faces_for_fontset (struct frame *f, int fontset)
-{
- struct face_cache *cache = FRAME_FACE_CACHE (f);
- struct face *face;
- int i;
-
- /* We must block input here because we can't process X events safely
- while only some faces are freed, or when the frame's current
- matrix still references freed faces. */
- BLOCK_INPUT;
-
- for (i = 0; i < cache->used; i++)
- {
- face = cache->faces_by_id[i];
- if (face
- && face->fontset == fontset)
- {
- uncache_face (cache, face);
- free_realized_face (f, face);
- }
- }
-
- /* Must do a thorough redisplay the next time. Mark current
- matrices as invalid because they will reference faces freed
- above. This function is also called when a frame is destroyed.
- In this case, the root window of F is nil. */
- if (WINDOWP (f->root_window))
- {
- clear_current_matrices (f);
- ++windows_or_buffers_changed;
- }
-
- UNBLOCK_INPUT;
-}
-
-
/* Free all realized faces on FRAME or on all frames if FRAME is nil.
This is done after attributes of a named face have been changed,
because we can't tell which realized faces depend on that face. */
Value is the ID of the face found. If no suitable face is found,
realize a new one. */
-INLINE int
+static INLINE int
lookup_face (struct frame *f, Lisp_Object *attr)
{
struct face_cache *cache = FRAME_FACE_CACHE (f);
}
-/* Return the ID of the realized ASCII face of Lisp face with ID
- LFACE_ID on frame F. Value is -1 if LFACE_ID isn't valid. */
-
-int
-ascii_face_of_lisp_face (struct frame *f, int lface_id)
-{
- int face_id;
-
- if (lface_id >= 0 && lface_id < lface_id_to_name_size)
- {
- Lisp_Object face_name = lface_id_to_name[lface_id];
- face_id = lookup_named_face (f, face_name, 1);
- }
- else
- face_id = -1;
-
- return face_id;
-}
-
-
/* Return a face for charset ASCII that is like the face with id
FACE_ID on frame F, but has a font that is STEPS steps smaller.
STEPS < 0 means larger. Value is the id of the face. */
#ifdef HAVE_WINDOW_SYSTEM
-/* Ignore the difference of font point size less than this value. */
-
-#define FONT_POINT_SIZE_QUANTUM 5
-
/* Return the fontset id of the base fontset name or alias name given
by the fontset attribute of ATTRS. Value is -1 if the fontset
attribute of ATTRS doesn't name a fontset. */
Lisp_Object lface = lface_from_face_name (f, symbol, 0);
Lisp_Object attrs[LFACE_VECTOR_SIZE];
Lisp_Object symbol_attrs[LFACE_VECTOR_SIZE];
- struct face *new_face;
/* The default face must exist and be fully specified. */
get_lface_attributes_no_remap (f, Qdefault, attrs, 1);
merge_face_vectors (f, symbol_attrs, attrs, 0);
/* Realize the face. */
- new_face = realize_face (c, attrs, id);
+ realize_face (c, attrs, id);
}
{
Lisp_Object frame, color, def;
int foreground_p = idx == LFACE_FOREGROUND_INDEX;
- unsigned long default_pixel, default_other_pixel, pixel;
+ unsigned long default_pixel =
+ foreground_p ? FACE_TTY_DEFAULT_FG_COLOR : FACE_TTY_DEFAULT_BG_COLOR;
+ unsigned long pixel = default_pixel;
+#ifdef MSDOS
+ unsigned long default_other_pixel =
+ foreground_p ? FACE_TTY_DEFAULT_BG_COLOR : FACE_TTY_DEFAULT_FG_COLOR;
+#endif
xassert (idx == LFACE_FOREGROUND_INDEX || idx == LFACE_BACKGROUND_INDEX);
- if (foreground_p)
- {
- pixel = default_pixel = FACE_TTY_DEFAULT_FG_COLOR;
- default_other_pixel = FACE_TTY_DEFAULT_BG_COLOR;
- }
- else
- {
- pixel = default_pixel = FACE_TTY_DEFAULT_BG_COLOR;
- default_other_pixel = FACE_TTY_DEFAULT_FG_COLOR;
- }
-
XSETFRAME (frame, f);
color = face->lface[idx];
{
int face_id;
- if (NILP (current_buffer->enable_multibyte_characters))
+ if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
ch = 0;
if (NILP (prop))
if we don't have fonts, so we can stop here if not working
on a window-system frame. */
|| !FRAME_WINDOW_P (f)
- || FACE_SUITABLE_FOR_CHAR_P (base_face, 0)))
+ || FACE_SUITABLE_FOR_ASCII_CHAR_P (base_face, 0)))
return base_face->id;
/* Begin with attributes from the base face. */
CHECK_STRING (filename);
abspath = Fexpand_file_name (filename, Qnil);
- fp = fopen (SDATA (filename), "rt");
+ fp = fopen (SDATA (abspath), "rt");
if (fp)
{
char buf[512];
defsubr (&Sdump_colors);
#endif
- DEFVAR_LISP ("font-list-limit", &Vfont_list_limit,
+ DEFVAR_LISP ("font-list-limit", Vfont_list_limit,
doc: /* *Limit for font matching.
If an integer > 0, font matching functions won't load more than
that number of fonts when searching for a matching font. */);
Vfont_list_limit = make_number (DEFAULT_FONT_LIST_LIMIT);
- DEFVAR_LISP ("face-new-frame-defaults", &Vface_new_frame_defaults,
+ DEFVAR_LISP ("face-new-frame-defaults", Vface_new_frame_defaults,
doc: /* List of global face definitions (for internal use only.) */);
Vface_new_frame_defaults = Qnil;
- DEFVAR_LISP ("face-default-stipple", &Vface_default_stipple,
+ DEFVAR_LISP ("face-default-stipple", Vface_default_stipple,
doc: /* *Default stipple pattern used on monochrome displays.
This stipple pattern is used on monochrome displays
instead of shades of gray for a face background color.
See `set-face-stipple' for possible values for this variable. */);
Vface_default_stipple = make_pure_c_string ("gray3");
- DEFVAR_LISP ("tty-defined-color-alist", &Vtty_defined_color_alist,
+ DEFVAR_LISP ("tty-defined-color-alist", Vtty_defined_color_alist,
doc: /* An alist of defined terminal colors and their RGB values.
See the docstring of `tty-color-alist' for the details. */);
Vtty_defined_color_alist = Qnil;
- DEFVAR_LISP ("scalable-fonts-allowed", &Vscalable_fonts_allowed,
+ DEFVAR_LISP ("scalable-fonts-allowed", Vscalable_fonts_allowed,
doc: /* Allowed scalable fonts.
A value of nil means don't allow any scalable fonts.
A value of t means allow any scalable font.
other font of the appropriate family and registry is available. */);
Vscalable_fonts_allowed = Qnil;
- DEFVAR_LISP ("face-ignored-fonts", &Vface_ignored_fonts,
+ DEFVAR_LISP ("face-ignored-fonts", Vface_ignored_fonts,
doc: /* List of ignored fonts.
Each element is a regular expression that matches names of fonts to
ignore. */);
Vface_ignored_fonts = Qnil;
- DEFVAR_LISP ("face-remapping-alist", &Vface_remapping_alist,
+ DEFVAR_LISP ("face-remapping-alist", Vface_remapping_alist,
doc: /* Alist of face remappings.
Each element is of the form:
changing this variable for it to take effect. */);
Vface_remapping_alist = Qnil;
- DEFVAR_LISP ("face-font-rescale-alist", &Vface_font_rescale_alist,
+ DEFVAR_LISP ("face-font-rescale-alist", Vface_font_rescale_alist,
doc: /* Alist of fonts vs the rescaling factors.
Each element is a cons (FONT-PATTERN . RESCALE-RATIO), where
FONT-PATTERN is a font-spec or a regular expression matching a font name, and
defsubr (&Sx_family_fonts);
#endif
}
-
HCoop / bpt / emacs.git / blobdiff