Allow comma separated lists after Java "implements".
[emacs.git] / src / fringe.c
blob3537027f1ddbc6ce3ce7c0a4d8f643a9cbffd8c6
1 /* Fringe handling (split from xdisp.c).
2 Copyright (C) 1985-1988, 1993-1995, 1997-2013 Free Software
3 Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 #include <config.h>
21 #include <stdio.h>
23 #include <byteswap.h>
25 #include "lisp.h"
26 #include "frame.h"
27 #include "window.h"
28 #include "dispextern.h"
29 #include "character.h"
30 #include "buffer.h"
31 #include "blockinput.h"
32 #include "termhooks.h"
34 /* Fringe bitmaps are represented in three different ways:
36 Logical bitmaps are used internally to denote things like
37 'end-of-buffer', 'left-truncation', 'overlay-arrow', etc.
39 Physical bitmaps specify the visual appearance of the bitmap,
40 e.g. 'bottom-left-angle', 'left-arrow', 'left-triangle', etc.
41 User defined bitmaps are physical bitmaps.
43 Internally, fringe bitmaps for a specific display row are
44 represented as a simple integer that is used as an index
45 into the table of all defined bitmaps. This index is stored
46 in the `fringe' property of the physical bitmap symbol.
48 Logical bitmaps are mapped to physical bitmaps through the
49 buffer-local `fringe-indicator-alist' variable.
51 Each element of this alist is a cons (LOGICAL . PHYSICAL)
52 mapping a logical bitmap to a physical bitmap.
53 PHYSICAL is either a symbol to use in both left and right fringe,
54 or a cons of two symbols (LEFT . RIGHT) denoting different
55 bitmaps to use in left and right fringe.
57 LOGICAL is first looked up in the window's buffer's buffer-local
58 value of the fringe-indicator-alist variable, and if not present,
59 in the global value of fringe-indicator-alist.
61 If LOGICAL is not present in either alist, or the PHYSICAL value
62 found is nil, no bitmap is shown for the logical bitmap.
64 The `left-fringe' and `right-fringe' display properties
65 must specify physical bitmap symbols.
68 static Lisp_Object Qtruncation, Qcontinuation, Qoverlay_arrow;
69 static Lisp_Object Qempty_line, Qtop_bottom;
70 static Lisp_Object Qhollow_small;
72 enum fringe_bitmap_align
74 ALIGN_BITMAP_CENTER = 0,
75 ALIGN_BITMAP_TOP,
76 ALIGN_BITMAP_BOTTOM
79 struct fringe_bitmap
81 unsigned short *bits;
82 unsigned height : 8;
83 unsigned width : 8;
84 unsigned period : 8;
85 unsigned align : 2;
86 unsigned dynamic : 1;
90 /***********************************************************************
91 Fringe bitmaps
92 ***********************************************************************/
94 /* Undefined bitmap. A question mark. */
96 ..xxxx..
97 .xxxxxx.
98 xx....xx
99 xx....xx
100 ....xx..
101 ...xx...
102 ...xx...
103 ........
104 ...xx...
105 ...xx...
107 static unsigned short question_mark_bits[] = {
108 0x3c, 0x7e, 0x7e, 0x0c, 0x18, 0x18, 0x00, 0x18, 0x18};
110 /* An exclamation mark. */
112 ...XX...
113 ...XX...
114 ...XX...
115 ...XX...
116 ...XX...
117 ...XX...
118 ...XX...
119 ........
120 ...XX...
121 ...XX...
123 static unsigned short exclamation_mark_bits[] = {
124 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18};
126 /* An arrow like this: `<-'. */
128 ...xx...
129 ..xx....
130 .xx.....
131 xxxxxx..
132 xxxxxx..
133 .xx.....
134 ..xx....
135 ...xx...
137 static unsigned short left_arrow_bits[] = {
138 0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
141 /* Right truncation arrow bitmap `->'. */
143 ...xx...
144 ....xx..
145 .....xx.
146 ..xxxxxx
147 ..xxxxxx
148 .....xx.
149 ....xx..
150 ...xx...
152 static unsigned short right_arrow_bits[] = {
153 0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
156 /* Up arrow bitmap. */
158 ...xx...
159 ..xxxx..
160 .xxxxxx.
161 xxxxxxxx
162 ...xx...
163 ...xx...
164 ...xx...
165 ...xx...
167 static unsigned short up_arrow_bits[] = {
168 0x18, 0x3c, 0x7e, 0xff, 0x18, 0x18, 0x18, 0x18};
171 /* Down arrow bitmap. */
173 ...xx...
174 ...xx...
175 ...xx...
176 ...xx...
177 xxxxxxxx
178 .xxxxxx.
179 ..xxxx..
180 ...xx...
182 static unsigned short down_arrow_bits[] = {
183 0x18, 0x18, 0x18, 0x18, 0xff, 0x7e, 0x3c, 0x18};
185 /* Marker for continuation lines. */
187 ..xxxx..
188 .xxxxx..
189 xx......
190 xxx..x..
191 xxxxxx..
192 .xxxxx..
193 ..xxxx..
194 .xxxxx..
196 static unsigned short left_curly_arrow_bits[] = {
197 0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
199 /* Marker for continued lines. */
201 ..xxxx..
202 ..xxxxx.
203 ......xx
204 ..x..xxx
205 ..xxxxxx
206 ..xxxxx.
207 ..xxxx..
208 ..xxxxx.
210 static unsigned short right_curly_arrow_bits[] = {
211 0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
213 /* Reverse Overlay arrow bitmap. A triangular arrow. */
215 ......xx
216 ....xxxx
217 ...xxxxx
218 ..xxxxxx
219 ..xxxxxx
220 ...xxxxx
221 ....xxxx
222 ......xx
224 static unsigned short left_triangle_bits[] = {
225 0x03, 0x0f, 0x1f, 0x3f, 0x3f, 0x1f, 0x0f, 0x03};
227 /* Overlay arrow bitmap. A triangular arrow. */
229 xx......
230 xxxx....
231 xxxxx...
232 xxxxxx..
233 xxxxxx..
234 xxxxx...
235 xxxx....
236 xx......
238 static unsigned short right_triangle_bits[] = {
239 0xc0, 0xf0, 0xf8, 0xfc, 0xfc, 0xf8, 0xf0, 0xc0};
241 /* First line bitmap. An top-left angle. */
243 xxxxxx..
244 xxxxxx..
245 xx......
246 xx......
247 xx......
248 xx......
249 xx......
250 ........
252 static unsigned short top_left_angle_bits[] = {
253 0xfc, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00};
255 /* First line bitmap. An right-up angle. */
257 ..xxxxxx
258 ..xxxxxx
259 ......xx
260 ......xx
261 ......xx
262 ......xx
263 ......xx
264 ........
266 static unsigned short top_right_angle_bits[] = {
267 0x3f, 0x3f, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00};
269 /* Last line bitmap. An left-down angle. */
271 ........
272 xx......
273 xx......
274 xx......
275 xx......
276 xx......
277 xxxxxx..
278 xxxxxx..
280 static unsigned short bottom_left_angle_bits[] = {
281 0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfc, 0xfc};
283 /* Last line bitmap. An right-down angle. */
285 ........
286 ......xx
287 ......xx
288 ......xx
289 ......xx
290 ......xx
291 ..xxxxxx
292 ..xxxxxx
294 static unsigned short bottom_right_angle_bits[] = {
295 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x3f, 0x3f};
297 /* First/last line bitmap. An left bracket. */
299 xxxxxx..
300 xxxxxx..
301 xx......
302 xx......
303 xx......
304 xx......
305 xx......
306 xx......
307 xxxxxx..
308 xxxxxx..
310 static unsigned short left_bracket_bits[] = {
311 0xfc, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfc, 0xfc};
313 /* First/last line bitmap. An right bracket. */
315 ..xxxxxx
316 ..xxxxxx
317 ......xx
318 ......xx
319 ......xx
320 ......xx
321 ......xx
322 ......xx
323 ..xxxxxx
324 ..xxxxxx
326 static unsigned short right_bracket_bits[] = {
327 0x3f, 0x3f, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x3f, 0x3f};
329 /* Filled box cursor bitmap. A filled box; max 13 pixels high. */
331 xxxxxxx.
332 xxxxxxx.
333 xxxxxxx.
334 xxxxxxx.
335 xxxxxxx.
336 xxxxxxx.
337 xxxxxxx.
338 xxxxxxx.
339 xxxxxxx.
340 xxxxxxx.
341 xxxxxxx.
342 xxxxxxx.
343 xxxxxxx.
345 static unsigned short filled_rectangle_bits[] = {
346 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe};
348 /* Hollow box cursor bitmap. A hollow box; max 13 pixels high. */
350 xxxxxxx.
351 x.....x.
352 x.....x.
353 x.....x.
354 x.....x.
355 x.....x.
356 x.....x.
357 x.....x.
358 x.....x.
359 x.....x.
360 x.....x.
361 x.....x.
362 xxxxxxx.
364 static unsigned short hollow_rectangle_bits[] = {
365 0xfe, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0xfe};
367 /* Hollow square bitmap. */
369 .xxxxxx.
370 .x....x.
371 .x....x.
372 .x....x.
373 .x....x.
374 .xxxxxx.
376 static unsigned short hollow_square_bits[] = {
377 0x7e, 0x42, 0x42, 0x42, 0x42, 0x7e};
379 /* Filled square bitmap. */
381 .xxxxxx.
382 .xxxxxx.
383 .xxxxxx.
384 .xxxxxx.
385 .xxxxxx.
386 .xxxxxx.
388 static unsigned short filled_square_bits[] = {
389 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e};
391 /* Bar cursor bitmap. A vertical bar; max 13 pixels high. */
393 xx......
394 xx......
395 xx......
396 xx......
397 xx......
398 xx......
399 xx......
400 xx......
401 xx......
402 xx......
403 xx......
404 xx......
405 xx......
407 static unsigned short vertical_bar_bits[] = {
408 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0};
410 /* HBar cursor bitmap. A horizontal bar; 2 pixels high. */
412 xxxxxxx.
413 xxxxxxx.
415 static unsigned short horizontal_bar_bits[] = {
416 0xfe, 0xfe};
419 /* Bitmap drawn to indicate lines not displaying text if
420 `indicate-empty-lines' is non-nil. */
422 ........
423 ..xxxx..
424 ........
425 ........
426 ..xxxx..
427 ........
429 static unsigned short empty_line_bits[] = {
430 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
431 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
432 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
433 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
434 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
435 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
436 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
437 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00};
440 #define BYTES_PER_BITMAP_ROW (sizeof (unsigned short))
441 #define STANDARD_BITMAP_HEIGHT(bits) (sizeof (bits)/BYTES_PER_BITMAP_ROW)
442 #define FRBITS(bits) bits, STANDARD_BITMAP_HEIGHT (bits)
444 /* NOTE: The order of these bitmaps must match the sequence
445 used in fringe.el to define the corresponding symbols. */
447 static struct fringe_bitmap standard_bitmaps[] =
449 { NULL, 0, 0, 0, 0, 0 }, /* NO_FRINGE_BITMAP */
450 { FRBITS (question_mark_bits), 8, 0, ALIGN_BITMAP_CENTER, 0 },
451 { FRBITS (exclamation_mark_bits), 8, 0, ALIGN_BITMAP_CENTER, 0 },
452 { FRBITS (left_arrow_bits), 8, 0, ALIGN_BITMAP_CENTER, 0 },
453 { FRBITS (right_arrow_bits), 8, 0, ALIGN_BITMAP_CENTER, 0 },
454 { FRBITS (up_arrow_bits), 8, 0, ALIGN_BITMAP_TOP, 0 },
455 { FRBITS (down_arrow_bits), 8, 0, ALIGN_BITMAP_BOTTOM, 0 },
456 { FRBITS (left_curly_arrow_bits), 8, 0, ALIGN_BITMAP_CENTER, 0 },
457 { FRBITS (right_curly_arrow_bits), 8, 0, ALIGN_BITMAP_CENTER, 0 },
458 { FRBITS (left_triangle_bits), 8, 0, ALIGN_BITMAP_CENTER, 0 },
459 { FRBITS (right_triangle_bits), 8, 0, ALIGN_BITMAP_CENTER, 0 },
460 { FRBITS (top_left_angle_bits), 8, 0, ALIGN_BITMAP_TOP, 0 },
461 { FRBITS (top_right_angle_bits), 8, 0, ALIGN_BITMAP_TOP, 0 },
462 { FRBITS (bottom_left_angle_bits), 8, 0, ALIGN_BITMAP_BOTTOM, 0 },
463 { FRBITS (bottom_right_angle_bits), 8, 0, ALIGN_BITMAP_BOTTOM, 0 },
464 { FRBITS (left_bracket_bits), 8, 0, ALIGN_BITMAP_CENTER, 0 },
465 { FRBITS (right_bracket_bits), 8, 0, ALIGN_BITMAP_CENTER, 0 },
466 { FRBITS (filled_rectangle_bits), 8, 0, ALIGN_BITMAP_CENTER, 0 },
467 { FRBITS (hollow_rectangle_bits), 8, 0, ALIGN_BITMAP_CENTER, 0 },
468 { FRBITS (filled_square_bits), 8, 0, ALIGN_BITMAP_CENTER, 0 },
469 { FRBITS (hollow_square_bits), 8, 0, ALIGN_BITMAP_CENTER, 0 },
470 { FRBITS (vertical_bar_bits), 8, 0, ALIGN_BITMAP_CENTER, 0 },
471 { FRBITS (horizontal_bar_bits), 8, 0, ALIGN_BITMAP_BOTTOM, 0 },
472 { FRBITS (empty_line_bits), 8, 3, ALIGN_BITMAP_TOP, 0 },
475 #define NO_FRINGE_BITMAP 0
476 #define UNDEF_FRINGE_BITMAP 1
477 #define MAX_STANDARD_FRINGE_BITMAPS (sizeof (standard_bitmaps)/sizeof (standard_bitmaps[0]))
479 static struct fringe_bitmap **fringe_bitmaps;
480 static Lisp_Object *fringe_faces;
481 static int max_fringe_bitmaps;
483 #ifndef HAVE_NS
484 static
485 #endif
486 int max_used_fringe_bitmap = MAX_STANDARD_FRINGE_BITMAPS;
489 /* Lookup bitmap number for symbol BITMAP.
490 Return 0 if not a bitmap. */
493 lookup_fringe_bitmap (Lisp_Object bitmap)
495 EMACS_INT bn;
497 bitmap = Fget (bitmap, Qfringe);
498 if (!INTEGERP (bitmap))
499 return 0;
501 bn = XINT (bitmap);
502 if (bn > NO_FRINGE_BITMAP
503 && bn < max_used_fringe_bitmap
504 && (bn < MAX_STANDARD_FRINGE_BITMAPS
505 || fringe_bitmaps[bn] != NULL))
506 return bn;
508 return 0;
511 /* Get fringe bitmap name for bitmap number BN.
513 Found by traversing Vfringe_bitmaps comparing BN to the
514 fringe property for each symbol.
516 Return BN if not found in Vfringe_bitmaps. */
518 static Lisp_Object
519 get_fringe_bitmap_name (int bn)
521 Lisp_Object bitmaps;
522 Lisp_Object num;
524 /* Zero means no bitmap -- return nil. */
525 if (bn <= 0)
526 return Qnil;
528 bitmaps = Vfringe_bitmaps;
529 num = make_number (bn);
531 while (CONSP (bitmaps))
533 Lisp_Object bitmap = XCAR (bitmaps);
534 if (EQ (num, Fget (bitmap, Qfringe)))
535 return bitmap;
536 bitmaps = XCDR (bitmaps);
539 return num;
542 /* Get fringe bitmap data for bitmap number BN. */
544 static struct fringe_bitmap *
545 get_fringe_bitmap_data (int bn)
547 struct fringe_bitmap *fb;
549 fb = fringe_bitmaps[bn];
550 if (fb == NULL)
551 fb = &standard_bitmaps[bn < MAX_STANDARD_FRINGE_BITMAPS
552 ? bn : UNDEF_FRINGE_BITMAP];
554 return fb;
557 /* Draw the bitmap WHICH in one of the left or right fringes of
558 window W. ROW is the glyph row for which to display the bitmap; it
559 determines the vertical position at which the bitmap has to be
560 drawn.
561 LEFT_P is 1 for left fringe, 0 for right fringe.
564 static void
565 draw_fringe_bitmap_1 (struct window *w, struct glyph_row *row, int left_p, int overlay, int which)
567 struct frame *f = XFRAME (WINDOW_FRAME (w));
568 struct draw_fringe_bitmap_params p;
569 struct fringe_bitmap *fb;
570 int period;
571 int face_id = DEFAULT_FACE_ID;
572 int offset, header_line_height;
574 p.overlay_p = (overlay & 1) == 1;
575 p.cursor_p = (overlay & 2) == 2;
577 if (which != NO_FRINGE_BITMAP)
579 offset = 0;
581 else if (left_p)
583 which = row->left_fringe_bitmap;
584 face_id = row->left_fringe_face_id;
585 offset = row->left_fringe_offset;
587 else
589 which = row->right_fringe_bitmap;
590 face_id = row->right_fringe_face_id;
591 offset = row->right_fringe_offset;
594 if (face_id == DEFAULT_FACE_ID)
596 Lisp_Object face = fringe_faces[which];
597 face_id = NILP (face) ? lookup_named_face (f, Qfringe, 0)
598 : lookup_derived_face (f, face, FRINGE_FACE_ID, 0);
599 if (face_id < 0)
600 face_id = FRINGE_FACE_ID;
603 fb = get_fringe_bitmap_data (which);
605 period = fb->period;
607 /* Convert row to frame coordinates. */
608 p.y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y) + offset;
610 p.which = which;
611 p.bits = fb->bits;
612 p.wd = fb->width;
614 p.h = fb->height;
615 p.dh = (period > 0 ? (p.y % period) : 0);
616 p.h -= p.dh;
618 /* Adjust y to the offset in the row to start drawing the bitmap. */
619 switch (fb->align)
621 case ALIGN_BITMAP_CENTER:
622 p.y += (row->height - p.h) / 2;
623 break;
624 case ALIGN_BITMAP_BOTTOM:
625 p.y += (row->visible_height - p.h);
626 break;
627 case ALIGN_BITMAP_TOP:
628 break;
631 p.face = FACE_FROM_ID (f, face_id);
633 if (p.face == NULL)
635 /* This could happen after clearing face cache.
636 But it shouldn't happen anymore. ++kfs */
637 return;
640 PREPARE_FACE_FOR_DISPLAY (f, p.face);
642 /* Clear left fringe if no bitmap to draw or if bitmap doesn't fill
643 the fringe. */
644 p.bx = -1;
645 header_line_height = WINDOW_HEADER_LINE_HEIGHT (w);
646 p.by = WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height, row->y));
647 p.ny = row->visible_height;
648 if (left_p)
650 int wd = WINDOW_LEFT_FRINGE_WIDTH (w);
651 int x = window_box_left (w, (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
652 ? LEFT_MARGIN_AREA
653 : TEXT_AREA));
654 if (p.wd > wd)
655 p.wd = wd;
656 p.x = x - p.wd - (wd - p.wd) / 2;
658 if (p.wd < wd || p.y > p.by || p.y + p.h < p.by + p.ny)
660 /* If W has a vertical border to its left, don't draw over it. */
661 wd -= ((!WINDOW_LEFTMOST_P (w)
662 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w)
663 /* But don't reduce the fringe width if the window
664 has a left margin, because that means we are not
665 in danger of drawing over the vertical border,
666 and OTOH leaving out that one pixel leaves behind
667 traces of the cursor, if it was in column zero
668 before drawing non-empty margin area. */
669 && w->left_margin_cols == 0)
670 ? 1 : 0);
671 p.bx = x - wd;
672 p.nx = wd;
675 else
677 int x = window_box_right (w,
678 (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
679 ? RIGHT_MARGIN_AREA
680 : TEXT_AREA));
681 int wd = WINDOW_RIGHT_FRINGE_WIDTH (w);
682 if (p.wd > wd)
683 p.wd = wd;
684 p.x = x + (wd - p.wd) / 2;
685 /* Clear right fringe if no bitmap to draw of if bitmap doesn't fill
686 the fringe. */
687 if (p.wd < wd || p.y > p.by || p.y + p.h < p.by + p.ny)
689 p.bx = x;
690 p.nx = wd;
694 FRAME_RIF (f)->draw_fringe_bitmap (w, row, &p);
697 static int
698 get_logical_cursor_bitmap (struct window *w, Lisp_Object cursor)
700 Lisp_Object cmap, bm = Qnil;
702 if ((cmap = BVAR (XBUFFER (w->contents), fringe_cursor_alist)), !NILP (cmap))
704 bm = Fassq (cursor, cmap);
705 if (CONSP (bm))
707 if ((bm = XCDR (bm)), NILP (bm))
708 return NO_FRINGE_BITMAP;
709 return lookup_fringe_bitmap (bm);
712 if (EQ (cmap, BVAR (&buffer_defaults, fringe_cursor_alist)))
713 return NO_FRINGE_BITMAP;
714 bm = Fassq (cursor, BVAR (&buffer_defaults, fringe_cursor_alist));
715 if (!CONSP (bm) || ((bm = XCDR (bm)), NILP (bm)))
716 return NO_FRINGE_BITMAP;
717 return lookup_fringe_bitmap (bm);
720 static int
721 get_logical_fringe_bitmap (struct window *w, Lisp_Object bitmap, int right_p, int partial_p)
723 Lisp_Object cmap, bm1 = Qnil, bm2 = Qnil, bm;
724 EMACS_INT ln1 = 0, ln2 = 0;
725 int ix1 = right_p;
726 int ix2 = ix1 + (partial_p ? 2 : 0);
728 /* Lookup in buffer-local fringe-indicator-alist before global alist.
730 Elements are:
731 BITMAP -- use for all
732 (L R) -- use for left right (whether partial or not)
733 (L R PL PR) -- use for left right partial-left partial-right
734 If any value in local binding is not present or t, use global value.
736 If partial, lookup partial bitmap in default value if not found here.
737 If not partial, or no partial spec is present, use non-partial bitmap. */
739 if ((cmap = BVAR (XBUFFER (w->contents), fringe_indicator_alist)), !NILP (cmap))
741 bm1 = Fassq (bitmap, cmap);
742 if (CONSP (bm1))
744 if ((bm1 = XCDR (bm1)), NILP (bm1))
745 return NO_FRINGE_BITMAP;
746 if (CONSP (bm1))
748 ln1 = XINT (Flength (bm1));
749 if (partial_p)
751 if (ln1 > ix2)
753 bm = Fnth (make_number (ix2), bm1);
754 if (!EQ (bm, Qt))
755 goto found;
758 else
760 if (ln1 > ix1)
762 bm = Fnth (make_number (ix1), bm1);
763 if (!EQ (bm, Qt))
764 goto found;
768 else if ((bm = bm1, !EQ (bm, Qt)))
769 goto found;
773 if (!EQ (cmap, BVAR (&buffer_defaults, fringe_indicator_alist))
774 && !NILP (BVAR (&buffer_defaults, fringe_indicator_alist)))
776 bm2 = Fassq (bitmap, BVAR (&buffer_defaults, fringe_indicator_alist));
777 if (CONSP (bm2))
779 if ((bm2 = XCDR (bm2)), !NILP (bm2))
781 if (CONSP (bm2))
783 ln2 = XINT (Flength (bm2));
784 if (partial_p)
786 if (ln2 > ix2)
788 bm = Fnth (make_number (ix2), bm2);
789 if (!EQ (bm, Qt))
790 goto found;
798 if (ln1 > ix1)
800 bm = Fnth (make_number (ix1), bm1);
801 if (!EQ (bm, Qt))
802 goto found;
805 if (ln2 > ix1)
807 bm = Fnth (make_number (ix1), bm2);
808 if (!EQ (bm, Qt))
809 goto found;
810 return NO_FRINGE_BITMAP;
812 else if ((bm = bm2, NILP (bm)))
813 return NO_FRINGE_BITMAP;
815 found:
816 return lookup_fringe_bitmap (bm);
820 void
821 draw_fringe_bitmap (struct window *w, struct glyph_row *row, int left_p)
823 int overlay = 0;
825 if (left_p == row->reversed_p && row->cursor_in_fringe_p)
827 Lisp_Object cursor = Qnil;
829 switch (w->phys_cursor_type)
831 case HOLLOW_BOX_CURSOR:
832 if (row->visible_height >= STANDARD_BITMAP_HEIGHT (hollow_rectangle_bits))
833 cursor = Qhollow;
834 else
835 cursor = Qhollow_small;
836 break;
837 case FILLED_BOX_CURSOR:
838 cursor = Qbox;
839 break;
840 case BAR_CURSOR:
841 cursor = Qbar;
842 break;
843 case HBAR_CURSOR:
844 cursor = Qhbar;
845 break;
846 case NO_CURSOR:
847 default:
848 w->phys_cursor_on_p = 0;
849 row->cursor_in_fringe_p = 0;
850 break;
852 if (!NILP (cursor))
854 int bm = get_logical_cursor_bitmap (w, cursor);
855 if (bm != NO_FRINGE_BITMAP)
857 draw_fringe_bitmap_1 (w, row, left_p, 2, bm);
858 overlay = EQ (cursor, Qbox) ? 3 : 1;
863 draw_fringe_bitmap_1 (w, row, left_p, overlay, NO_FRINGE_BITMAP);
865 if (left_p && row->overlay_arrow_bitmap != NO_FRINGE_BITMAP)
866 draw_fringe_bitmap_1 (w, row, 1, 1, row->overlay_arrow_bitmap);
870 /* Draw fringe bitmaps for glyph row ROW on window W. Call this
871 function with input blocked. */
873 void
874 draw_row_fringe_bitmaps (struct window *w, struct glyph_row *row)
876 eassert (input_blocked_p ());
878 /* If row is completely invisible, because of vscrolling, we
879 don't have to draw anything. */
880 if (row->visible_height <= 0)
881 return;
883 if (WINDOW_LEFT_FRINGE_WIDTH (w) != 0)
884 draw_fringe_bitmap (w, row, 1);
886 if (WINDOW_RIGHT_FRINGE_WIDTH (w) != 0)
887 draw_fringe_bitmap (w, row, 0);
890 /* Draw the fringes of window W. Only fringes for rows marked for
891 update in redraw_fringe_bitmaps_p are drawn.
893 Return nonzero if left or right fringe was redrawn in any way.
895 If NO_FRINGE_P is non-zero, also return nonzero if either fringe
896 has zero width.
898 A return nonzero value indicates that the vertical line between
899 windows needs update (as it may be drawn in the fringe).
902 bool
903 draw_window_fringes (struct window *w, bool no_fringe_p)
905 struct glyph_row *row;
906 int yb = window_text_bottom_y (w);
907 int nrows = w->current_matrix->nrows;
908 int y, rn;
909 bool updated_p = 0;
911 if (w->pseudo_window_p)
912 return updated_p;
914 /* Must draw line if no fringe */
915 if (no_fringe_p
916 && (WINDOW_LEFT_FRINGE_WIDTH (w) == 0
917 || WINDOW_RIGHT_FRINGE_WIDTH (w) == 0))
918 updated_p = 1;
920 for (y = w->vscroll, rn = 0, row = w->current_matrix->rows;
921 y < yb && rn < nrows;
922 y += row->height, ++row, ++rn)
924 if (!row->redraw_fringe_bitmaps_p)
925 continue;
926 draw_row_fringe_bitmaps (w, row);
927 row->redraw_fringe_bitmaps_p = 0;
928 updated_p = 1;
931 return updated_p;
935 /* Recalculate the bitmaps to show in the fringes of window W.
936 Only mark rows with modified bitmaps for update in redraw_fringe_bitmaps_p.
938 If KEEP_CURRENT_P is 0, update current_matrix too. */
940 bool
941 update_window_fringes (struct window *w, bool keep_current_p)
943 struct glyph_row *row, *cur = 0;
944 int yb = window_text_bottom_y (w);
945 int rn, nrows = w->current_matrix->nrows;
946 int y;
947 bool redraw_p = 0;
948 Lisp_Object boundary_top = Qnil, boundary_bot = Qnil;
949 Lisp_Object arrow_top = Qnil, arrow_bot = Qnil;
950 Lisp_Object empty_pos;
951 Lisp_Object ind = Qnil;
952 #define MAX_BITMAP_CACHE (8*4)
953 int bitmap_cache[MAX_BITMAP_CACHE];
954 int top_ind_rn, bot_ind_rn;
955 int top_ind_min_y, bot_ind_max_y;
957 /* top_ind_rn is set to a nonnegative value whenever
958 row->indicate_bob_p is set, so it's OK that top_row_ends_at_zv_p
959 is not initialized here. Similarly for bot_ind_rn,
960 row->indicate_eob_p and bot_row_ends_at_zv_p. */
961 int top_row_ends_at_zv_p IF_LINT (= 0), bot_row_ends_at_zv_p IF_LINT (= 0);
963 if (w->pseudo_window_p)
964 return 0;
966 if (!MINI_WINDOW_P (w)
967 && (ind = BVAR (XBUFFER (w->contents), indicate_buffer_boundaries), !NILP (ind)))
969 if (EQ (ind, Qleft) || EQ (ind, Qright))
970 boundary_top = boundary_bot = arrow_top = arrow_bot = ind;
971 else if (CONSP (ind) && CONSP (XCAR (ind)))
973 Lisp_Object pos;
974 if (pos = Fassq (Qt, ind), !NILP (pos))
975 boundary_top = boundary_bot = arrow_top = arrow_bot = XCDR (pos);
976 if (pos = Fassq (Qtop, ind), !NILP (pos))
977 boundary_top = XCDR (pos);
978 if (pos = Fassq (Qbottom, ind), !NILP (pos))
979 boundary_bot = XCDR (pos);
980 if (pos = Fassq (Qup, ind), !NILP (pos))
981 arrow_top = XCDR (pos);
982 if (pos = Fassq (Qdown, ind), !NILP (pos))
983 arrow_bot = XCDR (pos);
985 else
986 /* Anything else means boundary on left and no arrows. */
987 boundary_top = boundary_bot = Qleft;
990 top_ind_rn = bot_ind_rn = -1;
991 if (!NILP (ind))
993 for (y = w->vscroll, rn = 0;
994 y < yb && rn < nrows;
995 y += row->height, ++rn)
997 row = w->desired_matrix->rows + rn;
998 if (!row->enabled_p)
999 row = w->current_matrix->rows + rn;
1001 row->indicate_bob_p = row->indicate_top_line_p = 0;
1002 row->indicate_eob_p = row->indicate_bottom_line_p = 0;
1004 if (!row->mode_line_p)
1006 if (top_ind_rn < 0 && row->visible_height > 0)
1008 if (MATRIX_ROW_START_CHARPOS (row) <= BUF_BEGV (XBUFFER (w->contents))
1009 && !MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (w, row))
1010 row->indicate_bob_p = !NILP (boundary_top);
1011 else
1012 row->indicate_top_line_p = !NILP (arrow_top);
1013 top_ind_rn = rn;
1016 if (bot_ind_rn < 0)
1018 if (MATRIX_ROW_END_CHARPOS (row) >= BUF_ZV (XBUFFER (w->contents))
1019 && !MATRIX_ROW_PARTIALLY_VISIBLE_AT_BOTTOM_P (w, row))
1020 row->indicate_eob_p = !NILP (boundary_bot), bot_ind_rn = rn;
1021 else if (y + row->height >= yb)
1022 row->indicate_bottom_line_p = !NILP (arrow_bot), bot_ind_rn = rn;
1028 empty_pos = BVAR (XBUFFER (w->contents), indicate_empty_lines);
1029 if (!NILP (empty_pos) && !EQ (empty_pos, Qright))
1030 empty_pos = WINDOW_LEFT_FRINGE_WIDTH (w) == 0 ? Qright : Qleft;
1032 for (y = 0; y < MAX_BITMAP_CACHE; y++)
1033 bitmap_cache[y] = -1;
1035 #define LEFT_FRINGE(cache, which, partial_p) \
1036 (bitmap_cache[cache*4+partial_p] >= 0 \
1037 ? bitmap_cache[cache*4+partial_p] \
1038 : (bitmap_cache[cache*4+partial_p] = \
1039 get_logical_fringe_bitmap (w, which, 0, partial_p)))
1041 #define RIGHT_FRINGE(cache, which, partial_p) \
1042 (bitmap_cache[cache*4+2+partial_p] >= 0 \
1043 ? bitmap_cache[cache*4+2+partial_p] \
1044 : (bitmap_cache[cache*4+2+partial_p] = \
1045 get_logical_fringe_bitmap (w, which, 1, partial_p)))
1048 /* Extend top-aligned top indicator (or bottom-aligned bottom
1049 indicator) to adjacent rows if it doesn't fit in one row. */
1050 top_ind_min_y = bot_ind_max_y = -1;
1051 if (top_ind_rn >= 0)
1053 int bn = NO_FRINGE_BITMAP;
1055 row = w->desired_matrix->rows + top_ind_rn;
1056 if (!row->enabled_p)
1057 row = w->current_matrix->rows + top_ind_rn;
1059 top_row_ends_at_zv_p = row->ends_at_zv_p;
1060 if (row->indicate_bob_p)
1062 if (EQ (boundary_top, Qleft))
1063 bn = ((row->indicate_eob_p && EQ (boundary_bot, Qleft))
1064 ? LEFT_FRINGE (1, Qtop_bottom, row->ends_at_zv_p)
1065 : LEFT_FRINGE (2, Qtop, 0));
1066 else
1067 bn = ((row->indicate_eob_p && EQ (boundary_bot, Qright))
1068 ? RIGHT_FRINGE (1, Qtop_bottom, row->ends_at_zv_p)
1069 : RIGHT_FRINGE (2, Qtop, 0));
1071 else if (row->indicate_top_line_p)
1073 if (EQ (arrow_top, Qleft))
1074 bn = LEFT_FRINGE (6, Qup, 0);
1075 else
1076 bn = RIGHT_FRINGE (6, Qup, 0);
1079 if (bn != NO_FRINGE_BITMAP)
1081 struct fringe_bitmap *fb = get_fringe_bitmap_data (bn);
1083 if (fb->align == ALIGN_BITMAP_TOP && fb->period == 0)
1085 struct glyph_row *row1;
1086 int top_ind_max_y;
1088 top_ind_min_y = WINDOW_HEADER_LINE_HEIGHT (w);
1089 top_ind_max_y = top_ind_min_y + fb->height;
1090 if (top_ind_max_y > yb)
1091 top_ind_max_y = yb;
1093 for (y = row->y + row->height, rn = top_ind_rn + 1;
1094 y < top_ind_max_y && rn < nrows;
1095 y += row1->height, rn++)
1097 if (bot_ind_rn >= 0 && rn >= bot_ind_rn)
1098 break;
1100 row1 = w->desired_matrix->rows + rn;
1101 if (!row1->enabled_p)
1102 row1 = w->current_matrix->rows + rn;
1104 row1->indicate_bob_p = row->indicate_bob_p;
1105 row1->indicate_top_line_p = row->indicate_top_line_p;
1110 if (bot_ind_rn >= 0)
1112 int bn = NO_FRINGE_BITMAP;
1114 row = w->desired_matrix->rows + bot_ind_rn;
1115 if (!row->enabled_p)
1116 row = w->current_matrix->rows + bot_ind_rn;
1118 bot_row_ends_at_zv_p = row->ends_at_zv_p;
1119 if (row->indicate_eob_p)
1121 if (EQ (boundary_bot, Qleft))
1122 bn = LEFT_FRINGE (3, Qbottom, row->ends_at_zv_p);
1123 else
1124 bn = RIGHT_FRINGE (3, Qbottom, row->ends_at_zv_p);
1126 else if (row->indicate_bottom_line_p)
1128 if (EQ (arrow_bot, Qleft))
1129 bn = LEFT_FRINGE (7, Qdown, 0);
1130 else
1131 bn = RIGHT_FRINGE (7, Qdown, 0);
1134 if (bn != NO_FRINGE_BITMAP)
1136 struct fringe_bitmap *fb = get_fringe_bitmap_data (bn);
1138 if (fb->align == ALIGN_BITMAP_BOTTOM && fb->period == 0)
1140 struct glyph_row *row1;
1141 int bot_ind_min_y;
1143 bot_ind_max_y = row->y + row->visible_height;
1144 bot_ind_min_y = bot_ind_max_y - fb->height;
1145 if (bot_ind_min_y < WINDOW_HEADER_LINE_HEIGHT (w))
1146 bot_ind_min_y = WINDOW_HEADER_LINE_HEIGHT (w);
1148 for (y = row->y, rn = bot_ind_rn - 1;
1149 y >= bot_ind_min_y && rn >= 0;
1150 y -= row1->height, rn--)
1152 if (top_ind_rn >= 0 && rn <= top_ind_rn)
1153 break;
1155 row1 = w->desired_matrix->rows + rn;
1156 if (!row1->enabled_p)
1157 row1 = w->current_matrix->rows + rn;
1159 row1->indicate_eob_p = row->indicate_eob_p;
1160 row1->indicate_bottom_line_p = row->indicate_bottom_line_p;
1166 for (y = w->vscroll, rn = 0;
1167 y < yb && rn < nrows;
1168 y += row->height, rn++)
1170 int left, right;
1171 unsigned left_face_id, right_face_id;
1172 int left_offset, right_offset;
1173 bool periodic_p;
1175 row = w->desired_matrix->rows + rn;
1176 cur = w->current_matrix->rows + rn;
1177 if (!row->enabled_p)
1178 row = cur;
1180 left_face_id = right_face_id = DEFAULT_FACE_ID;
1181 left_offset = right_offset = 0;
1182 periodic_p = 0;
1184 /* Decide which bitmap to draw in the left fringe. */
1185 if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
1186 left = NO_FRINGE_BITMAP;
1187 else if (row->left_user_fringe_bitmap != NO_FRINGE_BITMAP)
1189 left = row->left_user_fringe_bitmap;
1190 left_face_id = row->left_user_fringe_face_id;
1192 else if ((!row->reversed_p && row->truncated_on_left_p)
1193 || (row->reversed_p && row->truncated_on_right_p))
1194 left = LEFT_FRINGE (0, Qtruncation, 0);
1195 else if (row->indicate_bob_p && EQ (boundary_top, Qleft))
1197 left = ((row->indicate_eob_p && EQ (boundary_bot, Qleft))
1198 ? LEFT_FRINGE (1, Qtop_bottom, top_row_ends_at_zv_p)
1199 : LEFT_FRINGE (2, Qtop, 0));
1200 if (top_ind_min_y >= 0)
1201 left_offset = top_ind_min_y - row->y;
1203 else if (row->indicate_eob_p && EQ (boundary_bot, Qleft))
1205 left = LEFT_FRINGE (3, Qbottom, bot_row_ends_at_zv_p);
1206 if (bot_ind_max_y >= 0)
1207 left_offset = bot_ind_max_y - (row->y + row->visible_height);
1209 else if ((!row->reversed_p && MATRIX_ROW_CONTINUATION_LINE_P (row))
1210 || (row->reversed_p && row->continued_p))
1211 left = LEFT_FRINGE (4, Qcontinuation, 0);
1212 else if (row->indicate_empty_line_p && EQ (empty_pos, Qleft))
1213 left = LEFT_FRINGE (5, Qempty_line, 0);
1214 else if (row->indicate_top_line_p && EQ (arrow_top, Qleft))
1216 left = LEFT_FRINGE (6, Qup, 0);
1217 if (top_ind_min_y >= 0)
1218 left_offset = top_ind_min_y - row->y;
1220 else if (row->indicate_bottom_line_p && EQ (arrow_bot, Qleft))
1222 left = LEFT_FRINGE (7, Qdown, 0);
1223 if (bot_ind_max_y >= 0)
1224 left_offset = bot_ind_max_y - (row->y + row->visible_height);
1226 else
1227 left = NO_FRINGE_BITMAP;
1229 /* Decide which bitmap to draw in the right fringe. */
1230 if (WINDOW_RIGHT_FRINGE_WIDTH (w) == 0)
1231 right = NO_FRINGE_BITMAP;
1232 else if (row->right_user_fringe_bitmap != NO_FRINGE_BITMAP)
1234 right = row->right_user_fringe_bitmap;
1235 right_face_id = row->right_user_fringe_face_id;
1237 else if ((!row->reversed_p && row->truncated_on_right_p)
1238 || (row->reversed_p && row->truncated_on_left_p))
1239 right = RIGHT_FRINGE (0, Qtruncation, 0);
1240 else if (row->indicate_bob_p && EQ (boundary_top, Qright))
1242 right = ((row->indicate_eob_p && EQ (boundary_bot, Qright))
1243 ? RIGHT_FRINGE (1, Qtop_bottom, top_row_ends_at_zv_p)
1244 : RIGHT_FRINGE (2, Qtop, 0));
1245 if (top_ind_min_y >= 0)
1246 right_offset = top_ind_min_y - row->y;
1248 else if (row->indicate_eob_p && EQ (boundary_bot, Qright))
1250 right = RIGHT_FRINGE (3, Qbottom, bot_row_ends_at_zv_p);
1251 if (bot_ind_max_y >= 0)
1252 right_offset = bot_ind_max_y - (row->y + row->visible_height);
1254 else if ((!row->reversed_p && row->continued_p)
1255 || (row->reversed_p && MATRIX_ROW_CONTINUATION_LINE_P (row)))
1256 right = RIGHT_FRINGE (4, Qcontinuation, 0);
1257 else if (row->indicate_top_line_p && EQ (arrow_top, Qright))
1259 right = RIGHT_FRINGE (6, Qup, 0);
1260 if (top_ind_min_y >= 0)
1261 right_offset = top_ind_min_y - row->y;
1263 else if (row->indicate_bottom_line_p && EQ (arrow_bot, Qright))
1265 right = RIGHT_FRINGE (7, Qdown, 0);
1266 if (bot_ind_max_y >= 0)
1267 right_offset = bot_ind_max_y - (row->y + row->visible_height);
1269 else if (row->indicate_empty_line_p && EQ (empty_pos, Qright))
1270 right = RIGHT_FRINGE (5, Qempty_line, 0);
1271 else
1272 right = NO_FRINGE_BITMAP;
1274 periodic_p = (get_fringe_bitmap_data (left)->period != 0
1275 || get_fringe_bitmap_data (right)->period != 0);
1277 if (row->y != cur->y
1278 || row->visible_height != cur->visible_height
1279 || row->ends_at_zv_p != cur->ends_at_zv_p
1280 || left != cur->left_fringe_bitmap
1281 || right != cur->right_fringe_bitmap
1282 || left_face_id != cur->left_fringe_face_id
1283 || right_face_id != cur->right_fringe_face_id
1284 || left_offset != cur->left_fringe_offset
1285 || right_offset != cur->right_fringe_offset
1286 || periodic_p != cur->fringe_bitmap_periodic_p
1287 || cur->redraw_fringe_bitmaps_p)
1289 redraw_p = 1, row->redraw_fringe_bitmaps_p = 1;
1290 if (!keep_current_p)
1292 cur->redraw_fringe_bitmaps_p = 1;
1293 cur->left_fringe_bitmap = left;
1294 cur->right_fringe_bitmap = right;
1295 cur->left_fringe_face_id = left_face_id;
1296 cur->right_fringe_face_id = right_face_id;
1297 cur->left_fringe_offset = left_offset;
1298 cur->right_fringe_offset = right_offset;
1299 cur->fringe_bitmap_periodic_p = periodic_p;
1303 if (row->overlay_arrow_bitmap < 0)
1304 row->overlay_arrow_bitmap = get_logical_fringe_bitmap (w, Qoverlay_arrow, 0, 0);
1306 if (row->overlay_arrow_bitmap != cur->overlay_arrow_bitmap)
1308 redraw_p = 1, row->redraw_fringe_bitmaps_p = 1;
1309 if (!keep_current_p)
1311 cur->redraw_fringe_bitmaps_p = 1;
1312 cur->overlay_arrow_bitmap = row->overlay_arrow_bitmap;
1316 row->left_fringe_bitmap = left;
1317 row->right_fringe_bitmap = right;
1318 row->left_fringe_face_id = left_face_id;
1319 row->right_fringe_face_id = right_face_id;
1320 row->left_fringe_offset = left_offset;
1321 row->right_fringe_offset = right_offset;
1322 row->fringe_bitmap_periodic_p = periodic_p;
1325 return redraw_p && !keep_current_p;
1329 /* Compute actual fringe widths for frame F.
1331 If REDRAW is 1, redraw F if the fringe settings was actually
1332 modified and F is visible.
1334 Since the combined left and right fringe must occupy an integral
1335 number of columns, we may need to add some pixels to each fringe.
1336 Typically, we add an equal amount (+/- 1 pixel) to each fringe,
1337 but a negative width value is taken literally (after negating it).
1339 We never make the fringes narrower than specified.
1342 void
1343 compute_fringe_widths (struct frame *f, bool redraw_p)
1345 int o_left = FRAME_LEFT_FRINGE_WIDTH (f);
1346 int o_right = FRAME_RIGHT_FRINGE_WIDTH (f);
1347 int o_cols = FRAME_FRINGE_COLS (f);
1349 Lisp_Object left_fringe = Fassq (Qleft_fringe, f->param_alist);
1350 Lisp_Object right_fringe = Fassq (Qright_fringe, f->param_alist);
1351 int left_fringe_width, right_fringe_width;
1353 if (!NILP (left_fringe))
1354 left_fringe = Fcdr (left_fringe);
1355 if (!NILP (right_fringe))
1356 right_fringe = Fcdr (right_fringe);
1358 left_fringe_width = ((NILP (left_fringe) || !INTEGERP (left_fringe)) ? 8 :
1359 XINT (left_fringe));
1360 right_fringe_width = ((NILP (right_fringe) || !INTEGERP (right_fringe)) ? 8 :
1361 XINT (right_fringe));
1363 if (left_fringe_width || right_fringe_width)
1365 int left_wid = eabs (left_fringe_width);
1366 int right_wid = eabs (right_fringe_width);
1367 int conf_wid = left_wid + right_wid;
1368 int font_wid = FRAME_COLUMN_WIDTH (f);
1369 int cols = (left_wid + right_wid + font_wid-1) / font_wid;
1370 int real_wid = cols * font_wid;
1371 if (left_wid && right_wid)
1373 if (left_fringe_width < 0)
1375 /* Left fringe width is fixed, adjust right fringe if necessary */
1376 FRAME_LEFT_FRINGE_WIDTH (f) = left_wid;
1377 FRAME_RIGHT_FRINGE_WIDTH (f) = real_wid - left_wid;
1379 else if (right_fringe_width < 0)
1381 /* Right fringe width is fixed, adjust left fringe if necessary */
1382 FRAME_LEFT_FRINGE_WIDTH (f) = real_wid - right_wid;
1383 FRAME_RIGHT_FRINGE_WIDTH (f) = right_wid;
1385 else
1387 /* Adjust both fringes with an equal amount.
1388 Note that we are doing integer arithmetic here, so don't
1389 lose a pixel if the total width is an odd number. */
1390 int fill = real_wid - conf_wid;
1391 FRAME_LEFT_FRINGE_WIDTH (f) = left_wid + fill/2;
1392 FRAME_RIGHT_FRINGE_WIDTH (f) = right_wid + fill - fill/2;
1395 else if (left_fringe_width)
1397 FRAME_LEFT_FRINGE_WIDTH (f) = real_wid;
1398 FRAME_RIGHT_FRINGE_WIDTH (f) = 0;
1400 else
1402 FRAME_LEFT_FRINGE_WIDTH (f) = 0;
1403 FRAME_RIGHT_FRINGE_WIDTH (f) = real_wid;
1405 FRAME_FRINGE_COLS (f) = cols;
1407 else
1409 FRAME_LEFT_FRINGE_WIDTH (f) = 0;
1410 FRAME_RIGHT_FRINGE_WIDTH (f) = 0;
1411 FRAME_FRINGE_COLS (f) = 0;
1414 if (redraw_p && FRAME_VISIBLE_P (f))
1415 if (o_left != FRAME_LEFT_FRINGE_WIDTH (f) ||
1416 o_right != FRAME_RIGHT_FRINGE_WIDTH (f) ||
1417 o_cols != FRAME_FRINGE_COLS (f))
1418 redraw_frame (f);
1422 /* Free resources used by a user-defined bitmap. */
1424 static void
1425 destroy_fringe_bitmap (int n)
1427 struct fringe_bitmap **fbp;
1429 fringe_faces[n] = Qnil;
1431 fbp = &fringe_bitmaps[n];
1432 if (*fbp && (*fbp)->dynamic)
1434 /* XXX Is SELECTED_FRAME OK here? */
1435 struct redisplay_interface *rif = FRAME_RIF (SELECTED_FRAME ());
1436 if (rif && rif->destroy_fringe_bitmap)
1437 rif->destroy_fringe_bitmap (n);
1438 xfree (*fbp);
1439 *fbp = NULL;
1442 while (max_used_fringe_bitmap > MAX_STANDARD_FRINGE_BITMAPS
1443 && fringe_bitmaps[max_used_fringe_bitmap - 1] == NULL)
1444 max_used_fringe_bitmap--;
1448 DEFUN ("destroy-fringe-bitmap", Fdestroy_fringe_bitmap, Sdestroy_fringe_bitmap,
1449 1, 1, 0,
1450 doc: /* Destroy fringe bitmap BITMAP.
1451 If BITMAP overrides a standard fringe bitmap, the original bitmap is restored. */)
1452 (Lisp_Object bitmap)
1454 int n;
1456 CHECK_SYMBOL (bitmap);
1457 n = lookup_fringe_bitmap (bitmap);
1458 if (!n)
1459 return Qnil;
1461 destroy_fringe_bitmap (n);
1463 if (n >= MAX_STANDARD_FRINGE_BITMAPS)
1465 Vfringe_bitmaps = Fdelq (bitmap, Vfringe_bitmaps);
1466 /* It would be better to remove the fringe property. */
1467 Fput (bitmap, Qfringe, Qnil);
1470 return Qnil;
1474 /* Initialize bitmap bit.
1476 On X, we bit-swap the built-in bitmaps and reduce bitmap
1477 from short to char array if width is <= 8 bits.
1479 On MAC with big-endian CPU, we need to byte-swap each short.
1481 On W32 and MAC (little endian), there's no need to do this.
1484 #if defined (HAVE_X_WINDOWS)
1485 static const unsigned char swap_nibble[16] = {
1486 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
1487 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
1488 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
1489 0x3, 0xb, 0x7, 0xf}; /* 0011 1011 0111 1111 */
1490 #endif /* HAVE_X_WINDOWS */
1492 static void
1493 init_fringe_bitmap (int which, struct fringe_bitmap *fb, int once_p)
1495 if (once_p || fb->dynamic)
1497 #if defined (HAVE_X_WINDOWS)
1498 unsigned short *bits = fb->bits;
1499 int j;
1501 if (fb->width <= 8)
1503 unsigned char *cbits = (unsigned char *)fb->bits;
1504 for (j = 0; j < fb->height; j++)
1506 unsigned short b = *bits++;
1507 unsigned char c;
1508 c = (unsigned char)((swap_nibble[b & 0xf] << 4)
1509 | (swap_nibble[(b>>4) & 0xf]));
1510 *cbits++ = (c >> (8 - fb->width));
1513 else
1515 for (j = 0; j < fb->height; j++)
1517 unsigned short b = *bits;
1518 b = (unsigned short)((swap_nibble[b & 0xf] << 12)
1519 | (swap_nibble[(b>>4) & 0xf] << 8)
1520 | (swap_nibble[(b>>8) & 0xf] << 4)
1521 | (swap_nibble[(b>>12) & 0xf]));
1522 b >>= (16 - fb->width);
1523 #ifdef WORDS_BIGENDIAN
1524 b = bswap_16 (b);
1525 #endif
1526 *bits++ = b;
1529 #endif /* HAVE_X_WINDOWS */
1533 if (!once_p)
1535 /* XXX Is SELECTED_FRAME OK here? */
1536 struct redisplay_interface *rif = FRAME_RIF (SELECTED_FRAME ());
1538 destroy_fringe_bitmap (which);
1540 if (rif && rif->define_fringe_bitmap)
1541 rif->define_fringe_bitmap (which, fb->bits, fb->height, fb->width);
1543 fringe_bitmaps[which] = fb;
1544 if (which >= max_used_fringe_bitmap)
1545 max_used_fringe_bitmap = which + 1;
1550 DEFUN ("define-fringe-bitmap", Fdefine_fringe_bitmap, Sdefine_fringe_bitmap,
1551 2, 5, 0,
1552 doc: /* Define fringe bitmap BITMAP from BITS of size HEIGHT x WIDTH.
1553 BITMAP is a symbol identifying the new fringe bitmap.
1554 BITS is either a string or a vector of integers.
1555 HEIGHT is height of bitmap. If HEIGHT is nil, use length of BITS.
1556 WIDTH must be an integer between 1 and 16, or nil which defaults to 8.
1557 Optional fifth arg ALIGN may be one of `top', `center', or `bottom',
1558 indicating the positioning of the bitmap relative to the rows where it
1559 is used; the default is to center the bitmap. Fifth arg may also be a
1560 list (ALIGN PERIODIC) where PERIODIC non-nil specifies that the bitmap
1561 should be repeated.
1562 If BITMAP already exists, the existing definition is replaced. */)
1563 (Lisp_Object bitmap, Lisp_Object bits, Lisp_Object height, Lisp_Object width, Lisp_Object align)
1565 int n, h, i, j;
1566 unsigned short *b;
1567 struct fringe_bitmap fb, *xfb;
1568 int fill1 = 0, fill2 = 0;
1570 CHECK_SYMBOL (bitmap);
1572 if (STRINGP (bits))
1573 h = SCHARS (bits);
1574 else if (VECTORP (bits))
1575 h = ASIZE (bits);
1576 else
1577 wrong_type_argument (Qsequencep, bits);
1579 if (NILP (height))
1580 fb.height = h;
1581 else
1583 CHECK_NUMBER (height);
1584 fb.height = max (0, min (XINT (height), 255));
1585 if (fb.height > h)
1587 fill1 = (fb.height - h) / 2;
1588 fill2 = fb.height - h - fill1;
1592 if (NILP (width))
1593 fb.width = 8;
1594 else
1596 CHECK_NUMBER (width);
1597 fb.width = max (0, min (XINT (width), 255));
1600 fb.period = 0;
1601 fb.align = ALIGN_BITMAP_CENTER;
1603 if (CONSP (align))
1605 Lisp_Object period = XCDR (align);
1606 if (CONSP (period))
1608 period = XCAR (period);
1609 if (!NILP (period))
1611 fb.period = fb.height;
1612 fb.height = 255;
1615 align = XCAR (align);
1617 if (EQ (align, Qtop))
1618 fb.align = ALIGN_BITMAP_TOP;
1619 else if (EQ (align, Qbottom))
1620 fb.align = ALIGN_BITMAP_BOTTOM;
1621 else if (!NILP (align) && !EQ (align, Qcenter))
1622 error ("Bad align argument");
1624 n = lookup_fringe_bitmap (bitmap);
1625 if (!n)
1627 if (max_used_fringe_bitmap < max_fringe_bitmaps)
1628 n = max_used_fringe_bitmap++;
1629 else
1631 for (n = MAX_STANDARD_FRINGE_BITMAPS;
1632 n < max_fringe_bitmaps;
1633 n++)
1634 if (fringe_bitmaps[n] == NULL)
1635 break;
1637 if (n == max_fringe_bitmaps)
1639 int bitmaps = max_fringe_bitmaps + 20;
1640 if (MAX_FRINGE_BITMAPS < bitmaps)
1641 error ("No free fringe bitmap slots");
1643 i = max_fringe_bitmaps;
1644 fringe_bitmaps = xrealloc (fringe_bitmaps,
1645 bitmaps * sizeof *fringe_bitmaps);
1646 fringe_faces = xrealloc (fringe_faces,
1647 bitmaps * sizeof *fringe_faces);
1649 for (i = max_fringe_bitmaps; i < bitmaps; i++)
1651 fringe_bitmaps[i] = NULL;
1652 fringe_faces[i] = Qnil;
1655 max_fringe_bitmaps = bitmaps;
1659 Vfringe_bitmaps = Fcons (bitmap, Vfringe_bitmaps);
1660 Fput (bitmap, Qfringe, make_number (n));
1663 fb.dynamic = 1;
1665 xfb = xmalloc (sizeof fb + fb.height * BYTES_PER_BITMAP_ROW);
1666 fb.bits = b = (unsigned short *) (xfb + 1);
1667 memset (b, 0, fb.height);
1669 j = 0;
1670 while (j < fb.height)
1672 for (i = 0; i < fill1 && j < fb.height; i++)
1673 b[j++] = 0;
1674 for (i = 0; i < h && j < fb.height; i++)
1676 Lisp_Object elt = Faref (bits, make_number (i));
1677 b[j++] = NUMBERP (elt) ? XINT (elt) : 0;
1679 for (i = 0; i < fill2 && j < fb.height; i++)
1680 b[j++] = 0;
1683 *xfb = fb;
1685 init_fringe_bitmap (n, xfb, 0);
1687 return bitmap;
1690 DEFUN ("set-fringe-bitmap-face", Fset_fringe_bitmap_face, Sset_fringe_bitmap_face,
1691 1, 2, 0,
1692 doc: /* Set face for fringe bitmap BITMAP to FACE.
1693 If FACE is nil, reset face to default fringe face. */)
1694 (Lisp_Object bitmap, Lisp_Object face)
1696 int n;
1698 CHECK_SYMBOL (bitmap);
1699 n = lookup_fringe_bitmap (bitmap);
1700 if (!n)
1701 error ("Undefined fringe bitmap");
1703 /* The purpose of the following code is to signal an error if FACE
1704 is not a face. This is for the caller's convenience only; the
1705 redisplay code should be able to fail gracefully. Skip the check
1706 if FRINGE_FACE_ID is unrealized (as in batch mode and during
1707 daemon startup). */
1708 if (!NILP (face))
1710 struct frame *f = SELECTED_FRAME ();
1712 if (FACE_FROM_ID (f, FRINGE_FACE_ID)
1713 && lookup_derived_face (f, face, FRINGE_FACE_ID, 1) < 0)
1714 error ("No such face");
1717 fringe_faces[n] = face;
1718 return Qnil;
1721 DEFUN ("fringe-bitmaps-at-pos", Ffringe_bitmaps_at_pos, Sfringe_bitmaps_at_pos,
1722 0, 2, 0,
1723 doc: /* Return fringe bitmaps of row containing position POS in window WINDOW.
1724 If WINDOW is nil, use selected window. If POS is nil, use value of point
1725 in that window. Return value is a list (LEFT RIGHT OV), where LEFT
1726 is the symbol for the bitmap in the left fringe (or nil if no bitmap),
1727 RIGHT is similar for the right fringe, and OV is non-nil if there is an
1728 overlay arrow in the left fringe.
1729 Return nil if POS is not visible in WINDOW. */)
1730 (Lisp_Object pos, Lisp_Object window)
1732 struct window *w;
1733 struct glyph_row *row;
1734 ptrdiff_t textpos;
1736 w = decode_any_window (window);
1737 XSETWINDOW (window, w);
1739 if (!NILP (pos))
1741 CHECK_NUMBER_COERCE_MARKER (pos);
1742 if (! (BEGV <= XINT (pos) && XINT (pos) <= ZV))
1743 args_out_of_range (window, pos);
1744 textpos = XINT (pos);
1746 else if (w == XWINDOW (selected_window))
1747 textpos = PT;
1748 else
1749 textpos = marker_position (w->pointm);
1751 row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
1752 row = row_containing_pos (w, textpos, row, NULL, 0);
1753 if (row)
1754 return list3 (get_fringe_bitmap_name (row->left_fringe_bitmap),
1755 get_fringe_bitmap_name (row->right_fringe_bitmap),
1756 (row->overlay_arrow_bitmap == 0 ? Qnil
1757 : row->overlay_arrow_bitmap < 0 ? Qt
1758 : get_fringe_bitmap_name (row->overlay_arrow_bitmap)));
1759 else
1760 return Qnil;
1764 /***********************************************************************
1765 Initialization
1766 ***********************************************************************/
1768 void
1769 syms_of_fringe (void)
1771 DEFSYM (Qtruncation, "truncation");
1772 DEFSYM (Qcontinuation, "continuation");
1773 DEFSYM (Qoverlay_arrow, "overlay-arrow");
1774 DEFSYM (Qempty_line, "empty-line");
1775 DEFSYM (Qtop_bottom, "top-bottom");
1776 DEFSYM (Qhollow_small, "hollow-small");
1778 defsubr (&Sdestroy_fringe_bitmap);
1779 defsubr (&Sdefine_fringe_bitmap);
1780 defsubr (&Sfringe_bitmaps_at_pos);
1781 defsubr (&Sset_fringe_bitmap_face);
1783 DEFVAR_LISP ("overflow-newline-into-fringe", Voverflow_newline_into_fringe,
1784 doc: /* Non-nil means that newline may flow into the right fringe.
1785 This means that display lines which are exactly as wide as the window
1786 (not counting the final newline) will only occupy one screen line, by
1787 showing (or hiding) the final newline in the right fringe; when point
1788 is at the final newline, the cursor is shown in the right fringe.
1789 If nil, also continue lines which are exactly as wide as the window. */);
1790 Voverflow_newline_into_fringe = Qt;
1792 DEFVAR_LISP ("fringe-bitmaps", Vfringe_bitmaps,
1793 doc: /* List of fringe bitmap symbols. */);
1794 Vfringe_bitmaps = Qnil;
1797 /* Garbage collection hook */
1799 void
1800 mark_fringe_data (void)
1802 int i;
1804 for (i = 0; i < max_fringe_bitmaps; i++)
1805 if (!NILP (fringe_faces[i]))
1806 mark_object (fringe_faces[i]);
1809 /* Initialize this module when Emacs starts. */
1811 void
1812 init_fringe_once (void)
1814 int bt;
1816 for (bt = NO_FRINGE_BITMAP + 1; bt < MAX_STANDARD_FRINGE_BITMAPS; bt++)
1817 init_fringe_bitmap (bt, &standard_bitmaps[bt], 1);
1820 void
1821 init_fringe (void)
1823 int i;
1825 max_fringe_bitmaps = MAX_STANDARD_FRINGE_BITMAPS + 20;
1827 fringe_bitmaps = xzalloc (max_fringe_bitmaps * sizeof *fringe_bitmaps);
1828 fringe_faces = xmalloc (max_fringe_bitmaps * sizeof *fringe_faces);
1830 for (i = 0; i < max_fringe_bitmaps; i++)
1831 fringe_faces[i] = Qnil;
1834 #ifdef HAVE_NTGUI
1836 void
1837 w32_init_fringe (struct redisplay_interface *rif)
1839 int bt;
1841 if (!rif)
1842 return;
1844 for (bt = NO_FRINGE_BITMAP + 1; bt < MAX_STANDARD_FRINGE_BITMAPS; bt++)
1846 struct fringe_bitmap *fb = &standard_bitmaps[bt];
1847 rif->define_fringe_bitmap (bt, fb->bits, fb->height, fb->width);
1851 void
1852 w32_reset_fringes (void)
1854 /* Destroy row bitmaps. */
1855 int bt;
1856 struct redisplay_interface *rif = FRAME_RIF (SELECTED_FRAME ());
1858 if (!rif)
1859 return;
1861 for (bt = NO_FRINGE_BITMAP + 1; bt < max_used_fringe_bitmap; bt++)
1862 rif->destroy_fringe_bitmap (bt);
1865 #endif /* HAVE_NTGUI */