/* Fringe handling (split from xdisp.c).
- Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995, 1997,
- 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
- 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+ Copyright (C) 1985-1988, 1993-1995, 1997-2011 Free Software Foundation, Inc.
This file is part of GNU Emacs.
#ifdef HAVE_WINDOW_SYSTEM
-extern Lisp_Object Qfringe;
-extern Lisp_Object Qtop, Qbottom, Qcenter;
-extern Lisp_Object Qup, Qdown, Qleft, Qright;
-
-/* Non-nil means that newline may flow into the right fringe. */
-
-Lisp_Object Voverflow_newline_into_fringe;
-
-/* List of known fringe bitmap symbols.
-
- The fringe bitmap number is stored in the `fringe' property on
- those symbols. Names for the built-in bitmaps are installed by
- loading fringe.el.
- */
-
-Lisp_Object Vfringe_bitmaps;
-
/* Fringe bitmaps are represented in three different ways:
Logical bitmaps are used internally to denote things like
'end-of-buffer', 'left-truncation', 'overlay-arrow', etc.
- Physical bitmaps specify the visual appearence of the bitmap,
+ Physical bitmaps specify the visual appearance of the bitmap,
e.g. 'bottom-left-angle', 'left-arrow', 'left-triangle', etc.
User defined bitmaps are physical bitmaps.
must specify physical bitmap symbols.
*/
-extern Lisp_Object Qunknown;
-Lisp_Object Qtruncation, Qcontinuation, Qoverlay_arrow;
-Lisp_Object Qempty_line, Qtop_bottom;
-extern Lisp_Object Qbar, Qhbar, Qbox, Qhollow;
-Lisp_Object Qhollow_small;
+static Lisp_Object Qtruncation, Qcontinuation, Qoverlay_arrow;
+static Lisp_Object Qempty_line, Qtop_bottom;
+static Lisp_Object Qhollow_small;
enum fringe_bitmap_align
{
/* NOTE: The order of these bitmaps must match the sequence
used in fringe.el to define the corresponding symbols. */
-struct fringe_bitmap standard_bitmaps[] =
+static struct fringe_bitmap standard_bitmaps[] =
{
{ NULL, 0, 0, 0, 0, 0 }, /* NO_FRINGE_BITMAP */
{ FRBITS (question_mark_bits), 8, 0, ALIGN_BITMAP_CENTER, 0 },
#define NO_FRINGE_BITMAP 0
#define UNDEF_FRINGE_BITMAP 1
-#define MAX_STANDARD_FRINGE_BITMAPS (sizeof(standard_bitmaps)/sizeof(standard_bitmaps[0]))
+#define MAX_STANDARD_FRINGE_BITMAPS (sizeof (standard_bitmaps)/sizeof (standard_bitmaps[0]))
static struct fringe_bitmap **fringe_bitmaps;
static Lisp_Object *fringe_faces;
static int max_fringe_bitmaps;
+#ifndef HAVE_NS
+static
+#endif
int max_used_fringe_bitmap = MAX_STANDARD_FRINGE_BITMAPS;
Return 0 if not a bitmap. */
int
-lookup_fringe_bitmap (bitmap)
- Lisp_Object bitmap;
+lookup_fringe_bitmap (Lisp_Object bitmap)
{
int bn;
Return BN if not found in Vfringe_bitmaps. */
static Lisp_Object
-get_fringe_bitmap_name (bn)
- int bn;
+get_fringe_bitmap_name (int bn)
{
Lisp_Object bitmaps;
Lisp_Object num;
return num;
}
+/* Get fringe bitmap data for bitmap number BN. */
+
+static struct fringe_bitmap *
+get_fringe_bitmap_data (int bn)
+{
+ struct fringe_bitmap *fb;
+
+ fb = fringe_bitmaps[bn];
+ if (fb == NULL)
+ fb = &standard_bitmaps[bn < MAX_STANDARD_FRINGE_BITMAPS
+ ? bn : UNDEF_FRINGE_BITMAP];
+
+ return fb;
+}
/* Draw the bitmap WHICH in one of the left or right fringes of
window W. ROW is the glyph row for which to display the bitmap; it
*/
static void
-draw_fringe_bitmap_1 (w, row, left_p, overlay, which)
- struct window *w;
- struct glyph_row *row;
- int left_p, overlay;
- int which;
+draw_fringe_bitmap_1 (struct window *w, struct glyph_row *row, int left_p, int overlay, int which)
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
struct draw_fringe_bitmap_params p;
if (face_id == DEFAULT_FACE_ID)
{
- Lisp_Object face;
-
- if ((face = fringe_faces[which], NILP (face))
- || (face_id = lookup_derived_face (f, face, FRINGE_FACE_ID, 0),
- face_id < 0))
+ Lisp_Object face = fringe_faces[which];
+ face_id = NILP (face) ? lookup_named_face (f, Qfringe, 0)
+ : lookup_derived_face (f, face, FRINGE_FACE_ID, 0);
+ if (face_id < 0)
face_id = FRINGE_FACE_ID;
}
- fb = fringe_bitmaps[which];
- if (fb == NULL)
- fb = &standard_bitmaps[which < MAX_STANDARD_FRINGE_BITMAPS
- ? which : UNDEF_FRINGE_BITMAP];
+ fb = get_fringe_bitmap_data (which);
period = fb->period;
}
static int
-get_logical_cursor_bitmap (w, cursor)
- struct window *w;
- Lisp_Object cursor;
+get_logical_cursor_bitmap (struct window *w, Lisp_Object cursor)
{
Lisp_Object cmap, bm = Qnil;
- if ((cmap = XBUFFER (w->buffer)->fringe_cursor_alist), !NILP (cmap))
+ if ((cmap = BVAR (XBUFFER (w->buffer), fringe_cursor_alist)), !NILP (cmap))
{
bm = Fassq (cursor, cmap);
if (CONSP (bm))
return lookup_fringe_bitmap (bm);
}
}
- if (EQ (cmap, buffer_defaults.fringe_cursor_alist))
+ if (EQ (cmap, BVAR (&buffer_defaults, fringe_cursor_alist)))
return NO_FRINGE_BITMAP;
- bm = Fassq (cursor, buffer_defaults.fringe_cursor_alist);
+ bm = Fassq (cursor, BVAR (&buffer_defaults, fringe_cursor_alist));
if (!CONSP (bm) || ((bm = XCDR (bm)), NILP (bm)))
return NO_FRINGE_BITMAP;
return lookup_fringe_bitmap (bm);
}
static int
-get_logical_fringe_bitmap (w, bitmap, right_p, partial_p)
- struct window *w;
- Lisp_Object bitmap;
- int right_p, partial_p;
+get_logical_fringe_bitmap (struct window *w, Lisp_Object bitmap, int right_p, int partial_p)
{
Lisp_Object cmap, bm1 = Qnil, bm2 = Qnil, bm;
int ln1 = 0, ln2 = 0;
If partial, lookup partial bitmap in default value if not found here.
If not partial, or no partial spec is present, use non-partial bitmap. */
- if ((cmap = XBUFFER (w->buffer)->fringe_indicator_alist), !NILP (cmap))
+ if ((cmap = BVAR (XBUFFER (w->buffer), fringe_indicator_alist)), !NILP (cmap))
{
bm1 = Fassq (bitmap, cmap);
if (CONSP (bm1))
}
}
- if (!EQ (cmap, buffer_defaults.fringe_indicator_alist)
- && !NILP (buffer_defaults.fringe_indicator_alist))
+ if (!EQ (cmap, BVAR (&buffer_defaults, fringe_indicator_alist))
+ && !NILP (BVAR (&buffer_defaults, fringe_indicator_alist)))
{
- bm2 = Fassq (bitmap, buffer_defaults.fringe_indicator_alist);
+ bm2 = Fassq (bitmap, BVAR (&buffer_defaults, fringe_indicator_alist));
if (CONSP (bm2))
{
if ((bm2 = XCDR (bm2)), !NILP (bm2))
void
-draw_fringe_bitmap (w, row, left_p)
- struct window *w;
- struct glyph_row *row;
- int left_p;
+draw_fringe_bitmap (struct window *w, struct glyph_row *row, int left_p)
{
int overlay = 0;
- if (!left_p && row->cursor_in_fringe_p)
+ if (left_p == row->reversed_p && row->cursor_in_fringe_p)
{
Lisp_Object cursor = Qnil;
int bm = get_logical_cursor_bitmap (w, cursor);
if (bm != NO_FRINGE_BITMAP)
{
- draw_fringe_bitmap_1 (w, row, 0, 2, bm);
+ draw_fringe_bitmap_1 (w, row, left_p, 2, bm);
overlay = EQ (cursor, Qbox) ? 3 : 1;
}
}
function with input blocked. */
void
-draw_row_fringe_bitmaps (w, row)
- struct window *w;
- struct glyph_row *row;
+draw_row_fringe_bitmaps (struct window *w, struct glyph_row *row)
{
xassert (interrupt_input_blocked);
*/
int
-draw_window_fringes (w, no_fringe)
- struct window *w;
- int no_fringe;
+draw_window_fringes (struct window *w, int no_fringe)
{
struct glyph_row *row;
int yb = window_text_bottom_y (w);
If KEEP_CURRENT_P is 0, update current_matrix too. */
int
-update_window_fringes (w, keep_current_p)
- struct window *w;
- int keep_current_p;
+update_window_fringes (struct window *w, int keep_current_p)
{
struct glyph_row *row, *cur = 0;
int yb = window_text_bottom_y (w);
int bitmap_cache[MAX_BITMAP_CACHE];
int top_ind_rn, bot_ind_rn;
int top_ind_min_y, bot_ind_max_y;
- int top_row_ends_at_zv_p, bot_row_ends_at_zv_p;
+
+ /* top_ind_rn is set to a nonnegative value whenever
+ row->indicate_bob_p is set, so it's OK that top_row_ends_at_zv_p
+ is not initialized here. Similarly for bot_ind_rn,
+ row->indicate_eob_p and bot_row_ends_at_zv_p. */
+ int top_row_ends_at_zv_p IF_LINT (= 0), bot_row_ends_at_zv_p IF_LINT (= 0);
if (w->pseudo_window_p)
return 0;
if (!MINI_WINDOW_P (w)
- && (ind = XBUFFER (w->buffer)->indicate_buffer_boundaries, !NILP (ind)))
+ && (ind = BVAR (XBUFFER (w->buffer), indicate_buffer_boundaries), !NILP (ind)))
{
if (EQ (ind, Qleft) || EQ (ind, Qright))
boundary_top = boundary_bot = arrow_top = arrow_bot = ind;
}
}
- empty_pos = XBUFFER (w->buffer)->indicate_empty_lines;
+ empty_pos = BVAR (XBUFFER (w->buffer), indicate_empty_lines);
if (!NILP (empty_pos) && !EQ (empty_pos, Qright))
empty_pos = WINDOW_LEFT_FRINGE_WIDTH (w) == 0 ? Qright : Qleft;
if (bn != NO_FRINGE_BITMAP)
{
- struct fringe_bitmap *fb;
+ struct fringe_bitmap *fb = get_fringe_bitmap_data (bn);
- fb = fringe_bitmaps[bn];
- if (fb == NULL)
- fb = &standard_bitmaps[bn < MAX_STANDARD_FRINGE_BITMAPS
- ? bn : UNDEF_FRINGE_BITMAP];
if (fb->align == ALIGN_BITMAP_TOP && fb->period == 0)
{
struct glyph_row *row1;
if (bn != NO_FRINGE_BITMAP)
{
- struct fringe_bitmap *fb;
+ struct fringe_bitmap *fb = get_fringe_bitmap_data (bn);
- fb = fringe_bitmaps[bn];
- if (fb == NULL)
- fb = &standard_bitmaps[bn < MAX_STANDARD_FRINGE_BITMAPS
- ? bn : UNDEF_FRINGE_BITMAP];
if (fb->align == ALIGN_BITMAP_BOTTOM && fb->period == 0)
{
struct glyph_row *row1;
int left, right;
unsigned left_face_id, right_face_id;
int left_offset, right_offset;
+ int periodic_p;
row = w->desired_matrix->rows + rn;
cur = w->current_matrix->rows + rn;
left_face_id = right_face_id = DEFAULT_FACE_ID;
left_offset = right_offset = 0;
+ periodic_p = 0;
/* Decide which bitmap to draw in the left fringe. */
if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
left = row->left_user_fringe_bitmap;
left_face_id = row->left_user_fringe_face_id;
}
- else if (row->truncated_on_left_p)
- left = LEFT_FRINGE(0, Qtruncation, 0);
+ else if ((!row->reversed_p && row->truncated_on_left_p)
+ || (row->reversed_p && row->truncated_on_right_p))
+ left = LEFT_FRINGE (0, Qtruncation, 0);
else if (row->indicate_bob_p && EQ (boundary_top, Qleft))
{
left = ((row->indicate_eob_p && EQ (boundary_bot, Qleft))
if (bot_ind_max_y >= 0)
left_offset = bot_ind_max_y - (row->y + row->visible_height);
}
- else if (MATRIX_ROW_CONTINUATION_LINE_P (row))
+ else if ((!row->reversed_p && MATRIX_ROW_CONTINUATION_LINE_P (row))
+ || (row->reversed_p && row->continued_p))
left = LEFT_FRINGE (4, Qcontinuation, 0);
else if (row->indicate_empty_line_p && EQ (empty_pos, Qleft))
left = LEFT_FRINGE (5, Qempty_line, 0);
right = row->right_user_fringe_bitmap;
right_face_id = row->right_user_fringe_face_id;
}
- else if (row->truncated_on_right_p)
+ else if ((!row->reversed_p && row->truncated_on_right_p)
+ || (row->reversed_p && row->truncated_on_left_p))
right = RIGHT_FRINGE (0, Qtruncation, 0);
else if (row->indicate_bob_p && EQ (boundary_top, Qright))
{
if (bot_ind_max_y >= 0)
right_offset = bot_ind_max_y - (row->y + row->visible_height);
}
- else if (row->continued_p)
+ else if ((!row->reversed_p && row->continued_p)
+ || (row->reversed_p && MATRIX_ROW_CONTINUATION_LINE_P (row)))
right = RIGHT_FRINGE (4, Qcontinuation, 0);
else if (row->indicate_top_line_p && EQ (arrow_top, Qright))
{
else
right = NO_FRINGE_BITMAP;
+ periodic_p = (get_fringe_bitmap_data (left)->period != 0
+ || get_fringe_bitmap_data (right)->period != 0);
+
if (row->y != cur->y
|| row->visible_height != cur->visible_height
|| row->ends_at_zv_p != cur->ends_at_zv_p
|| right_face_id != cur->right_fringe_face_id
|| left_offset != cur->left_fringe_offset
|| right_offset != cur->right_fringe_offset
+ || periodic_p != cur->fringe_bitmap_periodic_p
|| cur->redraw_fringe_bitmaps_p)
{
redraw_p = row->redraw_fringe_bitmaps_p = 1;
cur->right_fringe_face_id = right_face_id;
cur->left_fringe_offset = left_offset;
cur->right_fringe_offset = right_offset;
+ cur->fringe_bitmap_periodic_p = periodic_p;
}
}
if (row->overlay_arrow_bitmap != cur->overlay_arrow_bitmap)
{
- redraw_p = row->redraw_fringe_bitmaps_p = cur->redraw_fringe_bitmaps_p = 1;
- cur->overlay_arrow_bitmap = row->overlay_arrow_bitmap;
+ redraw_p = row->redraw_fringe_bitmaps_p = 1;
+ if (!keep_current_p)
+ {
+ cur->redraw_fringe_bitmaps_p = 1;
+ cur->overlay_arrow_bitmap = row->overlay_arrow_bitmap;
+ }
}
row->left_fringe_bitmap = left;
row->right_fringe_face_id = right_face_id;
row->left_fringe_offset = left_offset;
row->right_fringe_offset = right_offset;
+ row->fringe_bitmap_periodic_p = periodic_p;
}
return redraw_p && !keep_current_p;
*/
void
-compute_fringe_widths (f, redraw)
- struct frame *f;
- int redraw;
+compute_fringe_widths (struct frame *f, int redraw)
{
int o_left = FRAME_LEFT_FRINGE_WIDTH (f);
int o_right = FRAME_RIGHT_FRINGE_WIDTH (f);
/* Free resources used by a user-defined bitmap. */
-void
-destroy_fringe_bitmap (n)
- int n;
+static void
+destroy_fringe_bitmap (int n)
{
struct fringe_bitmap **fbp;
1, 1, 0,
doc: /* Destroy fringe bitmap BITMAP.
If BITMAP overrides a standard fringe bitmap, the original bitmap is restored. */)
- (bitmap)
- Lisp_Object bitmap;
+ (Lisp_Object bitmap)
{
int n;
0x3, 0xb, 0x7, 0xf}; /* 0011 1011 0111 1111 */
#endif /* HAVE_X_WINDOWS */
-void
-init_fringe_bitmap (which, fb, once_p)
- int which;
- struct fringe_bitmap *fb;
- int once_p;
+static void
+init_fringe_bitmap (int which, struct fringe_bitmap *fb, int once_p)
{
if (once_p || fb->dynamic)
{
| (swap_nibble[(b>>8) & 0xf] << 4)
| (swap_nibble[(b>>12) & 0xf]));
b >>= (16 - fb->width);
-#ifdef WORDS_BIG_ENDIAN
+#ifdef WORDS_BIGENDIAN
b = ((b >> 8) | (b << 8));
#endif
*bits++ = b;
list (ALIGN PERIODIC) where PERIODIC non-nil specifies that the bitmap
should be repeated.
If BITMAP already exists, the existing definition is replaced. */)
- (bitmap, bits, height, width, align)
- Lisp_Object bitmap, bits, height, width, align;
+ (Lisp_Object bitmap, Lisp_Object bits, Lisp_Object height, Lisp_Object width, Lisp_Object align)
{
int n, h, i, j;
unsigned short *b;
if (STRINGP (bits))
h = SCHARS (bits);
else if (VECTORP (bits))
- h = XVECTOR (bits)->size;
+ h = ASIZE (bits);
else
wrong_type_argument (Qsequencep, bits);
if (n == max_fringe_bitmaps)
{
- if ((max_fringe_bitmaps + 20) > MAX_FRINGE_BITMAPS)
+ int bitmaps = max_fringe_bitmaps + 20;
+ if (MAX_FRINGE_BITMAPS < bitmaps)
error ("No free fringe bitmap slots");
i = max_fringe_bitmaps;
- max_fringe_bitmaps += 20;
fringe_bitmaps
= ((struct fringe_bitmap **)
- xrealloc (fringe_bitmaps, max_fringe_bitmaps * sizeof (struct fringe_bitmap *)));
+ xrealloc (fringe_bitmaps, bitmaps * sizeof *fringe_bitmaps));
fringe_faces
- = (Lisp_Object *) xrealloc (fringe_faces, max_fringe_bitmaps * sizeof (Lisp_Object));
+ = (Lisp_Object *) xrealloc (fringe_faces,
+ bitmaps * sizeof *fringe_faces);
- for (; i < max_fringe_bitmaps; i++)
+ for (i = max_fringe_bitmaps; i < bitmaps; i++)
{
fringe_bitmaps[i] = NULL;
fringe_faces[i] = Qnil;
}
+
+ max_fringe_bitmaps = bitmaps;
}
}
xfb = (struct fringe_bitmap *) xmalloc (sizeof fb
+ fb.height * BYTES_PER_BITMAP_ROW);
fb.bits = b = (unsigned short *) (xfb + 1);
- bzero (b, fb.height);
+ memset (b, 0, fb.height);
j = 0;
while (j < fb.height)
1, 2, 0,
doc: /* Set face for fringe bitmap BITMAP to FACE.
If FACE is nil, reset face to default fringe face. */)
- (bitmap, face)
- Lisp_Object bitmap, face;
+ (Lisp_Object bitmap, Lisp_Object face)
{
int n;
int face_id;
RIGHT is similar for the right fringe, and OV is non-nil if there is an
overlay arrow in the left fringe.
Return nil if POS is not visible in WINDOW. */)
- (pos, window)
- Lisp_Object pos, window;
+ (Lisp_Object pos, Lisp_Object window)
{
struct window *w;
struct glyph_row *row;
***********************************************************************/
void
-syms_of_fringe ()
+syms_of_fringe (void)
{
- Qtruncation = intern_c_string ("truncation");
- staticpro (&Qtruncation);
- Qcontinuation = intern_c_string ("continuation");
- staticpro (&Qcontinuation);
- Qoverlay_arrow = intern_c_string ("overlay-arrow");
- staticpro (&Qoverlay_arrow);
- Qempty_line = intern_c_string ("empty-line");
- staticpro (&Qempty_line);
- Qtop_bottom = intern_c_string ("top-bottom");
- staticpro (&Qtop_bottom);
- Qhollow_small = intern_c_string ("hollow-small");
- staticpro (&Qhollow_small);
+ DEFSYM (Qtruncation, "truncation");
+ DEFSYM (Qcontinuation, "continuation");
+ DEFSYM (Qoverlay_arrow, "overlay-arrow");
+ DEFSYM (Qempty_line, "empty-line");
+ DEFSYM (Qtop_bottom, "top-bottom");
+ DEFSYM (Qhollow_small, "hollow-small");
defsubr (&Sdestroy_fringe_bitmap);
defsubr (&Sdefine_fringe_bitmap);
defsubr (&Sfringe_bitmaps_at_pos);
defsubr (&Sset_fringe_bitmap_face);
- DEFVAR_LISP ("overflow-newline-into-fringe", &Voverflow_newline_into_fringe,
+ DEFVAR_LISP ("overflow-newline-into-fringe", Voverflow_newline_into_fringe,
doc: /* *Non-nil means that newline may flow into the right fringe.
This means that display lines which are exactly as wide as the window
(not counting the final newline) will only occupy one screen line, by
If nil, also continue lines which are exactly as wide as the window. */);
Voverflow_newline_into_fringe = Qt;
- DEFVAR_LISP ("fringe-bitmaps", &Vfringe_bitmaps,
+ DEFVAR_LISP ("fringe-bitmaps", Vfringe_bitmaps,
doc: /* List of fringe bitmap symbols. */);
Vfringe_bitmaps = Qnil;
}
/* Garbage collection hook */
void
-mark_fringe_data ()
+mark_fringe_data (void)
{
int i;
/* Initialize this module when Emacs starts. */
void
-init_fringe_once ()
+init_fringe_once (void)
{
int bt;
for (bt = NO_FRINGE_BITMAP + 1; bt < MAX_STANDARD_FRINGE_BITMAPS; bt++)
- init_fringe_bitmap(bt, &standard_bitmaps[bt], 1);
+ init_fringe_bitmap (bt, &standard_bitmaps[bt], 1);
}
void
-init_fringe ()
+init_fringe (void)
{
int i;
}
void
-w32_reset_fringes ()
+w32_reset_fringes (void)
{
/* Destroy row bitmaps. */
int bt;
#endif /* HAVE_NTGUI */
#endif /* HAVE_WINDOW_SYSTEM */
-
-/* arch-tag: 04596920-43eb-473d-b319-82712338162d
- (do not change this comment) */