1 /* Fringe handling (split from xdisp.c).
2 Copyright (C) 1985-1988, 1993-1995, 1997-2014 Free Software
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/>. */
28 #include "dispextern.h"
29 #include "character.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,
90 /***********************************************************************
92 ***********************************************************************/
94 /* Undefined bitmap. A question mark. */
107 static unsigned short question_mark_bits
[] = {
108 0x3c, 0x7e, 0x7e, 0x0c, 0x18, 0x18, 0x00, 0x18, 0x18};
110 /* An exclamation mark. */
123 static unsigned short exclamation_mark_bits
[] = {
124 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18};
126 /* An arrow like this: `<-'. */
137 static unsigned short left_arrow_bits
[] = {
138 0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
141 /* Right truncation arrow bitmap `->'. */
152 static unsigned short right_arrow_bits
[] = {
153 0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
156 /* Up arrow bitmap. */
167 static unsigned short up_arrow_bits
[] = {
168 0x18, 0x3c, 0x7e, 0xff, 0x18, 0x18, 0x18, 0x18};
171 /* Down arrow bitmap. */
182 static unsigned short down_arrow_bits
[] = {
183 0x18, 0x18, 0x18, 0x18, 0xff, 0x7e, 0x3c, 0x18};
185 /* Marker for continuation lines. */
196 static unsigned short left_curly_arrow_bits
[] = {
197 0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
199 /* Marker for continued lines. */
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. */
224 static unsigned short left_triangle_bits
[] = {
225 0x03, 0x0f, 0x1f, 0x3f, 0x3f, 0x1f, 0x0f, 0x03};
227 /* Overlay arrow bitmap. A triangular arrow. */
238 static unsigned short right_triangle_bits
[] = {
239 0xc0, 0xf0, 0xf8, 0xfc, 0xfc, 0xf8, 0xf0, 0xc0};
241 /* First line bitmap. An top-left angle. */
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. */
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. */
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. */
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. */
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. */
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. */
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. */
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. */
376 static unsigned short hollow_square_bits
[] = {
377 0x7e, 0x42, 0x42, 0x42, 0x42, 0x7e};
379 /* Filled square bitmap. */
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. */
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. */
415 static unsigned short horizontal_bar_bits
[] = {
419 /* Bitmap drawn to indicate lines not displaying text if
420 `indicate-empty-lines' is non-nil. */
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
)
494 bitmap
= Fget (bitmap
, Qfringe
);
495 if (!INTEGERP (bitmap
))
499 if (bn
> NO_FRINGE_BITMAP
500 && bn
< max_used_fringe_bitmap
501 && (bn
< MAX_STANDARD_FRINGE_BITMAPS
502 || fringe_bitmaps
[bn
] != NULL
))
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. */
516 get_fringe_bitmap_name (int bn
)
521 /* Zero means no bitmap -- return nil. */
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
)))
533 bitmaps
= XCDR (bitmaps
);
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
];
548 fb
= &standard_bitmaps
[bn
< MAX_STANDARD_FRINGE_BITMAPS
549 ? bn
: UNDEF_FRINGE_BITMAP
];
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
558 LEFT_P is 1 for left fringe, 0 for right fringe.
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
;
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
)
580 which
= row
->left_fringe_bitmap
;
581 face_id
= row
->left_fringe_face_id
;
582 offset
= row
->left_fringe_offset
;
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);
597 face_id
= FRINGE_FACE_ID
;
600 fb
= get_fringe_bitmap_data (which
);
604 /* Convert row to frame coordinates. */
605 p
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
) + offset
;
612 p
.dh
= (period
> 0 ? (p
.y
% period
) : 0);
615 /* Adjust y to the offset in the row to start drawing the bitmap. */
618 case ALIGN_BITMAP_CENTER
:
619 p
.y
+= (row
->height
- p
.h
) / 2;
621 case ALIGN_BITMAP_BOTTOM
:
622 p
.y
+= (row
->visible_height
- p
.h
);
624 case ALIGN_BITMAP_TOP
:
628 p
.face
= FACE_FROM_ID (f
, face_id
);
632 /* This could happen after clearing face cache.
633 But it shouldn't happen anymore. ++kfs */
637 prepare_face_for_display (f
, p
.face
);
639 /* Clear left fringe if no bitmap to draw or if bitmap doesn't fill
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
;
647 int wd
= WINDOW_LEFT_FRINGE_WIDTH (w
);
648 int x
= window_box_left (w
, (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
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
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)
678 int x
= window_box_right (w
,
679 (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
682 int wd
= WINDOW_RIGHT_FRINGE_WIDTH (w
);
685 p
.x
= x
+ (wd
- p
.wd
) / 2;
686 /* Clear right fringe if no bitmap to draw of if bitmap doesn't fill
688 if (p
.wd
< wd
|| p
.y
> p
.by
|| p
.y
+ p
.h
< p
.by
+ p
.ny
)
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
);
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
);
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
);
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;
729 int ix2
= ix1
+ (partial_p
? 2 : 0);
731 /* Lookup in buffer-local fringe-indicator-alist before global alist.
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
);
747 if ((bm1
= XCDR (bm1
)), NILP (bm1
))
748 return NO_FRINGE_BITMAP
;
751 ln1
= XINT (Flength (bm1
));
756 bm
= Fnth (make_number (ix2
), bm1
);
765 bm
= Fnth (make_number (ix1
), bm1
);
771 else if ((bm
= bm1
, !EQ (bm
, Qt
)))
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
));
782 if ((bm2
= XCDR (bm2
)), !NILP (bm2
))
786 ln2
= XINT (Flength (bm2
));
791 bm
= Fnth (make_number (ix2
), bm2
);
803 bm
= Fnth (make_number (ix1
), bm1
);
810 bm
= Fnth (make_number (ix1
), bm2
);
813 return NO_FRINGE_BITMAP
;
815 else if ((bm
= bm2
, NILP (bm
)))
816 return NO_FRINGE_BITMAP
;
819 return lookup_fringe_bitmap (bm
);
824 draw_fringe_bitmap (struct window
*w
, struct glyph_row
*row
, int left_p
)
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
))
838 cursor
= Qhollow_small
;
840 case FILLED_BOX_CURSOR
:
851 w
->phys_cursor_on_p
= 0;
852 row
->cursor_in_fringe_p
= 0;
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. */
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)
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
901 A return nonzero value indicates that the vertical line between
902 windows needs update (as it may be drawn in the fringe).
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
;
914 if (w
->pseudo_window_p
)
917 /* Must draw line if no fringe */
919 && (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0
920 || WINDOW_RIGHT_FRINGE_WIDTH (w
) == 0))
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
)
929 draw_row_fringe_bitmaps (w
, row
);
930 row
->redraw_fringe_bitmaps_p
= 0;
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. */
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
;
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
)
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
)))
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
);
989 /* Anything else means boundary on left and no arrows. */
990 boundary_top
= boundary_bot
= Qleft
;
993 top_ind_rn
= bot_ind_rn
= -1;
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
);
1015 row
->indicate_top_line_p
= !NILP (arrow_top
);
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));
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);
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
;
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
)
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
)
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
);
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);
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
;
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
)
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
++)
1174 unsigned left_face_id
, right_face_id
;
1175 int left_offset
, right_offset
;
1178 row
= w
->desired_matrix
->rows
+ rn
;
1179 cur
= w
->current_matrix
->rows
+ rn
;
1180 if (!row
->enabled_p
)
1183 left_face_id
= right_face_id
= DEFAULT_FACE_ID
;
1184 left_offset
= right_offset
= 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
);
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);
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
;
1332 /* Compute actual fringe widths for frame F.
1334 If REDRAW is 1, redraw F if the fringe settings was actually
1335 modified and F is visible.
1337 Since the combined left and right fringe must occupy an integral
1338 number of columns, we may need to add some pixels to each fringe.
1339 Typically, we add an equal amount (+/- 1 pixel) to each fringe,
1340 but a negative width value is taken literally (after negating it).
1342 We never make the fringes narrower than specified.
1346 compute_fringe_widths (struct frame
*f
, bool redraw_p
)
1348 int o_left
= FRAME_LEFT_FRINGE_WIDTH (f
);
1349 int o_right
= FRAME_RIGHT_FRINGE_WIDTH (f
);
1350 int o_cols
= FRAME_FRINGE_COLS (f
);
1352 Lisp_Object left_fringe
= Fassq (Qleft_fringe
, f
->param_alist
);
1353 Lisp_Object right_fringe
= Fassq (Qright_fringe
, f
->param_alist
);
1354 int left_fringe_width
, right_fringe_width
;
1356 if (!NILP (left_fringe
))
1357 left_fringe
= Fcdr (left_fringe
);
1358 if (!NILP (right_fringe
))
1359 right_fringe
= Fcdr (right_fringe
);
1361 left_fringe_width
= ((NILP (left_fringe
) || !INTEGERP (left_fringe
)) ? 8 :
1362 XINT (left_fringe
));
1363 right_fringe_width
= ((NILP (right_fringe
) || !INTEGERP (right_fringe
)) ? 8 :
1364 XINT (right_fringe
));
1366 if (left_fringe_width
|| right_fringe_width
)
1368 int left_wid
= eabs (left_fringe_width
);
1369 int right_wid
= eabs (right_fringe_width
);
1370 int conf_wid
= left_wid
+ right_wid
;
1371 int font_wid
= FRAME_COLUMN_WIDTH (f
);
1372 int cols
= (left_wid
+ right_wid
+ font_wid
-1) / font_wid
;
1373 int real_wid
= cols
* font_wid
;
1374 if (left_wid
&& right_wid
)
1376 if (left_fringe_width
< 0)
1378 /* Left fringe width is fixed, adjust right fringe if necessary */
1379 FRAME_LEFT_FRINGE_WIDTH (f
) = left_wid
;
1380 FRAME_RIGHT_FRINGE_WIDTH (f
) = real_wid
- left_wid
;
1382 else if (right_fringe_width
< 0)
1384 /* Right fringe width is fixed, adjust left fringe if necessary */
1385 FRAME_LEFT_FRINGE_WIDTH (f
) = real_wid
- right_wid
;
1386 FRAME_RIGHT_FRINGE_WIDTH (f
) = right_wid
;
1390 /* Adjust both fringes with an equal amount.
1391 Note that we are doing integer arithmetic here, so don't
1392 lose a pixel if the total width is an odd number. */
1393 int fill
= real_wid
- conf_wid
;
1394 FRAME_LEFT_FRINGE_WIDTH (f
) = left_wid
+ fill
/2;
1395 FRAME_RIGHT_FRINGE_WIDTH (f
) = right_wid
+ fill
- fill
/2;
1398 else if (left_fringe_width
)
1400 FRAME_LEFT_FRINGE_WIDTH (f
) = real_wid
;
1401 FRAME_RIGHT_FRINGE_WIDTH (f
) = 0;
1405 FRAME_LEFT_FRINGE_WIDTH (f
) = 0;
1406 FRAME_RIGHT_FRINGE_WIDTH (f
) = real_wid
;
1408 FRAME_FRINGE_COLS (f
) = cols
;
1412 FRAME_LEFT_FRINGE_WIDTH (f
) = 0;
1413 FRAME_RIGHT_FRINGE_WIDTH (f
) = 0;
1414 FRAME_FRINGE_COLS (f
) = 0;
1417 if (redraw_p
&& FRAME_VISIBLE_P (f
))
1418 if (o_left
!= FRAME_LEFT_FRINGE_WIDTH (f
) ||
1419 o_right
!= FRAME_RIGHT_FRINGE_WIDTH (f
) ||
1420 o_cols
!= FRAME_FRINGE_COLS (f
))
1425 /* Free resources used by a user-defined bitmap. */
1428 destroy_fringe_bitmap (int n
)
1430 struct fringe_bitmap
**fbp
;
1432 fringe_faces
[n
] = Qnil
;
1434 fbp
= &fringe_bitmaps
[n
];
1435 if (*fbp
&& (*fbp
)->dynamic
)
1437 /* XXX Is SELECTED_FRAME OK here? */
1438 struct redisplay_interface
*rif
= FRAME_RIF (SELECTED_FRAME ());
1439 if (rif
&& rif
->destroy_fringe_bitmap
)
1440 rif
->destroy_fringe_bitmap (n
);
1445 while (max_used_fringe_bitmap
> MAX_STANDARD_FRINGE_BITMAPS
1446 && fringe_bitmaps
[max_used_fringe_bitmap
- 1] == NULL
)
1447 max_used_fringe_bitmap
--;
1451 DEFUN ("destroy-fringe-bitmap", Fdestroy_fringe_bitmap
, Sdestroy_fringe_bitmap
,
1453 doc
: /* Destroy fringe bitmap BITMAP.
1454 If BITMAP overrides a standard fringe bitmap, the original bitmap is restored. */)
1455 (Lisp_Object bitmap
)
1459 CHECK_SYMBOL (bitmap
);
1460 n
= lookup_fringe_bitmap (bitmap
);
1464 destroy_fringe_bitmap (n
);
1466 if (n
>= MAX_STANDARD_FRINGE_BITMAPS
)
1468 Vfringe_bitmaps
= Fdelq (bitmap
, Vfringe_bitmaps
);
1469 /* It would be better to remove the fringe property. */
1470 Fput (bitmap
, Qfringe
, Qnil
);
1477 /* Initialize bitmap bit.
1479 On X, we bit-swap the built-in bitmaps and reduce bitmap
1480 from short to char array if width is <= 8 bits.
1482 On MAC with big-endian CPU, we need to byte-swap each short.
1484 On W32 and MAC (little endian), there's no need to do this.
1487 #if defined (HAVE_X_WINDOWS)
1488 static const unsigned char swap_nibble
[16] = {
1489 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
1490 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
1491 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
1492 0x3, 0xb, 0x7, 0xf}; /* 0011 1011 0111 1111 */
1493 #endif /* HAVE_X_WINDOWS */
1496 init_fringe_bitmap (int which
, struct fringe_bitmap
*fb
, int once_p
)
1498 if (once_p
|| fb
->dynamic
)
1500 #if defined (HAVE_X_WINDOWS)
1501 unsigned short *bits
= fb
->bits
;
1506 unsigned char *cbits
= (unsigned char *)fb
->bits
;
1507 for (j
= 0; j
< fb
->height
; j
++)
1509 unsigned short b
= *bits
++;
1511 c
= (unsigned char)((swap_nibble
[b
& 0xf] << 4)
1512 | (swap_nibble
[(b
>>4) & 0xf]));
1513 *cbits
++ = (c
>> (8 - fb
->width
));
1518 for (j
= 0; j
< fb
->height
; j
++)
1520 unsigned short b
= *bits
;
1521 b
= (unsigned short)((swap_nibble
[b
& 0xf] << 12)
1522 | (swap_nibble
[(b
>>4) & 0xf] << 8)
1523 | (swap_nibble
[(b
>>8) & 0xf] << 4)
1524 | (swap_nibble
[(b
>>12) & 0xf]));
1525 b
>>= (16 - fb
->width
);
1526 #ifdef WORDS_BIGENDIAN
1532 #endif /* HAVE_X_WINDOWS */
1538 /* XXX Is SELECTED_FRAME OK here? */
1539 struct redisplay_interface
*rif
= FRAME_RIF (SELECTED_FRAME ());
1541 destroy_fringe_bitmap (which
);
1543 if (rif
&& rif
->define_fringe_bitmap
)
1544 rif
->define_fringe_bitmap (which
, fb
->bits
, fb
->height
, fb
->width
);
1546 fringe_bitmaps
[which
] = fb
;
1547 if (which
>= max_used_fringe_bitmap
)
1548 max_used_fringe_bitmap
= which
+ 1;
1553 DEFUN ("define-fringe-bitmap", Fdefine_fringe_bitmap
, Sdefine_fringe_bitmap
,
1555 doc
: /* Define fringe bitmap BITMAP from BITS of size HEIGHT x WIDTH.
1556 BITMAP is a symbol identifying the new fringe bitmap.
1557 BITS is either a string or a vector of integers.
1558 HEIGHT is height of bitmap. If HEIGHT is nil, use length of BITS.
1559 WIDTH must be an integer between 1 and 16, or nil which defaults to 8.
1560 Optional fifth arg ALIGN may be one of `top', `center', or `bottom',
1561 indicating the positioning of the bitmap relative to the rows where it
1562 is used; the default is to center the bitmap. Fifth arg may also be a
1563 list (ALIGN PERIODIC) where PERIODIC non-nil specifies that the bitmap
1565 If BITMAP already exists, the existing definition is replaced. */)
1566 (Lisp_Object bitmap
, Lisp_Object bits
, Lisp_Object height
, Lisp_Object width
, Lisp_Object align
)
1570 struct fringe_bitmap fb
, *xfb
;
1571 int fill1
= 0, fill2
= 0;
1573 CHECK_SYMBOL (bitmap
);
1574 h
= CHECK_VECTOR_OR_STRING (bits
);
1580 CHECK_NUMBER (height
);
1581 fb
.height
= max (0, min (XINT (height
), 255));
1584 fill1
= (fb
.height
- h
) / 2;
1585 fill2
= fb
.height
- h
- fill1
;
1593 CHECK_NUMBER (width
);
1594 fb
.width
= max (0, min (XINT (width
), 255));
1598 fb
.align
= ALIGN_BITMAP_CENTER
;
1602 Lisp_Object period
= XCDR (align
);
1605 period
= XCAR (period
);
1608 fb
.period
= fb
.height
;
1612 align
= XCAR (align
);
1614 if (EQ (align
, Qtop
))
1615 fb
.align
= ALIGN_BITMAP_TOP
;
1616 else if (EQ (align
, Qbottom
))
1617 fb
.align
= ALIGN_BITMAP_BOTTOM
;
1618 else if (!NILP (align
) && !EQ (align
, Qcenter
))
1619 error ("Bad align argument");
1621 n
= lookup_fringe_bitmap (bitmap
);
1624 if (max_used_fringe_bitmap
< max_fringe_bitmaps
)
1625 n
= max_used_fringe_bitmap
++;
1628 for (n
= MAX_STANDARD_FRINGE_BITMAPS
;
1629 n
< max_fringe_bitmaps
;
1631 if (fringe_bitmaps
[n
] == NULL
)
1634 if (n
== max_fringe_bitmaps
)
1636 int bitmaps
= max_fringe_bitmaps
+ 20;
1637 if (MAX_FRINGE_BITMAPS
< bitmaps
)
1638 error ("No free fringe bitmap slots");
1640 i
= max_fringe_bitmaps
;
1641 fringe_bitmaps
= xrealloc (fringe_bitmaps
,
1642 bitmaps
* sizeof *fringe_bitmaps
);
1643 fringe_faces
= xrealloc (fringe_faces
,
1644 bitmaps
* sizeof *fringe_faces
);
1646 for (i
= max_fringe_bitmaps
; i
< bitmaps
; i
++)
1648 fringe_bitmaps
[i
] = NULL
;
1649 fringe_faces
[i
] = Qnil
;
1652 max_fringe_bitmaps
= bitmaps
;
1656 Vfringe_bitmaps
= Fcons (bitmap
, Vfringe_bitmaps
);
1657 Fput (bitmap
, Qfringe
, make_number (n
));
1662 xfb
= xmalloc (sizeof fb
+ fb
.height
* BYTES_PER_BITMAP_ROW
);
1663 fb
.bits
= b
= (unsigned short *) (xfb
+ 1);
1664 memset (b
, 0, fb
.height
);
1667 while (j
< fb
.height
)
1669 for (i
= 0; i
< fill1
&& j
< fb
.height
; i
++)
1671 for (i
= 0; i
< h
&& j
< fb
.height
; i
++)
1673 Lisp_Object elt
= Faref (bits
, make_number (i
));
1674 b
[j
++] = NUMBERP (elt
) ? XINT (elt
) : 0;
1676 for (i
= 0; i
< fill2
&& j
< fb
.height
; i
++)
1682 init_fringe_bitmap (n
, xfb
, 0);
1687 DEFUN ("set-fringe-bitmap-face", Fset_fringe_bitmap_face
, Sset_fringe_bitmap_face
,
1689 doc
: /* Set face for fringe bitmap BITMAP to FACE.
1690 FACE is merged with the `fringe' face, so normally FACE should specify
1691 only the foreground color.
1692 If FACE is nil, reset face to default fringe face. */)
1693 (Lisp_Object bitmap
, Lisp_Object face
)
1697 CHECK_SYMBOL (bitmap
);
1698 n
= lookup_fringe_bitmap (bitmap
);
1700 error ("Undefined fringe bitmap");
1702 /* The purpose of the following code is to signal an error if FACE
1703 is not a face. This is for the caller's convenience only; the
1704 redisplay code should be able to fail gracefully. Skip the check
1705 if FRINGE_FACE_ID is unrealized (as in batch mode and during
1709 struct frame
*f
= SELECTED_FRAME ();
1711 if (FACE_FROM_ID (f
, FRINGE_FACE_ID
)
1712 && lookup_derived_face (f
, face
, FRINGE_FACE_ID
, 1) < 0)
1713 error ("No such face");
1716 fringe_faces
[n
] = face
;
1720 DEFUN ("fringe-bitmaps-at-pos", Ffringe_bitmaps_at_pos
, Sfringe_bitmaps_at_pos
,
1722 doc
: /* Return fringe bitmaps of row containing position POS in window WINDOW.
1723 If WINDOW is nil, use selected window. If POS is nil, use value of point
1724 in that window. Return value is a list (LEFT RIGHT OV), where LEFT
1725 is the symbol for the bitmap in the left fringe (or nil if no bitmap),
1726 RIGHT is similar for the right fringe, and OV is non-nil if there is an
1727 overlay arrow in the left fringe.
1728 Return nil if POS is not visible in WINDOW. */)
1729 (Lisp_Object pos
, Lisp_Object window
)
1732 struct glyph_row
*row
;
1735 w
= decode_any_window (window
);
1736 XSETWINDOW (window
, w
);
1740 CHECK_NUMBER_COERCE_MARKER (pos
);
1741 if (! (BEGV
<= XINT (pos
) && XINT (pos
) <= ZV
))
1742 args_out_of_range (window
, pos
);
1743 textpos
= XINT (pos
);
1745 else if (w
== XWINDOW (selected_window
))
1748 textpos
= marker_position (w
->pointm
);
1750 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1751 row
= row_containing_pos (w
, textpos
, row
, NULL
, 0);
1753 return list3 (get_fringe_bitmap_name (row
->left_fringe_bitmap
),
1754 get_fringe_bitmap_name (row
->right_fringe_bitmap
),
1755 (row
->overlay_arrow_bitmap
== 0 ? Qnil
1756 : row
->overlay_arrow_bitmap
< 0 ? Qt
1757 : get_fringe_bitmap_name (row
->overlay_arrow_bitmap
)));
1763 /***********************************************************************
1765 ***********************************************************************/
1768 syms_of_fringe (void)
1770 DEFSYM (Qtruncation
, "truncation");
1771 DEFSYM (Qcontinuation
, "continuation");
1772 DEFSYM (Qoverlay_arrow
, "overlay-arrow");
1773 DEFSYM (Qempty_line
, "empty-line");
1774 DEFSYM (Qtop_bottom
, "top-bottom");
1775 DEFSYM (Qhollow_small
, "hollow-small");
1777 defsubr (&Sdestroy_fringe_bitmap
);
1778 defsubr (&Sdefine_fringe_bitmap
);
1779 defsubr (&Sfringe_bitmaps_at_pos
);
1780 defsubr (&Sset_fringe_bitmap_face
);
1782 DEFVAR_LISP ("overflow-newline-into-fringe", Voverflow_newline_into_fringe
,
1783 doc
: /* Non-nil means that newline may flow into the right fringe.
1784 This means that display lines which are exactly as wide as the window
1785 (not counting the final newline) will only occupy one screen line, by
1786 showing (or hiding) the final newline in the right fringe; when point
1787 is at the final newline, the cursor is shown in the right fringe.
1788 If nil, also continue lines which are exactly as wide as the window. */);
1789 Voverflow_newline_into_fringe
= Qt
;
1791 DEFVAR_LISP ("fringe-bitmaps", Vfringe_bitmaps
,
1792 doc
: /* List of fringe bitmap symbols. */);
1793 Vfringe_bitmaps
= Qnil
;
1796 /* Garbage collection hook */
1799 mark_fringe_data (void)
1803 for (i
= 0; i
< max_fringe_bitmaps
; i
++)
1804 if (!NILP (fringe_faces
[i
]))
1805 mark_object (fringe_faces
[i
]);
1808 /* Initialize this module when Emacs starts. */
1811 init_fringe_once (void)
1815 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< MAX_STANDARD_FRINGE_BITMAPS
; bt
++)
1816 init_fringe_bitmap (bt
, &standard_bitmaps
[bt
], 1);
1824 max_fringe_bitmaps
= MAX_STANDARD_FRINGE_BITMAPS
+ 20;
1826 fringe_bitmaps
= xzalloc (max_fringe_bitmaps
* sizeof *fringe_bitmaps
);
1827 fringe_faces
= xmalloc (max_fringe_bitmaps
* sizeof *fringe_faces
);
1829 for (i
= 0; i
< max_fringe_bitmaps
; i
++)
1830 fringe_faces
[i
] = Qnil
;
1836 w32_init_fringe (struct redisplay_interface
*rif
)
1843 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< MAX_STANDARD_FRINGE_BITMAPS
; bt
++)
1845 struct fringe_bitmap
*fb
= &standard_bitmaps
[bt
];
1846 rif
->define_fringe_bitmap (bt
, fb
->bits
, fb
->height
, fb
->width
);
1851 w32_reset_fringes (void)
1853 /* Destroy row bitmaps. */
1855 struct redisplay_interface
*rif
= FRAME_RIF (SELECTED_FRAME ());
1860 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< max_used_fringe_bitmap
; bt
++)
1861 rif
->destroy_fringe_bitmap (bt
);
1864 #endif /* HAVE_NTGUI */