Merge from origin/emacs-24
[emacs.git] / src / fringe.c
blob3c0e883b2e98f3f355720c6b3be95e1dd623c870
1 /* Fringe handling (split from xdisp.c).
2 Copyright (C) 1985-1988, 1993-1995, 1997-2014 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 bool_bf 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 ARRAYELTS (standard_bitmaps)
479 static struct fringe_bitmap **fringe_bitmaps;
480 static Lisp_Object *fringe_faces;
481 static int max_fringe_bitmaps;
483 int max_used_fringe_bitmap = MAX_STANDARD_FRINGE_BITMAPS;
486 /* Lookup bitmap number for symbol BITMAP.
487 Return 0 if not a bitmap. */
490 lookup_fringe_bitmap (Lisp_Object bitmap)
492 EMACS_INT bn;
494 bitmap = Fget (bitmap, Qfringe);
495 if (!INTEGERP (bitmap))
496 return 0;
498 bn = XINT (bitmap);
499 if (bn > NO_FRINGE_BITMAP
500 && bn < max_used_fringe_bitmap
501 && (bn < MAX_STANDARD_FRINGE_BITMAPS
502 || fringe_bitmaps[bn] != NULL))
503 return bn;
505 return 0;
508 /* Get fringe bitmap name for bitmap number BN.
510 Found by traversing Vfringe_bitmaps comparing BN to the
511 fringe property for each symbol.
513 Return BN if not found in Vfringe_bitmaps. */
515 static Lisp_Object
516 get_fringe_bitmap_name (int bn)
518 Lisp_Object bitmaps;
519 Lisp_Object num;
521 /* Zero means no bitmap -- return nil. */
522 if (bn <= 0)
523 return Qnil;
525 bitmaps = Vfringe_bitmaps;
526 num = make_number (bn);
528 while (CONSP (bitmaps))
530 Lisp_Object bitmap = XCAR (bitmaps);
531 if (EQ (num, Fget (bitmap, Qfringe)))
532 return bitmap;
533 bitmaps = XCDR (bitmaps);
536 return num;
539 /* Get fringe bitmap data for bitmap number BN. */
541 static struct fringe_bitmap *
542 get_fringe_bitmap_data (int bn)
544 struct fringe_bitmap *fb;
546 fb = fringe_bitmaps[bn];
547 if (fb == NULL)
548 fb = &standard_bitmaps[bn < MAX_STANDARD_FRINGE_BITMAPS
549 ? bn : UNDEF_FRINGE_BITMAP];
551 return fb;
554 /* Draw the bitmap WHICH in one of the left or right fringes of
555 window W. ROW is the glyph row for which to display the bitmap; it
556 determines the vertical position at which the bitmap has to be
557 drawn.
558 LEFT_P is 1 for left fringe, 0 for right fringe.
561 static void
562 draw_fringe_bitmap_1 (struct window *w, struct glyph_row *row, int left_p, int overlay, int which)
564 struct frame *f = XFRAME (WINDOW_FRAME (w));
565 struct draw_fringe_bitmap_params p;
566 struct fringe_bitmap *fb;
567 int period;
568 int face_id = DEFAULT_FACE_ID;
569 int offset, header_line_height;
571 p.overlay_p = (overlay & 1) == 1;
572 p.cursor_p = (overlay & 2) == 2;
574 if (which != NO_FRINGE_BITMAP)
576 offset = 0;
578 else if (left_p)
580 which = row->left_fringe_bitmap;
581 face_id = row->left_fringe_face_id;
582 offset = row->left_fringe_offset;
584 else
586 which = row->right_fringe_bitmap;
587 face_id = row->right_fringe_face_id;
588 offset = row->right_fringe_offset;
591 if (face_id == DEFAULT_FACE_ID)
593 Lisp_Object face = fringe_faces[which];
594 face_id = NILP (face) ? lookup_named_face (f, Qfringe, 0)
595 : lookup_derived_face (f, face, FRINGE_FACE_ID, 0);
596 if (face_id < 0)
597 face_id = FRINGE_FACE_ID;
600 fb = get_fringe_bitmap_data (which);
602 period = fb->period;
604 /* Convert row to frame coordinates. */
605 p.y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y) + offset;
607 p.which = which;
608 p.bits = fb->bits;
609 p.wd = fb->width;
611 p.h = fb->height;
612 p.dh = (period > 0 ? (p.y % period) : 0);
613 p.h -= p.dh;
615 /* Adjust y to the offset in the row to start drawing the bitmap. */
616 switch (fb->align)
618 case ALIGN_BITMAP_CENTER:
619 p.y += (row->height - p.h) / 2;
620 break;
621 case ALIGN_BITMAP_BOTTOM:
622 p.y += (row->visible_height - p.h);
623 break;
624 case ALIGN_BITMAP_TOP:
625 break;
628 p.face = FACE_FROM_ID (f, face_id);
630 if (p.face == NULL)
632 /* This could happen after clearing face cache.
633 But it shouldn't happen anymore. ++kfs */
634 return;
637 prepare_face_for_display (f, p.face);
639 /* Clear left fringe if no bitmap to draw or if bitmap doesn't fill
640 the fringe. */
641 p.bx = -1;
642 header_line_height = WINDOW_HEADER_LINE_HEIGHT (w);
643 p.by = WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height, row->y));
644 p.ny = row->visible_height;
645 if (left_p)
647 int wd = WINDOW_LEFT_FRINGE_WIDTH (w);
648 int x = window_box_left (w, (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
649 ? LEFT_MARGIN_AREA
650 : TEXT_AREA));
651 if (p.wd > wd)
652 p.wd = wd;
653 p.x = x - p.wd - (wd - p.wd) / 2;
655 if (p.wd < wd || p.y > p.by || p.y + p.h < p.by + p.ny)
657 /* If W has a vertical border to its left, don't draw over it. */
658 wd -= ((!WINDOW_LEFTMOST_P (w)
659 /* This could be wrong when we allow window local
660 right dividers - but the window on the left is hard
661 to get. */
662 && !FRAME_RIGHT_DIVIDER_WIDTH (f)
663 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w)
664 /* But don't reduce the fringe width if the window
665 has a left margin, because that means we are not
666 in danger of drawing over the vertical border,
667 and OTOH leaving out that one pixel leaves behind
668 traces of the cursor, if it was in column zero
669 before drawing non-empty margin area. */
670 && w->left_margin_cols == 0)
671 ? 1 : 0);
672 p.bx = x - wd;
673 p.nx = wd;
676 else
678 int x = window_box_right (w,
679 (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
680 ? RIGHT_MARGIN_AREA
681 : TEXT_AREA));
682 int wd = WINDOW_RIGHT_FRINGE_WIDTH (w);
683 if (p.wd > wd)
684 p.wd = wd;
685 p.x = x + (wd - p.wd) / 2;
686 /* Clear right fringe if no bitmap to draw of if bitmap doesn't fill
687 the fringe. */
688 if (p.wd < wd || p.y > p.by || p.y + p.h < p.by + p.ny)
690 p.bx = x;
691 p.nx = wd;
695 if (p.x >= WINDOW_BOX_LEFT_EDGE_X (w)
696 && (p.x + p.wd) <= WINDOW_BOX_LEFT_EDGE_X (w) + WINDOW_PIXEL_WIDTH (w))
697 FRAME_RIF (f)->draw_fringe_bitmap (w, row, &p);
700 static int
701 get_logical_cursor_bitmap (struct window *w, Lisp_Object cursor)
703 Lisp_Object cmap, bm = Qnil;
705 if ((cmap = BVAR (XBUFFER (w->contents), fringe_cursor_alist)), !NILP (cmap))
707 bm = Fassq (cursor, cmap);
708 if (CONSP (bm))
710 if ((bm = XCDR (bm)), NILP (bm))
711 return NO_FRINGE_BITMAP;
712 return lookup_fringe_bitmap (bm);
715 if (EQ (cmap, BVAR (&buffer_defaults, fringe_cursor_alist)))
716 return NO_FRINGE_BITMAP;
717 bm = Fassq (cursor, BVAR (&buffer_defaults, fringe_cursor_alist));
718 if (!CONSP (bm) || ((bm = XCDR (bm)), NILP (bm)))
719 return NO_FRINGE_BITMAP;
720 return lookup_fringe_bitmap (bm);
723 static int
724 get_logical_fringe_bitmap (struct window *w, Lisp_Object bitmap, int right_p, int partial_p)
726 Lisp_Object cmap, bm1 = Qnil, bm2 = Qnil, bm;
727 EMACS_INT ln1 = 0, ln2 = 0;
728 int ix1 = right_p;
729 int ix2 = ix1 + (partial_p ? 2 : 0);
731 /* Lookup in buffer-local fringe-indicator-alist before global alist.
733 Elements are:
734 BITMAP -- use for all
735 (L R) -- use for left right (whether partial or not)
736 (L R PL PR) -- use for left right partial-left partial-right
737 If any value in local binding is not present or t, use global value.
739 If partial, lookup partial bitmap in default value if not found here.
740 If not partial, or no partial spec is present, use non-partial bitmap. */
742 if ((cmap = BVAR (XBUFFER (w->contents), fringe_indicator_alist)), !NILP (cmap))
744 bm1 = Fassq (bitmap, cmap);
745 if (CONSP (bm1))
747 if ((bm1 = XCDR (bm1)), NILP (bm1))
748 return NO_FRINGE_BITMAP;
749 if (CONSP (bm1))
751 ln1 = XINT (Flength (bm1));
752 if (partial_p)
754 if (ln1 > ix2)
756 bm = Fnth (make_number (ix2), bm1);
757 if (!EQ (bm, Qt))
758 goto found;
761 else
763 if (ln1 > ix1)
765 bm = Fnth (make_number (ix1), bm1);
766 if (!EQ (bm, Qt))
767 goto found;
771 else if ((bm = bm1, !EQ (bm, Qt)))
772 goto found;
776 if (!EQ (cmap, BVAR (&buffer_defaults, fringe_indicator_alist))
777 && !NILP (BVAR (&buffer_defaults, fringe_indicator_alist)))
779 bm2 = Fassq (bitmap, BVAR (&buffer_defaults, fringe_indicator_alist));
780 if (CONSP (bm2))
782 if ((bm2 = XCDR (bm2)), !NILP (bm2))
784 if (CONSP (bm2))
786 ln2 = XINT (Flength (bm2));
787 if (partial_p)
789 if (ln2 > ix2)
791 bm = Fnth (make_number (ix2), bm2);
792 if (!EQ (bm, Qt))
793 goto found;
801 if (ln1 > ix1)
803 bm = Fnth (make_number (ix1), bm1);
804 if (!EQ (bm, Qt))
805 goto found;
808 if (ln2 > ix1)
810 bm = Fnth (make_number (ix1), bm2);
811 if (!EQ (bm, Qt))
812 goto found;
813 return NO_FRINGE_BITMAP;
815 else if ((bm = bm2, NILP (bm)))
816 return NO_FRINGE_BITMAP;
818 found:
819 return lookup_fringe_bitmap (bm);
823 void
824 draw_fringe_bitmap (struct window *w, struct glyph_row *row, int left_p)
826 int overlay = 0;
828 if (left_p == row->reversed_p && row->cursor_in_fringe_p)
830 Lisp_Object cursor = Qnil;
832 switch (w->phys_cursor_type)
834 case HOLLOW_BOX_CURSOR:
835 if (row->visible_height >= STANDARD_BITMAP_HEIGHT (hollow_rectangle_bits))
836 cursor = Qhollow;
837 else
838 cursor = Qhollow_small;
839 break;
840 case FILLED_BOX_CURSOR:
841 cursor = Qbox;
842 break;
843 case BAR_CURSOR:
844 cursor = Qbar;
845 break;
846 case HBAR_CURSOR:
847 cursor = Qhbar;
848 break;
849 case NO_CURSOR:
850 default:
851 w->phys_cursor_on_p = 0;
852 row->cursor_in_fringe_p = 0;
853 break;
855 if (!NILP (cursor))
857 int bm = get_logical_cursor_bitmap (w, cursor);
858 if (bm != NO_FRINGE_BITMAP)
860 draw_fringe_bitmap_1 (w, row, left_p, 2, bm);
861 overlay = EQ (cursor, Qbox) ? 3 : 1;
866 draw_fringe_bitmap_1 (w, row, left_p, overlay, NO_FRINGE_BITMAP);
868 if (left_p && row->overlay_arrow_bitmap != NO_FRINGE_BITMAP)
869 draw_fringe_bitmap_1 (w, row, 1, 1, row->overlay_arrow_bitmap);
873 /* Draw fringe bitmaps for glyph row ROW on window W. Call this
874 function with input blocked. */
876 void
877 draw_row_fringe_bitmaps (struct window *w, struct glyph_row *row)
879 eassert (input_blocked_p ());
881 /* If row is completely invisible, because of vscrolling, we
882 don't have to draw anything. */
883 if (row->visible_height <= 0)
884 return;
886 if (WINDOW_LEFT_FRINGE_WIDTH (w) != 0)
887 draw_fringe_bitmap (w, row, 1);
889 if (WINDOW_RIGHT_FRINGE_WIDTH (w) != 0)
890 draw_fringe_bitmap (w, row, 0);
893 /* Draw the fringes of window W. Only fringes for rows marked for
894 update in redraw_fringe_bitmaps_p are drawn.
896 Return nonzero if left or right fringe was redrawn in any way.
898 If NO_FRINGE_P is non-zero, also return nonzero if either fringe
899 has zero width.
901 A return nonzero value indicates that the vertical line between
902 windows needs update (as it may be drawn in the fringe).
905 bool
906 draw_window_fringes (struct window *w, bool no_fringe_p)
908 struct glyph_row *row;
909 int yb = window_text_bottom_y (w);
910 int nrows = w->current_matrix->nrows;
911 int y, rn;
912 bool updated_p = 0;
914 if (w->pseudo_window_p)
915 return updated_p;
917 /* Must draw line if no fringe */
918 if (no_fringe_p
919 && (WINDOW_LEFT_FRINGE_WIDTH (w) == 0
920 || WINDOW_RIGHT_FRINGE_WIDTH (w) == 0))
921 updated_p = 1;
923 for (y = w->vscroll, rn = 0, row = w->current_matrix->rows;
924 y < yb && rn < nrows;
925 y += row->height, ++row, ++rn)
927 if (!row->redraw_fringe_bitmaps_p)
928 continue;
929 draw_row_fringe_bitmaps (w, row);
930 row->redraw_fringe_bitmaps_p = 0;
931 updated_p = 1;
934 return updated_p;
938 /* Recalculate the bitmaps to show in the fringes of window W.
939 Only mark rows with modified bitmaps for update in redraw_fringe_bitmaps_p.
941 If KEEP_CURRENT_P is 0, update current_matrix too. */
943 bool
944 update_window_fringes (struct window *w, bool keep_current_p)
946 struct glyph_row *row, *cur = 0;
947 int yb = window_text_bottom_y (w);
948 int rn, nrows = w->current_matrix->nrows;
949 int y;
950 bool redraw_p = 0;
951 Lisp_Object boundary_top = Qnil, boundary_bot = Qnil;
952 Lisp_Object arrow_top = Qnil, arrow_bot = Qnil;
953 Lisp_Object empty_pos;
954 Lisp_Object ind = Qnil;
955 #define MAX_BITMAP_CACHE (8*4)
956 int bitmap_cache[MAX_BITMAP_CACHE];
957 int top_ind_rn, bot_ind_rn;
958 int top_ind_min_y, bot_ind_max_y;
960 /* top_ind_rn is set to a nonnegative value whenever
961 row->indicate_bob_p is set, so it's OK that top_row_ends_at_zv_p
962 is not initialized here. Similarly for bot_ind_rn,
963 row->indicate_eob_p and bot_row_ends_at_zv_p. */
964 int top_row_ends_at_zv_p IF_LINT (= 0), bot_row_ends_at_zv_p IF_LINT (= 0);
966 if (w->pseudo_window_p)
967 return 0;
969 if (!MINI_WINDOW_P (w)
970 && (ind = BVAR (XBUFFER (w->contents), indicate_buffer_boundaries), !NILP (ind)))
972 if (EQ (ind, Qleft) || EQ (ind, Qright))
973 boundary_top = boundary_bot = arrow_top = arrow_bot = ind;
974 else if (CONSP (ind) && CONSP (XCAR (ind)))
976 Lisp_Object pos;
977 if (pos = Fassq (Qt, ind), !NILP (pos))
978 boundary_top = boundary_bot = arrow_top = arrow_bot = XCDR (pos);
979 if (pos = Fassq (Qtop, ind), !NILP (pos))
980 boundary_top = XCDR (pos);
981 if (pos = Fassq (Qbottom, ind), !NILP (pos))
982 boundary_bot = XCDR (pos);
983 if (pos = Fassq (Qup, ind), !NILP (pos))
984 arrow_top = XCDR (pos);
985 if (pos = Fassq (Qdown, ind), !NILP (pos))
986 arrow_bot = XCDR (pos);
988 else
989 /* Anything else means boundary on left and no arrows. */
990 boundary_top = boundary_bot = Qleft;
993 top_ind_rn = bot_ind_rn = -1;
994 if (!NILP (ind))
996 for (y = w->vscroll, rn = 0;
997 y < yb && rn < nrows;
998 y += row->height, ++rn)
1000 row = w->desired_matrix->rows + rn;
1001 if (!row->enabled_p)
1002 row = w->current_matrix->rows + rn;
1004 row->indicate_bob_p = row->indicate_top_line_p = 0;
1005 row->indicate_eob_p = row->indicate_bottom_line_p = 0;
1007 if (!row->mode_line_p)
1009 if (top_ind_rn < 0 && row->visible_height > 0)
1011 if (MATRIX_ROW_START_CHARPOS (row) <= BUF_BEGV (XBUFFER (w->contents))
1012 && !MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (w, row))
1013 row->indicate_bob_p = !NILP (boundary_top);
1014 else
1015 row->indicate_top_line_p = !NILP (arrow_top);
1016 top_ind_rn = rn;
1019 if (bot_ind_rn < 0)
1021 if (MATRIX_ROW_END_CHARPOS (row) >= BUF_ZV (XBUFFER (w->contents))
1022 && !MATRIX_ROW_PARTIALLY_VISIBLE_AT_BOTTOM_P (w, row))
1023 row->indicate_eob_p = !NILP (boundary_bot), bot_ind_rn = rn;
1024 else if (y + row->height >= yb)
1025 row->indicate_bottom_line_p = !NILP (arrow_bot), bot_ind_rn = rn;
1031 empty_pos = BVAR (XBUFFER (w->contents), indicate_empty_lines);
1032 if (!NILP (empty_pos) && !EQ (empty_pos, Qright))
1033 empty_pos = WINDOW_LEFT_FRINGE_WIDTH (w) == 0 ? Qright : Qleft;
1035 for (y = 0; y < MAX_BITMAP_CACHE; y++)
1036 bitmap_cache[y] = -1;
1038 #define LEFT_FRINGE(cache, which, partial_p) \
1039 (bitmap_cache[cache*4+partial_p] >= 0 \
1040 ? bitmap_cache[cache*4+partial_p] \
1041 : (bitmap_cache[cache*4+partial_p] = \
1042 get_logical_fringe_bitmap (w, which, 0, partial_p)))
1044 #define RIGHT_FRINGE(cache, which, partial_p) \
1045 (bitmap_cache[cache*4+2+partial_p] >= 0 \
1046 ? bitmap_cache[cache*4+2+partial_p] \
1047 : (bitmap_cache[cache*4+2+partial_p] = \
1048 get_logical_fringe_bitmap (w, which, 1, partial_p)))
1051 /* Extend top-aligned top indicator (or bottom-aligned bottom
1052 indicator) to adjacent rows if it doesn't fit in one row. */
1053 top_ind_min_y = bot_ind_max_y = -1;
1054 if (top_ind_rn >= 0)
1056 int bn = NO_FRINGE_BITMAP;
1058 row = w->desired_matrix->rows + top_ind_rn;
1059 if (!row->enabled_p)
1060 row = w->current_matrix->rows + top_ind_rn;
1062 top_row_ends_at_zv_p = row->ends_at_zv_p;
1063 if (row->indicate_bob_p)
1065 if (EQ (boundary_top, Qleft))
1066 bn = ((row->indicate_eob_p && EQ (boundary_bot, Qleft))
1067 ? LEFT_FRINGE (1, Qtop_bottom, row->ends_at_zv_p)
1068 : LEFT_FRINGE (2, Qtop, 0));
1069 else
1070 bn = ((row->indicate_eob_p && EQ (boundary_bot, Qright))
1071 ? RIGHT_FRINGE (1, Qtop_bottom, row->ends_at_zv_p)
1072 : RIGHT_FRINGE (2, Qtop, 0));
1074 else if (row->indicate_top_line_p)
1076 if (EQ (arrow_top, Qleft))
1077 bn = LEFT_FRINGE (6, Qup, 0);
1078 else
1079 bn = RIGHT_FRINGE (6, Qup, 0);
1082 if (bn != NO_FRINGE_BITMAP)
1084 struct fringe_bitmap *fb = get_fringe_bitmap_data (bn);
1086 if (fb->align == ALIGN_BITMAP_TOP && fb->period == 0)
1088 struct glyph_row *row1;
1089 int top_ind_max_y;
1091 top_ind_min_y = WINDOW_HEADER_LINE_HEIGHT (w);
1092 top_ind_max_y = top_ind_min_y + fb->height;
1093 if (top_ind_max_y > yb)
1094 top_ind_max_y = yb;
1096 for (y = row->y + row->height, rn = top_ind_rn + 1;
1097 y < top_ind_max_y && rn < nrows;
1098 y += row1->height, rn++)
1100 if (bot_ind_rn >= 0 && rn >= bot_ind_rn)
1101 break;
1103 row1 = w->desired_matrix->rows + rn;
1104 if (!row1->enabled_p)
1105 row1 = w->current_matrix->rows + rn;
1107 row1->indicate_bob_p = row->indicate_bob_p;
1108 row1->indicate_top_line_p = row->indicate_top_line_p;
1113 if (bot_ind_rn >= 0)
1115 int bn = NO_FRINGE_BITMAP;
1117 row = w->desired_matrix->rows + bot_ind_rn;
1118 if (!row->enabled_p)
1119 row = w->current_matrix->rows + bot_ind_rn;
1121 bot_row_ends_at_zv_p = row->ends_at_zv_p;
1122 if (row->indicate_eob_p)
1124 if (EQ (boundary_bot, Qleft))
1125 bn = LEFT_FRINGE (3, Qbottom, row->ends_at_zv_p);
1126 else
1127 bn = RIGHT_FRINGE (3, Qbottom, row->ends_at_zv_p);
1129 else if (row->indicate_bottom_line_p)
1131 if (EQ (arrow_bot, Qleft))
1132 bn = LEFT_FRINGE (7, Qdown, 0);
1133 else
1134 bn = RIGHT_FRINGE (7, Qdown, 0);
1137 if (bn != NO_FRINGE_BITMAP)
1139 struct fringe_bitmap *fb = get_fringe_bitmap_data (bn);
1141 if (fb->align == ALIGN_BITMAP_BOTTOM && fb->period == 0)
1143 struct glyph_row *row1;
1144 int bot_ind_min_y;
1146 bot_ind_max_y = row->y + row->visible_height;
1147 bot_ind_min_y = bot_ind_max_y - fb->height;
1148 if (bot_ind_min_y < WINDOW_HEADER_LINE_HEIGHT (w))
1149 bot_ind_min_y = WINDOW_HEADER_LINE_HEIGHT (w);
1151 for (y = row->y, rn = bot_ind_rn - 1;
1152 y >= bot_ind_min_y && rn >= 0;
1153 y -= row1->height, rn--)
1155 if (top_ind_rn >= 0 && rn <= top_ind_rn)
1156 break;
1158 row1 = w->desired_matrix->rows + rn;
1159 if (!row1->enabled_p)
1160 row1 = w->current_matrix->rows + rn;
1162 row1->indicate_eob_p = row->indicate_eob_p;
1163 row1->indicate_bottom_line_p = row->indicate_bottom_line_p;
1169 for (y = w->vscroll, rn = 0;
1170 y < yb && rn < nrows;
1171 y += row->height, rn++)
1173 int left, right;
1174 unsigned left_face_id, right_face_id;
1175 int left_offset, right_offset;
1176 bool periodic_p;
1178 row = w->desired_matrix->rows + rn;
1179 cur = w->current_matrix->rows + rn;
1180 if (!row->enabled_p)
1181 row = cur;
1183 left_face_id = right_face_id = DEFAULT_FACE_ID;
1184 left_offset = right_offset = 0;
1185 periodic_p = 0;
1187 /* Decide which bitmap to draw in the left fringe. */
1188 if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
1189 left = NO_FRINGE_BITMAP;
1190 else if (row->left_user_fringe_bitmap != NO_FRINGE_BITMAP)
1192 left = row->left_user_fringe_bitmap;
1193 left_face_id = row->left_user_fringe_face_id;
1195 else if ((!row->reversed_p && row->truncated_on_left_p)
1196 || (row->reversed_p && row->truncated_on_right_p))
1197 left = LEFT_FRINGE (0, Qtruncation, 0);
1198 else if (row->indicate_bob_p && EQ (boundary_top, Qleft))
1200 left = ((row->indicate_eob_p && EQ (boundary_bot, Qleft))
1201 ? LEFT_FRINGE (1, Qtop_bottom, top_row_ends_at_zv_p)
1202 : LEFT_FRINGE (2, Qtop, 0));
1203 if (top_ind_min_y >= 0)
1204 left_offset = top_ind_min_y - row->y;
1206 else if (row->indicate_eob_p && EQ (boundary_bot, Qleft))
1208 left = LEFT_FRINGE (3, Qbottom, bot_row_ends_at_zv_p);
1209 if (bot_ind_max_y >= 0)
1210 left_offset = bot_ind_max_y - (row->y + row->visible_height);
1212 else if ((!row->reversed_p && MATRIX_ROW_CONTINUATION_LINE_P (row))
1213 || (row->reversed_p && row->continued_p))
1214 left = LEFT_FRINGE (4, Qcontinuation, 0);
1215 else if (row->indicate_empty_line_p && EQ (empty_pos, Qleft))
1216 left = LEFT_FRINGE (5, Qempty_line, 0);
1217 else if (row->indicate_top_line_p && EQ (arrow_top, Qleft))
1219 left = LEFT_FRINGE (6, Qup, 0);
1220 if (top_ind_min_y >= 0)
1221 left_offset = top_ind_min_y - row->y;
1223 else if (row->indicate_bottom_line_p && EQ (arrow_bot, Qleft))
1225 left = LEFT_FRINGE (7, Qdown, 0);
1226 if (bot_ind_max_y >= 0)
1227 left_offset = bot_ind_max_y - (row->y + row->visible_height);
1229 else
1230 left = NO_FRINGE_BITMAP;
1232 /* Decide which bitmap to draw in the right fringe. */
1233 if (WINDOW_RIGHT_FRINGE_WIDTH (w) == 0)
1234 right = NO_FRINGE_BITMAP;
1235 else if (row->right_user_fringe_bitmap != NO_FRINGE_BITMAP)
1237 right = row->right_user_fringe_bitmap;
1238 right_face_id = row->right_user_fringe_face_id;
1240 else if ((!row->reversed_p && row->truncated_on_right_p)
1241 || (row->reversed_p && row->truncated_on_left_p))
1242 right = RIGHT_FRINGE (0, Qtruncation, 0);
1243 else if (row->indicate_bob_p && EQ (boundary_top, Qright))
1245 right = ((row->indicate_eob_p && EQ (boundary_bot, Qright))
1246 ? RIGHT_FRINGE (1, Qtop_bottom, top_row_ends_at_zv_p)
1247 : RIGHT_FRINGE (2, Qtop, 0));
1248 if (top_ind_min_y >= 0)
1249 right_offset = top_ind_min_y - row->y;
1251 else if (row->indicate_eob_p && EQ (boundary_bot, Qright))
1253 right = RIGHT_FRINGE (3, Qbottom, bot_row_ends_at_zv_p);
1254 if (bot_ind_max_y >= 0)
1255 right_offset = bot_ind_max_y - (row->y + row->visible_height);
1257 else if ((!row->reversed_p && row->continued_p)
1258 || (row->reversed_p && MATRIX_ROW_CONTINUATION_LINE_P (row)))
1259 right = RIGHT_FRINGE (4, Qcontinuation, 0);
1260 else if (row->indicate_top_line_p && EQ (arrow_top, Qright))
1262 right = RIGHT_FRINGE (6, Qup, 0);
1263 if (top_ind_min_y >= 0)
1264 right_offset = top_ind_min_y - row->y;
1266 else if (row->indicate_bottom_line_p && EQ (arrow_bot, Qright))
1268 right = RIGHT_FRINGE (7, Qdown, 0);
1269 if (bot_ind_max_y >= 0)
1270 right_offset = bot_ind_max_y - (row->y + row->visible_height);
1272 else if (row->indicate_empty_line_p && EQ (empty_pos, Qright))
1273 right = RIGHT_FRINGE (5, Qempty_line, 0);
1274 else
1275 right = NO_FRINGE_BITMAP;
1277 periodic_p = (get_fringe_bitmap_data (left)->period != 0
1278 || get_fringe_bitmap_data (right)->period != 0);
1280 if (row->y != cur->y
1281 || row->visible_height != cur->visible_height
1282 || row->ends_at_zv_p != cur->ends_at_zv_p
1283 || left != cur->left_fringe_bitmap
1284 || right != cur->right_fringe_bitmap
1285 || left_face_id != cur->left_fringe_face_id
1286 || right_face_id != cur->right_fringe_face_id
1287 || left_offset != cur->left_fringe_offset
1288 || right_offset != cur->right_fringe_offset
1289 || periodic_p != cur->fringe_bitmap_periodic_p
1290 || cur->redraw_fringe_bitmaps_p)
1292 redraw_p = 1, row->redraw_fringe_bitmaps_p = 1;
1293 if (!keep_current_p)
1295 cur->redraw_fringe_bitmaps_p = 1;
1296 cur->left_fringe_bitmap = left;
1297 cur->right_fringe_bitmap = right;
1298 cur->left_fringe_face_id = left_face_id;
1299 cur->right_fringe_face_id = right_face_id;
1300 cur->left_fringe_offset = left_offset;
1301 cur->right_fringe_offset = right_offset;
1302 cur->fringe_bitmap_periodic_p = periodic_p;
1306 if (row->overlay_arrow_bitmap < 0)
1307 row->overlay_arrow_bitmap = get_logical_fringe_bitmap (w, Qoverlay_arrow, 0, 0);
1309 if (row->overlay_arrow_bitmap != cur->overlay_arrow_bitmap)
1311 redraw_p = 1, row->redraw_fringe_bitmaps_p = 1;
1312 if (!keep_current_p)
1314 cur->redraw_fringe_bitmaps_p = 1;
1315 cur->overlay_arrow_bitmap = row->overlay_arrow_bitmap;
1319 row->left_fringe_bitmap = left;
1320 row->right_fringe_bitmap = right;
1321 row->left_fringe_face_id = left_face_id;
1322 row->right_fringe_face_id = right_face_id;
1323 row->left_fringe_offset = left_offset;
1324 row->right_fringe_offset = right_offset;
1325 row->fringe_bitmap_periodic_p = periodic_p;
1328 return redraw_p && !keep_current_p;
1333 /* Free resources used by a user-defined bitmap. */
1335 static void
1336 destroy_fringe_bitmap (int n)
1338 struct fringe_bitmap **fbp;
1340 fringe_faces[n] = Qnil;
1342 fbp = &fringe_bitmaps[n];
1343 if (*fbp && (*fbp)->dynamic)
1345 /* XXX Is SELECTED_FRAME OK here? */
1346 struct redisplay_interface *rif = FRAME_RIF (SELECTED_FRAME ());
1347 if (rif && rif->destroy_fringe_bitmap)
1348 rif->destroy_fringe_bitmap (n);
1349 xfree (*fbp);
1350 *fbp = NULL;
1353 while (max_used_fringe_bitmap > MAX_STANDARD_FRINGE_BITMAPS
1354 && fringe_bitmaps[max_used_fringe_bitmap - 1] == NULL)
1355 max_used_fringe_bitmap--;
1359 DEFUN ("destroy-fringe-bitmap", Fdestroy_fringe_bitmap, Sdestroy_fringe_bitmap,
1360 1, 1, 0,
1361 doc: /* Destroy fringe bitmap BITMAP.
1362 If BITMAP overrides a standard fringe bitmap, the original bitmap is restored. */)
1363 (Lisp_Object bitmap)
1365 int n;
1367 CHECK_SYMBOL (bitmap);
1368 n = lookup_fringe_bitmap (bitmap);
1369 if (!n)
1370 return Qnil;
1372 destroy_fringe_bitmap (n);
1374 if (n >= MAX_STANDARD_FRINGE_BITMAPS)
1376 Vfringe_bitmaps = Fdelq (bitmap, Vfringe_bitmaps);
1377 /* It would be better to remove the fringe property. */
1378 Fput (bitmap, Qfringe, Qnil);
1381 return Qnil;
1385 /* Initialize bitmap bit.
1387 On X, we bit-swap the built-in bitmaps and reduce bitmap
1388 from short to char array if width is <= 8 bits.
1390 On MAC with big-endian CPU, we need to byte-swap each short.
1392 On W32 and MAC (little endian), there's no need to do this.
1395 #if defined (HAVE_X_WINDOWS)
1396 static const unsigned char swap_nibble[16] = {
1397 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
1398 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
1399 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
1400 0x3, 0xb, 0x7, 0xf}; /* 0011 1011 0111 1111 */
1401 #endif /* HAVE_X_WINDOWS */
1403 static void
1404 init_fringe_bitmap (int which, struct fringe_bitmap *fb, int once_p)
1406 if (once_p || fb->dynamic)
1408 #if defined (HAVE_X_WINDOWS)
1409 unsigned short *bits = fb->bits;
1410 int j;
1412 if (fb->width <= 8)
1414 unsigned char *cbits = (unsigned char *)fb->bits;
1415 for (j = 0; j < fb->height; j++)
1417 unsigned short b = *bits++;
1418 unsigned char c;
1419 c = (unsigned char)((swap_nibble[b & 0xf] << 4)
1420 | (swap_nibble[(b>>4) & 0xf]));
1421 *cbits++ = (c >> (8 - fb->width));
1424 else
1426 for (j = 0; j < fb->height; j++)
1428 unsigned short b = *bits;
1429 b = (unsigned short)((swap_nibble[b & 0xf] << 12)
1430 | (swap_nibble[(b>>4) & 0xf] << 8)
1431 | (swap_nibble[(b>>8) & 0xf] << 4)
1432 | (swap_nibble[(b>>12) & 0xf]));
1433 b >>= (16 - fb->width);
1434 #ifdef WORDS_BIGENDIAN
1435 b = bswap_16 (b);
1436 #endif
1437 *bits++ = b;
1440 #endif /* HAVE_X_WINDOWS */
1444 if (!once_p)
1446 /* XXX Is SELECTED_FRAME OK here? */
1447 struct redisplay_interface *rif = FRAME_RIF (SELECTED_FRAME ());
1449 destroy_fringe_bitmap (which);
1451 if (rif && rif->define_fringe_bitmap)
1452 rif->define_fringe_bitmap (which, fb->bits, fb->height, fb->width);
1454 fringe_bitmaps[which] = fb;
1455 if (which >= max_used_fringe_bitmap)
1456 max_used_fringe_bitmap = which + 1;
1461 DEFUN ("define-fringe-bitmap", Fdefine_fringe_bitmap, Sdefine_fringe_bitmap,
1462 2, 5, 0,
1463 doc: /* Define fringe bitmap BITMAP from BITS of size HEIGHT x WIDTH.
1464 BITMAP is a symbol identifying the new fringe bitmap.
1465 BITS is either a string or a vector of integers.
1466 HEIGHT is height of bitmap. If HEIGHT is nil, use length of BITS.
1467 WIDTH must be an integer between 1 and 16, or nil which defaults to 8.
1468 Optional fifth arg ALIGN may be one of `top', `center', or `bottom',
1469 indicating the positioning of the bitmap relative to the rows where it
1470 is used; the default is to center the bitmap. Fifth arg may also be a
1471 list (ALIGN PERIODIC) where PERIODIC non-nil specifies that the bitmap
1472 should be repeated.
1473 If BITMAP already exists, the existing definition is replaced. */)
1474 (Lisp_Object bitmap, Lisp_Object bits, Lisp_Object height, Lisp_Object width, Lisp_Object align)
1476 int n, h, i, j;
1477 unsigned short *b;
1478 struct fringe_bitmap fb, *xfb;
1479 int fill1 = 0, fill2 = 0;
1481 CHECK_SYMBOL (bitmap);
1482 h = CHECK_VECTOR_OR_STRING (bits);
1484 if (NILP (height))
1485 fb.height = h;
1486 else
1488 CHECK_NUMBER (height);
1489 fb.height = max (0, min (XINT (height), 255));
1490 if (fb.height > h)
1492 fill1 = (fb.height - h) / 2;
1493 fill2 = fb.height - h - fill1;
1497 if (NILP (width))
1498 fb.width = 8;
1499 else
1501 CHECK_NUMBER (width);
1502 fb.width = max (0, min (XINT (width), 255));
1505 fb.period = 0;
1506 fb.align = ALIGN_BITMAP_CENTER;
1508 if (CONSP (align))
1510 Lisp_Object period = XCDR (align);
1511 if (CONSP (period))
1513 period = XCAR (period);
1514 if (!NILP (period))
1516 fb.period = fb.height;
1517 fb.height = 255;
1520 align = XCAR (align);
1522 if (EQ (align, Qtop))
1523 fb.align = ALIGN_BITMAP_TOP;
1524 else if (EQ (align, Qbottom))
1525 fb.align = ALIGN_BITMAP_BOTTOM;
1526 else if (!NILP (align) && !EQ (align, Qcenter))
1527 error ("Bad align argument");
1529 n = lookup_fringe_bitmap (bitmap);
1530 if (!n)
1532 if (max_used_fringe_bitmap < max_fringe_bitmaps)
1533 n = max_used_fringe_bitmap++;
1534 else
1536 for (n = MAX_STANDARD_FRINGE_BITMAPS;
1537 n < max_fringe_bitmaps;
1538 n++)
1539 if (fringe_bitmaps[n] == NULL)
1540 break;
1542 if (n == max_fringe_bitmaps)
1544 int bitmaps = max_fringe_bitmaps + 20;
1545 if (MAX_FRINGE_BITMAPS < bitmaps)
1546 error ("No free fringe bitmap slots");
1548 i = max_fringe_bitmaps;
1549 fringe_bitmaps = xrealloc (fringe_bitmaps,
1550 bitmaps * sizeof *fringe_bitmaps);
1551 fringe_faces = xrealloc (fringe_faces,
1552 bitmaps * sizeof *fringe_faces);
1554 for (i = max_fringe_bitmaps; i < bitmaps; i++)
1556 fringe_bitmaps[i] = NULL;
1557 fringe_faces[i] = Qnil;
1560 max_fringe_bitmaps = bitmaps;
1564 Vfringe_bitmaps = Fcons (bitmap, Vfringe_bitmaps);
1565 Fput (bitmap, Qfringe, make_number (n));
1568 fb.dynamic = true;
1570 xfb = xmalloc (sizeof fb + fb.height * BYTES_PER_BITMAP_ROW);
1571 fb.bits = b = (unsigned short *) (xfb + 1);
1572 memset (b, 0, fb.height);
1574 j = 0;
1575 while (j < fb.height)
1577 for (i = 0; i < fill1 && j < fb.height; i++)
1578 b[j++] = 0;
1579 for (i = 0; i < h && j < fb.height; i++)
1581 Lisp_Object elt = Faref (bits, make_number (i));
1582 b[j++] = NUMBERP (elt) ? XINT (elt) : 0;
1584 for (i = 0; i < fill2 && j < fb.height; i++)
1585 b[j++] = 0;
1588 *xfb = fb;
1590 init_fringe_bitmap (n, xfb, 0);
1592 return bitmap;
1595 DEFUN ("set-fringe-bitmap-face", Fset_fringe_bitmap_face, Sset_fringe_bitmap_face,
1596 1, 2, 0,
1597 doc: /* Set face for fringe bitmap BITMAP to FACE.
1598 FACE is merged with the `fringe' face, so normally FACE should specify
1599 only the foreground color.
1600 If FACE is nil, reset face to default fringe face. */)
1601 (Lisp_Object bitmap, Lisp_Object face)
1603 int n;
1605 CHECK_SYMBOL (bitmap);
1606 n = lookup_fringe_bitmap (bitmap);
1607 if (!n)
1608 error ("Undefined fringe bitmap");
1610 /* The purpose of the following code is to signal an error if FACE
1611 is not a face. This is for the caller's convenience only; the
1612 redisplay code should be able to fail gracefully. Skip the check
1613 if FRINGE_FACE_ID is unrealized (as in batch mode and during
1614 daemon startup). */
1615 if (!NILP (face))
1617 struct frame *f = SELECTED_FRAME ();
1619 if (FACE_FROM_ID (f, FRINGE_FACE_ID)
1620 && lookup_derived_face (f, face, FRINGE_FACE_ID, 1) < 0)
1621 error ("No such face");
1624 fringe_faces[n] = face;
1625 return Qnil;
1628 DEFUN ("fringe-bitmaps-at-pos", Ffringe_bitmaps_at_pos, Sfringe_bitmaps_at_pos,
1629 0, 2, 0,
1630 doc: /* Return fringe bitmaps of row containing position POS in window WINDOW.
1631 If WINDOW is nil, use selected window. If POS is nil, use value of point
1632 in that window. Return value is a list (LEFT RIGHT OV), where LEFT
1633 is the symbol for the bitmap in the left fringe (or nil if no bitmap),
1634 RIGHT is similar for the right fringe, and OV is non-nil if there is an
1635 overlay arrow in the left fringe.
1636 Return nil if POS is not visible in WINDOW. */)
1637 (Lisp_Object pos, Lisp_Object window)
1639 struct window *w;
1640 struct glyph_row *row;
1641 ptrdiff_t textpos;
1643 w = decode_any_window (window);
1644 XSETWINDOW (window, w);
1646 if (!NILP (pos))
1648 CHECK_NUMBER_COERCE_MARKER (pos);
1649 if (! (BEGV <= XINT (pos) && XINT (pos) <= ZV))
1650 args_out_of_range (window, pos);
1651 textpos = XINT (pos);
1653 else if (w == XWINDOW (selected_window))
1654 textpos = PT;
1655 else
1656 textpos = marker_position (w->pointm);
1658 row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
1659 row = row_containing_pos (w, textpos, row, NULL, 0);
1660 if (row)
1661 return list3 (get_fringe_bitmap_name (row->left_fringe_bitmap),
1662 get_fringe_bitmap_name (row->right_fringe_bitmap),
1663 (row->overlay_arrow_bitmap == 0 ? Qnil
1664 : row->overlay_arrow_bitmap < 0 ? Qt
1665 : get_fringe_bitmap_name (row->overlay_arrow_bitmap)));
1666 else
1667 return Qnil;
1671 /***********************************************************************
1672 Initialization
1673 ***********************************************************************/
1675 void
1676 syms_of_fringe (void)
1678 DEFSYM (Qtruncation, "truncation");
1679 DEFSYM (Qcontinuation, "continuation");
1680 DEFSYM (Qoverlay_arrow, "overlay-arrow");
1681 DEFSYM (Qempty_line, "empty-line");
1682 DEFSYM (Qtop_bottom, "top-bottom");
1683 DEFSYM (Qhollow_small, "hollow-small");
1685 defsubr (&Sdestroy_fringe_bitmap);
1686 defsubr (&Sdefine_fringe_bitmap);
1687 defsubr (&Sfringe_bitmaps_at_pos);
1688 defsubr (&Sset_fringe_bitmap_face);
1690 DEFVAR_LISP ("overflow-newline-into-fringe", Voverflow_newline_into_fringe,
1691 doc: /* Non-nil means that newline may flow into the right fringe.
1692 This means that display lines which are exactly as wide as the window
1693 (not counting the final newline) will only occupy one screen line, by
1694 showing (or hiding) the final newline in the right fringe; when point
1695 is at the final newline, the cursor is shown in the right fringe.
1696 If nil, also continue lines which are exactly as wide as the window. */);
1697 Voverflow_newline_into_fringe = Qt;
1699 DEFVAR_LISP ("fringe-bitmaps", Vfringe_bitmaps,
1700 doc: /* List of fringe bitmap symbols. */);
1701 Vfringe_bitmaps = Qnil;
1704 /* Garbage collection hook */
1706 void
1707 mark_fringe_data (void)
1709 int i;
1711 for (i = 0; i < max_fringe_bitmaps; i++)
1712 if (!NILP (fringe_faces[i]))
1713 mark_object (fringe_faces[i]);
1716 /* Initialize this module when Emacs starts. */
1718 void
1719 init_fringe_once (void)
1721 int bt;
1723 for (bt = NO_FRINGE_BITMAP + 1; bt < MAX_STANDARD_FRINGE_BITMAPS; bt++)
1724 init_fringe_bitmap (bt, &standard_bitmaps[bt], 1);
1727 void
1728 init_fringe (void)
1730 int i;
1732 max_fringe_bitmaps = MAX_STANDARD_FRINGE_BITMAPS + 20;
1734 fringe_bitmaps = xzalloc (max_fringe_bitmaps * sizeof *fringe_bitmaps);
1735 fringe_faces = xmalloc (max_fringe_bitmaps * sizeof *fringe_faces);
1737 for (i = 0; i < max_fringe_bitmaps; i++)
1738 fringe_faces[i] = Qnil;
1741 #ifdef HAVE_NTGUI
1743 void
1744 w32_init_fringe (struct redisplay_interface *rif)
1746 int bt;
1748 if (!rif)
1749 return;
1751 for (bt = NO_FRINGE_BITMAP + 1; bt < MAX_STANDARD_FRINGE_BITMAPS; bt++)
1753 struct fringe_bitmap *fb = &standard_bitmaps[bt];
1754 rif->define_fringe_bitmap (bt, fb->bits, fb->height, fb->width);
1758 void
1759 w32_reset_fringes (void)
1761 /* Destroy row bitmaps. */
1762 int bt;
1763 struct redisplay_interface *rif = FRAME_RIF (SELECTED_FRAME ());
1765 if (!rif)
1766 return;
1768 for (bt = NO_FRINGE_BITMAP + 1; bt < max_used_fringe_bitmap; bt++)
1769 rif->destroy_fringe_bitmap (bt);
1772 #endif /* HAVE_NTGUI */