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 static Lisp_Object Qtruncation
, Qcontinuation
, Qoverlay_arrow
;
68 static Lisp_Object Qempty_line
, Qtop_bottom
;
69 static 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 static 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
;
468 int max_used_fringe_bitmap
= MAX_STANDARD_FRINGE_BITMAPS
;
471 /* Lookup bitmap number for symbol BITMAP.
472 Return 0 if not a bitmap. */
475 lookup_fringe_bitmap (Lisp_Object bitmap
)
479 bitmap
= Fget (bitmap
, Qfringe
);
480 if (!INTEGERP (bitmap
))
484 if (bn
> NO_FRINGE_BITMAP
485 && bn
< max_used_fringe_bitmap
486 && (bn
< MAX_STANDARD_FRINGE_BITMAPS
487 || fringe_bitmaps
[bn
] != NULL
))
493 /* Get fringe bitmap name for bitmap number BN.
495 Found by traversing Vfringe_bitmaps comparing BN to the
496 fringe property for each symbol.
498 Return BN if not found in Vfringe_bitmaps. */
501 get_fringe_bitmap_name (int bn
)
506 /* Zero means no bitmap -- return nil. */
510 bitmaps
= Vfringe_bitmaps
;
511 num
= make_number (bn
);
513 while (CONSP (bitmaps
))
515 Lisp_Object bitmap
= XCAR (bitmaps
);
516 if (EQ (num
, Fget (bitmap
, Qfringe
)))
518 bitmaps
= XCDR (bitmaps
);
525 /* Draw the bitmap WHICH in one of the left or right fringes of
526 window W. ROW is the glyph row for which to display the bitmap; it
527 determines the vertical position at which the bitmap has to be
529 LEFT_P is 1 for left fringe, 0 for right fringe.
533 draw_fringe_bitmap_1 (struct window
*w
, struct glyph_row
*row
, int left_p
, int overlay
, int which
)
535 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
536 struct draw_fringe_bitmap_params p
;
537 struct fringe_bitmap
*fb
;
539 int face_id
= DEFAULT_FACE_ID
;
540 int offset
, header_line_height
;
542 p
.overlay_p
= (overlay
& 1) == 1;
543 p
.cursor_p
= (overlay
& 2) == 2;
545 if (which
!= NO_FRINGE_BITMAP
)
551 which
= row
->left_fringe_bitmap
;
552 face_id
= row
->left_fringe_face_id
;
553 offset
= row
->left_fringe_offset
;
557 which
= row
->right_fringe_bitmap
;
558 face_id
= row
->right_fringe_face_id
;
559 offset
= row
->right_fringe_offset
;
562 if (face_id
== DEFAULT_FACE_ID
)
564 Lisp_Object face
= fringe_faces
[which
];
565 face_id
= NILP (face
) ? lookup_named_face (f
, Qfringe
, 0)
566 : lookup_derived_face (f
, face
, FRINGE_FACE_ID
, 0);
568 face_id
= FRINGE_FACE_ID
;
571 fb
= fringe_bitmaps
[which
];
573 fb
= &standard_bitmaps
[which
< MAX_STANDARD_FRINGE_BITMAPS
574 ? which
: UNDEF_FRINGE_BITMAP
];
578 /* Convert row to frame coordinates. */
579 p
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
) + offset
;
586 p
.dh
= (period
> 0 ? (p
.y
% period
) : 0);
589 /* Adjust y to the offset in the row to start drawing the bitmap. */
592 case ALIGN_BITMAP_CENTER
:
593 p
.y
+= (row
->height
- p
.h
) / 2;
595 case ALIGN_BITMAP_BOTTOM
:
596 p
.y
+= (row
->visible_height
- p
.h
);
598 case ALIGN_BITMAP_TOP
:
602 p
.face
= FACE_FROM_ID (f
, face_id
);
606 /* This could happen after clearing face cache.
607 But it shouldn't happen anymore. ++kfs */
611 PREPARE_FACE_FOR_DISPLAY (f
, p
.face
);
613 /* Clear left fringe if no bitmap to draw or if bitmap doesn't fill
616 header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
617 p
.by
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
, row
->y
));
618 p
.ny
= row
->visible_height
;
621 int wd
= WINDOW_LEFT_FRINGE_WIDTH (w
);
622 int x
= window_box_left (w
, (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
627 p
.x
= x
- p
.wd
- (wd
- p
.wd
) / 2;
629 if (p
.wd
< wd
|| p
.y
> p
.by
|| p
.y
+ p
.h
< p
.by
+ p
.ny
)
631 /* If W has a vertical border to its left, don't draw over it. */
632 wd
-= ((!WINDOW_LEFTMOST_P (w
)
633 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
641 int x
= window_box_right (w
,
642 (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
645 int wd
= WINDOW_RIGHT_FRINGE_WIDTH (w
);
648 p
.x
= x
+ (wd
- p
.wd
) / 2;
649 /* Clear right fringe if no bitmap to draw of if bitmap doesn't fill
651 if (p
.wd
< wd
|| p
.y
> p
.by
|| p
.y
+ p
.h
< p
.by
+ p
.ny
)
658 FRAME_RIF (f
)->draw_fringe_bitmap (w
, row
, &p
);
662 get_logical_cursor_bitmap (struct window
*w
, Lisp_Object cursor
)
664 Lisp_Object cmap
, bm
= Qnil
;
666 if ((cmap
= BVAR (XBUFFER (w
->buffer
), fringe_cursor_alist
)), !NILP (cmap
))
668 bm
= Fassq (cursor
, cmap
);
671 if ((bm
= XCDR (bm
)), NILP (bm
))
672 return NO_FRINGE_BITMAP
;
673 return lookup_fringe_bitmap (bm
);
676 if (EQ (cmap
, BVAR (&buffer_defaults
, fringe_cursor_alist
)))
677 return NO_FRINGE_BITMAP
;
678 bm
= Fassq (cursor
, BVAR (&buffer_defaults
, fringe_cursor_alist
));
679 if (!CONSP (bm
) || ((bm
= XCDR (bm
)), NILP (bm
)))
680 return NO_FRINGE_BITMAP
;
681 return lookup_fringe_bitmap (bm
);
685 get_logical_fringe_bitmap (struct window
*w
, Lisp_Object bitmap
, int right_p
, int partial_p
)
687 Lisp_Object cmap
, bm1
= Qnil
, bm2
= Qnil
, bm
;
688 int ln1
= 0, ln2
= 0;
690 int ix2
= ix1
+ (partial_p
? 2 : 0);
692 /* Lookup in buffer-local fringe-indicator-alist before global alist.
695 BITMAP -- use for all
696 (L R) -- use for left right (whether partial or not)
697 (L R PL PR) -- use for left right partial-left partial-right
698 If any value in local binding is not present or t, use global value.
700 If partial, lookup partial bitmap in default value if not found here.
701 If not partial, or no partial spec is present, use non-partial bitmap. */
703 if ((cmap
= BVAR (XBUFFER (w
->buffer
), fringe_indicator_alist
)), !NILP (cmap
))
705 bm1
= Fassq (bitmap
, cmap
);
708 if ((bm1
= XCDR (bm1
)), NILP (bm1
))
709 return NO_FRINGE_BITMAP
;
712 ln1
= XINT (Flength (bm1
));
717 bm
= Fnth (make_number (ix2
), bm1
);
726 bm
= Fnth (make_number (ix1
), bm1
);
732 else if ((bm
= bm1
, !EQ (bm
, Qt
)))
737 if (!EQ (cmap
, BVAR (&buffer_defaults
, fringe_indicator_alist
))
738 && !NILP (BVAR (&buffer_defaults
, fringe_indicator_alist
)))
740 bm2
= Fassq (bitmap
, BVAR (&buffer_defaults
, fringe_indicator_alist
));
743 if ((bm2
= XCDR (bm2
)), !NILP (bm2
))
747 ln2
= XINT (Flength (bm2
));
752 bm
= Fnth (make_number (ix2
), bm2
);
764 bm
= Fnth (make_number (ix1
), bm1
);
771 bm
= Fnth (make_number (ix1
), bm2
);
774 return NO_FRINGE_BITMAP
;
776 else if ((bm
= bm2
, NILP (bm
)))
777 return NO_FRINGE_BITMAP
;
780 return lookup_fringe_bitmap (bm
);
785 draw_fringe_bitmap (struct window
*w
, struct glyph_row
*row
, int left_p
)
789 if (left_p
== row
->reversed_p
&& row
->cursor_in_fringe_p
)
791 Lisp_Object cursor
= Qnil
;
793 switch (w
->phys_cursor_type
)
795 case HOLLOW_BOX_CURSOR
:
796 if (row
->visible_height
>= STANDARD_BITMAP_HEIGHT (hollow_rectangle_bits
))
799 cursor
= Qhollow_small
;
801 case FILLED_BOX_CURSOR
:
812 w
->phys_cursor_on_p
= 0;
813 row
->cursor_in_fringe_p
= 0;
818 int bm
= get_logical_cursor_bitmap (w
, cursor
);
819 if (bm
!= NO_FRINGE_BITMAP
)
821 draw_fringe_bitmap_1 (w
, row
, left_p
, 2, bm
);
822 overlay
= EQ (cursor
, Qbox
) ? 3 : 1;
827 draw_fringe_bitmap_1 (w
, row
, left_p
, overlay
, NO_FRINGE_BITMAP
);
829 if (left_p
&& row
->overlay_arrow_bitmap
!= NO_FRINGE_BITMAP
)
830 draw_fringe_bitmap_1 (w
, row
, 1, 1, row
->overlay_arrow_bitmap
);
834 /* Draw fringe bitmaps for glyph row ROW on window W. Call this
835 function with input blocked. */
838 draw_row_fringe_bitmaps (struct window
*w
, struct glyph_row
*row
)
840 xassert (interrupt_input_blocked
);
842 /* If row is completely invisible, because of vscrolling, we
843 don't have to draw anything. */
844 if (row
->visible_height
<= 0)
847 if (WINDOW_LEFT_FRINGE_WIDTH (w
) != 0)
848 draw_fringe_bitmap (w
, row
, 1);
850 if (WINDOW_RIGHT_FRINGE_WIDTH (w
) != 0)
851 draw_fringe_bitmap (w
, row
, 0);
854 /* Draw the fringes of window W. Only fringes for rows marked for
855 update in redraw_fringe_bitmaps_p are drawn.
857 Return >0 if left or right fringe was redrawn in any way.
859 If NO_FRINGE is non-zero, also return >0 if either fringe has zero width.
861 A return value >0 indicates that the vertical line between windows
862 needs update (as it may be drawn in the fringe).
866 draw_window_fringes (struct window
*w
, int no_fringe
)
868 struct glyph_row
*row
;
869 int yb
= window_text_bottom_y (w
);
870 int nrows
= w
->current_matrix
->nrows
;
874 if (w
->pseudo_window_p
)
877 /* Must draw line if no fringe */
879 && (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0
880 || WINDOW_RIGHT_FRINGE_WIDTH (w
) == 0))
883 for (y
= w
->vscroll
, rn
= 0, row
= w
->current_matrix
->rows
;
884 y
< yb
&& rn
< nrows
;
885 y
+= row
->height
, ++row
, ++rn
)
887 if (!row
->redraw_fringe_bitmaps_p
)
889 draw_row_fringe_bitmaps (w
, row
);
890 row
->redraw_fringe_bitmaps_p
= 0;
898 /* Recalculate the bitmaps to show in the fringes of window W.
899 Only mark rows with modified bitmaps for update in redraw_fringe_bitmaps_p.
901 If KEEP_CURRENT_P is 0, update current_matrix too. */
904 update_window_fringes (struct window
*w
, int keep_current_p
)
906 struct glyph_row
*row
, *cur
= 0;
907 int yb
= window_text_bottom_y (w
);
908 int rn
, nrows
= w
->current_matrix
->nrows
;
911 Lisp_Object boundary_top
= Qnil
, boundary_bot
= Qnil
;
912 Lisp_Object arrow_top
= Qnil
, arrow_bot
= Qnil
;
913 Lisp_Object empty_pos
;
914 Lisp_Object ind
= Qnil
;
915 #define MAX_BITMAP_CACHE (8*4)
916 int bitmap_cache
[MAX_BITMAP_CACHE
];
917 int top_ind_rn
, bot_ind_rn
;
918 int top_ind_min_y
, bot_ind_max_y
;
920 /* top_ind_rn is set to a nonnegative value whenver
921 row->indicate_bob_p is set, so it's OK that top_row_ends_at_zv_p
922 is not initialized here. Similarly for bot_ind_rn,
923 row->indicate_eob_p and bot_row_ends_at_zv_p. */
924 int top_row_ends_at_zv_p
IF_LINT (= 0), bot_row_ends_at_zv_p
IF_LINT (= 0);
926 if (w
->pseudo_window_p
)
929 if (!MINI_WINDOW_P (w
)
930 && (ind
= BVAR (XBUFFER (w
->buffer
), indicate_buffer_boundaries
), !NILP (ind
)))
932 if (EQ (ind
, Qleft
) || EQ (ind
, Qright
))
933 boundary_top
= boundary_bot
= arrow_top
= arrow_bot
= ind
;
934 else if (CONSP (ind
) && CONSP (XCAR (ind
)))
937 if (pos
= Fassq (Qt
, ind
), !NILP (pos
))
938 boundary_top
= boundary_bot
= arrow_top
= arrow_bot
= XCDR (pos
);
939 if (pos
= Fassq (Qtop
, ind
), !NILP (pos
))
940 boundary_top
= XCDR (pos
);
941 if (pos
= Fassq (Qbottom
, ind
), !NILP (pos
))
942 boundary_bot
= XCDR (pos
);
943 if (pos
= Fassq (Qup
, ind
), !NILP (pos
))
944 arrow_top
= XCDR (pos
);
945 if (pos
= Fassq (Qdown
, ind
), !NILP (pos
))
946 arrow_bot
= XCDR (pos
);
949 /* Anything else means boundary on left and no arrows. */
950 boundary_top
= boundary_bot
= Qleft
;
953 top_ind_rn
= bot_ind_rn
= -1;
956 for (y
= w
->vscroll
, rn
= 0;
957 y
< yb
&& rn
< nrows
;
958 y
+= row
->height
, ++rn
)
960 row
= w
->desired_matrix
->rows
+ rn
;
962 row
= w
->current_matrix
->rows
+ rn
;
964 row
->indicate_bob_p
= row
->indicate_top_line_p
= 0;
965 row
->indicate_eob_p
= row
->indicate_bottom_line_p
= 0;
967 if (!row
->mode_line_p
)
969 if (top_ind_rn
< 0 && row
->visible_height
> 0)
971 if (MATRIX_ROW_START_CHARPOS (row
) <= BUF_BEGV (XBUFFER (w
->buffer
))
972 && !MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (w
, row
))
973 row
->indicate_bob_p
= !NILP (boundary_top
);
975 row
->indicate_top_line_p
= !NILP (arrow_top
);
981 if (MATRIX_ROW_END_CHARPOS (row
) >= BUF_ZV (XBUFFER (w
->buffer
))
982 && !MATRIX_ROW_PARTIALLY_VISIBLE_AT_BOTTOM_P (w
, row
))
983 row
->indicate_eob_p
= !NILP (boundary_bot
), bot_ind_rn
= rn
;
984 else if (y
+ row
->height
>= yb
)
985 row
->indicate_bottom_line_p
= !NILP (arrow_bot
), bot_ind_rn
= rn
;
991 empty_pos
= BVAR (XBUFFER (w
->buffer
), indicate_empty_lines
);
992 if (!NILP (empty_pos
) && !EQ (empty_pos
, Qright
))
993 empty_pos
= WINDOW_LEFT_FRINGE_WIDTH (w
) == 0 ? Qright
: Qleft
;
995 for (y
= 0; y
< MAX_BITMAP_CACHE
; y
++)
996 bitmap_cache
[y
] = -1;
998 #define LEFT_FRINGE(cache, which, partial_p) \
999 (bitmap_cache[cache*4+partial_p] >= 0 \
1000 ? bitmap_cache[cache*4+partial_p] \
1001 : (bitmap_cache[cache*4+partial_p] = \
1002 get_logical_fringe_bitmap (w, which, 0, partial_p)))
1004 #define RIGHT_FRINGE(cache, which, partial_p) \
1005 (bitmap_cache[cache*4+2+partial_p] >= 0 \
1006 ? bitmap_cache[cache*4+2+partial_p] \
1007 : (bitmap_cache[cache*4+2+partial_p] = \
1008 get_logical_fringe_bitmap (w, which, 1, partial_p)))
1011 /* Extend top-aligned top indicator (or bottom-aligned bottom
1012 indicator) to adjacent rows if it doesn't fit in one row. */
1013 top_ind_min_y
= bot_ind_max_y
= -1;
1014 if (top_ind_rn
>= 0)
1016 int bn
= NO_FRINGE_BITMAP
;
1018 row
= w
->desired_matrix
->rows
+ top_ind_rn
;
1019 if (!row
->enabled_p
)
1020 row
= w
->current_matrix
->rows
+ top_ind_rn
;
1022 top_row_ends_at_zv_p
= row
->ends_at_zv_p
;
1023 if (row
->indicate_bob_p
)
1025 if (EQ (boundary_top
, Qleft
))
1026 bn
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qleft
))
1027 ? LEFT_FRINGE (1, Qtop_bottom
, row
->ends_at_zv_p
)
1028 : LEFT_FRINGE (2, Qtop
, 0));
1030 bn
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qright
))
1031 ? RIGHT_FRINGE (1, Qtop_bottom
, row
->ends_at_zv_p
)
1032 : RIGHT_FRINGE (2, Qtop
, 0));
1034 else if (row
->indicate_top_line_p
)
1036 if (EQ (arrow_top
, Qleft
))
1037 bn
= LEFT_FRINGE (6, Qup
, 0);
1039 bn
= RIGHT_FRINGE (6, Qup
, 0);
1042 if (bn
!= NO_FRINGE_BITMAP
)
1044 struct fringe_bitmap
*fb
;
1046 fb
= fringe_bitmaps
[bn
];
1048 fb
= &standard_bitmaps
[bn
< MAX_STANDARD_FRINGE_BITMAPS
1049 ? bn
: UNDEF_FRINGE_BITMAP
];
1050 if (fb
->align
== ALIGN_BITMAP_TOP
&& fb
->period
== 0)
1052 struct glyph_row
*row1
;
1055 top_ind_min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
1056 top_ind_max_y
= top_ind_min_y
+ fb
->height
;
1057 if (top_ind_max_y
> yb
)
1060 for (y
= row
->y
+ row
->height
, rn
= top_ind_rn
+ 1;
1061 y
< top_ind_max_y
&& rn
< nrows
;
1062 y
+= row1
->height
, rn
++)
1064 if (bot_ind_rn
>= 0 && rn
>= bot_ind_rn
)
1067 row1
= w
->desired_matrix
->rows
+ rn
;
1068 if (!row1
->enabled_p
)
1069 row1
= w
->current_matrix
->rows
+ rn
;
1071 row1
->indicate_bob_p
= row
->indicate_bob_p
;
1072 row1
->indicate_top_line_p
= row
->indicate_top_line_p
;
1077 if (bot_ind_rn
>= 0)
1079 int bn
= NO_FRINGE_BITMAP
;
1081 row
= w
->desired_matrix
->rows
+ bot_ind_rn
;
1082 if (!row
->enabled_p
)
1083 row
= w
->current_matrix
->rows
+ bot_ind_rn
;
1085 bot_row_ends_at_zv_p
= row
->ends_at_zv_p
;
1086 if (row
->indicate_eob_p
)
1088 if (EQ (boundary_bot
, Qleft
))
1089 bn
= LEFT_FRINGE (3, Qbottom
, row
->ends_at_zv_p
);
1091 bn
= RIGHT_FRINGE (3, Qbottom
, row
->ends_at_zv_p
);
1093 else if (row
->indicate_bottom_line_p
)
1095 if (EQ (arrow_bot
, Qleft
))
1096 bn
= LEFT_FRINGE (7, Qdown
, 0);
1098 bn
= RIGHT_FRINGE (7, Qdown
, 0);
1101 if (bn
!= NO_FRINGE_BITMAP
)
1103 struct fringe_bitmap
*fb
;
1105 fb
= fringe_bitmaps
[bn
];
1107 fb
= &standard_bitmaps
[bn
< MAX_STANDARD_FRINGE_BITMAPS
1108 ? bn
: UNDEF_FRINGE_BITMAP
];
1109 if (fb
->align
== ALIGN_BITMAP_BOTTOM
&& fb
->period
== 0)
1111 struct glyph_row
*row1
;
1114 bot_ind_max_y
= row
->y
+ row
->visible_height
;
1115 bot_ind_min_y
= bot_ind_max_y
- fb
->height
;
1116 if (bot_ind_min_y
< WINDOW_HEADER_LINE_HEIGHT (w
))
1117 bot_ind_min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
1119 for (y
= row
->y
, rn
= bot_ind_rn
- 1;
1120 y
>= bot_ind_min_y
&& rn
>= 0;
1121 y
-= row1
->height
, rn
--)
1123 if (top_ind_rn
>= 0 && rn
<= top_ind_rn
)
1126 row1
= w
->desired_matrix
->rows
+ rn
;
1127 if (!row1
->enabled_p
)
1128 row1
= w
->current_matrix
->rows
+ rn
;
1130 row1
->indicate_eob_p
= row
->indicate_eob_p
;
1131 row1
->indicate_bottom_line_p
= row
->indicate_bottom_line_p
;
1137 for (y
= w
->vscroll
, rn
= 0;
1138 y
< yb
&& rn
< nrows
;
1139 y
+= row
->height
, rn
++)
1142 unsigned left_face_id
, right_face_id
;
1143 int left_offset
, right_offset
;
1145 row
= w
->desired_matrix
->rows
+ rn
;
1146 cur
= w
->current_matrix
->rows
+ rn
;
1147 if (!row
->enabled_p
)
1150 left_face_id
= right_face_id
= DEFAULT_FACE_ID
;
1151 left_offset
= right_offset
= 0;
1153 /* Decide which bitmap to draw in the left fringe. */
1154 if (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0)
1155 left
= NO_FRINGE_BITMAP
;
1156 else if (row
->left_user_fringe_bitmap
!= NO_FRINGE_BITMAP
)
1158 left
= row
->left_user_fringe_bitmap
;
1159 left_face_id
= row
->left_user_fringe_face_id
;
1161 else if ((!row
->reversed_p
&& row
->truncated_on_left_p
)
1162 || (row
->reversed_p
&& row
->truncated_on_right_p
))
1163 left
= LEFT_FRINGE(0, Qtruncation
, 0);
1164 else if (row
->indicate_bob_p
&& EQ (boundary_top
, Qleft
))
1166 left
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qleft
))
1167 ? LEFT_FRINGE (1, Qtop_bottom
, top_row_ends_at_zv_p
)
1168 : LEFT_FRINGE (2, Qtop
, 0));
1169 if (top_ind_min_y
>= 0)
1170 left_offset
= top_ind_min_y
- row
->y
;
1172 else if (row
->indicate_eob_p
&& EQ (boundary_bot
, Qleft
))
1174 left
= LEFT_FRINGE (3, Qbottom
, bot_row_ends_at_zv_p
);
1175 if (bot_ind_max_y
>= 0)
1176 left_offset
= bot_ind_max_y
- (row
->y
+ row
->visible_height
);
1178 else if ((!row
->reversed_p
&& MATRIX_ROW_CONTINUATION_LINE_P (row
))
1179 || (row
->reversed_p
&& row
->continued_p
))
1180 left
= LEFT_FRINGE (4, Qcontinuation
, 0);
1181 else if (row
->indicate_empty_line_p
&& EQ (empty_pos
, Qleft
))
1182 left
= LEFT_FRINGE (5, Qempty_line
, 0);
1183 else if (row
->indicate_top_line_p
&& EQ (arrow_top
, Qleft
))
1185 left
= LEFT_FRINGE (6, Qup
, 0);
1186 if (top_ind_min_y
>= 0)
1187 left_offset
= top_ind_min_y
- row
->y
;
1189 else if (row
->indicate_bottom_line_p
&& EQ (arrow_bot
, Qleft
))
1191 left
= LEFT_FRINGE (7, Qdown
, 0);
1192 if (bot_ind_max_y
>= 0)
1193 left_offset
= bot_ind_max_y
- (row
->y
+ row
->visible_height
);
1196 left
= NO_FRINGE_BITMAP
;
1198 /* Decide which bitmap to draw in the right fringe. */
1199 if (WINDOW_RIGHT_FRINGE_WIDTH (w
) == 0)
1200 right
= NO_FRINGE_BITMAP
;
1201 else if (row
->right_user_fringe_bitmap
!= NO_FRINGE_BITMAP
)
1203 right
= row
->right_user_fringe_bitmap
;
1204 right_face_id
= row
->right_user_fringe_face_id
;
1206 else if ((!row
->reversed_p
&& row
->truncated_on_right_p
)
1207 || (row
->reversed_p
&& row
->truncated_on_left_p
))
1208 right
= RIGHT_FRINGE (0, Qtruncation
, 0);
1209 else if (row
->indicate_bob_p
&& EQ (boundary_top
, Qright
))
1211 right
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qright
))
1212 ? RIGHT_FRINGE (1, Qtop_bottom
, top_row_ends_at_zv_p
)
1213 : RIGHT_FRINGE (2, Qtop
, 0));
1214 if (top_ind_min_y
>= 0)
1215 right_offset
= top_ind_min_y
- row
->y
;
1217 else if (row
->indicate_eob_p
&& EQ (boundary_bot
, Qright
))
1219 right
= RIGHT_FRINGE (3, Qbottom
, bot_row_ends_at_zv_p
);
1220 if (bot_ind_max_y
>= 0)
1221 right_offset
= bot_ind_max_y
- (row
->y
+ row
->visible_height
);
1223 else if ((!row
->reversed_p
&& row
->continued_p
)
1224 || (row
->reversed_p
&& MATRIX_ROW_CONTINUATION_LINE_P (row
)))
1225 right
= RIGHT_FRINGE (4, Qcontinuation
, 0);
1226 else if (row
->indicate_top_line_p
&& EQ (arrow_top
, Qright
))
1228 right
= RIGHT_FRINGE (6, Qup
, 0);
1229 if (top_ind_min_y
>= 0)
1230 right_offset
= top_ind_min_y
- row
->y
;
1232 else if (row
->indicate_bottom_line_p
&& EQ (arrow_bot
, Qright
))
1234 right
= RIGHT_FRINGE (7, Qdown
, 0);
1235 if (bot_ind_max_y
>= 0)
1236 right_offset
= bot_ind_max_y
- (row
->y
+ row
->visible_height
);
1238 else if (row
->indicate_empty_line_p
&& EQ (empty_pos
, Qright
))
1239 right
= RIGHT_FRINGE (5, Qempty_line
, 0);
1241 right
= NO_FRINGE_BITMAP
;
1243 if (row
->y
!= cur
->y
1244 || row
->visible_height
!= cur
->visible_height
1245 || row
->ends_at_zv_p
!= cur
->ends_at_zv_p
1246 || left
!= cur
->left_fringe_bitmap
1247 || right
!= cur
->right_fringe_bitmap
1248 || left_face_id
!= cur
->left_fringe_face_id
1249 || right_face_id
!= cur
->right_fringe_face_id
1250 || left_offset
!= cur
->left_fringe_offset
1251 || right_offset
!= cur
->right_fringe_offset
1252 || cur
->redraw_fringe_bitmaps_p
)
1254 redraw_p
= row
->redraw_fringe_bitmaps_p
= 1;
1255 if (!keep_current_p
)
1257 cur
->redraw_fringe_bitmaps_p
= 1;
1258 cur
->left_fringe_bitmap
= left
;
1259 cur
->right_fringe_bitmap
= right
;
1260 cur
->left_fringe_face_id
= left_face_id
;
1261 cur
->right_fringe_face_id
= right_face_id
;
1262 cur
->left_fringe_offset
= left_offset
;
1263 cur
->right_fringe_offset
= right_offset
;
1267 if (row
->overlay_arrow_bitmap
< 0)
1268 row
->overlay_arrow_bitmap
= get_logical_fringe_bitmap (w
, Qoverlay_arrow
, 0, 0);
1270 if (row
->overlay_arrow_bitmap
!= cur
->overlay_arrow_bitmap
)
1272 redraw_p
= row
->redraw_fringe_bitmaps_p
= cur
->redraw_fringe_bitmaps_p
= 1;
1273 cur
->overlay_arrow_bitmap
= row
->overlay_arrow_bitmap
;
1276 row
->left_fringe_bitmap
= left
;
1277 row
->right_fringe_bitmap
= right
;
1278 row
->left_fringe_face_id
= left_face_id
;
1279 row
->right_fringe_face_id
= right_face_id
;
1280 row
->left_fringe_offset
= left_offset
;
1281 row
->right_fringe_offset
= right_offset
;
1284 return redraw_p
&& !keep_current_p
;
1288 /* Compute actual fringe widths for frame F.
1290 If REDRAW is 1, redraw F if the fringe settings was actually
1291 modified and F is visible.
1293 Since the combined left and right fringe must occupy an integral
1294 number of columns, we may need to add some pixels to each fringe.
1295 Typically, we add an equal amount (+/- 1 pixel) to each fringe,
1296 but a negative width value is taken literally (after negating it).
1298 We never make the fringes narrower than specified.
1302 compute_fringe_widths (struct frame
*f
, int redraw
)
1304 int o_left
= FRAME_LEFT_FRINGE_WIDTH (f
);
1305 int o_right
= FRAME_RIGHT_FRINGE_WIDTH (f
);
1306 int o_cols
= FRAME_FRINGE_COLS (f
);
1308 Lisp_Object left_fringe
= Fassq (Qleft_fringe
, f
->param_alist
);
1309 Lisp_Object right_fringe
= Fassq (Qright_fringe
, f
->param_alist
);
1310 int left_fringe_width
, right_fringe_width
;
1312 if (!NILP (left_fringe
))
1313 left_fringe
= Fcdr (left_fringe
);
1314 if (!NILP (right_fringe
))
1315 right_fringe
= Fcdr (right_fringe
);
1317 left_fringe_width
= ((NILP (left_fringe
) || !INTEGERP (left_fringe
)) ? 8 :
1318 XINT (left_fringe
));
1319 right_fringe_width
= ((NILP (right_fringe
) || !INTEGERP (right_fringe
)) ? 8 :
1320 XINT (right_fringe
));
1322 if (left_fringe_width
|| right_fringe_width
)
1324 int left_wid
= left_fringe_width
>= 0 ? left_fringe_width
: -left_fringe_width
;
1325 int right_wid
= right_fringe_width
>= 0 ? right_fringe_width
: -right_fringe_width
;
1326 int conf_wid
= left_wid
+ right_wid
;
1327 int font_wid
= FRAME_COLUMN_WIDTH (f
);
1328 int cols
= (left_wid
+ right_wid
+ font_wid
-1) / font_wid
;
1329 int real_wid
= cols
* font_wid
;
1330 if (left_wid
&& right_wid
)
1332 if (left_fringe_width
< 0)
1334 /* Left fringe width is fixed, adjust right fringe if necessary */
1335 FRAME_LEFT_FRINGE_WIDTH (f
) = left_wid
;
1336 FRAME_RIGHT_FRINGE_WIDTH (f
) = real_wid
- left_wid
;
1338 else if (right_fringe_width
< 0)
1340 /* Right fringe width is fixed, adjust left fringe if necessary */
1341 FRAME_LEFT_FRINGE_WIDTH (f
) = real_wid
- right_wid
;
1342 FRAME_RIGHT_FRINGE_WIDTH (f
) = right_wid
;
1346 /* Adjust both fringes with an equal amount.
1347 Note that we are doing integer arithmetic here, so don't
1348 lose a pixel if the total width is an odd number. */
1349 int fill
= real_wid
- conf_wid
;
1350 FRAME_LEFT_FRINGE_WIDTH (f
) = left_wid
+ fill
/2;
1351 FRAME_RIGHT_FRINGE_WIDTH (f
) = right_wid
+ fill
- fill
/2;
1354 else if (left_fringe_width
)
1356 FRAME_LEFT_FRINGE_WIDTH (f
) = real_wid
;
1357 FRAME_RIGHT_FRINGE_WIDTH (f
) = 0;
1361 FRAME_LEFT_FRINGE_WIDTH (f
) = 0;
1362 FRAME_RIGHT_FRINGE_WIDTH (f
) = real_wid
;
1364 FRAME_FRINGE_COLS (f
) = cols
;
1368 FRAME_LEFT_FRINGE_WIDTH (f
) = 0;
1369 FRAME_RIGHT_FRINGE_WIDTH (f
) = 0;
1370 FRAME_FRINGE_COLS (f
) = 0;
1373 if (redraw
&& FRAME_VISIBLE_P (f
))
1374 if (o_left
!= FRAME_LEFT_FRINGE_WIDTH (f
) ||
1375 o_right
!= FRAME_RIGHT_FRINGE_WIDTH (f
) ||
1376 o_cols
!= FRAME_FRINGE_COLS (f
))
1381 /* Free resources used by a user-defined bitmap. */
1384 destroy_fringe_bitmap (int n
)
1386 struct fringe_bitmap
**fbp
;
1388 fringe_faces
[n
] = Qnil
;
1390 fbp
= &fringe_bitmaps
[n
];
1391 if (*fbp
&& (*fbp
)->dynamic
)
1393 /* XXX Is SELECTED_FRAME OK here? */
1394 struct redisplay_interface
*rif
= FRAME_RIF (SELECTED_FRAME ());
1395 if (rif
&& rif
->destroy_fringe_bitmap
)
1396 rif
->destroy_fringe_bitmap (n
);
1401 while (max_used_fringe_bitmap
> MAX_STANDARD_FRINGE_BITMAPS
1402 && fringe_bitmaps
[max_used_fringe_bitmap
- 1] == NULL
)
1403 max_used_fringe_bitmap
--;
1407 DEFUN ("destroy-fringe-bitmap", Fdestroy_fringe_bitmap
, Sdestroy_fringe_bitmap
,
1409 doc
: /* Destroy fringe bitmap BITMAP.
1410 If BITMAP overrides a standard fringe bitmap, the original bitmap is restored. */)
1411 (Lisp_Object bitmap
)
1415 CHECK_SYMBOL (bitmap
);
1416 n
= lookup_fringe_bitmap (bitmap
);
1420 destroy_fringe_bitmap (n
);
1422 if (n
>= MAX_STANDARD_FRINGE_BITMAPS
)
1424 Vfringe_bitmaps
= Fdelq (bitmap
, Vfringe_bitmaps
);
1425 /* It would be better to remove the fringe property. */
1426 Fput (bitmap
, Qfringe
, Qnil
);
1433 /* Initialize bitmap bit.
1435 On X, we bit-swap the built-in bitmaps and reduce bitmap
1436 from short to char array if width is <= 8 bits.
1438 On MAC with big-endian CPU, we need to byte-swap each short.
1440 On W32 and MAC (little endian), there's no need to do this.
1443 #if defined (HAVE_X_WINDOWS)
1444 static const unsigned char swap_nibble
[16] = {
1445 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
1446 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
1447 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
1448 0x3, 0xb, 0x7, 0xf}; /* 0011 1011 0111 1111 */
1449 #endif /* HAVE_X_WINDOWS */
1452 init_fringe_bitmap (int which
, struct fringe_bitmap
*fb
, int once_p
)
1454 if (once_p
|| fb
->dynamic
)
1456 #if defined (HAVE_X_WINDOWS)
1457 unsigned short *bits
= fb
->bits
;
1462 unsigned char *cbits
= (unsigned char *)fb
->bits
;
1463 for (j
= 0; j
< fb
->height
; j
++)
1465 unsigned short b
= *bits
++;
1467 c
= (unsigned char)((swap_nibble
[b
& 0xf] << 4)
1468 | (swap_nibble
[(b
>>4) & 0xf]));
1469 *cbits
++ = (c
>> (8 - fb
->width
));
1474 for (j
= 0; j
< fb
->height
; j
++)
1476 unsigned short b
= *bits
;
1477 b
= (unsigned short)((swap_nibble
[b
& 0xf] << 12)
1478 | (swap_nibble
[(b
>>4) & 0xf] << 8)
1479 | (swap_nibble
[(b
>>8) & 0xf] << 4)
1480 | (swap_nibble
[(b
>>12) & 0xf]));
1481 b
>>= (16 - fb
->width
);
1482 #ifdef WORDS_BIGENDIAN
1483 b
= ((b
>> 8) | (b
<< 8));
1488 #endif /* HAVE_X_WINDOWS */
1494 /* XXX Is SELECTED_FRAME OK here? */
1495 struct redisplay_interface
*rif
= FRAME_RIF (SELECTED_FRAME ());
1497 destroy_fringe_bitmap (which
);
1499 if (rif
&& rif
->define_fringe_bitmap
)
1500 rif
->define_fringe_bitmap (which
, fb
->bits
, fb
->height
, fb
->width
);
1502 fringe_bitmaps
[which
] = fb
;
1503 if (which
>= max_used_fringe_bitmap
)
1504 max_used_fringe_bitmap
= which
+ 1;
1509 DEFUN ("define-fringe-bitmap", Fdefine_fringe_bitmap
, Sdefine_fringe_bitmap
,
1511 doc
: /* Define fringe bitmap BITMAP from BITS of size HEIGHT x WIDTH.
1512 BITMAP is a symbol identifying the new fringe bitmap.
1513 BITS is either a string or a vector of integers.
1514 HEIGHT is height of bitmap. If HEIGHT is nil, use length of BITS.
1515 WIDTH must be an integer between 1 and 16, or nil which defaults to 8.
1516 Optional fifth arg ALIGN may be one of `top', `center', or `bottom',
1517 indicating the positioning of the bitmap relative to the rows where it
1518 is used; the default is to center the bitmap. Fifth arg may also be a
1519 list (ALIGN PERIODIC) where PERIODIC non-nil specifies that the bitmap
1521 If BITMAP already exists, the existing definition is replaced. */)
1522 (Lisp_Object bitmap
, Lisp_Object bits
, Lisp_Object height
, Lisp_Object width
, Lisp_Object align
)
1526 struct fringe_bitmap fb
, *xfb
;
1527 int fill1
= 0, fill2
= 0;
1529 CHECK_SYMBOL (bitmap
);
1533 else if (VECTORP (bits
))
1536 wrong_type_argument (Qsequencep
, bits
);
1542 CHECK_NUMBER (height
);
1543 fb
.height
= min (XINT (height
), 255);
1546 fill1
= (fb
.height
- h
) / 2;
1547 fill2
= fb
.height
- h
- fill1
;
1555 CHECK_NUMBER (width
);
1556 fb
.width
= min (XINT (width
), 255);
1560 fb
.align
= ALIGN_BITMAP_CENTER
;
1564 Lisp_Object period
= XCDR (align
);
1567 period
= XCAR (period
);
1570 fb
.period
= fb
.height
;
1574 align
= XCAR (align
);
1576 if (EQ (align
, Qtop
))
1577 fb
.align
= ALIGN_BITMAP_TOP
;
1578 else if (EQ (align
, Qbottom
))
1579 fb
.align
= ALIGN_BITMAP_BOTTOM
;
1580 else if (!NILP (align
) && !EQ (align
, Qcenter
))
1581 error ("Bad align argument");
1583 n
= lookup_fringe_bitmap (bitmap
);
1586 if (max_used_fringe_bitmap
< max_fringe_bitmaps
)
1587 n
= max_used_fringe_bitmap
++;
1590 for (n
= MAX_STANDARD_FRINGE_BITMAPS
;
1591 n
< max_fringe_bitmaps
;
1593 if (fringe_bitmaps
[n
] == NULL
)
1596 if (n
== max_fringe_bitmaps
)
1598 if ((max_fringe_bitmaps
+ 20) > MAX_FRINGE_BITMAPS
)
1599 error ("No free fringe bitmap slots");
1601 i
= max_fringe_bitmaps
;
1602 max_fringe_bitmaps
+= 20;
1604 = ((struct fringe_bitmap
**)
1605 xrealloc (fringe_bitmaps
, max_fringe_bitmaps
* sizeof (struct fringe_bitmap
*)));
1607 = (Lisp_Object
*) xrealloc (fringe_faces
, max_fringe_bitmaps
* sizeof (Lisp_Object
));
1609 for (; i
< max_fringe_bitmaps
; i
++)
1611 fringe_bitmaps
[i
] = NULL
;
1612 fringe_faces
[i
] = Qnil
;
1617 Vfringe_bitmaps
= Fcons (bitmap
, Vfringe_bitmaps
);
1618 Fput (bitmap
, Qfringe
, make_number (n
));
1623 xfb
= (struct fringe_bitmap
*) xmalloc (sizeof fb
1624 + fb
.height
* BYTES_PER_BITMAP_ROW
);
1625 fb
.bits
= b
= (unsigned short *) (xfb
+ 1);
1626 memset (b
, 0, fb
.height
);
1629 while (j
< fb
.height
)
1631 for (i
= 0; i
< fill1
&& j
< fb
.height
; i
++)
1633 for (i
= 0; i
< h
&& j
< fb
.height
; i
++)
1635 Lisp_Object elt
= Faref (bits
, make_number (i
));
1636 b
[j
++] = NUMBERP (elt
) ? XINT (elt
) : 0;
1638 for (i
= 0; i
< fill2
&& j
< fb
.height
; i
++)
1644 init_fringe_bitmap (n
, xfb
, 0);
1649 DEFUN ("set-fringe-bitmap-face", Fset_fringe_bitmap_face
, Sset_fringe_bitmap_face
,
1651 doc
: /* Set face for fringe bitmap BITMAP to FACE.
1652 If FACE is nil, reset face to default fringe face. */)
1653 (Lisp_Object bitmap
, Lisp_Object face
)
1658 CHECK_SYMBOL (bitmap
);
1659 n
= lookup_fringe_bitmap (bitmap
);
1661 error ("Undefined fringe bitmap");
1665 face_id
= lookup_derived_face (SELECTED_FRAME (), face
,
1668 error ("No such face");
1671 fringe_faces
[n
] = face
;
1676 DEFUN ("fringe-bitmaps-at-pos", Ffringe_bitmaps_at_pos
, Sfringe_bitmaps_at_pos
,
1678 doc
: /* Return fringe bitmaps of row containing position POS in window WINDOW.
1679 If WINDOW is nil, use selected window. If POS is nil, use value of point
1680 in that window. Return value is a list (LEFT RIGHT OV), where LEFT
1681 is the symbol for the bitmap in the left fringe (or nil if no bitmap),
1682 RIGHT is similar for the right fringe, and OV is non-nil if there is an
1683 overlay arrow in the left fringe.
1684 Return nil if POS is not visible in WINDOW. */)
1685 (Lisp_Object pos
, Lisp_Object window
)
1688 struct glyph_row
*row
;
1692 window
= selected_window
;
1693 CHECK_WINDOW (window
);
1694 w
= XWINDOW (window
);
1698 CHECK_NUMBER_COERCE_MARKER (pos
);
1699 textpos
= XINT (pos
);
1701 else if (w
== XWINDOW (selected_window
))
1704 textpos
= XMARKER (w
->pointm
)->charpos
;
1706 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1707 row
= row_containing_pos (w
, textpos
, row
, NULL
, 0);
1709 return list3 (get_fringe_bitmap_name (row
->left_fringe_bitmap
),
1710 get_fringe_bitmap_name (row
->right_fringe_bitmap
),
1711 (row
->overlay_arrow_bitmap
== 0 ? Qnil
1712 : row
->overlay_arrow_bitmap
< 0 ? Qt
1713 : get_fringe_bitmap_name (row
->overlay_arrow_bitmap
)));
1719 /***********************************************************************
1721 ***********************************************************************/
1724 syms_of_fringe (void)
1726 Qtruncation
= intern_c_string ("truncation");
1727 staticpro (&Qtruncation
);
1728 Qcontinuation
= intern_c_string ("continuation");
1729 staticpro (&Qcontinuation
);
1730 Qoverlay_arrow
= intern_c_string ("overlay-arrow");
1731 staticpro (&Qoverlay_arrow
);
1732 Qempty_line
= intern_c_string ("empty-line");
1733 staticpro (&Qempty_line
);
1734 Qtop_bottom
= intern_c_string ("top-bottom");
1735 staticpro (&Qtop_bottom
);
1736 Qhollow_small
= intern_c_string ("hollow-small");
1737 staticpro (&Qhollow_small
);
1739 defsubr (&Sdestroy_fringe_bitmap
);
1740 defsubr (&Sdefine_fringe_bitmap
);
1741 defsubr (&Sfringe_bitmaps_at_pos
);
1742 defsubr (&Sset_fringe_bitmap_face
);
1744 DEFVAR_LISP ("overflow-newline-into-fringe", Voverflow_newline_into_fringe
,
1745 doc
: /* *Non-nil means that newline may flow into the right fringe.
1746 This means that display lines which are exactly as wide as the window
1747 (not counting the final newline) will only occupy one screen line, by
1748 showing (or hiding) the final newline in the right fringe; when point
1749 is at the final newline, the cursor is shown in the right fringe.
1750 If nil, also continue lines which are exactly as wide as the window. */);
1751 Voverflow_newline_into_fringe
= Qt
;
1753 DEFVAR_LISP ("fringe-bitmaps", Vfringe_bitmaps
,
1754 doc
: /* List of fringe bitmap symbols. */);
1755 Vfringe_bitmaps
= Qnil
;
1758 /* Garbage collection hook */
1761 mark_fringe_data (void)
1765 for (i
= 0; i
< max_fringe_bitmaps
; i
++)
1766 if (!NILP (fringe_faces
[i
]))
1767 mark_object (fringe_faces
[i
]);
1770 /* Initialize this module when Emacs starts. */
1773 init_fringe_once (void)
1777 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< MAX_STANDARD_FRINGE_BITMAPS
; bt
++)
1778 init_fringe_bitmap(bt
, &standard_bitmaps
[bt
], 1);
1786 max_fringe_bitmaps
= MAX_STANDARD_FRINGE_BITMAPS
+ 20;
1789 = (struct fringe_bitmap
**) xmalloc (max_fringe_bitmaps
* sizeof (struct fringe_bitmap
*));
1791 = (Lisp_Object
*) xmalloc (max_fringe_bitmaps
* sizeof (Lisp_Object
));
1793 for (i
= 0; i
< max_fringe_bitmaps
; i
++)
1795 fringe_bitmaps
[i
] = NULL
;
1796 fringe_faces
[i
] = Qnil
;
1803 w32_init_fringe (struct redisplay_interface
*rif
)
1810 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< MAX_STANDARD_FRINGE_BITMAPS
; bt
++)
1812 struct fringe_bitmap
*fb
= &standard_bitmaps
[bt
];
1813 rif
->define_fringe_bitmap (bt
, fb
->bits
, fb
->height
, fb
->width
);
1818 w32_reset_fringes (void)
1820 /* Destroy row bitmaps. */
1822 struct redisplay_interface
*rif
= FRAME_RIF (SELECTED_FRAME ());
1827 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< max_used_fringe_bitmap
; bt
++)
1828 rif
->destroy_fringe_bitmap (bt
);
1831 #endif /* HAVE_NTGUI */
1833 #endif /* HAVE_WINDOW_SYSTEM */