#include <c-ctype.h>
-/* Non-zero if face attribute ATTR is unspecified. */
+/* True if face attribute ATTR is unspecified. */
#define UNSPECIFIEDP(ATTR) EQ ((ATTR), Qunspecified)
-/* Non-zero if face attribute ATTR is `ignore-defface'. */
+/* True if face attribute ATTR is `ignore-defface'. */
#define IGNORE_DEFFACE_P(ATTR) EQ ((ATTR), QCignore_defface)
int face_change_count;
-/* Non-zero means don't display bold text if a face's foreground
+/* True means don't display bold text if a face's foreground
and background colors are the inverse of the default colors of the
display. This is a kluge to suppress `bold black' foreground text
which is hard to read on an LCD monitor. */
-static int tty_suppress_bold_inverse_default_colors_p;
+static bool tty_suppress_bold_inverse_default_colors_p;
/* A list of the form `((x . y))' used to avoid consing in
Finternal_set_lisp_face_attribute. */
static int ngcs;
#endif
-/* Non-zero means the definition of the `menu' face for new frames has
+/* True means the definition of the `menu' face for new frames has
been changed. */
-static int menu_face_changed_default;
+static bool menu_face_changed_default;
struct named_merge_point;
static void realize_named_face (struct frame *, Lisp_Object, int);
static struct face_cache *make_face_cache (struct frame *);
static void free_face_cache (struct face_cache *);
-static int merge_face_ref (struct frame *, Lisp_Object, Lisp_Object *,
- int, struct named_merge_point *);
+static bool merge_face_ref (struct frame *, Lisp_Object, Lisp_Object *,
+ bool, struct named_merge_point *);
static int color_distance (XColor *x, XColor *y);
#ifdef HAVE_WINDOW_SYSTEM
{
if (FRAME_FACE_CACHE (f))
{
- clear_face_cache (0);
+ clear_face_cache (false);
if (!realize_basic_faces (f))
emacs_abort ();
}
}
-/* Clear the face caches of all frames. CLEAR_FONTS_P non-zero means
+/* Clear the face caches of all frames. CLEAR_FONTS_P means
try to free unused fonts, too. */
void
\(WIDTH + 7)/8 bytes. */)
(Lisp_Object object)
{
- bool pixmap_p = 0;
+ bool pixmap_p = false;
if (STRINGP (object))
/* If OBJECT is a string, it's a file name. */
- pixmap_p = 1;
+ pixmap_p = true;
else if (CONSP (object))
{
/* Otherwise OBJECT must be (WIDTH HEIGHT DATA), WIDTH and
int bytes_per_row = ((XINT (width) + BITS_PER_CHAR - 1)
/ BITS_PER_CHAR);
if (XINT (height) <= SBYTES (data) / bytes_per_row)
- pixmap_p = 1;
+ pixmap_p = true;
}
}
/* Parse RGB_LIST, and fill in the RGB fields of COLOR.
RGB_LIST should contain (at least) 3 lisp integers.
- Return 0 if there's a problem with RGB_LIST, otherwise return 1. */
+ Return true iff RGB_LIST is OK. */
-static int
+static bool
parse_rgb_list (Lisp_Object rgb_list, XColor *color)
{
#define PARSE_RGB_LIST_FIELD(field) \
rgb_list = XCDR (rgb_list); \
} \
else \
- return 0;
+ return false;
PARSE_RGB_LIST_FIELD (red);
PARSE_RGB_LIST_FIELD (green);
PARSE_RGB_LIST_FIELD (blue);
- return 1;
+ return true;
}
Lisp_Object frame, color_desc;
if (!STRINGP (color) || NILP (Ffboundp (Qtty_color_desc)))
- return 0;
+ return false;
XSETFRAME (frame, f);
Lisp_Object rgb;
if (! INTEGERP (XCAR (XCDR (color_desc))))
- return 0;
+ return false;
tty_color->pixel = XINT (XCAR (XCDR (color_desc)));
rgb = XCDR (XCDR (color_desc));
if (! parse_rgb_list (rgb, tty_color))
- return 0;
+ return false;
/* Should we fill in STD_COLOR too? */
if (std_color)
/* Look up STD_COLOR separately. */
rgb = call1 (Qtty_color_standard_values, color);
if (! parse_rgb_list (rgb, std_color))
- return 0;
+ return false;
}
}
- return 1;
+ return true;
}
else if (NILP (Fsymbol_value (intern ("tty-defined-color-alist"))))
/* We were called early during startup, and the colors are not
yet set up in tty-defined-color-alist. Don't return a failure
indication, since this produces the annoying "Unable to
load color" messages in the *Messages* buffer. */
- return 1;
+ return true;
else
/* tty-color-desc seems to have returned a bad value. */
- return 0;
+ return false;
}
/* A version of defined_color for non-X frames. */
tty_defined_color (struct frame *f, const char *color_name,
XColor *color_def, bool alloc)
{
- bool status = 1;
+ bool status = true;
/* Defaults. */
color_def->pixel = FACE_TTY_DEFAULT_COLOR;
}
if (color_def->pixel != FACE_TTY_DEFAULT_COLOR)
- status = 1;
+ status = true;
return status;
}
#endif
#ifdef HAVE_NS
else if (FRAME_NS_P (f))
- return ns_defined_color (f, color_name, color_def, alloc, 1);
+ return ns_defined_color (f, color_name, color_def, alloc, true);
#endif
else
emacs_abort ();
}
-/* Return non-zero if COLOR_NAME is a shade of gray (or white or
+/* Return true if COLOR_NAME is a shade of gray (or white or
black) on frame F.
The criterion implemented here is not a terribly sophisticated one. */
-static int
+static bool
face_color_gray_p (struct frame *f, const char *color_name)
{
XColor color;
- int gray_p;
+ bool gray_p;
- if (defined_color (f, color_name, &color, 0))
+ if (defined_color (f, color_name, &color, false))
gray_p = (/* Any color sufficiently close to black counts as gray. */
(color.red < 5000 && color.green < 5000 && color.blue < 5000)
||
&& (eabs (color.blue - color.red)
< max (color.blue, color.red) / 20)));
else
- gray_p = 0;
+ gray_p = false;
return gray_p;
}
-/* Return non-zero if color COLOR_NAME can be displayed on frame F.
- BACKGROUND_P non-zero means the color will be used as background
- color. */
+/* Return true if color COLOR_NAME can be displayed on frame F.
+ BACKGROUND_P means the color will be used as background color. */
-static int
+static bool
face_color_supported_p (struct frame *f, const char *color_name,
- int background_p)
+ bool background_p)
{
Lisp_Object frame;
XColor not_used;
&& face_color_gray_p (f, color_name)))
:
#endif
- tty_defined_color (f, color_name, ¬_used, 0);
+ tty_defined_color (f, color_name, ¬_used, false);
}
/* if the color map is full, defined_color will return a best match
to the values in an existing cell. */
- if (!defined_color (f, SSDATA (name), color, 1))
+ if (!defined_color (f, SSDATA (name), color, true))
{
add_to_log ("Unable to load color \"%s\"", name, Qnil);
switch (target_index)
{
case LFACE_FOREGROUND_INDEX:
- face->foreground_defaulted_p = 1;
+ face->foreground_defaulted_p = true;
color->pixel = FRAME_FOREGROUND_PIXEL (f);
break;
case LFACE_BACKGROUND_INDEX:
- face->background_defaulted_p = 1;
+ face->background_defaulted_p = true;
color->pixel = FRAME_BACKGROUND_PIXEL (f);
break;
case LFACE_UNDERLINE_INDEX:
- face->underline_defaulted_p = 1;
+ face->underline_defaulted_p = true;
color->pixel = FRAME_FOREGROUND_PIXEL (f);
break;
case LFACE_OVERLINE_INDEX:
- face->overline_color_defaulted_p = 1;
+ face->overline_color_defaulted_p = true;
color->pixel = FRAME_FOREGROUND_PIXEL (f);
break;
case LFACE_STRIKE_THROUGH_INDEX:
- face->strike_through_color_defaulted_p = 1;
+ face->strike_through_color_defaulted_p = true;
color->pixel = FRAME_FOREGROUND_PIXEL (f);
break;
case LFACE_BOX_INDEX:
- face->box_color_defaulted_p = 1;
+ face->box_color_defaulted_p = true;
color->pixel = FRAME_FOREGROUND_PIXEL (f);
break;
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, SSDATA (bg), 0)
+ if (!face_color_supported_p (f, SSDATA (bg), false)
&& !NILP (Fbitmap_spec_p (Vface_default_stipple)))
{
x_destroy_bitmap (f, face->stipple);
{
/* 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);
+ int face_id = lookup_named_face (f, face, false);
struct face *width_face = (face_id < 0
? NULL
: FACE_FROM_ID (f, face_id));
#define LFACE_DISTANT_FOREGROUND(LFACE) \
AREF ((LFACE), LFACE_DISTANT_FOREGROUND_INDEX)
-/* Non-zero if LFACE is a Lisp face. A Lisp face is a vector of size
+/* True 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) \
};
-/* If a face merging cycle is detected for FACE_NAME, return 0,
+/* If a face merging cycle is detected for FACE_NAME, return false,
otherwise add NEW_NAMED_MERGE_POINT, which is initialized using
FACE_NAME and NAMED_MERGE_POINT_KIND, as the head of the linked list
- pointed to by NAMED_MERGE_POINTS, and return 1. */
+ pointed to by NAMED_MERGE_POINTS, and return true. */
-static int
+static bool
push_named_merge_point (struct named_merge_point *new_named_merge_point,
Lisp_Object face_name,
enum named_merge_point_kind named_merge_point_kind,
{
if (prev->named_merge_point_kind == named_merge_point_kind)
/* A cycle, so fail. */
- return 0;
+ return false;
else if (prev->named_merge_point_kind == NAMED_MERGE_POINT_REMAP)
/* A remap `hides ' any previous normal merge points
(because the remap means that it's actually different face),
*named_merge_points = new_named_merge_point;
- return 1;
+ return true;
}
\f
Return default face in case of errors. */
static Lisp_Object
-resolve_face_name (Lisp_Object face_name, int signal_p)
+resolve_face_name (Lisp_Object face_name, bool signal_p)
{
Lisp_Object orig_face;
Lisp_Object tortoise, hare;
orig_face = face_name;
tortoise = hare = face_name;
- while (1)
+ while (true)
{
face_name = hare;
hare = Fget (hare, Qface_alias);
/* Return the face definition of FACE_NAME on frame F. F null means
return the definition for new frames. FACE_NAME may be a string or
a symbol (apparently Emacs 20.2 allowed strings as face names in
- face text properties; Ediff uses that). If SIGNAL_P is non-zero,
- signal an error if FACE_NAME is not a valid face name. If SIGNAL_P
- is zero, value is nil if FACE_NAME is not a valid face name. */
+ face text properties; Ediff uses that).
+ If SIGNAL_P, signal an error if FACE_NAME is not a valid face name.
+ Otherwise, value is nil if FACE_NAME is not a valid face name. */
static Lisp_Object
lface_from_face_name_no_resolve (struct frame *f, Lisp_Object face_name,
- int signal_p)
+ bool signal_p)
{
Lisp_Object lface;
return the definition for new frames. FACE_NAME may be a string or
a symbol (apparently Emacs 20.2 allowed strings as face names in
face text properties; Ediff uses that). If FACE_NAME is an alias
- for another face, return that face's definition. If SIGNAL_P is
- non-zero, signal an error if FACE_NAME is not a valid face name.
- If SIGNAL_P is zero, value is nil if FACE_NAME is not a valid face
- name. */
+ for another face, return that face's definition.
+ If SIGNAL_P, signal an error if FACE_NAME is not a valid face name.
+ Otherwise, value is nil if FACE_NAME is not a valid face name. */
static Lisp_Object
-lface_from_face_name (struct frame *f, Lisp_Object face_name, int signal_p)
+lface_from_face_name (struct frame *f, Lisp_Object face_name, bool signal_p)
{
face_name = resolve_face_name (face_name, signal_p);
return lface_from_face_name_no_resolve (f, face_name, signal_p);
/* Get face attributes of face FACE_NAME from frame-local faces on
frame F. Store the resulting attributes in ATTRS which must point
- to a vector of Lisp_Objects of size LFACE_VECTOR_SIZE. If SIGNAL_P
- is non-zero, signal an error if FACE_NAME does not name a face.
- Otherwise, value is zero if FACE_NAME is not a face. */
+ to a vector of Lisp_Objects of size LFACE_VECTOR_SIZE.
+ If SIGNAL_P, signal an error if FACE_NAME does not name a face.
+ Otherwise, return true iff FACE_NAME is a face. */
-static int
+static bool
get_lface_attributes_no_remap (struct frame *f, Lisp_Object face_name,
Lisp_Object attrs[LFACE_VECTOR_SIZE],
- int signal_p)
+ bool signal_p)
{
Lisp_Object lface;
/* Get face attributes of face FACE_NAME from frame-local faces on frame
F. Store the resulting attributes in ATTRS which must point to a
vector of Lisp_Objects of size LFACE_VECTOR_SIZE. If FACE_NAME is an
- alias for another face, use that face's definition. If SIGNAL_P is
- non-zero, signal an error if FACE_NAME does not name a face.
- Otherwise, value is zero if FACE_NAME is not a face. */
+ alias for another face, use that face's definition.
+ If SIGNAL_P, signal an error if FACE_NAME does not name a face.
+ Otherwise, return true iff FACE_NAME is a face. */
-static int
+static bool
get_lface_attributes (struct frame *f, Lisp_Object face_name,
- Lisp_Object attrs[LFACE_VECTOR_SIZE], int signal_p,
+ Lisp_Object attrs[LFACE_VECTOR_SIZE], bool signal_p,
struct named_merge_point *named_merge_points)
{
Lisp_Object face_remapping;
}
-/* Non-zero if all attributes in face attribute vector ATTRS are
+/* True iff all attributes in face attribute vector ATTRS are
specified, i.e. are non-nil. */
-static int
+static bool
lface_fully_specified_p (Lisp_Object attrs[LFACE_VECTOR_SIZE])
{
int i;
#ifdef HAVE_WINDOW_SYSTEM
/* Set font-related attributes of Lisp face LFACE from FONT-OBJECT.
- If FORCE_P is zero, set only unspecified attributes of LFACE. The
+ If FORCE_P, set only unspecified attributes of LFACE. The
exception is `font' attribute. It is set to FONT_OBJECT regardless
of FORCE_P. */
-static int
+static void
set_lface_from_font (struct frame *f, Lisp_Object lface,
- Lisp_Object font_object, int force_p)
+ Lisp_Object font_object, bool force_p)
{
Lisp_Object val;
struct font *font = XFONT_OBJECT (font_object);
}
ASET (lface, LFACE_FONT_INDEX, font_object);
- return 1;
}
#endif /* HAVE_WINDOW_SYSTEM */
other code uses `unspecified' as a generic value for face attributes. */
if (!UNSPECIFIEDP (from[LFACE_INHERIT_INDEX])
&& !NILP (from[LFACE_INHERIT_INDEX]))
- merge_face_ref (f, from[LFACE_INHERIT_INDEX], to, 0, named_merge_points);
+ merge_face_ref (f, from[LFACE_INHERIT_INDEX], to, false, named_merge_points);
if (FONT_SPEC_P (from[LFACE_FONT_INDEX]))
{
}
/* Merge the named face FACE_NAME on frame F, into the vector of face
- attributes TO. NAMED_MERGE_POINTS is used to detect loops in face
- inheritance. Returns true if FACE_NAME is a valid face name and
+ attributes TO. Use NAMED_MERGE_POINTS to detect loops in face
+ inheritance. Return true if FACE_NAME is a valid face name and
merging succeeded. */
-static int
+static bool
merge_named_face (struct frame *f, Lisp_Object face_name, Lisp_Object *to,
struct named_merge_point *named_merge_points)
{
{
struct gcpro gcpro1;
Lisp_Object from[LFACE_VECTOR_SIZE];
- int ok = get_lface_attributes (f, face_name, from, 0, named_merge_points);
+ bool ok = get_lface_attributes (f, face_name, from, false,
+ named_merge_points);
if (ok)
{
return ok;
}
else
- return 0;
+ return false;
}
/* Merge face attributes from the lisp `face reference' FACE_REF on
- frame F into the face attribute vector TO. If ERR_MSGS is non-zero,
+ frame F into the face attribute vector TO. If ERR_MSGS,
problems with FACE_REF cause an error message to be shown. Return
- non-zero if no errors occurred (regardless of the value of ERR_MSGS).
- NAMED_MERGE_POINTS is used to detect loops in face inheritance or
+ true if no errors occurred (regardless of the value of ERR_MSGS).
+ Use NAMED_MERGE_POINTS to detect loops in face inheritance or
list structure; it may be 0 for most callers.
FACE_REF may be a single face specification or a list of such
Face specifications earlier in lists take precedence over later
specifications. */
-static int
+static bool
merge_face_ref (struct frame *f, Lisp_Object face_ref, Lisp_Object *to,
- int err_msgs, struct named_merge_point *named_merge_points)
+ bool err_msgs, struct named_merge_point *named_merge_points)
{
- int ok = 1; /* Succeed without an error? */
+ bool ok = true; /* Succeed without an error? */
if (CONSP (face_ref))
{
{
if (err_msgs)
add_to_log ("Invalid face color", color_name, Qnil);
- ok = 0;
+ ok = false;
}
}
else if (SYMBOLP (first)
{
Lisp_Object keyword = XCAR (face_ref);
Lisp_Object value = XCAR (XCDR (face_ref));
- int err = 0;
+ bool err = false;
/* Specifying `unspecified' is a no-op. */
if (EQ (value, Qunspecified))
font_clear_prop (to, FONT_FAMILY_INDEX);
}
else
- err = 1;
+ err = true;
}
else if (EQ (keyword, QCfoundry))
{
font_clear_prop (to, FONT_FOUNDRY_INDEX);
}
else
- err = 1;
+ err = true;
}
else if (EQ (keyword, QCheight))
{
font_clear_prop (to, FONT_SIZE_INDEX);
}
else
- err = 1;
+ err = true;
}
else if (EQ (keyword, QCweight))
{
font_clear_prop (to, FONT_WEIGHT_INDEX);
}
else
- err = 1;
+ err = true;
}
else if (EQ (keyword, QCslant))
{
font_clear_prop (to, FONT_SLANT_INDEX);
}
else
- err = 1;
+ err = true;
}
else if (EQ (keyword, QCunderline))
{
|| CONSP (value))
to[LFACE_UNDERLINE_INDEX] = value;
else
- err = 1;
+ err = true;
}
else if (EQ (keyword, QCoverline))
{
|| STRINGP (value))
to[LFACE_OVERLINE_INDEX] = value;
else
- err = 1;
+ err = true;
}
else if (EQ (keyword, QCstrike_through))
{
|| STRINGP (value))
to[LFACE_STRIKE_THROUGH_INDEX] = value;
else
- err = 1;
+ err = true;
}
else if (EQ (keyword, QCbox))
{
|| NILP (value))
to[LFACE_BOX_INDEX] = value;
else
- err = 1;
+ err = true;
}
else if (EQ (keyword, QCinverse_video)
|| EQ (keyword, QCreverse_video))
if (EQ (value, Qt) || NILP (value))
to[LFACE_INVERSE_INDEX] = value;
else
- err = 1;
+ err = true;
}
else if (EQ (keyword, QCforeground))
{
if (STRINGP (value))
to[LFACE_FOREGROUND_INDEX] = value;
else
- err = 1;
+ err = true;
}
else if (EQ (keyword, QCdistant_foreground))
{
if (STRINGP (value))
to[LFACE_DISTANT_FOREGROUND_INDEX] = value;
else
- err = 1;
+ err = true;
}
else if (EQ (keyword, QCbackground))
{
if (STRINGP (value))
to[LFACE_BACKGROUND_INDEX] = value;
else
- err = 1;
+ err = true;
}
else if (EQ (keyword, QCstipple))
{
if (!NILP (pixmap_p))
to[LFACE_STIPPLE_INDEX] = value;
else
- err = 1;
+ err = true;
#endif /* HAVE_WINDOW_SYSTEM */
}
else if (EQ (keyword, QCwidth))
font_clear_prop (to, FONT_WIDTH_INDEX);
}
else
- err = 1;
+ err = true;
}
else if (EQ (keyword, QCfont))
{
if (FONTP (value))
to[LFACE_FONT_INDEX] = value;
else
- err = 1;
+ err = true;
}
else if (EQ (keyword, QCinherit))
{
normal face reference. */
if (! merge_face_ref (f, value, to,
err_msgs, named_merge_points))
- err = 1;
+ err = true;
}
else
- err = 1;
+ err = true;
if (err)
{
add_to_log ("Invalid face attribute %S %S", keyword, value);
- ok = 0;
+ ok = false;
}
face_ref = XCDR (XCDR (face_ref));
ok = merge_face_ref (f, next, to, err_msgs, named_merge_points);
if (! merge_face_ref (f, first, to, err_msgs, named_merge_points))
- ok = 0;
+ ok = false;
}
}
else
int i;
CHECK_SYMBOL (face);
- global_lface = lface_from_face_name (NULL, face, 0);
+ global_lface = lface_from_face_name (NULL, face, false);
if (!NILP (frame))
{
CHECK_LIVE_FRAME (frame);
f = XFRAME (frame);
- lface = lface_from_face_name (f, face, 0);
+ lface = lface_from_face_name (f, face, false);
}
else
f = NULL, lface = Qnil;
{
Lisp_Object lface;
- face = resolve_face_name (face, 1);
+ face = resolve_face_name (face, true);
if (!NILP (frame))
{
CHECK_LIVE_FRAME (frame);
- lface = lface_from_face_name (XFRAME (frame), face, 0);
+ lface = lface_from_face_name (XFRAME (frame), face, false);
}
else
- lface = lface_from_face_name (NULL, face, 0);
+ lface = lface_from_face_name (NULL, face, false);
return lface;
}
{
/* Copy global definition of FROM. We don't make copies of
strings etc. because 20.2 didn't do it either. */
- lface = lface_from_face_name (NULL, from, 1);
+ lface = lface_from_face_name (NULL, from, true);
copy = Finternal_make_lisp_face (to, Qnil);
}
else
new_frame = frame;
CHECK_LIVE_FRAME (frame);
CHECK_LIVE_FRAME (new_frame);
- lface = lface_from_face_name (XFRAME (frame), from, 1);
+ lface = lface_from_face_name (XFRAME (frame), from, true);
copy = Finternal_make_lisp_face (to, new_frame);
}
CHECK_SYMBOL (face);
CHECK_SYMBOL (attr);
- face = resolve_face_name (face, 1);
+ face = resolve_face_name (face, true);
/* If FRAME is 0, change face on all frames, and change the
default for new frames. */
/* Set lface to the Lisp attribute vector of FACE. */
if (EQ (frame, Qt))
{
- lface = lface_from_face_name (NULL, face, 1);
+ lface = lface_from_face_name (NULL, face, true);
/* When updating face-new-frame-defaults, we put :ignore-defface
where the caller wants `unspecified'. This forces the frame
frame = selected_frame;
CHECK_LIVE_FRAME (frame);
- lface = lface_from_face_name (XFRAME (frame), face, 0);
+ lface = lface_from_face_name (XFRAME (frame), face, false);
/* If a frame-local face doesn't exist yet, create one. */
if (NILP (lface))
}
else if (EQ (attr, QCunderline))
{
- bool valid_p = 0;
+ bool valid_p = false;
if (UNSPECIFIEDP (value) || IGNORE_DEFFACE_P (value))
- valid_p = 1;
+ valid_p = true;
else if (NILP (value) || EQ (value, Qt))
- valid_p = 1;
+ valid_p = true;
else if (STRINGP (value) && SCHARS (value) > 0)
- valid_p = 1;
+ valid_p = true;
else if (CONSP (value))
{
Lisp_Object key, val, list;
Non-nil symbols other than t are not documented as being valid.
Eg compare with inverse-video, which explicitly rejects them.
*/
- valid_p = 1;
+ valid_p = true;
while (!NILP (CAR_SAFE(list)))
{
if (NILP (key) || NILP (val))
{
- valid_p = 0;
+ valid_p = false;
break;
}
&& !(EQ (val, Qforeground_color)
|| (STRINGP (val) && SCHARS (val) > 0)))
{
- valid_p = 0;
+ valid_p = false;
break;
}
else if (EQ (key, QCstyle)
&& !(EQ (val, Qline) || EQ (val, Qwave)))
{
- valid_p = 0;
+ valid_p = false;
break;
}
}
value = make_number (1);
if (UNSPECIFIEDP (value) || IGNORE_DEFFACE_P (value))
- valid_p = 1;
+ valid_p = true;
else if (NILP (value))
- valid_p = 1;
+ valid_p = true;
else if (INTEGERP (value))
valid_p = XINT (value) != 0;
else if (STRINGP (value))
valid_p = NILP (tem);
}
else
- valid_p = 0;
+ valid_p = false;
if (!valid_p)
signal_error ("Invalid face box", value);
signal_error ("Font not available", value);
value = font_object;
}
- set_lface_from_font (f, lface, value, 1);
+ set_lface_from_font (f, lface, value, true);
}
}
else
struct frame *f = XFRAME (frame);
if (FRAME_FACE_CACHE (f) == NULL)
FRAME_FACE_CACHE (f) = make_face_cache (f);
- FRAME_FACE_CACHE (f)->menu_face_changed_p = 1;
+ FRAME_FACE_CACHE (f)->menu_face_changed_p = true;
}
else
- menu_face_changed_default = 1;
+ menu_face_changed_default = true;
}
if (!NILP (param))
if (EQ (param, Qforeground_color))
{
face = Qdefault;
- lface = lface_from_face_name (f, face, 1);
+ lface = lface_from_face_name (f, face, true);
ASET (lface, LFACE_FOREGROUND_INDEX,
(STRINGP (new_value) ? new_value : Qunspecified));
realize_basic_faces (f);
call1 (Qframe_set_background_mode, frame);
face = Qdefault;
- lface = lface_from_face_name (f, face, 1);
+ lface = lface_from_face_name (f, face, true);
ASET (lface, LFACE_BACKGROUND_INDEX,
(STRINGP (new_value) ? new_value : Qunspecified));
realize_basic_faces (f);
else if (EQ (param, Qborder_color))
{
face = Qborder;
- lface = lface_from_face_name (f, face, 1);
+ lface = lface_from_face_name (f, face, true);
ASET (lface, LFACE_BACKGROUND_INDEX,
(STRINGP (new_value) ? new_value : Qunspecified));
}
else if (EQ (param, Qcursor_color))
{
face = Qcursor;
- lface = lface_from_face_name (f, face, 1);
+ lface = lface_from_face_name (f, face, true);
ASET (lface, LFACE_BACKGROUND_INDEX,
(STRINGP (new_value) ? new_value : Qunspecified));
}
else if (EQ (param, Qmouse_color))
{
face = Qmouse;
- lface = lface_from_face_name (f, face, 1);
+ lface = lface_from_face_name (f, face, true);
ASET (lface, LFACE_BACKGROUND_INDEX,
(STRINGP (new_value) ? new_value : Qunspecified));
}
return;
ASET (lface, LFACE_FONT_INDEX, font);
}
- f->default_face_done_p = 0;
+ f->default_face_done_p = false;
AUTO_FRAME_ARG (arg, Qfont, font);
Fmodify_frame_parameters (frame, arg);
}
/* Return resource string VALUE as a boolean value, i.e. nil, or t.
If VALUE is "on" or "true", return t. If VALUE is "off" or
- "false", return nil. Otherwise, if SIGNAL_P is non-zero, signal an
- error; if SIGNAL_P is zero, return 0. */
+ "false", return nil. Otherwise, if SIGNAL_P, signal an
+ error; if !SIGNAL_P, return 0. */
static Lisp_Object
-face_boolean_x_resource_value (Lisp_Object value, int signal_p)
+face_boolean_x_resource_value (Lisp_Object value, bool signal_p)
{
Lisp_Object result = make_number (0);
signal_error ("Invalid face height from X resource", value);
}
else if (EQ (attr, QCbold) || EQ (attr, QCitalic))
- value = face_boolean_x_resource_value (value, 1);
+ value = face_boolean_x_resource_value (value, true);
else if (EQ (attr, QCweight) || EQ (attr, QCslant) || EQ (attr, QCwidth))
value = intern (SSDATA (value));
else if (EQ (attr, QCreverse_video) || EQ (attr, QCinverse_video))
- value = face_boolean_x_resource_value (value, 1);
+ value = face_boolean_x_resource_value (value, true);
else if (EQ (attr, QCunderline)
|| EQ (attr, QCoverline)
|| EQ (attr, QCstrike_through))
/* If the result of face_boolean_x_resource_value is t or nil,
VALUE does NOT specify a color. */
- boolean_value = face_boolean_x_resource_value (value, 0);
+ boolean_value = face_boolean_x_resource_value (value, false);
if (SYMBOLP (boolean_value))
value = boolean_value;
}
char line[512];
char *buf = line;
ptrdiff_t bufsize = sizeof line;
- Lisp_Object lface = lface_from_face_name (f, Qmenu, 1);
+ Lisp_Object lface = lface_from_face_name (f, Qmenu, true);
struct face *face = FACE_FROM_ID (f, MENU_FACE_ID);
const char *myname = SSDATA (Vx_resource_name);
- bool changed_p = 0;
+ bool changed_p = false;
#ifdef USE_MOTIF
const char *popup_path = "popup_menu";
#else
exprintf (&buf, &bufsize, line, -1, "%s.pane.menubar*foreground: %s",
myname, SDATA (LFACE_FOREGROUND (lface)));
XrmPutLineResource (&rdb, line);
- changed_p = 1;
+ changed_p = true;
}
if (STRINGP (LFACE_BACKGROUND (lface)))
exprintf (&buf, &bufsize, line, -1, "%s.pane.menubar*background: %s",
myname, SDATA (LFACE_BACKGROUND (lface)));
XrmPutLineResource (&rdb, line);
- changed_p = 1;
+ changed_p = true;
}
if (face->font
exprintf (&buf, &bufsize, line, -1, "%s.%s*font%s: %s",
myname, popup_path, suffix, fontsetname);
XrmPutLineResource (&rdb, line);
- changed_p = 1;
+ changed_p = true;
if (fontsetname != SSDATA (xlfd))
xfree (fontsetname);
}
(Lisp_Object symbol, Lisp_Object keyword, Lisp_Object frame)
{
struct frame *f = EQ (frame, Qt) ? NULL : decode_live_frame (frame);
- Lisp_Object lface = lface_from_face_name (f, symbol, 1), value = Qnil;
+ Lisp_Object lface = lface_from_face_name (f, symbol, true), value = Qnil;
CHECK_SYMBOL (symbol);
CHECK_SYMBOL (keyword);
struct frame *f = XFRAME (frame);
CHECK_LIVE_FRAME (frame);
- global_lface = lface_from_face_name (NULL, face, 1);
- local_lface = lface_from_face_name (f, face, 0);
+ global_lface = lface_from_face_name (NULL, face, true);
+ local_lface = lface_from_face_name (f, face, false);
if (NILP (local_lface))
local_lface = Finternal_make_lisp_face (face, frame);
if (EQ (frame, Qt))
{
Lisp_Object result = Qnil;
- Lisp_Object lface = lface_from_face_name (NULL, face, 1);
+ Lisp_Object lface = lface_from_face_name (NULL, face, true);
if (!UNSPECIFIEDP (LFACE_WEIGHT (lface))
&& !EQ (LFACE_WEIGHT (lface), Qnormal))
else
{
struct frame *f = decode_live_frame (frame);
- int face_id = lookup_named_face (f, face, 1);
+ int face_id = lookup_named_face (f, face, true);
struct face *fface = FACE_FROM_ID (f, face_id);
if (! fface)
}
-/* Compare face-attribute values v1 and v2 for equality. Value is non-zero if
+/* Compare face-attribute values v1 and v2 for equality. Value is true if
all attributes are `equal'. Tries to be fast because this function
is called quite often. */
/* Type can differ, e.g. when one attribute is unspecified, i.e. nil,
and the other is specified. */
if (XTYPE (v1) != XTYPE (v2))
- return 0;
+ return false;
if (EQ (v1, v2))
- return 1;
+ return true;
switch (XTYPE (v1))
{
case Lisp_String:
if (SBYTES (v1) != SBYTES (v2))
- return 0;
+ return false;
return memcmp (SDATA (v1), SDATA (v2), SBYTES (v1)) == 0;
case_Lisp_Int:
case Lisp_Symbol:
- return 0;
+ return false;
default:
return !NILP (Fequal (v1, v2));
}
-/* Compare face vectors V1 and V2 for equality. Value is non-zero if
+/* Compare face vectors V1 and V2 for equality. Value is true if
all attributes are `equal'. Tries to be fast because this function
is called quite often. */
lface_equal_p (Lisp_Object *v1, Lisp_Object *v2)
{
int i;
- bool equal_p = 1;
+ bool equal_p = true;
for (i = 1; i < LFACE_VECTOR_SIZE && equal_p; ++i)
equal_p = face_attr_equal_p (v1[i], v2[i]);
If FRAME is omitted or nil, use the selected frame. */)
(Lisp_Object face1, Lisp_Object face2, Lisp_Object frame)
{
- int equal_p;
+ bool equal_p;
struct frame *f;
Lisp_Object lface1, lface2;
Emacs. That frame is not an X frame. */
f = EQ (frame, Qt) ? NULL : decode_live_frame (frame);
- lface1 = lface_from_face_name (f, face1, 1);
- lface2 = lface_from_face_name (f, face2, 1);
+ lface1 = lface_from_face_name (f, face1, true);
+ lface2 = lface_from_face_name (f, face2, true);
equal_p = lface_equal_p (XVECTOR (lface1)->contents,
XVECTOR (lface2)->contents);
return equal_p ? Qt : Qnil;
(Lisp_Object face, Lisp_Object frame)
{
struct frame *f = EQ (frame, Qt) ? NULL : decode_live_frame (frame);
- Lisp_Object lface = lface_from_face_name (f, face, 1);
+ Lisp_Object lface = lface_from_face_name (f, face, true);
int i;
for (i = 1; i < LFACE_VECTOR_SIZE; ++i)
#ifdef HAVE_WINDOW_SYSTEM
-/* Return non-zero if LFACE1 and LFACE2 specify the same font (without
+/* Return true if LFACE1 and LFACE2 specify the same font (without
considering charsets/registries). They do if they specify the same
family, point size, weight, width, slant, and font. Both
LFACE1 and LFACE2 must be fully-specified. */
-static int
+static bool
lface_same_font_attributes_p (Lisp_Object *lface1, Lisp_Object *lface2)
{
eassert (lface_fully_specified_p (lface1)
XColor cdef1, cdef2;
if (!(CONSP (color1) && parse_rgb_list (color1, &cdef1))
- && !(STRINGP (color1) && defined_color (f, SSDATA (color1), &cdef1, 0)))
+ && !(STRINGP (color1)
+ && defined_color (f, SSDATA (color1), &cdef1, false)))
signal_error ("Invalid color", color1);
if (!(CONSP (color2) && parse_rgb_list (color2, &cdef2))
- && !(STRINGP (color2) && defined_color (f, SSDATA (color2), &cdef2, 0)))
+ && !(STRINGP (color2)
+ && defined_color (f, SSDATA (color2), &cdef2, false)))
signal_error ("Invalid color", color2);
return make_number (color_distance (&cdef1, &cdef2));
face isn't realized and cannot be realized. */
int
-lookup_named_face (struct frame *f, Lisp_Object symbol, int signal_p)
+lookup_named_face (struct frame *f, Lisp_Object symbol, bool signal_p)
{
Lisp_Object attrs[LFACE_VECTOR_SIZE];
Lisp_Object symbol_attrs[LFACE_VECTOR_SIZE];
/* If there is a remapping entry, lookup the face using NAME, which will
handle the remapping too. */
- remapped_face_id = lookup_named_face (f, name, 0);
+ remapped_face_id = lookup_named_face (f, name, false);
if (remapped_face_id < 0)
return face_id; /* Give up. */
int
lookup_derived_face (struct frame *f, Lisp_Object symbol, int face_id,
- int signal_p)
+ bool signal_p)
{
Lisp_Object attrs[LFACE_VECTOR_SIZE];
Lisp_Object symbol_attrs[LFACE_VECTOR_SIZE];
lface = Fmake_vector (make_number (LFACE_VECTOR_SIZE),
Qunspecified);
merge_face_ref (XFRAME (selected_frame), plist, XVECTOR (lface)->contents,
- 1, 0);
+ true, 0);
return lface;
}
|| (!UNSPECIFIEDP (attrs[LFACE_BOX_INDEX])
&& face_attr_equal_p (attrs[LFACE_BOX_INDEX],
def_attrs[LFACE_BOX_INDEX])))
- return 0;
+ return false;
/* Check font-related attributes, as those are the most commonly
"unsupported" on a window-system (because of missing fonts). */
supported. */
if (face->font == def_face->font
|| ! face->font)
- return 0;
+ return false;
for (i = FONT_TYPE_INDEX; i <= FONT_SIZE_INDEX; i++)
if (! EQ (face->font->props[i], def_face->font->props[i]))
{
if (i < FONT_FOUNDRY_INDEX || i > FONT_REGISTRY_INDEX
|| face->font->driver->case_sensitive)
- return 1;
+ return true;
s1 = SYMBOL_NAME (face->font->props[i]);
s2 = SYMBOL_NAME (def_face->font->props[i]);
if (! EQ (Fcompare_strings (s1, make_number (0), Qnil,
s2, make_number (0), Qnil, Qt), Qt))
- return 1;
+ return true;
}
- return 0;
+ return false;
}
/* Everything checks out, this face is supported. */
- return 1;
+ return true;
}
#endif /* HAVE_WINDOW_SYSTEM */
|| !UNSPECIFIEDP (attrs[LFACE_OVERLINE_INDEX])
|| !UNSPECIFIEDP (attrs[LFACE_STRIKE_THROUGH_INDEX])
|| !UNSPECIFIEDP (attrs[LFACE_BOX_INDEX]))
- return 0;
+ return false;
/* Test for terminal `capabilities' (non-color character attributes). */
if (weight > 100)
{
if (def_weight > 100)
- return 0; /* same as default */
+ return false; /* same as default */
test_caps = TTY_CAP_BOLD;
}
else if (weight < 100)
{
if (def_weight < 100)
- return 0; /* same as default */
+ return false; /* same as default */
test_caps = TTY_CAP_DIM;
}
else if (def_weight == 100)
- return 0; /* same as default */
+ return false; /* same as default */
}
/* font slant */
{
int def_slant = FONT_SLANT_NAME_NUMERIC (def_attrs[LFACE_SLANT_INDEX]);
if (slant == 100 || slant == def_slant)
- return 0; /* same as default */
+ return false; /* same as default */
else
test_caps |= TTY_CAP_ITALIC;
}
if (!UNSPECIFIEDP (val))
{
if (STRINGP (val))
- return 0; /* ttys can't use colored underlines */
+ return false; /* ttys can't use colored underlines */
else if (EQ (CAR_SAFE (val), QCstyle) && EQ (CAR_SAFE (CDR_SAFE (val)), Qwave))
- return 0; /* ttys can't use wave underlines */
+ return false; /* ttys can't use wave underlines */
else if (face_attr_equal_p (val, def_attrs[LFACE_UNDERLINE_INDEX]))
- return 0; /* same as default */
+ return false; /* same as default */
else
test_caps |= TTY_CAP_UNDERLINE;
}
if (!UNSPECIFIEDP (val))
{
if (face_attr_equal_p (val, def_attrs[LFACE_INVERSE_INDEX]))
- return 0; /* same as default */
+ return false; /* same as default */
else
test_caps |= TTY_CAP_INVERSE;
}
Lisp_Object def_fg = def_attrs[LFACE_FOREGROUND_INDEX];
if (face_attr_equal_p (fg, def_fg))
- return 0; /* same as default */
+ return false; /* same as default */
else if (! tty_lookup_color (f, fg, &fg_tty_color, &fg_std_color))
- return 0; /* not a valid color */
+ return false; /* not a valid color */
else if (color_distance (&fg_tty_color, &fg_std_color)
> TTY_SAME_COLOR_THRESHOLD)
- return 0; /* displayed color is too different */
+ return false; /* displayed color is too different */
else
/* Make sure the color is really different than the default. */
{
if (tty_lookup_color (f, def_fg, &def_fg_color, 0)
&& (color_distance (&fg_tty_color, &def_fg_color)
<= TTY_SAME_COLOR_THRESHOLD))
- return 0;
+ return false;
}
}
Lisp_Object def_bg = def_attrs[LFACE_BACKGROUND_INDEX];
if (face_attr_equal_p (bg, def_bg))
- return 0; /* same as default */
+ return false; /* same as default */
else if (! tty_lookup_color (f, bg, &bg_tty_color, &bg_std_color))
- return 0; /* not a valid color */
+ return false; /* not a valid color */
else if (color_distance (&bg_tty_color, &bg_std_color)
> TTY_SAME_COLOR_THRESHOLD)
- return 0; /* displayed color is too different */
+ return false; /* displayed color is too different */
else
/* Make sure the color is really different than the default. */
{
if (tty_lookup_color (f, def_bg, &def_bg_color, 0)
&& (color_distance (&bg_tty_color, &def_bg_color)
<= TTY_SAME_COLOR_THRESHOLD))
- return 0;
+ return false;
}
}
- color_distance (&fg_tty_color, &bg_tty_color));
if (delta_delta > TTY_SAME_COLOR_THRESHOLD
|| delta_delta < -TTY_SAME_COLOR_THRESHOLD)
- return 0;
+ return false;
}
face for italic. */)
(Lisp_Object attributes, Lisp_Object display)
{
- bool supports = 0;
+ bool supports = false;
int i;
Lisp_Object frame;
struct frame *f;
for (i = 0; i < LFACE_VECTOR_SIZE; i++)
attrs[i] = Qunspecified;
- merge_face_ref (f, attributes, attrs, 1, 0);
+ merge_face_ref (f, attributes, attrs, true, 0);
def_face = FACE_FROM_ID (f, DEFAULT_FACE_ID);
if (def_face == NULL)
static bool
realize_basic_faces (struct frame *f)
{
- bool success_p = 0;
+ bool success_p = false;
ptrdiff_t count = SPECPDL_INDEX ();
/* Block input here so that we won't be surprised by an X expose
/* Reflect changes in the `menu' face in menu bars. */
if (FRAME_FACE_CACHE (f)->menu_face_changed_p)
{
- FRAME_FACE_CACHE (f)->menu_face_changed_p = 0;
+ FRAME_FACE_CACHE (f)->menu_face_changed_p = false;
#ifdef USE_X_TOOLKIT
if (FRAME_WINDOW_P (f))
x_update_menu_appearance (f);
#endif
}
- success_p = 1;
+ success_p = true;
}
unbind_to (count, Qnil);
struct face *face;
/* If the `default' face is not yet known, create it. */
- lface = lface_from_face_name (f, Qdefault, 0);
+ lface = lface_from_face_name (f, Qdefault, false);
if (NILP (lface))
{
Lisp_Object frame;
XSETFONT (font_object, FRAME_FONT (f));
set_lface_from_font (f, lface, font_object, f->default_face_done_p);
ASET (lface, LFACE_FONTSET_INDEX, fontset_name (FRAME_FONTSET (f)));
- f->default_face_done_p = 1;
+ f->default_face_done_p = true;
}
#endif /* HAVE_WINDOW_SYSTEM */
if (CONSP (color) && STRINGP (XCDR (color)))
ASET (lface, LFACE_FOREGROUND_INDEX, XCDR (color));
else if (FRAME_WINDOW_P (f))
- return 0;
+ return false;
else if (FRAME_INITIAL_P (f) || FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f))
ASET (lface, LFACE_FOREGROUND_INDEX, build_string (unspecified_fg));
else
if (CONSP (color) && STRINGP (XCDR (color)))
ASET (lface, LFACE_BACKGROUND_INDEX, XCDR (color));
else if (FRAME_WINDOW_P (f))
- return 0;
+ return false;
else if (FRAME_INITIAL_P (f) || FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f))
ASET (lface, LFACE_BACKGROUND_INDEX, build_string (unspecified_bg));
else
/* This can happen when making a frame on a display that does
not support the default font. */
if (!face->font)
- return 0;
+ return false;
/* Otherwise, the font specified for the frame was not
acceptable as a font for the default face (perhaps because
}
#endif /* HAVE_X_WINDOWS */
#endif /* HAVE_WINDOW_SYSTEM */
- return 1;
+ return true;
}
realize_named_face (struct frame *f, Lisp_Object symbol, int id)
{
struct face_cache *c = FRAME_FACE_CACHE (f);
- Lisp_Object lface = lface_from_face_name (f, symbol, 0);
+ Lisp_Object lface = lface_from_face_name (f, symbol, false);
Lisp_Object attrs[LFACE_VECTOR_SIZE];
Lisp_Object symbol_attrs[LFACE_VECTOR_SIZE];
/* The default face must exist and be fully specified. */
- get_lface_attributes_no_remap (f, Qdefault, attrs, 1);
+ get_lface_attributes_no_remap (f, Qdefault, attrs, true);
check_lface_attrs (attrs);
eassert (lface_fully_specified_p (attrs));
}
/* Merge SYMBOL's face with the default face. */
- get_lface_attributes_no_remap (f, symbol, symbol_attrs, 1);
+ get_lface_attributes_no_remap (f, symbol, symbol_attrs, true);
merge_face_vectors (f, symbol_attrs, attrs, 0);
/* Realize the face. */
&& FONT_WEIGHT_NUMERIC (font_object) <= 100);
/* Don't try to free the colors copied bitwise from BASE_FACE. */
- face->colors_copied_bitwise_p = 1;
+ face->colors_copied_bitwise_p = true;
face->font = NILP (font_object) ? NULL : XFONT_OBJECT (font_object);
face->gc = 0;
if (face->font
&& FONT_WEIGHT_NAME_NUMERIC (attrs[LFACE_WEIGHT_INDEX]) > 100
&& FONT_WEIGHT_NUMERIC (attrs[LFACE_FONT_INDEX]) <= 100)
- face->overstrike = 1;
+ face->overstrike = true;
/* Load colors, and set remaining attributes. */
face->box = FACE_SIMPLE_BOX;
face->box_line_width = XINT (box);
face->box_color = face->foreground;
- face->box_color_defaulted_p = 1;
+ face->box_color_defaulted_p = true;
}
else if (CONSP (box))
{
being one of `raised' or `sunken'. */
face->box = FACE_SIMPLE_BOX;
face->box_color = face->foreground;
- face->box_color_defaulted_p = 1;
+ face->box_color_defaulted_p = true;
face->box_line_width = 1;
while (CONSP (box))
{
face->box_color = load_color (f, face, value,
LFACE_BOX_INDEX);
- face->use_box_color_for_shadows_p = 1;
+ face->use_box_color_for_shadows_p = true;
}
}
else if (EQ (keyword, QCstyle))
if (EQ (underline, Qt))
{
/* Use default color (same as foreground color). */
- face->underline_p = 1;
+ face->underline_p = true;
face->underline_type = FACE_UNDER_LINE;
- face->underline_defaulted_p = 1;
+ face->underline_defaulted_p = true;
face->underline_color = 0;
}
else if (STRINGP (underline))
{
/* Use specified color. */
- face->underline_p = 1;
+ face->underline_p = true;
face->underline_type = FACE_UNDER_LINE;
- face->underline_defaulted_p = 0;
+ face->underline_defaulted_p = false;
face->underline_color
= load_color (f, face, underline,
LFACE_UNDERLINE_INDEX);
}
else if (NILP (underline))
{
- face->underline_p = 0;
- face->underline_defaulted_p = 0;
+ face->underline_p = false;
+ face->underline_defaulted_p = false;
face->underline_color = 0;
}
else if (CONSP (underline))
{
/* `(:color COLOR :style STYLE)'.
STYLE being one of `line' or `wave'. */
- face->underline_p = 1;
+ face->underline_p = true;
face->underline_color = 0;
- face->underline_defaulted_p = 1;
+ face->underline_defaulted_p = true;
face->underline_type = FACE_UNDER_LINE;
/* FIXME? This is also not robust about checking the precise form.
{
if (EQ (value, Qforeground_color))
{
- face->underline_defaulted_p = 1;
+ face->underline_defaulted_p = true;
face->underline_color = 0;
}
else if (STRINGP (value))
{
- face->underline_defaulted_p = 0;
+ face->underline_defaulted_p = false;
face->underline_color = load_color (f, face, value,
LFACE_UNDERLINE_INDEX);
}
face->overline_color
= load_color (f, face, attrs[LFACE_OVERLINE_INDEX],
LFACE_OVERLINE_INDEX);
- face->overline_p = 1;
+ face->overline_p = true;
}
else if (EQ (overline, Qt))
{
face->overline_color = face->foreground;
- face->overline_color_defaulted_p = 1;
- face->overline_p = 1;
+ face->overline_color_defaulted_p = true;
+ face->overline_p = true;
}
strike_through = attrs[LFACE_STRIKE_THROUGH_INDEX];
face->strike_through_color
= load_color (f, face, attrs[LFACE_STRIKE_THROUGH_INDEX],
LFACE_STRIKE_THROUGH_INDEX);
- face->strike_through_p = 1;
+ face->strike_through_p = true;
}
else if (EQ (strike_through, Qt))
{
face->strike_through_color = face->foreground;
- face->strike_through_color_defaulted_p = 1;
- face->strike_through_p = 1;
+ face->strike_through_color_defaulted_p = true;
+ face->strike_through_p = true;
}
stipple = attrs[LFACE_STIPPLE_INDEX];
/* Map a specified color of face FACE on frame F to a tty color index.
IDX is either LFACE_FOREGROUND_INDEX or LFACE_BACKGROUND_INDEX, and
- specifies which color to map. Set *DEFAULTED to 1 if mapping to the
+ specifies which color to map. Set *DEFAULTED to true if mapping to the
default foreground/background colors. */
static void
map_tty_color (struct frame *f, struct face *face,
- enum lface_attribute_index idx, int *defaulted)
+ enum lface_attribute_index idx, bool *defaulted)
{
Lisp_Object frame, color, def;
- int foreground_p = idx == LFACE_FOREGROUND_INDEX;
+ bool foreground_p = idx == LFACE_FOREGROUND_INDEX;
unsigned long default_pixel =
foreground_p ? FACE_TTY_DEFAULT_FG_COLOR : FACE_TTY_DEFAULT_BG_COLOR;
unsigned long pixel = default_pixel;
else
pixel = FRAME_BACKGROUND_PIXEL (f);
face->lface[idx] = tty_color_name (f, pixel);
- *defaulted = 1;
+ *defaulted = true;
}
else if (pixel == default_other_pixel)
{
else
pixel = FRAME_FOREGROUND_PIXEL (f);
face->lface[idx] = tty_color_name (f, pixel);
- *defaulted = 1;
+ *defaulted = true;
}
}
#endif /* MSDOS */
{
struct face *face;
int weight, slant;
- int face_colors_defaulted = 0;
+ bool face_colors_defaulted = false;
struct frame *f = cache->f;
/* Frame must be a termcap frame. */
/* Allocate a new realized face. */
face = make_realized_face (attrs);
-#if 0
+#if false
face->font_name = FRAME_MSDOS_P (cache->f) ? "ms-dos" : "tty";
#endif
weight = FONT_WEIGHT_NAME_NUMERIC (attrs[LFACE_WEIGHT_INDEX]);
slant = FONT_SLANT_NAME_NUMERIC (attrs[LFACE_SLANT_INDEX]);
if (weight > 100)
- face->tty_bold_p = 1;
+ face->tty_bold_p = true;
if (slant != 100)
- face->tty_italic_p = 1;
+ face->tty_italic_p = true;
if (!NILP (attrs[LFACE_UNDERLINE_INDEX]))
- face->tty_underline_p = 1;
+ face->tty_underline_p = true;
if (!NILP (attrs[LFACE_INVERSE_INDEX]))
- face->tty_reverse_p = 1;
+ face->tty_reverse_p = true;
/* Map color names to color indices. */
map_tty_color (f, face, LFACE_FOREGROUND_INDEX, &face_colors_defaulted);
&& face->tty_bold_p
&& face->background == FACE_TTY_DEFAULT_FG_COLOR
&& face->foreground == FACE_TTY_DEFAULT_BG_COLOR)
- face->tty_bold_p = 0;
+ face->tty_bold_p = false;
return face;
}
Lisp_Object attrs[LFACE_VECTOR_SIZE];
struct face *default_face = FACE_FROM_ID (f, DEFAULT_FACE_ID);
memcpy (attrs, default_face->lface, sizeof attrs);
- merge_face_ref (f, prop, attrs, 1, 0);
+ merge_face_ref (f, prop, attrs, true, 0);
face_id = lookup_face (f, attrs);
}
LIMIT is a position not to scan beyond. That is to limit the time
this function can take.
- If MOUSE is non-zero, use the character's mouse-face, not its face.
+ If MOUSE, use the character's mouse-face, not its face.
BASE_FACE_ID, if non-negative, specifies a base face id to use
instead of DEFAULT_FACE_ID.
int
face_at_buffer_position (struct window *w, ptrdiff_t pos,
ptrdiff_t *endptr, ptrdiff_t limit,
- int mouse, int base_face_id)
+ bool mouse, int base_face_id)
{
struct frame *f = XFRAME (w->frame);
Lisp_Object attrs[LFACE_VECTOR_SIZE];
{
ptrdiff_t next_overlay;
- GET_OVERLAYS_AT (pos, overlay_vec, noverlays, &next_overlay, 0);
+ GET_OVERLAYS_AT (pos, overlay_vec, noverlays, &next_overlay, false);
if (next_overlay < endpos)
endpos = next_overlay;
}
/* Merge in attributes specified via text properties. */
if (!NILP (prop))
- merge_face_ref (f, prop, attrs, 1, 0);
+ merge_face_ref (f, prop, attrs, true, 0);
/* Now merge the overlay data. */
noverlays = sort_overlays (overlay_vec, noverlays, w);
prop = Foverlay_get (overlay_vec[i], propname);
if (!NILP (prop))
- merge_face_ref (f, prop, attrs, 1, 0);
+ merge_face_ref (f, prop, attrs, true, 0);
oend = OVERLAY_END (overlay_vec[i]);
oendpos = OVERLAY_POSITION (oend);
int
face_for_overlay_string (struct window *w, ptrdiff_t pos,
ptrdiff_t *endptr, ptrdiff_t limit,
- int mouse, Lisp_Object overlay)
+ bool mouse, Lisp_Object overlay)
{
struct frame *f = XFRAME (w->frame);
Lisp_Object attrs[LFACE_VECTOR_SIZE];
/* Merge in attributes specified via text properties. */
if (!NILP (prop))
- merge_face_ref (f, prop, attrs, 1, 0);
+ merge_face_ref (f, prop, attrs, true, 0);
*endptr = endpos;
BASE_FACE_ID is the id of a face to merge with. For strings coming
from overlays or the `display' property it is the face at BUFPOS.
- If MOUSE_P is non-zero, use the character's mouse-face, not its face.
+ If MOUSE_P, use the character's mouse-face, not its face.
Set *ENDPTR to the next position where to check for faces in
STRING; -1 if the face is constant from POS to the end of the
face_at_string_position (struct window *w, Lisp_Object string,
ptrdiff_t pos, ptrdiff_t bufpos,
ptrdiff_t *endptr, enum face_id base_face_id,
- int mouse_p)
+ bool mouse_p)
{
Lisp_Object prop, position, end, limit;
struct frame *f = XFRAME (WINDOW_FRAME (w));
/* Merge in attributes specified via text properties. */
if (!NILP (prop))
- merge_face_ref (f, prop, attrs, 1, 0);
+ merge_face_ref (f, prop, attrs, true, 0);
/* Look up a realized face with the given face attributes,
or realize a new one for ASCII characters. */
projects / emacs.git / commitdiff