1 /* Fringe handling (split from xdisp.c).
2 Copyright (C) 1985-1988, 1993-1995, 1997-2011 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
26 #include "dispextern.h"
28 #include "blockinput.h"
29 #include "termhooks.h"
31 #ifdef HAVE_WINDOW_SYSTEM
33 /* Fringe bitmaps are represented in three different ways:
35 Logical bitmaps are used internally to denote things like
36 'end-of-buffer', 'left-truncation', 'overlay-arrow', etc.
38 Physical bitmaps specify the visual appearence of the bitmap,
39 e.g. 'bottom-left-angle', 'left-arrow', 'left-triangle', etc.
40 User defined bitmaps are physical bitmaps.
42 Internally, fringe bitmaps for a specific display row are
43 represented as a simple integer that is used as an index
44 into the table of all defined bitmaps. This index is stored
45 in the `fringe' property of the physical bitmap symbol.
47 Logical bitmaps are mapped to physical bitmaps through the
48 buffer-local `fringe-indicator-alist' variable.
50 Each element of this alist is a cons (LOGICAL . PHYSICAL)
51 mapping a logical bitmap to a physical bitmap.
52 PHYSICAL is either a symbol to use in both left and right fringe,
53 or a cons of two symbols (LEFT . RIGHT) denoting different
54 bitmaps to use in left and right fringe.
56 LOGICAL is first looked up in the window's buffer's buffer-local
57 value of the fringe-indicator-alist variable, and if not present,
58 in the global value of fringe-indicator-alist.
60 If LOGICAL is not present in either alist, or the PHYSICAL value
61 found is nil, no bitmap is shown for the logical bitmap.
63 The `left-fringe' and `right-fringe' display properties
64 must specify physical bitmap symbols.
67 Lisp_Object Qtruncation
, Qcontinuation
, Qoverlay_arrow
;
68 Lisp_Object Qempty_line
, Qtop_bottom
;
69 Lisp_Object Qhollow_small
;
71 enum fringe_bitmap_align
73 ALIGN_BITMAP_CENTER
= 0,
89 /***********************************************************************
91 ***********************************************************************/
93 /* Undefined bitmap. A question mark. */
106 static unsigned short question_mark_bits
[] = {
107 0x3c, 0x7e, 0x7e, 0x0c, 0x18, 0x18, 0x00, 0x18, 0x18};
109 /* An arrow like this: `<-'. */
120 static unsigned short left_arrow_bits
[] = {
121 0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
124 /* Right truncation arrow bitmap `->'. */
135 static unsigned short right_arrow_bits
[] = {
136 0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
139 /* Up arrow bitmap. */
150 static unsigned short up_arrow_bits
[] = {
151 0x18, 0x3c, 0x7e, 0xff, 0x18, 0x18, 0x18, 0x18};
154 /* Down arrow bitmap. */
165 static unsigned short down_arrow_bits
[] = {
166 0x18, 0x18, 0x18, 0x18, 0xff, 0x7e, 0x3c, 0x18};
168 /* Marker for continuation lines. */
179 static unsigned short left_curly_arrow_bits
[] = {
180 0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
182 /* Marker for continued lines. */
193 static unsigned short right_curly_arrow_bits
[] = {
194 0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
196 /* Reverse Overlay arrow bitmap. A triangular arrow. */
207 static unsigned short left_triangle_bits
[] = {
208 0x03, 0x0f, 0x1f, 0x3f, 0x3f, 0x1f, 0x0f, 0x03};
210 /* Overlay arrow bitmap. A triangular arrow. */
221 static unsigned short right_triangle_bits
[] = {
222 0xc0, 0xf0, 0xf8, 0xfc, 0xfc, 0xf8, 0xf0, 0xc0};
224 /* First line bitmap. An top-left angle. */
235 static unsigned short top_left_angle_bits
[] = {
236 0xfc, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00};
238 /* First line bitmap. An right-up angle. */
249 static unsigned short top_right_angle_bits
[] = {
250 0x3f, 0x3f, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00};
252 /* Last line bitmap. An left-down angle. */
263 static unsigned short bottom_left_angle_bits
[] = {
264 0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfc, 0xfc};
266 /* Last line bitmap. An right-down angle. */
277 static unsigned short bottom_right_angle_bits
[] = {
278 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x3f, 0x3f};
280 /* First/last line bitmap. An left bracket. */
293 static unsigned short left_bracket_bits
[] = {
294 0xfc, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfc, 0xfc};
296 /* First/last line bitmap. An right bracket. */
309 static unsigned short right_bracket_bits
[] = {
310 0x3f, 0x3f, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x3f, 0x3f};
312 /* Filled box cursor bitmap. A filled box; max 13 pixels high. */
328 static unsigned short filled_rectangle_bits
[] = {
329 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe};
331 /* Hollow box cursor bitmap. A hollow box; max 13 pixels high. */
347 static unsigned short hollow_rectangle_bits
[] = {
348 0xfe, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0xfe};
350 /* Hollow square bitmap. */
359 static unsigned short hollow_square_bits
[] = {
360 0x7e, 0x42, 0x42, 0x42, 0x42, 0x7e};
362 /* Filled square bitmap. */
371 static unsigned short filled_square_bits
[] = {
372 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e};
374 /* Bar cursor bitmap. A vertical bar; max 13 pixels high. */
390 static unsigned short vertical_bar_bits
[] = {
391 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0};
393 /* HBar cursor bitmap. A horizontal bar; 2 pixels high. */
398 static unsigned short horizontal_bar_bits
[] = {
402 /* Bitmap drawn to indicate lines not displaying text if
403 `indicate-empty-lines' is non-nil. */
412 static unsigned short empty_line_bits
[] = {
413 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
414 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
415 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
416 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
417 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
418 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
419 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
420 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00};
423 #define BYTES_PER_BITMAP_ROW (sizeof (unsigned short))
424 #define STANDARD_BITMAP_HEIGHT(bits) (sizeof (bits)/BYTES_PER_BITMAP_ROW)
425 #define FRBITS(bits) bits, STANDARD_BITMAP_HEIGHT (bits)
427 /* NOTE: The order of these bitmaps must match the sequence
428 used in fringe.el to define the corresponding symbols. */
430 struct fringe_bitmap standard_bitmaps
[] =
432 { NULL
, 0, 0, 0, 0, 0 }, /* NO_FRINGE_BITMAP */
433 { FRBITS (question_mark_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
434 { FRBITS (left_arrow_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
435 { FRBITS (right_arrow_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
436 { FRBITS (up_arrow_bits
), 8, 0, ALIGN_BITMAP_TOP
, 0 },
437 { FRBITS (down_arrow_bits
), 8, 0, ALIGN_BITMAP_BOTTOM
, 0 },
438 { FRBITS (left_curly_arrow_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
439 { FRBITS (right_curly_arrow_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
440 { FRBITS (left_triangle_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
441 { FRBITS (right_triangle_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
442 { FRBITS (top_left_angle_bits
), 8, 0, ALIGN_BITMAP_TOP
, 0 },
443 { FRBITS (top_right_angle_bits
), 8, 0, ALIGN_BITMAP_TOP
, 0 },
444 { FRBITS (bottom_left_angle_bits
), 8, 0, ALIGN_BITMAP_BOTTOM
, 0 },
445 { FRBITS (bottom_right_angle_bits
), 8, 0, ALIGN_BITMAP_BOTTOM
, 0 },
446 { FRBITS (left_bracket_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
447 { FRBITS (right_bracket_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
448 { FRBITS (filled_rectangle_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
449 { FRBITS (hollow_rectangle_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
450 { FRBITS (filled_square_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
451 { FRBITS (hollow_square_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
452 { FRBITS (vertical_bar_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
453 { FRBITS (horizontal_bar_bits
), 8, 0, ALIGN_BITMAP_BOTTOM
, 0 },
454 { FRBITS (empty_line_bits
), 8, 3, ALIGN_BITMAP_TOP
, 0 },
457 #define NO_FRINGE_BITMAP 0
458 #define UNDEF_FRINGE_BITMAP 1
459 #define MAX_STANDARD_FRINGE_BITMAPS (sizeof(standard_bitmaps)/sizeof(standard_bitmaps[0]))
461 static struct fringe_bitmap
**fringe_bitmaps
;
462 static Lisp_Object
*fringe_faces
;
463 static int max_fringe_bitmaps
;
465 int max_used_fringe_bitmap
= MAX_STANDARD_FRINGE_BITMAPS
;
468 /* Lookup bitmap number for symbol BITMAP.
469 Return 0 if not a bitmap. */
472 lookup_fringe_bitmap (Lisp_Object bitmap
)
476 bitmap
= Fget (bitmap
, Qfringe
);
477 if (!INTEGERP (bitmap
))
481 if (bn
> NO_FRINGE_BITMAP
482 && bn
< max_used_fringe_bitmap
483 && (bn
< MAX_STANDARD_FRINGE_BITMAPS
484 || fringe_bitmaps
[bn
] != NULL
))
490 /* Get fringe bitmap name for bitmap number BN.
492 Found by traversing Vfringe_bitmaps comparing BN to the
493 fringe property for each symbol.
495 Return BN if not found in Vfringe_bitmaps. */
498 get_fringe_bitmap_name (int bn
)
503 /* Zero means no bitmap -- return nil. */
507 bitmaps
= Vfringe_bitmaps
;
508 num
= make_number (bn
);
510 while (CONSP (bitmaps
))
512 Lisp_Object bitmap
= XCAR (bitmaps
);
513 if (EQ (num
, Fget (bitmap
, Qfringe
)))
515 bitmaps
= XCDR (bitmaps
);
522 /* Draw the bitmap WHICH in one of the left or right fringes of
523 window W. ROW is the glyph row for which to display the bitmap; it
524 determines the vertical position at which the bitmap has to be
526 LEFT_P is 1 for left fringe, 0 for right fringe.
530 draw_fringe_bitmap_1 (struct window
*w
, struct glyph_row
*row
, int left_p
, int overlay
, int which
)
532 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
533 struct draw_fringe_bitmap_params p
;
534 struct fringe_bitmap
*fb
;
536 int face_id
= DEFAULT_FACE_ID
;
537 int offset
, header_line_height
;
539 p
.overlay_p
= (overlay
& 1) == 1;
540 p
.cursor_p
= (overlay
& 2) == 2;
542 if (which
!= NO_FRINGE_BITMAP
)
548 which
= row
->left_fringe_bitmap
;
549 face_id
= row
->left_fringe_face_id
;
550 offset
= row
->left_fringe_offset
;
554 which
= row
->right_fringe_bitmap
;
555 face_id
= row
->right_fringe_face_id
;
556 offset
= row
->right_fringe_offset
;
559 if (face_id
== DEFAULT_FACE_ID
)
561 Lisp_Object face
= fringe_faces
[which
];
562 face_id
= NILP (face
) ? lookup_named_face (f
, Qfringe
, 0)
563 : lookup_derived_face (f
, face
, FRINGE_FACE_ID
, 0);
565 face_id
= FRINGE_FACE_ID
;
568 fb
= fringe_bitmaps
[which
];
570 fb
= &standard_bitmaps
[which
< MAX_STANDARD_FRINGE_BITMAPS
571 ? which
: UNDEF_FRINGE_BITMAP
];
575 /* Convert row to frame coordinates. */
576 p
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
) + offset
;
583 p
.dh
= (period
> 0 ? (p
.y
% period
) : 0);
586 /* Adjust y to the offset in the row to start drawing the bitmap. */
589 case ALIGN_BITMAP_CENTER
:
590 p
.y
+= (row
->height
- p
.h
) / 2;
592 case ALIGN_BITMAP_BOTTOM
:
593 p
.y
+= (row
->visible_height
- p
.h
);
595 case ALIGN_BITMAP_TOP
:
599 p
.face
= FACE_FROM_ID (f
, face_id
);
603 /* This could happen after clearing face cache.
604 But it shouldn't happen anymore. ++kfs */
608 PREPARE_FACE_FOR_DISPLAY (f
, p
.face
);
610 /* Clear left fringe if no bitmap to draw or if bitmap doesn't fill
613 header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
614 p
.by
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
, row
->y
));
615 p
.ny
= row
->visible_height
;
618 int wd
= WINDOW_LEFT_FRINGE_WIDTH (w
);
619 int x
= window_box_left (w
, (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
624 p
.x
= x
- p
.wd
- (wd
- p
.wd
) / 2;
626 if (p
.wd
< wd
|| p
.y
> p
.by
|| p
.y
+ p
.h
< p
.by
+ p
.ny
)
628 /* If W has a vertical border to its left, don't draw over it. */
629 wd
-= ((!WINDOW_LEFTMOST_P (w
)
630 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
638 int x
= window_box_right (w
,
639 (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
642 int wd
= WINDOW_RIGHT_FRINGE_WIDTH (w
);
645 p
.x
= x
+ (wd
- p
.wd
) / 2;
646 /* Clear right fringe if no bitmap to draw of if bitmap doesn't fill
648 if (p
.wd
< wd
|| p
.y
> p
.by
|| p
.y
+ p
.h
< p
.by
+ p
.ny
)
655 FRAME_RIF (f
)->draw_fringe_bitmap (w
, row
, &p
);
659 get_logical_cursor_bitmap (struct window
*w
, Lisp_Object cursor
)
661 Lisp_Object cmap
, bm
= Qnil
;
663 if ((cmap
= BVAR (XBUFFER (w
->buffer
), fringe_cursor_alist
)), !NILP (cmap
))
665 bm
= Fassq (cursor
, cmap
);
668 if ((bm
= XCDR (bm
)), NILP (bm
))
669 return NO_FRINGE_BITMAP
;
670 return lookup_fringe_bitmap (bm
);
673 if (EQ (cmap
, BVAR (&buffer_defaults
, fringe_cursor_alist
)))
674 return NO_FRINGE_BITMAP
;
675 bm
= Fassq (cursor
, BVAR (&buffer_defaults
, fringe_cursor_alist
));
676 if (!CONSP (bm
) || ((bm
= XCDR (bm
)), NILP (bm
)))
677 return NO_FRINGE_BITMAP
;
678 return lookup_fringe_bitmap (bm
);
682 get_logical_fringe_bitmap (struct window
*w
, Lisp_Object bitmap
, int right_p
, int partial_p
)
684 Lisp_Object cmap
, bm1
= Qnil
, bm2
= Qnil
, bm
;
685 int ln1
= 0, ln2
= 0;
687 int ix2
= ix1
+ (partial_p
? 2 : 0);
689 /* Lookup in buffer-local fringe-indicator-alist before global alist.
692 BITMAP -- use for all
693 (L R) -- use for left right (whether partial or not)
694 (L R PL PR) -- use for left right partial-left partial-right
695 If any value in local binding is not present or t, use global value.
697 If partial, lookup partial bitmap in default value if not found here.
698 If not partial, or no partial spec is present, use non-partial bitmap. */
700 if ((cmap
= BVAR (XBUFFER (w
->buffer
), fringe_indicator_alist
)), !NILP (cmap
))
702 bm1
= Fassq (bitmap
, cmap
);
705 if ((bm1
= XCDR (bm1
)), NILP (bm1
))
706 return NO_FRINGE_BITMAP
;
709 ln1
= XINT (Flength (bm1
));
714 bm
= Fnth (make_number (ix2
), bm1
);
723 bm
= Fnth (make_number (ix1
), bm1
);
729 else if ((bm
= bm1
, !EQ (bm
, Qt
)))
734 if (!EQ (cmap
, BVAR (&buffer_defaults
, fringe_indicator_alist
))
735 && !NILP (BVAR (&buffer_defaults
, fringe_indicator_alist
)))
737 bm2
= Fassq (bitmap
, BVAR (&buffer_defaults
, fringe_indicator_alist
));
740 if ((bm2
= XCDR (bm2
)), !NILP (bm2
))
744 ln2
= XINT (Flength (bm2
));
749 bm
= Fnth (make_number (ix2
), bm2
);
761 bm
= Fnth (make_number (ix1
), bm1
);
768 bm
= Fnth (make_number (ix1
), bm2
);
771 return NO_FRINGE_BITMAP
;
773 else if ((bm
= bm2
, NILP (bm
)))
774 return NO_FRINGE_BITMAP
;
777 return lookup_fringe_bitmap (bm
);
782 draw_fringe_bitmap (struct window
*w
, struct glyph_row
*row
, int left_p
)
786 if (left_p
== row
->reversed_p
&& row
->cursor_in_fringe_p
)
788 Lisp_Object cursor
= Qnil
;
790 switch (w
->phys_cursor_type
)
792 case HOLLOW_BOX_CURSOR
:
793 if (row
->visible_height
>= STANDARD_BITMAP_HEIGHT (hollow_rectangle_bits
))
796 cursor
= Qhollow_small
;
798 case FILLED_BOX_CURSOR
:
809 w
->phys_cursor_on_p
= 0;
810 row
->cursor_in_fringe_p
= 0;
815 int bm
= get_logical_cursor_bitmap (w
, cursor
);
816 if (bm
!= NO_FRINGE_BITMAP
)
818 draw_fringe_bitmap_1 (w
, row
, left_p
, 2, bm
);
819 overlay
= EQ (cursor
, Qbox
) ? 3 : 1;
824 draw_fringe_bitmap_1 (w
, row
, left_p
, overlay
, NO_FRINGE_BITMAP
);
826 if (left_p
&& row
->overlay_arrow_bitmap
!= NO_FRINGE_BITMAP
)
827 draw_fringe_bitmap_1 (w
, row
, 1, 1, row
->overlay_arrow_bitmap
);
831 /* Draw fringe bitmaps for glyph row ROW on window W. Call this
832 function with input blocked. */
835 draw_row_fringe_bitmaps (struct window
*w
, struct glyph_row
*row
)
837 xassert (interrupt_input_blocked
);
839 /* If row is completely invisible, because of vscrolling, we
840 don't have to draw anything. */
841 if (row
->visible_height
<= 0)
844 if (WINDOW_LEFT_FRINGE_WIDTH (w
) != 0)
845 draw_fringe_bitmap (w
, row
, 1);
847 if (WINDOW_RIGHT_FRINGE_WIDTH (w
) != 0)
848 draw_fringe_bitmap (w
, row
, 0);
851 /* Draw the fringes of window W. Only fringes for rows marked for
852 update in redraw_fringe_bitmaps_p are drawn.
854 Return >0 if left or right fringe was redrawn in any way.
856 If NO_FRINGE is non-zero, also return >0 if either fringe has zero width.
858 A return value >0 indicates that the vertical line between windows
859 needs update (as it may be drawn in the fringe).
863 draw_window_fringes (struct window
*w
, int no_fringe
)
865 struct glyph_row
*row
;
866 int yb
= window_text_bottom_y (w
);
867 int nrows
= w
->current_matrix
->nrows
;
871 if (w
->pseudo_window_p
)
874 /* Must draw line if no fringe */
876 && (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0
877 || WINDOW_RIGHT_FRINGE_WIDTH (w
) == 0))
880 for (y
= w
->vscroll
, rn
= 0, row
= w
->current_matrix
->rows
;
881 y
< yb
&& rn
< nrows
;
882 y
+= row
->height
, ++row
, ++rn
)
884 if (!row
->redraw_fringe_bitmaps_p
)
886 draw_row_fringe_bitmaps (w
, row
);
887 row
->redraw_fringe_bitmaps_p
= 0;
895 /* Recalculate the bitmaps to show in the fringes of window W.
896 Only mark rows with modified bitmaps for update in redraw_fringe_bitmaps_p.
898 If KEEP_CURRENT_P is 0, update current_matrix too. */
901 update_window_fringes (struct window
*w
, int keep_current_p
)
903 struct glyph_row
*row
, *cur
= 0;
904 int yb
= window_text_bottom_y (w
);
905 int rn
, nrows
= w
->current_matrix
->nrows
;
908 Lisp_Object boundary_top
= Qnil
, boundary_bot
= Qnil
;
909 Lisp_Object arrow_top
= Qnil
, arrow_bot
= Qnil
;
910 Lisp_Object empty_pos
;
911 Lisp_Object ind
= Qnil
;
912 #define MAX_BITMAP_CACHE (8*4)
913 int bitmap_cache
[MAX_BITMAP_CACHE
];
914 int top_ind_rn
, bot_ind_rn
;
915 int top_ind_min_y
, bot_ind_max_y
;
917 /* FIXME: Do these need to be initialized? If not, please change
918 their "= 0"s to "IF_LINT (= 0)"s. Either way, please explain. */
919 int top_row_ends_at_zv_p
= 0, bot_row_ends_at_zv_p
= 0;
921 if (w
->pseudo_window_p
)
924 if (!MINI_WINDOW_P (w
)
925 && (ind
= BVAR (XBUFFER (w
->buffer
), indicate_buffer_boundaries
), !NILP (ind
)))
927 if (EQ (ind
, Qleft
) || EQ (ind
, Qright
))
928 boundary_top
= boundary_bot
= arrow_top
= arrow_bot
= ind
;
929 else if (CONSP (ind
) && CONSP (XCAR (ind
)))
932 if (pos
= Fassq (Qt
, ind
), !NILP (pos
))
933 boundary_top
= boundary_bot
= arrow_top
= arrow_bot
= XCDR (pos
);
934 if (pos
= Fassq (Qtop
, ind
), !NILP (pos
))
935 boundary_top
= XCDR (pos
);
936 if (pos
= Fassq (Qbottom
, ind
), !NILP (pos
))
937 boundary_bot
= XCDR (pos
);
938 if (pos
= Fassq (Qup
, ind
), !NILP (pos
))
939 arrow_top
= XCDR (pos
);
940 if (pos
= Fassq (Qdown
, ind
), !NILP (pos
))
941 arrow_bot
= XCDR (pos
);
944 /* Anything else means boundary on left and no arrows. */
945 boundary_top
= boundary_bot
= Qleft
;
948 top_ind_rn
= bot_ind_rn
= -1;
951 for (y
= w
->vscroll
, rn
= 0;
952 y
< yb
&& rn
< nrows
;
953 y
+= row
->height
, ++rn
)
955 unsigned indicate_bob_p
, indicate_top_line_p
;
956 unsigned indicate_eob_p
, indicate_bottom_line_p
;
958 row
= w
->desired_matrix
->rows
+ rn
;
960 row
= w
->current_matrix
->rows
+ rn
;
962 indicate_bob_p
= row
->indicate_bob_p
;
963 indicate_top_line_p
= row
->indicate_top_line_p
;
964 indicate_eob_p
= row
->indicate_eob_p
;
965 indicate_bottom_line_p
= row
->indicate_bottom_line_p
;
967 row
->indicate_bob_p
= row
->indicate_top_line_p
= 0;
968 row
->indicate_eob_p
= row
->indicate_bottom_line_p
= 0;
970 if (!row
->mode_line_p
)
972 if (top_ind_rn
< 0 && row
->visible_height
> 0)
974 if (MATRIX_ROW_START_CHARPOS (row
) <= BUF_BEGV (XBUFFER (w
->buffer
))
975 && !MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (w
, row
))
976 row
->indicate_bob_p
= !NILP (boundary_top
);
978 row
->indicate_top_line_p
= !NILP (arrow_top
);
984 if (MATRIX_ROW_END_CHARPOS (row
) >= BUF_ZV (XBUFFER (w
->buffer
))
985 && !MATRIX_ROW_PARTIALLY_VISIBLE_AT_BOTTOM_P (w
, row
))
986 row
->indicate_eob_p
= !NILP (boundary_bot
), bot_ind_rn
= rn
;
987 else if (y
+ row
->height
>= yb
)
988 row
->indicate_bottom_line_p
= !NILP (arrow_bot
), bot_ind_rn
= rn
;
994 empty_pos
= BVAR (XBUFFER (w
->buffer
), indicate_empty_lines
);
995 if (!NILP (empty_pos
) && !EQ (empty_pos
, Qright
))
996 empty_pos
= WINDOW_LEFT_FRINGE_WIDTH (w
) == 0 ? Qright
: Qleft
;
998 for (y
= 0; y
< MAX_BITMAP_CACHE
; y
++)
999 bitmap_cache
[y
] = -1;
1001 #define LEFT_FRINGE(cache, which, partial_p) \
1002 (bitmap_cache[cache*4+partial_p] >= 0 \
1003 ? bitmap_cache[cache*4+partial_p] \
1004 : (bitmap_cache[cache*4+partial_p] = \
1005 get_logical_fringe_bitmap (w, which, 0, partial_p)))
1007 #define RIGHT_FRINGE(cache, which, partial_p) \
1008 (bitmap_cache[cache*4+2+partial_p] >= 0 \
1009 ? bitmap_cache[cache*4+2+partial_p] \
1010 : (bitmap_cache[cache*4+2+partial_p] = \
1011 get_logical_fringe_bitmap (w, which, 1, partial_p)))
1014 /* Extend top-aligned top indicator (or bottom-aligned bottom
1015 indicator) to adjacent rows if it doesn't fit in one row. */
1016 top_ind_min_y
= bot_ind_max_y
= -1;
1017 if (top_ind_rn
>= 0)
1019 int bn
= NO_FRINGE_BITMAP
;
1021 row
= w
->desired_matrix
->rows
+ top_ind_rn
;
1022 if (!row
->enabled_p
)
1023 row
= w
->current_matrix
->rows
+ top_ind_rn
;
1025 top_row_ends_at_zv_p
= row
->ends_at_zv_p
;
1026 if (row
->indicate_bob_p
)
1028 if (EQ (boundary_top
, Qleft
))
1029 bn
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qleft
))
1030 ? LEFT_FRINGE (1, Qtop_bottom
, row
->ends_at_zv_p
)
1031 : LEFT_FRINGE (2, Qtop
, 0));
1033 bn
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qright
))
1034 ? RIGHT_FRINGE (1, Qtop_bottom
, row
->ends_at_zv_p
)
1035 : RIGHT_FRINGE (2, Qtop
, 0));
1037 else if (row
->indicate_top_line_p
)
1039 if (EQ (arrow_top
, Qleft
))
1040 bn
= LEFT_FRINGE (6, Qup
, 0);
1042 bn
= RIGHT_FRINGE (6, Qup
, 0);
1045 if (bn
!= NO_FRINGE_BITMAP
)
1047 struct fringe_bitmap
*fb
;
1049 fb
= fringe_bitmaps
[bn
];
1051 fb
= &standard_bitmaps
[bn
< MAX_STANDARD_FRINGE_BITMAPS
1052 ? bn
: UNDEF_FRINGE_BITMAP
];
1053 if (fb
->align
== ALIGN_BITMAP_TOP
&& fb
->period
== 0)
1055 struct glyph_row
*row1
;
1058 top_ind_min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
1059 top_ind_max_y
= top_ind_min_y
+ fb
->height
;
1060 if (top_ind_max_y
> yb
)
1063 for (y
= row
->y
+ row
->height
, rn
= top_ind_rn
+ 1;
1064 y
< top_ind_max_y
&& rn
< nrows
;
1065 y
+= row1
->height
, rn
++)
1067 if (bot_ind_rn
>= 0 && rn
>= bot_ind_rn
)
1070 row1
= w
->desired_matrix
->rows
+ rn
;
1071 if (!row1
->enabled_p
)
1072 row1
= w
->current_matrix
->rows
+ rn
;
1074 row1
->indicate_bob_p
= row
->indicate_bob_p
;
1075 row1
->indicate_top_line_p
= row
->indicate_top_line_p
;
1080 if (bot_ind_rn
>= 0)
1082 int bn
= NO_FRINGE_BITMAP
;
1084 row
= w
->desired_matrix
->rows
+ bot_ind_rn
;
1085 if (!row
->enabled_p
)
1086 row
= w
->current_matrix
->rows
+ bot_ind_rn
;
1088 bot_row_ends_at_zv_p
= row
->ends_at_zv_p
;
1089 if (row
->indicate_eob_p
)
1091 if (EQ (boundary_bot
, Qleft
))
1092 bn
= LEFT_FRINGE (3, Qbottom
, row
->ends_at_zv_p
);
1094 bn
= RIGHT_FRINGE (3, Qbottom
, row
->ends_at_zv_p
);
1096 else if (row
->indicate_bottom_line_p
)
1098 if (EQ (arrow_bot
, Qleft
))
1099 bn
= LEFT_FRINGE (7, Qdown
, 0);
1101 bn
= RIGHT_FRINGE (7, Qdown
, 0);
1104 if (bn
!= NO_FRINGE_BITMAP
)
1106 struct fringe_bitmap
*fb
;
1108 fb
= fringe_bitmaps
[bn
];
1110 fb
= &standard_bitmaps
[bn
< MAX_STANDARD_FRINGE_BITMAPS
1111 ? bn
: UNDEF_FRINGE_BITMAP
];
1112 if (fb
->align
== ALIGN_BITMAP_BOTTOM
&& fb
->period
== 0)
1114 struct glyph_row
*row1
;
1117 bot_ind_max_y
= row
->y
+ row
->visible_height
;
1118 bot_ind_min_y
= bot_ind_max_y
- fb
->height
;
1119 if (bot_ind_min_y
< WINDOW_HEADER_LINE_HEIGHT (w
))
1120 bot_ind_min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
1122 for (y
= row
->y
, rn
= bot_ind_rn
- 1;
1123 y
>= bot_ind_min_y
&& rn
>= 0;
1124 y
-= row1
->height
, rn
--)
1126 if (top_ind_rn
>= 0 && rn
<= top_ind_rn
)
1129 row1
= w
->desired_matrix
->rows
+ rn
;
1130 if (!row1
->enabled_p
)
1131 row1
= w
->current_matrix
->rows
+ rn
;
1133 row1
->indicate_eob_p
= row
->indicate_eob_p
;
1134 row1
->indicate_bottom_line_p
= row
->indicate_bottom_line_p
;
1140 for (y
= w
->vscroll
, rn
= 0;
1141 y
< yb
&& rn
< nrows
;
1142 y
+= row
->height
, rn
++)
1145 unsigned left_face_id
, right_face_id
;
1146 int left_offset
, right_offset
;
1148 row
= w
->desired_matrix
->rows
+ rn
;
1149 cur
= w
->current_matrix
->rows
+ rn
;
1150 if (!row
->enabled_p
)
1153 left_face_id
= right_face_id
= DEFAULT_FACE_ID
;
1154 left_offset
= right_offset
= 0;
1156 /* Decide which bitmap to draw in the left fringe. */
1157 if (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0)
1158 left
= NO_FRINGE_BITMAP
;
1159 else if (row
->left_user_fringe_bitmap
!= NO_FRINGE_BITMAP
)
1161 left
= row
->left_user_fringe_bitmap
;
1162 left_face_id
= row
->left_user_fringe_face_id
;
1164 else if ((!row
->reversed_p
&& row
->truncated_on_left_p
)
1165 || (row
->reversed_p
&& row
->truncated_on_right_p
))
1166 left
= LEFT_FRINGE(0, Qtruncation
, 0);
1167 else if (row
->indicate_bob_p
&& EQ (boundary_top
, Qleft
))
1169 left
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qleft
))
1170 ? LEFT_FRINGE (1, Qtop_bottom
, top_row_ends_at_zv_p
)
1171 : LEFT_FRINGE (2, Qtop
, 0));
1172 if (top_ind_min_y
>= 0)
1173 left_offset
= top_ind_min_y
- row
->y
;
1175 else if (row
->indicate_eob_p
&& EQ (boundary_bot
, Qleft
))
1177 left
= LEFT_FRINGE (3, Qbottom
, bot_row_ends_at_zv_p
);
1178 if (bot_ind_max_y
>= 0)
1179 left_offset
= bot_ind_max_y
- (row
->y
+ row
->visible_height
);
1181 else if ((!row
->reversed_p
&& MATRIX_ROW_CONTINUATION_LINE_P (row
))
1182 || (row
->reversed_p
&& row
->continued_p
))
1183 left
= LEFT_FRINGE (4, Qcontinuation
, 0);
1184 else if (row
->indicate_empty_line_p
&& EQ (empty_pos
, Qleft
))
1185 left
= LEFT_FRINGE (5, Qempty_line
, 0);
1186 else if (row
->indicate_top_line_p
&& EQ (arrow_top
, Qleft
))
1188 left
= LEFT_FRINGE (6, Qup
, 0);
1189 if (top_ind_min_y
>= 0)
1190 left_offset
= top_ind_min_y
- row
->y
;
1192 else if (row
->indicate_bottom_line_p
&& EQ (arrow_bot
, Qleft
))
1194 left
= LEFT_FRINGE (7, Qdown
, 0);
1195 if (bot_ind_max_y
>= 0)
1196 left_offset
= bot_ind_max_y
- (row
->y
+ row
->visible_height
);
1199 left
= NO_FRINGE_BITMAP
;
1201 /* Decide which bitmap to draw in the right fringe. */
1202 if (WINDOW_RIGHT_FRINGE_WIDTH (w
) == 0)
1203 right
= NO_FRINGE_BITMAP
;
1204 else if (row
->right_user_fringe_bitmap
!= NO_FRINGE_BITMAP
)
1206 right
= row
->right_user_fringe_bitmap
;
1207 right_face_id
= row
->right_user_fringe_face_id
;
1209 else if ((!row
->reversed_p
&& row
->truncated_on_right_p
)
1210 || (row
->reversed_p
&& row
->truncated_on_left_p
))
1211 right
= RIGHT_FRINGE (0, Qtruncation
, 0);
1212 else if (row
->indicate_bob_p
&& EQ (boundary_top
, Qright
))
1214 right
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qright
))
1215 ? RIGHT_FRINGE (1, Qtop_bottom
, top_row_ends_at_zv_p
)
1216 : RIGHT_FRINGE (2, Qtop
, 0));
1217 if (top_ind_min_y
>= 0)
1218 right_offset
= top_ind_min_y
- row
->y
;
1220 else if (row
->indicate_eob_p
&& EQ (boundary_bot
, Qright
))
1222 right
= RIGHT_FRINGE (3, Qbottom
, bot_row_ends_at_zv_p
);
1223 if (bot_ind_max_y
>= 0)
1224 right_offset
= bot_ind_max_y
- (row
->y
+ row
->visible_height
);
1226 else if ((!row
->reversed_p
&& row
->continued_p
)
1227 || (row
->reversed_p
&& MATRIX_ROW_CONTINUATION_LINE_P (row
)))
1228 right
= RIGHT_FRINGE (4, Qcontinuation
, 0);
1229 else if (row
->indicate_top_line_p
&& EQ (arrow_top
, Qright
))
1231 right
= RIGHT_FRINGE (6, Qup
, 0);
1232 if (top_ind_min_y
>= 0)
1233 right_offset
= top_ind_min_y
- row
->y
;
1235 else if (row
->indicate_bottom_line_p
&& EQ (arrow_bot
, Qright
))
1237 right
= RIGHT_FRINGE (7, Qdown
, 0);
1238 if (bot_ind_max_y
>= 0)
1239 right_offset
= bot_ind_max_y
- (row
->y
+ row
->visible_height
);
1241 else if (row
->indicate_empty_line_p
&& EQ (empty_pos
, Qright
))
1242 right
= RIGHT_FRINGE (5, Qempty_line
, 0);
1244 right
= NO_FRINGE_BITMAP
;
1246 if (row
->y
!= cur
->y
1247 || row
->visible_height
!= cur
->visible_height
1248 || row
->ends_at_zv_p
!= cur
->ends_at_zv_p
1249 || left
!= cur
->left_fringe_bitmap
1250 || right
!= cur
->right_fringe_bitmap
1251 || left_face_id
!= cur
->left_fringe_face_id
1252 || right_face_id
!= cur
->right_fringe_face_id
1253 || left_offset
!= cur
->left_fringe_offset
1254 || right_offset
!= cur
->right_fringe_offset
1255 || cur
->redraw_fringe_bitmaps_p
)
1257 redraw_p
= row
->redraw_fringe_bitmaps_p
= 1;
1258 if (!keep_current_p
)
1260 cur
->redraw_fringe_bitmaps_p
= 1;
1261 cur
->left_fringe_bitmap
= left
;
1262 cur
->right_fringe_bitmap
= right
;
1263 cur
->left_fringe_face_id
= left_face_id
;
1264 cur
->right_fringe_face_id
= right_face_id
;
1265 cur
->left_fringe_offset
= left_offset
;
1266 cur
->right_fringe_offset
= right_offset
;
1270 if (row
->overlay_arrow_bitmap
< 0)
1271 row
->overlay_arrow_bitmap
= get_logical_fringe_bitmap (w
, Qoverlay_arrow
, 0, 0);
1273 if (row
->overlay_arrow_bitmap
!= cur
->overlay_arrow_bitmap
)
1275 redraw_p
= row
->redraw_fringe_bitmaps_p
= cur
->redraw_fringe_bitmaps_p
= 1;
1276 cur
->overlay_arrow_bitmap
= row
->overlay_arrow_bitmap
;
1279 row
->left_fringe_bitmap
= left
;
1280 row
->right_fringe_bitmap
= right
;
1281 row
->left_fringe_face_id
= left_face_id
;
1282 row
->right_fringe_face_id
= right_face_id
;
1283 row
->left_fringe_offset
= left_offset
;
1284 row
->right_fringe_offset
= right_offset
;
1287 return redraw_p
&& !keep_current_p
;
1291 /* Compute actual fringe widths for frame F.
1293 If REDRAW is 1, redraw F if the fringe settings was actually
1294 modified and F is visible.
1296 Since the combined left and right fringe must occupy an integral
1297 number of columns, we may need to add some pixels to each fringe.
1298 Typically, we add an equal amount (+/- 1 pixel) to each fringe,
1299 but a negative width value is taken literally (after negating it).
1301 We never make the fringes narrower than specified.
1305 compute_fringe_widths (struct frame
*f
, int redraw
)
1307 int o_left
= FRAME_LEFT_FRINGE_WIDTH (f
);
1308 int o_right
= FRAME_RIGHT_FRINGE_WIDTH (f
);
1309 int o_cols
= FRAME_FRINGE_COLS (f
);
1311 Lisp_Object left_fringe
= Fassq (Qleft_fringe
, f
->param_alist
);
1312 Lisp_Object right_fringe
= Fassq (Qright_fringe
, f
->param_alist
);
1313 int left_fringe_width
, right_fringe_width
;
1315 if (!NILP (left_fringe
))
1316 left_fringe
= Fcdr (left_fringe
);
1317 if (!NILP (right_fringe
))
1318 right_fringe
= Fcdr (right_fringe
);
1320 left_fringe_width
= ((NILP (left_fringe
) || !INTEGERP (left_fringe
)) ? 8 :
1321 XINT (left_fringe
));
1322 right_fringe_width
= ((NILP (right_fringe
) || !INTEGERP (right_fringe
)) ? 8 :
1323 XINT (right_fringe
));
1325 if (left_fringe_width
|| right_fringe_width
)
1327 int left_wid
= left_fringe_width
>= 0 ? left_fringe_width
: -left_fringe_width
;
1328 int right_wid
= right_fringe_width
>= 0 ? right_fringe_width
: -right_fringe_width
;
1329 int conf_wid
= left_wid
+ right_wid
;
1330 int font_wid
= FRAME_COLUMN_WIDTH (f
);
1331 int cols
= (left_wid
+ right_wid
+ font_wid
-1) / font_wid
;
1332 int real_wid
= cols
* font_wid
;
1333 if (left_wid
&& right_wid
)
1335 if (left_fringe_width
< 0)
1337 /* Left fringe width is fixed, adjust right fringe if necessary */
1338 FRAME_LEFT_FRINGE_WIDTH (f
) = left_wid
;
1339 FRAME_RIGHT_FRINGE_WIDTH (f
) = real_wid
- left_wid
;
1341 else if (right_fringe_width
< 0)
1343 /* Right fringe width is fixed, adjust left fringe if necessary */
1344 FRAME_LEFT_FRINGE_WIDTH (f
) = real_wid
- right_wid
;
1345 FRAME_RIGHT_FRINGE_WIDTH (f
) = right_wid
;
1349 /* Adjust both fringes with an equal amount.
1350 Note that we are doing integer arithmetic here, so don't
1351 lose a pixel if the total width is an odd number. */
1352 int fill
= real_wid
- conf_wid
;
1353 FRAME_LEFT_FRINGE_WIDTH (f
) = left_wid
+ fill
/2;
1354 FRAME_RIGHT_FRINGE_WIDTH (f
) = right_wid
+ fill
- fill
/2;
1357 else if (left_fringe_width
)
1359 FRAME_LEFT_FRINGE_WIDTH (f
) = real_wid
;
1360 FRAME_RIGHT_FRINGE_WIDTH (f
) = 0;
1364 FRAME_LEFT_FRINGE_WIDTH (f
) = 0;
1365 FRAME_RIGHT_FRINGE_WIDTH (f
) = real_wid
;
1367 FRAME_FRINGE_COLS (f
) = cols
;
1371 FRAME_LEFT_FRINGE_WIDTH (f
) = 0;
1372 FRAME_RIGHT_FRINGE_WIDTH (f
) = 0;
1373 FRAME_FRINGE_COLS (f
) = 0;
1376 if (redraw
&& FRAME_VISIBLE_P (f
))
1377 if (o_left
!= FRAME_LEFT_FRINGE_WIDTH (f
) ||
1378 o_right
!= FRAME_RIGHT_FRINGE_WIDTH (f
) ||
1379 o_cols
!= FRAME_FRINGE_COLS (f
))
1384 /* Free resources used by a user-defined bitmap. */
1387 destroy_fringe_bitmap (int n
)
1389 struct fringe_bitmap
**fbp
;
1391 fringe_faces
[n
] = Qnil
;
1393 fbp
= &fringe_bitmaps
[n
];
1394 if (*fbp
&& (*fbp
)->dynamic
)
1396 /* XXX Is SELECTED_FRAME OK here? */
1397 struct redisplay_interface
*rif
= FRAME_RIF (SELECTED_FRAME ());
1398 if (rif
&& rif
->destroy_fringe_bitmap
)
1399 rif
->destroy_fringe_bitmap (n
);
1404 while (max_used_fringe_bitmap
> MAX_STANDARD_FRINGE_BITMAPS
1405 && fringe_bitmaps
[max_used_fringe_bitmap
- 1] == NULL
)
1406 max_used_fringe_bitmap
--;
1410 DEFUN ("destroy-fringe-bitmap", Fdestroy_fringe_bitmap
, Sdestroy_fringe_bitmap
,
1412 doc
: /* Destroy fringe bitmap BITMAP.
1413 If BITMAP overrides a standard fringe bitmap, the original bitmap is restored. */)
1414 (Lisp_Object bitmap
)
1418 CHECK_SYMBOL (bitmap
);
1419 n
= lookup_fringe_bitmap (bitmap
);
1423 destroy_fringe_bitmap (n
);
1425 if (n
>= MAX_STANDARD_FRINGE_BITMAPS
)
1427 Vfringe_bitmaps
= Fdelq (bitmap
, Vfringe_bitmaps
);
1428 /* It would be better to remove the fringe property. */
1429 Fput (bitmap
, Qfringe
, Qnil
);
1436 /* Initialize bitmap bit.
1438 On X, we bit-swap the built-in bitmaps and reduce bitmap
1439 from short to char array if width is <= 8 bits.
1441 On MAC with big-endian CPU, we need to byte-swap each short.
1443 On W32 and MAC (little endian), there's no need to do this.
1446 #if defined (HAVE_X_WINDOWS)
1447 static const unsigned char swap_nibble
[16] = {
1448 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
1449 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
1450 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
1451 0x3, 0xb, 0x7, 0xf}; /* 0011 1011 0111 1111 */
1452 #endif /* HAVE_X_WINDOWS */
1455 init_fringe_bitmap (int which
, struct fringe_bitmap
*fb
, int once_p
)
1457 if (once_p
|| fb
->dynamic
)
1459 #if defined (HAVE_X_WINDOWS)
1460 unsigned short *bits
= fb
->bits
;
1465 unsigned char *cbits
= (unsigned char *)fb
->bits
;
1466 for (j
= 0; j
< fb
->height
; j
++)
1468 unsigned short b
= *bits
++;
1470 c
= (unsigned char)((swap_nibble
[b
& 0xf] << 4)
1471 | (swap_nibble
[(b
>>4) & 0xf]));
1472 *cbits
++ = (c
>> (8 - fb
->width
));
1477 for (j
= 0; j
< fb
->height
; j
++)
1479 unsigned short b
= *bits
;
1480 b
= (unsigned short)((swap_nibble
[b
& 0xf] << 12)
1481 | (swap_nibble
[(b
>>4) & 0xf] << 8)
1482 | (swap_nibble
[(b
>>8) & 0xf] << 4)
1483 | (swap_nibble
[(b
>>12) & 0xf]));
1484 b
>>= (16 - fb
->width
);
1485 #ifdef WORDS_BIGENDIAN
1486 b
= ((b
>> 8) | (b
<< 8));
1491 #endif /* HAVE_X_WINDOWS */
1497 /* XXX Is SELECTED_FRAME OK here? */
1498 struct redisplay_interface
*rif
= FRAME_RIF (SELECTED_FRAME ());
1500 destroy_fringe_bitmap (which
);
1502 if (rif
&& rif
->define_fringe_bitmap
)
1503 rif
->define_fringe_bitmap (which
, fb
->bits
, fb
->height
, fb
->width
);
1505 fringe_bitmaps
[which
] = fb
;
1506 if (which
>= max_used_fringe_bitmap
)
1507 max_used_fringe_bitmap
= which
+ 1;
1512 DEFUN ("define-fringe-bitmap", Fdefine_fringe_bitmap
, Sdefine_fringe_bitmap
,
1514 doc
: /* Define fringe bitmap BITMAP from BITS of size HEIGHT x WIDTH.
1515 BITMAP is a symbol identifying the new fringe bitmap.
1516 BITS is either a string or a vector of integers.
1517 HEIGHT is height of bitmap. If HEIGHT is nil, use length of BITS.
1518 WIDTH must be an integer between 1 and 16, or nil which defaults to 8.
1519 Optional fifth arg ALIGN may be one of `top', `center', or `bottom',
1520 indicating the positioning of the bitmap relative to the rows where it
1521 is used; the default is to center the bitmap. Fifth arg may also be a
1522 list (ALIGN PERIODIC) where PERIODIC non-nil specifies that the bitmap
1524 If BITMAP already exists, the existing definition is replaced. */)
1525 (Lisp_Object bitmap
, Lisp_Object bits
, Lisp_Object height
, Lisp_Object width
, Lisp_Object align
)
1529 struct fringe_bitmap fb
, *xfb
;
1530 int fill1
= 0, fill2
= 0;
1532 CHECK_SYMBOL (bitmap
);
1536 else if (VECTORP (bits
))
1537 h
= XVECTOR (bits
)->size
;
1539 wrong_type_argument (Qsequencep
, bits
);
1545 CHECK_NUMBER (height
);
1546 fb
.height
= min (XINT (height
), 255);
1549 fill1
= (fb
.height
- h
) / 2;
1550 fill2
= fb
.height
- h
- fill1
;
1558 CHECK_NUMBER (width
);
1559 fb
.width
= min (XINT (width
), 255);
1563 fb
.align
= ALIGN_BITMAP_CENTER
;
1567 Lisp_Object period
= XCDR (align
);
1570 period
= XCAR (period
);
1573 fb
.period
= fb
.height
;
1577 align
= XCAR (align
);
1579 if (EQ (align
, Qtop
))
1580 fb
.align
= ALIGN_BITMAP_TOP
;
1581 else if (EQ (align
, Qbottom
))
1582 fb
.align
= ALIGN_BITMAP_BOTTOM
;
1583 else if (!NILP (align
) && !EQ (align
, Qcenter
))
1584 error ("Bad align argument");
1586 n
= lookup_fringe_bitmap (bitmap
);
1589 if (max_used_fringe_bitmap
< max_fringe_bitmaps
)
1590 n
= max_used_fringe_bitmap
++;
1593 for (n
= MAX_STANDARD_FRINGE_BITMAPS
;
1594 n
< max_fringe_bitmaps
;
1596 if (fringe_bitmaps
[n
] == NULL
)
1599 if (n
== max_fringe_bitmaps
)
1601 if ((max_fringe_bitmaps
+ 20) > MAX_FRINGE_BITMAPS
)
1602 error ("No free fringe bitmap slots");
1604 i
= max_fringe_bitmaps
;
1605 max_fringe_bitmaps
+= 20;
1607 = ((struct fringe_bitmap
**)
1608 xrealloc (fringe_bitmaps
, max_fringe_bitmaps
* sizeof (struct fringe_bitmap
*)));
1610 = (Lisp_Object
*) xrealloc (fringe_faces
, max_fringe_bitmaps
* sizeof (Lisp_Object
));
1612 for (; i
< max_fringe_bitmaps
; i
++)
1614 fringe_bitmaps
[i
] = NULL
;
1615 fringe_faces
[i
] = Qnil
;
1620 Vfringe_bitmaps
= Fcons (bitmap
, Vfringe_bitmaps
);
1621 Fput (bitmap
, Qfringe
, make_number (n
));
1626 xfb
= (struct fringe_bitmap
*) xmalloc (sizeof fb
1627 + fb
.height
* BYTES_PER_BITMAP_ROW
);
1628 fb
.bits
= b
= (unsigned short *) (xfb
+ 1);
1629 memset (b
, 0, fb
.height
);
1632 while (j
< fb
.height
)
1634 for (i
= 0; i
< fill1
&& j
< fb
.height
; i
++)
1636 for (i
= 0; i
< h
&& j
< fb
.height
; i
++)
1638 Lisp_Object elt
= Faref (bits
, make_number (i
));
1639 b
[j
++] = NUMBERP (elt
) ? XINT (elt
) : 0;
1641 for (i
= 0; i
< fill2
&& j
< fb
.height
; i
++)
1647 init_fringe_bitmap (n
, xfb
, 0);
1652 DEFUN ("set-fringe-bitmap-face", Fset_fringe_bitmap_face
, Sset_fringe_bitmap_face
,
1654 doc
: /* Set face for fringe bitmap BITMAP to FACE.
1655 If FACE is nil, reset face to default fringe face. */)
1656 (Lisp_Object bitmap
, Lisp_Object face
)
1661 CHECK_SYMBOL (bitmap
);
1662 n
= lookup_fringe_bitmap (bitmap
);
1664 error ("Undefined fringe bitmap");
1668 face_id
= lookup_derived_face (SELECTED_FRAME (), face
,
1671 error ("No such face");
1674 fringe_faces
[n
] = face
;
1679 DEFUN ("fringe-bitmaps-at-pos", Ffringe_bitmaps_at_pos
, Sfringe_bitmaps_at_pos
,
1681 doc
: /* Return fringe bitmaps of row containing position POS in window WINDOW.
1682 If WINDOW is nil, use selected window. If POS is nil, use value of point
1683 in that window. Return value is a list (LEFT RIGHT OV), where LEFT
1684 is the symbol for the bitmap in the left fringe (or nil if no bitmap),
1685 RIGHT is similar for the right fringe, and OV is non-nil if there is an
1686 overlay arrow in the left fringe.
1687 Return nil if POS is not visible in WINDOW. */)
1688 (Lisp_Object pos
, Lisp_Object window
)
1691 struct glyph_row
*row
;
1695 window
= selected_window
;
1696 CHECK_WINDOW (window
);
1697 w
= XWINDOW (window
);
1701 CHECK_NUMBER_COERCE_MARKER (pos
);
1702 textpos
= XINT (pos
);
1704 else if (w
== XWINDOW (selected_window
))
1707 textpos
= XMARKER (w
->pointm
)->charpos
;
1709 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1710 row
= row_containing_pos (w
, textpos
, row
, NULL
, 0);
1712 return list3 (get_fringe_bitmap_name (row
->left_fringe_bitmap
),
1713 get_fringe_bitmap_name (row
->right_fringe_bitmap
),
1714 (row
->overlay_arrow_bitmap
== 0 ? Qnil
1715 : row
->overlay_arrow_bitmap
< 0 ? Qt
1716 : get_fringe_bitmap_name (row
->overlay_arrow_bitmap
)));
1722 /***********************************************************************
1724 ***********************************************************************/
1727 syms_of_fringe (void)
1729 Qtruncation
= intern_c_string ("truncation");
1730 staticpro (&Qtruncation
);
1731 Qcontinuation
= intern_c_string ("continuation");
1732 staticpro (&Qcontinuation
);
1733 Qoverlay_arrow
= intern_c_string ("overlay-arrow");
1734 staticpro (&Qoverlay_arrow
);
1735 Qempty_line
= intern_c_string ("empty-line");
1736 staticpro (&Qempty_line
);
1737 Qtop_bottom
= intern_c_string ("top-bottom");
1738 staticpro (&Qtop_bottom
);
1739 Qhollow_small
= intern_c_string ("hollow-small");
1740 staticpro (&Qhollow_small
);
1742 defsubr (&Sdestroy_fringe_bitmap
);
1743 defsubr (&Sdefine_fringe_bitmap
);
1744 defsubr (&Sfringe_bitmaps_at_pos
);
1745 defsubr (&Sset_fringe_bitmap_face
);
1747 DEFVAR_LISP ("overflow-newline-into-fringe", Voverflow_newline_into_fringe
,
1748 doc
: /* *Non-nil means that newline may flow into the right fringe.
1749 This means that display lines which are exactly as wide as the window
1750 (not counting the final newline) will only occupy one screen line, by
1751 showing (or hiding) the final newline in the right fringe; when point
1752 is at the final newline, the cursor is shown in the right fringe.
1753 If nil, also continue lines which are exactly as wide as the window. */);
1754 Voverflow_newline_into_fringe
= Qt
;
1756 DEFVAR_LISP ("fringe-bitmaps", Vfringe_bitmaps
,
1757 doc
: /* List of fringe bitmap symbols. */);
1758 Vfringe_bitmaps
= Qnil
;
1761 /* Garbage collection hook */
1764 mark_fringe_data (void)
1768 for (i
= 0; i
< max_fringe_bitmaps
; i
++)
1769 if (!NILP (fringe_faces
[i
]))
1770 mark_object (fringe_faces
[i
]);
1773 /* Initialize this module when Emacs starts. */
1776 init_fringe_once (void)
1780 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< MAX_STANDARD_FRINGE_BITMAPS
; bt
++)
1781 init_fringe_bitmap(bt
, &standard_bitmaps
[bt
], 1);
1789 max_fringe_bitmaps
= MAX_STANDARD_FRINGE_BITMAPS
+ 20;
1792 = (struct fringe_bitmap
**) xmalloc (max_fringe_bitmaps
* sizeof (struct fringe_bitmap
*));
1794 = (Lisp_Object
*) xmalloc (max_fringe_bitmaps
* sizeof (Lisp_Object
));
1796 for (i
= 0; i
< max_fringe_bitmaps
; i
++)
1798 fringe_bitmaps
[i
] = NULL
;
1799 fringe_faces
[i
] = Qnil
;
1806 w32_init_fringe (struct redisplay_interface
*rif
)
1813 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< MAX_STANDARD_FRINGE_BITMAPS
; bt
++)
1815 struct fringe_bitmap
*fb
= &standard_bitmaps
[bt
];
1816 rif
->define_fringe_bitmap (bt
, fb
->bits
, fb
->height
, fb
->width
);
1821 w32_reset_fringes (void)
1823 /* Destroy row bitmaps. */
1825 struct redisplay_interface
*rif
= FRAME_RIF (SELECTED_FRAME ());
1830 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< max_used_fringe_bitmap
; bt
++)
1831 rif
->destroy_fringe_bitmap (bt
);
1834 #endif /* HAVE_NTGUI */
1836 #endif /* HAVE_WINDOW_SYSTEM */