#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;
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;
enum fringe_bitmap_align
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;
*/
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;
}
}
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;
}
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;
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);
left = row->left_user_fringe_bitmap;
left_face_id = row->left_user_fringe_face_id;
}
- else if (row->truncated_on_left_p)
+ 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))
{
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))
{
*/
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;
+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;
#endif /* HAVE_X_WINDOWS */
void
-init_fringe_bitmap (which, fb, once_p)
- int which;
- struct fringe_bitmap *fb;
- int once_p;
+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;
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);
/* 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;
}
void
-init_fringe ()
+init_fringe (void)
{
int i;
}
void
-w32_reset_fringes ()
+w32_reset_fringes (void)
{
/* Destroy row bitmaps. */
int bt;