1 /* Fringe handling (split from xdisp.c).
2 Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
28 #include "dispextern.h"
30 #include "blockinput.h"
31 #include "termhooks.h"
33 #ifdef HAVE_WINDOW_SYSTEM
35 /* Fringe bitmaps are represented in three different ways:
37 Logical bitmaps are used internally to denote things like
38 'end-of-buffer', 'left-truncation', 'overlay-arrow', etc.
40 Physical bitmaps specify the visual appearence of the bitmap,
41 e.g. 'bottom-left-angle', 'left-arrow', 'left-triangle', etc.
42 User defined bitmaps are physical bitmaps.
44 Internally, fringe bitmaps for a specific display row are
45 represented as a simple integer that is used as an index
46 into the table of all defined bitmaps. This index is stored
47 in the `fringe' property of the physical bitmap symbol.
49 Logical bitmaps are mapped to physical bitmaps through the
50 buffer-local `fringe-indicator-alist' variable.
52 Each element of this alist is a cons (LOGICAL . PHYSICAL)
53 mapping a logical bitmap to a physical bitmap.
54 PHYSICAL is either a symbol to use in both left and right fringe,
55 or a cons of two symbols (LEFT . RIGHT) denoting different
56 bitmaps to use in left and right fringe.
58 LOGICAL is first looked up in the window's buffer's buffer-local
59 value of the fringe-indicator-alist variable, and if not present,
60 in the global value of fringe-indicator-alist.
62 If LOGICAL is not present in either alist, or the PHYSICAL value
63 found is nil, no bitmap is shown for the logical bitmap.
65 The `left-fringe' and `right-fringe' display properties
66 must specify physical bitmap symbols.
69 Lisp_Object Qtruncation
, Qcontinuation
, Qoverlay_arrow
;
70 Lisp_Object Qempty_line
, Qtop_bottom
;
71 Lisp_Object Qhollow_small
;
73 enum fringe_bitmap_align
75 ALIGN_BITMAP_CENTER
= 0,
91 /***********************************************************************
93 ***********************************************************************/
95 /* Undefined bitmap. A question mark. */
108 static unsigned short question_mark_bits
[] = {
109 0x3c, 0x7e, 0x7e, 0x0c, 0x18, 0x18, 0x00, 0x18, 0x18};
111 /* An arrow like this: `<-'. */
122 static unsigned short left_arrow_bits
[] = {
123 0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
126 /* Right truncation arrow bitmap `->'. */
137 static unsigned short right_arrow_bits
[] = {
138 0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
141 /* Up arrow bitmap. */
152 static unsigned short up_arrow_bits
[] = {
153 0x18, 0x3c, 0x7e, 0xff, 0x18, 0x18, 0x18, 0x18};
156 /* Down arrow bitmap. */
167 static unsigned short down_arrow_bits
[] = {
168 0x18, 0x18, 0x18, 0x18, 0xff, 0x7e, 0x3c, 0x18};
170 /* Marker for continuation lines. */
181 static unsigned short left_curly_arrow_bits
[] = {
182 0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
184 /* Marker for continued lines. */
195 static unsigned short right_curly_arrow_bits
[] = {
196 0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
198 /* Reverse Overlay arrow bitmap. A triangular arrow. */
209 static unsigned short left_triangle_bits
[] = {
210 0x03, 0x0f, 0x1f, 0x3f, 0x3f, 0x1f, 0x0f, 0x03};
212 /* Overlay arrow bitmap. A triangular arrow. */
223 static unsigned short right_triangle_bits
[] = {
224 0xc0, 0xf0, 0xf8, 0xfc, 0xfc, 0xf8, 0xf0, 0xc0};
226 /* First line bitmap. An top-left angle. */
237 static unsigned short top_left_angle_bits
[] = {
238 0xfc, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00};
240 /* First line bitmap. An right-up angle. */
251 static unsigned short top_right_angle_bits
[] = {
252 0x3f, 0x3f, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00};
254 /* Last line bitmap. An left-down angle. */
265 static unsigned short bottom_left_angle_bits
[] = {
266 0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfc, 0xfc};
268 /* Last line bitmap. An right-down angle. */
279 static unsigned short bottom_right_angle_bits
[] = {
280 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x3f, 0x3f};
282 /* First/last line bitmap. An left bracket. */
295 static unsigned short left_bracket_bits
[] = {
296 0xfc, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfc, 0xfc};
298 /* First/last line bitmap. An right bracket. */
311 static unsigned short right_bracket_bits
[] = {
312 0x3f, 0x3f, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x3f, 0x3f};
314 /* Filled box cursor bitmap. A filled box; max 13 pixels high. */
330 static unsigned short filled_rectangle_bits
[] = {
331 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe};
333 /* Hollow box cursor bitmap. A hollow box; max 13 pixels high. */
349 static unsigned short hollow_rectangle_bits
[] = {
350 0xfe, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0xfe};
352 /* Hollow square bitmap. */
361 static unsigned short hollow_square_bits
[] = {
362 0x7e, 0x42, 0x42, 0x42, 0x42, 0x7e};
364 /* Filled square bitmap. */
373 static unsigned short filled_square_bits
[] = {
374 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e};
376 /* Bar cursor bitmap. A vertical bar; max 13 pixels high. */
392 static unsigned short vertical_bar_bits
[] = {
393 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0};
395 /* HBar cursor bitmap. A horizontal bar; 2 pixels high. */
400 static unsigned short horizontal_bar_bits
[] = {
404 /* Bitmap drawn to indicate lines not displaying text if
405 `indicate-empty-lines' is non-nil. */
414 static unsigned short empty_line_bits
[] = {
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,
421 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
422 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00};
425 #define BYTES_PER_BITMAP_ROW (sizeof (unsigned short))
426 #define STANDARD_BITMAP_HEIGHT(bits) (sizeof (bits)/BYTES_PER_BITMAP_ROW)
427 #define FRBITS(bits) bits, STANDARD_BITMAP_HEIGHT (bits)
429 /* NOTE: The order of these bitmaps must match the sequence
430 used in fringe.el to define the corresponding symbols. */
432 struct fringe_bitmap standard_bitmaps
[] =
434 { NULL
, 0, 0, 0, 0, 0 }, /* NO_FRINGE_BITMAP */
435 { FRBITS (question_mark_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
436 { FRBITS (left_arrow_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
437 { FRBITS (right_arrow_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
438 { FRBITS (up_arrow_bits
), 8, 0, ALIGN_BITMAP_TOP
, 0 },
439 { FRBITS (down_arrow_bits
), 8, 0, ALIGN_BITMAP_BOTTOM
, 0 },
440 { FRBITS (left_curly_arrow_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
441 { FRBITS (right_curly_arrow_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
442 { FRBITS (left_triangle_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
443 { FRBITS (right_triangle_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
444 { FRBITS (top_left_angle_bits
), 8, 0, ALIGN_BITMAP_TOP
, 0 },
445 { FRBITS (top_right_angle_bits
), 8, 0, ALIGN_BITMAP_TOP
, 0 },
446 { FRBITS (bottom_left_angle_bits
), 8, 0, ALIGN_BITMAP_BOTTOM
, 0 },
447 { FRBITS (bottom_right_angle_bits
), 8, 0, ALIGN_BITMAP_BOTTOM
, 0 },
448 { FRBITS (left_bracket_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
449 { FRBITS (right_bracket_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
450 { FRBITS (filled_rectangle_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
451 { FRBITS (hollow_rectangle_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
452 { FRBITS (filled_square_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
453 { FRBITS (hollow_square_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
454 { FRBITS (vertical_bar_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
455 { FRBITS (horizontal_bar_bits
), 8, 0, ALIGN_BITMAP_BOTTOM
, 0 },
456 { FRBITS (empty_line_bits
), 8, 3, ALIGN_BITMAP_TOP
, 0 },
459 #define NO_FRINGE_BITMAP 0
460 #define UNDEF_FRINGE_BITMAP 1
461 #define MAX_STANDARD_FRINGE_BITMAPS (sizeof(standard_bitmaps)/sizeof(standard_bitmaps[0]))
463 static struct fringe_bitmap
**fringe_bitmaps
;
464 static Lisp_Object
*fringe_faces
;
465 static int max_fringe_bitmaps
;
467 int max_used_fringe_bitmap
= MAX_STANDARD_FRINGE_BITMAPS
;
470 /* Lookup bitmap number for symbol BITMAP.
471 Return 0 if not a bitmap. */
474 lookup_fringe_bitmap (Lisp_Object bitmap
)
478 bitmap
= Fget (bitmap
, Qfringe
);
479 if (!INTEGERP (bitmap
))
483 if (bn
> NO_FRINGE_BITMAP
484 && bn
< max_used_fringe_bitmap
485 && (bn
< MAX_STANDARD_FRINGE_BITMAPS
486 || fringe_bitmaps
[bn
] != NULL
))
492 /* Get fringe bitmap name for bitmap number BN.
494 Found by traversing Vfringe_bitmaps comparing BN to the
495 fringe property for each symbol.
497 Return BN if not found in Vfringe_bitmaps. */
500 get_fringe_bitmap_name (int bn
)
505 /* Zero means no bitmap -- return nil. */
509 bitmaps
= Vfringe_bitmaps
;
510 num
= make_number (bn
);
512 while (CONSP (bitmaps
))
514 Lisp_Object bitmap
= XCAR (bitmaps
);
515 if (EQ (num
, Fget (bitmap
, Qfringe
)))
517 bitmaps
= XCDR (bitmaps
);
524 /* Draw the bitmap WHICH in one of the left or right fringes of
525 window W. ROW is the glyph row for which to display the bitmap; it
526 determines the vertical position at which the bitmap has to be
528 LEFT_P is 1 for left fringe, 0 for right fringe.
532 draw_fringe_bitmap_1 (struct window
*w
, struct glyph_row
*row
, int left_p
, int overlay
, int which
)
534 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
535 struct draw_fringe_bitmap_params p
;
536 struct fringe_bitmap
*fb
;
538 int face_id
= DEFAULT_FACE_ID
;
539 int offset
, header_line_height
;
541 p
.overlay_p
= (overlay
& 1) == 1;
542 p
.cursor_p
= (overlay
& 2) == 2;
544 if (which
!= NO_FRINGE_BITMAP
)
550 which
= row
->left_fringe_bitmap
;
551 face_id
= row
->left_fringe_face_id
;
552 offset
= row
->left_fringe_offset
;
556 which
= row
->right_fringe_bitmap
;
557 face_id
= row
->right_fringe_face_id
;
558 offset
= row
->right_fringe_offset
;
561 if (face_id
== DEFAULT_FACE_ID
)
563 Lisp_Object face
= fringe_faces
[which
];
564 face_id
= NILP (face
) ? lookup_named_face (f
, Qfringe
, 0)
565 : lookup_derived_face (f
, face
, FRINGE_FACE_ID
, 0);
567 face_id
= FRINGE_FACE_ID
;
570 fb
= fringe_bitmaps
[which
];
572 fb
= &standard_bitmaps
[which
< MAX_STANDARD_FRINGE_BITMAPS
573 ? which
: UNDEF_FRINGE_BITMAP
];
577 /* Convert row to frame coordinates. */
578 p
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
) + offset
;
585 p
.dh
= (period
> 0 ? (p
.y
% period
) : 0);
588 /* Adjust y to the offset in the row to start drawing the bitmap. */
591 case ALIGN_BITMAP_CENTER
:
592 p
.y
+= (row
->height
- p
.h
) / 2;
594 case ALIGN_BITMAP_BOTTOM
:
595 p
.y
+= (row
->visible_height
- p
.h
);
597 case ALIGN_BITMAP_TOP
:
601 p
.face
= FACE_FROM_ID (f
, face_id
);
605 /* This could happen after clearing face cache.
606 But it shouldn't happen anymore. ++kfs */
610 PREPARE_FACE_FOR_DISPLAY (f
, p
.face
);
612 /* Clear left fringe if no bitmap to draw or if bitmap doesn't fill
615 header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
616 p
.by
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
, row
->y
));
617 p
.ny
= row
->visible_height
;
620 int wd
= WINDOW_LEFT_FRINGE_WIDTH (w
);
621 int x
= window_box_left (w
, (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
626 p
.x
= x
- p
.wd
- (wd
- p
.wd
) / 2;
628 if (p
.wd
< wd
|| p
.y
> p
.by
|| p
.y
+ p
.h
< p
.by
+ p
.ny
)
630 /* If W has a vertical border to its left, don't draw over it. */
631 wd
-= ((!WINDOW_LEFTMOST_P (w
)
632 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
640 int x
= window_box_right (w
,
641 (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
644 int wd
= WINDOW_RIGHT_FRINGE_WIDTH (w
);
647 p
.x
= x
+ (wd
- p
.wd
) / 2;
648 /* Clear right fringe if no bitmap to draw of if bitmap doesn't fill
650 if (p
.wd
< wd
|| p
.y
> p
.by
|| p
.y
+ p
.h
< p
.by
+ p
.ny
)
657 FRAME_RIF (f
)->draw_fringe_bitmap (w
, row
, &p
);
661 get_logical_cursor_bitmap (struct window
*w
, Lisp_Object cursor
)
663 Lisp_Object cmap
, bm
= Qnil
;
665 if ((cmap
= XBUFFER (w
->buffer
)->fringe_cursor_alist
), !NILP (cmap
))
667 bm
= Fassq (cursor
, cmap
);
670 if ((bm
= XCDR (bm
)), NILP (bm
))
671 return NO_FRINGE_BITMAP
;
672 return lookup_fringe_bitmap (bm
);
675 if (EQ (cmap
, buffer_defaults
.fringe_cursor_alist
))
676 return NO_FRINGE_BITMAP
;
677 bm
= Fassq (cursor
, buffer_defaults
.fringe_cursor_alist
);
678 if (!CONSP (bm
) || ((bm
= XCDR (bm
)), NILP (bm
)))
679 return NO_FRINGE_BITMAP
;
680 return lookup_fringe_bitmap (bm
);
684 get_logical_fringe_bitmap (struct window
*w
, Lisp_Object bitmap
, int right_p
, int partial_p
)
686 Lisp_Object cmap
, bm1
= Qnil
, bm2
= Qnil
, bm
;
687 int ln1
= 0, ln2
= 0;
689 int ix2
= ix1
+ (partial_p
? 2 : 0);
691 /* Lookup in buffer-local fringe-indicator-alist before global alist.
694 BITMAP -- use for all
695 (L R) -- use for left right (whether partial or not)
696 (L R PL PR) -- use for left right partial-left partial-right
697 If any value in local binding is not present or t, use global value.
699 If partial, lookup partial bitmap in default value if not found here.
700 If not partial, or no partial spec is present, use non-partial bitmap. */
702 if ((cmap
= XBUFFER (w
->buffer
)->fringe_indicator_alist
), !NILP (cmap
))
704 bm1
= Fassq (bitmap
, cmap
);
707 if ((bm1
= XCDR (bm1
)), NILP (bm1
))
708 return NO_FRINGE_BITMAP
;
711 ln1
= XINT (Flength (bm1
));
716 bm
= Fnth (make_number (ix2
), bm1
);
725 bm
= Fnth (make_number (ix1
), bm1
);
731 else if ((bm
= bm1
, !EQ (bm
, Qt
)))
736 if (!EQ (cmap
, buffer_defaults
.fringe_indicator_alist
)
737 && !NILP (buffer_defaults
.fringe_indicator_alist
))
739 bm2
= Fassq (bitmap
, buffer_defaults
.fringe_indicator_alist
);
742 if ((bm2
= XCDR (bm2
)), !NILP (bm2
))
746 ln2
= XINT (Flength (bm2
));
751 bm
= Fnth (make_number (ix2
), bm2
);
763 bm
= Fnth (make_number (ix1
), bm1
);
770 bm
= Fnth (make_number (ix1
), bm2
);
773 return NO_FRINGE_BITMAP
;
775 else if ((bm
= bm2
, NILP (bm
)))
776 return NO_FRINGE_BITMAP
;
779 return lookup_fringe_bitmap (bm
);
784 draw_fringe_bitmap (struct window
*w
, struct glyph_row
*row
, int left_p
)
788 if (left_p
== row
->reversed_p
&& row
->cursor_in_fringe_p
)
790 Lisp_Object cursor
= Qnil
;
792 switch (w
->phys_cursor_type
)
794 case HOLLOW_BOX_CURSOR
:
795 if (row
->visible_height
>= STANDARD_BITMAP_HEIGHT (hollow_rectangle_bits
))
798 cursor
= Qhollow_small
;
800 case FILLED_BOX_CURSOR
:
811 w
->phys_cursor_on_p
= 0;
812 row
->cursor_in_fringe_p
= 0;
817 int bm
= get_logical_cursor_bitmap (w
, cursor
);
818 if (bm
!= NO_FRINGE_BITMAP
)
820 draw_fringe_bitmap_1 (w
, row
, left_p
, 2, bm
);
821 overlay
= EQ (cursor
, Qbox
) ? 3 : 1;
826 draw_fringe_bitmap_1 (w
, row
, left_p
, overlay
, NO_FRINGE_BITMAP
);
828 if (left_p
&& row
->overlay_arrow_bitmap
!= NO_FRINGE_BITMAP
)
829 draw_fringe_bitmap_1 (w
, row
, 1, 1, row
->overlay_arrow_bitmap
);
833 /* Draw fringe bitmaps for glyph row ROW on window W. Call this
834 function with input blocked. */
837 draw_row_fringe_bitmaps (struct window
*w
, struct glyph_row
*row
)
839 xassert (interrupt_input_blocked
);
841 /* If row is completely invisible, because of vscrolling, we
842 don't have to draw anything. */
843 if (row
->visible_height
<= 0)
846 if (WINDOW_LEFT_FRINGE_WIDTH (w
) != 0)
847 draw_fringe_bitmap (w
, row
, 1);
849 if (WINDOW_RIGHT_FRINGE_WIDTH (w
) != 0)
850 draw_fringe_bitmap (w
, row
, 0);
853 /* Draw the fringes of window W. Only fringes for rows marked for
854 update in redraw_fringe_bitmaps_p are drawn.
856 Return >0 if left or right fringe was redrawn in any way.
858 If NO_FRINGE is non-zero, also return >0 if either fringe has zero width.
860 A return value >0 indicates that the vertical line between windows
861 needs update (as it may be drawn in the fringe).
865 draw_window_fringes (struct window
*w
, int no_fringe
)
867 struct glyph_row
*row
;
868 int yb
= window_text_bottom_y (w
);
869 int nrows
= w
->current_matrix
->nrows
;
873 if (w
->pseudo_window_p
)
876 /* Must draw line if no fringe */
878 && (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0
879 || WINDOW_RIGHT_FRINGE_WIDTH (w
) == 0))
882 for (y
= w
->vscroll
, rn
= 0, row
= w
->current_matrix
->rows
;
883 y
< yb
&& rn
< nrows
;
884 y
+= row
->height
, ++row
, ++rn
)
886 if (!row
->redraw_fringe_bitmaps_p
)
888 draw_row_fringe_bitmaps (w
, row
);
889 row
->redraw_fringe_bitmaps_p
= 0;
897 /* Recalculate the bitmaps to show in the fringes of window W.
898 Only mark rows with modified bitmaps for update in redraw_fringe_bitmaps_p.
900 If KEEP_CURRENT_P is 0, update current_matrix too. */
903 update_window_fringes (struct window
*w
, int keep_current_p
)
905 struct glyph_row
*row
, *cur
= 0;
906 int yb
= window_text_bottom_y (w
);
907 int rn
, nrows
= w
->current_matrix
->nrows
;
910 Lisp_Object boundary_top
= Qnil
, boundary_bot
= Qnil
;
911 Lisp_Object arrow_top
= Qnil
, arrow_bot
= Qnil
;
912 Lisp_Object empty_pos
;
913 Lisp_Object ind
= Qnil
;
914 #define MAX_BITMAP_CACHE (8*4)
915 int bitmap_cache
[MAX_BITMAP_CACHE
];
916 int top_ind_rn
, bot_ind_rn
;
917 int top_ind_min_y
, bot_ind_max_y
;
918 int top_row_ends_at_zv_p
, bot_row_ends_at_zv_p
;
920 if (w
->pseudo_window_p
)
923 if (!MINI_WINDOW_P (w
)
924 && (ind
= XBUFFER (w
->buffer
)->indicate_buffer_boundaries
, !NILP (ind
)))
926 if (EQ (ind
, Qleft
) || EQ (ind
, Qright
))
927 boundary_top
= boundary_bot
= arrow_top
= arrow_bot
= ind
;
928 else if (CONSP (ind
) && CONSP (XCAR (ind
)))
931 if (pos
= Fassq (Qt
, ind
), !NILP (pos
))
932 boundary_top
= boundary_bot
= arrow_top
= arrow_bot
= XCDR (pos
);
933 if (pos
= Fassq (Qtop
, ind
), !NILP (pos
))
934 boundary_top
= XCDR (pos
);
935 if (pos
= Fassq (Qbottom
, ind
), !NILP (pos
))
936 boundary_bot
= XCDR (pos
);
937 if (pos
= Fassq (Qup
, ind
), !NILP (pos
))
938 arrow_top
= XCDR (pos
);
939 if (pos
= Fassq (Qdown
, ind
), !NILP (pos
))
940 arrow_bot
= XCDR (pos
);
943 /* Anything else means boundary on left and no arrows. */
944 boundary_top
= boundary_bot
= Qleft
;
947 top_ind_rn
= bot_ind_rn
= -1;
950 for (y
= w
->vscroll
, rn
= 0;
951 y
< yb
&& rn
< nrows
;
952 y
+= row
->height
, ++rn
)
954 unsigned indicate_bob_p
, indicate_top_line_p
;
955 unsigned indicate_eob_p
, indicate_bottom_line_p
;
957 row
= w
->desired_matrix
->rows
+ rn
;
959 row
= w
->current_matrix
->rows
+ rn
;
961 indicate_bob_p
= row
->indicate_bob_p
;
962 indicate_top_line_p
= row
->indicate_top_line_p
;
963 indicate_eob_p
= row
->indicate_eob_p
;
964 indicate_bottom_line_p
= row
->indicate_bottom_line_p
;
966 row
->indicate_bob_p
= row
->indicate_top_line_p
= 0;
967 row
->indicate_eob_p
= row
->indicate_bottom_line_p
= 0;
969 if (!row
->mode_line_p
)
971 if (top_ind_rn
< 0 && row
->visible_height
> 0)
973 if (MATRIX_ROW_START_CHARPOS (row
) <= BUF_BEGV (XBUFFER (w
->buffer
))
974 && !MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (w
, row
))
975 row
->indicate_bob_p
= !NILP (boundary_top
);
977 row
->indicate_top_line_p
= !NILP (arrow_top
);
983 if (MATRIX_ROW_END_CHARPOS (row
) >= BUF_ZV (XBUFFER (w
->buffer
))
984 && !MATRIX_ROW_PARTIALLY_VISIBLE_AT_BOTTOM_P (w
, row
))
985 row
->indicate_eob_p
= !NILP (boundary_bot
), bot_ind_rn
= rn
;
986 else if (y
+ row
->height
>= yb
)
987 row
->indicate_bottom_line_p
= !NILP (arrow_bot
), bot_ind_rn
= rn
;
993 empty_pos
= XBUFFER (w
->buffer
)->indicate_empty_lines
;
994 if (!NILP (empty_pos
) && !EQ (empty_pos
, Qright
))
995 empty_pos
= WINDOW_LEFT_FRINGE_WIDTH (w
) == 0 ? Qright
: Qleft
;
997 for (y
= 0; y
< MAX_BITMAP_CACHE
; y
++)
998 bitmap_cache
[y
] = -1;
1000 #define LEFT_FRINGE(cache, which, partial_p) \
1001 (bitmap_cache[cache*4+partial_p] >= 0 \
1002 ? bitmap_cache[cache*4+partial_p] \
1003 : (bitmap_cache[cache*4+partial_p] = \
1004 get_logical_fringe_bitmap (w, which, 0, partial_p)))
1006 #define RIGHT_FRINGE(cache, which, partial_p) \
1007 (bitmap_cache[cache*4+2+partial_p] >= 0 \
1008 ? bitmap_cache[cache*4+2+partial_p] \
1009 : (bitmap_cache[cache*4+2+partial_p] = \
1010 get_logical_fringe_bitmap (w, which, 1, partial_p)))
1013 /* Extend top-aligned top indicator (or bottom-aligned bottom
1014 indicator) to adjacent rows if it doesn't fit in one row. */
1015 top_ind_min_y
= bot_ind_max_y
= -1;
1016 if (top_ind_rn
>= 0)
1018 int bn
= NO_FRINGE_BITMAP
;
1020 row
= w
->desired_matrix
->rows
+ top_ind_rn
;
1021 if (!row
->enabled_p
)
1022 row
= w
->current_matrix
->rows
+ top_ind_rn
;
1024 top_row_ends_at_zv_p
= row
->ends_at_zv_p
;
1025 if (row
->indicate_bob_p
)
1027 if (EQ (boundary_top
, Qleft
))
1028 bn
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qleft
))
1029 ? LEFT_FRINGE (1, Qtop_bottom
, row
->ends_at_zv_p
)
1030 : LEFT_FRINGE (2, Qtop
, 0));
1032 bn
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qright
))
1033 ? RIGHT_FRINGE (1, Qtop_bottom
, row
->ends_at_zv_p
)
1034 : RIGHT_FRINGE (2, Qtop
, 0));
1036 else if (row
->indicate_top_line_p
)
1038 if (EQ (arrow_top
, Qleft
))
1039 bn
= LEFT_FRINGE (6, Qup
, 0);
1041 bn
= RIGHT_FRINGE (6, Qup
, 0);
1044 if (bn
!= NO_FRINGE_BITMAP
)
1046 struct fringe_bitmap
*fb
;
1048 fb
= fringe_bitmaps
[bn
];
1050 fb
= &standard_bitmaps
[bn
< MAX_STANDARD_FRINGE_BITMAPS
1051 ? bn
: UNDEF_FRINGE_BITMAP
];
1052 if (fb
->align
== ALIGN_BITMAP_TOP
&& fb
->period
== 0)
1054 struct glyph_row
*row1
;
1057 top_ind_min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
1058 top_ind_max_y
= top_ind_min_y
+ fb
->height
;
1059 if (top_ind_max_y
> yb
)
1062 for (y
= row
->y
+ row
->height
, rn
= top_ind_rn
+ 1;
1063 y
< top_ind_max_y
&& rn
< nrows
;
1064 y
+= row1
->height
, rn
++)
1066 if (bot_ind_rn
>= 0 && rn
>= bot_ind_rn
)
1069 row1
= w
->desired_matrix
->rows
+ rn
;
1070 if (!row1
->enabled_p
)
1071 row1
= w
->current_matrix
->rows
+ rn
;
1073 row1
->indicate_bob_p
= row
->indicate_bob_p
;
1074 row1
->indicate_top_line_p
= row
->indicate_top_line_p
;
1079 if (bot_ind_rn
>= 0)
1081 int bn
= NO_FRINGE_BITMAP
;
1083 row
= w
->desired_matrix
->rows
+ bot_ind_rn
;
1084 if (!row
->enabled_p
)
1085 row
= w
->current_matrix
->rows
+ bot_ind_rn
;
1087 bot_row_ends_at_zv_p
= row
->ends_at_zv_p
;
1088 if (row
->indicate_eob_p
)
1090 if (EQ (boundary_bot
, Qleft
))
1091 bn
= LEFT_FRINGE (3, Qbottom
, row
->ends_at_zv_p
);
1093 bn
= RIGHT_FRINGE (3, Qbottom
, row
->ends_at_zv_p
);
1095 else if (row
->indicate_bottom_line_p
)
1097 if (EQ (arrow_bot
, Qleft
))
1098 bn
= LEFT_FRINGE (7, Qdown
, 0);
1100 bn
= RIGHT_FRINGE (7, Qdown
, 0);
1103 if (bn
!= NO_FRINGE_BITMAP
)
1105 struct fringe_bitmap
*fb
;
1107 fb
= fringe_bitmaps
[bn
];
1109 fb
= &standard_bitmaps
[bn
< MAX_STANDARD_FRINGE_BITMAPS
1110 ? bn
: UNDEF_FRINGE_BITMAP
];
1111 if (fb
->align
== ALIGN_BITMAP_BOTTOM
&& fb
->period
== 0)
1113 struct glyph_row
*row1
;
1116 bot_ind_max_y
= row
->y
+ row
->visible_height
;
1117 bot_ind_min_y
= bot_ind_max_y
- fb
->height
;
1118 if (bot_ind_min_y
< WINDOW_HEADER_LINE_HEIGHT (w
))
1119 bot_ind_min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
1121 for (y
= row
->y
, rn
= bot_ind_rn
- 1;
1122 y
>= bot_ind_min_y
&& rn
>= 0;
1123 y
-= row1
->height
, rn
--)
1125 if (top_ind_rn
>= 0 && rn
<= top_ind_rn
)
1128 row1
= w
->desired_matrix
->rows
+ rn
;
1129 if (!row1
->enabled_p
)
1130 row1
= w
->current_matrix
->rows
+ rn
;
1132 row1
->indicate_eob_p
= row
->indicate_eob_p
;
1133 row1
->indicate_bottom_line_p
= row
->indicate_bottom_line_p
;
1139 for (y
= w
->vscroll
, rn
= 0;
1140 y
< yb
&& rn
< nrows
;
1141 y
+= row
->height
, rn
++)
1144 unsigned left_face_id
, right_face_id
;
1145 int left_offset
, right_offset
;
1147 row
= w
->desired_matrix
->rows
+ rn
;
1148 cur
= w
->current_matrix
->rows
+ rn
;
1149 if (!row
->enabled_p
)
1152 left_face_id
= right_face_id
= DEFAULT_FACE_ID
;
1153 left_offset
= right_offset
= 0;
1155 /* Decide which bitmap to draw in the left fringe. */
1156 if (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0)
1157 left
= NO_FRINGE_BITMAP
;
1158 else if (row
->left_user_fringe_bitmap
!= NO_FRINGE_BITMAP
)
1160 left
= row
->left_user_fringe_bitmap
;
1161 left_face_id
= row
->left_user_fringe_face_id
;
1163 else if ((!row
->reversed_p
&& row
->truncated_on_left_p
)
1164 || (row
->reversed_p
&& row
->truncated_on_right_p
))
1165 left
= LEFT_FRINGE(0, Qtruncation
, 0);
1166 else if (row
->indicate_bob_p
&& EQ (boundary_top
, Qleft
))
1168 left
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qleft
))
1169 ? LEFT_FRINGE (1, Qtop_bottom
, top_row_ends_at_zv_p
)
1170 : LEFT_FRINGE (2, Qtop
, 0));
1171 if (top_ind_min_y
>= 0)
1172 left_offset
= top_ind_min_y
- row
->y
;
1174 else if (row
->indicate_eob_p
&& EQ (boundary_bot
, Qleft
))
1176 left
= LEFT_FRINGE (3, Qbottom
, bot_row_ends_at_zv_p
);
1177 if (bot_ind_max_y
>= 0)
1178 left_offset
= bot_ind_max_y
- (row
->y
+ row
->visible_height
);
1180 else if ((!row
->reversed_p
&& MATRIX_ROW_CONTINUATION_LINE_P (row
))
1181 || (row
->reversed_p
&& row
->continued_p
))
1182 left
= LEFT_FRINGE (4, Qcontinuation
, 0);
1183 else if (row
->indicate_empty_line_p
&& EQ (empty_pos
, Qleft
))
1184 left
= LEFT_FRINGE (5, Qempty_line
, 0);
1185 else if (row
->indicate_top_line_p
&& EQ (arrow_top
, Qleft
))
1187 left
= LEFT_FRINGE (6, Qup
, 0);
1188 if (top_ind_min_y
>= 0)
1189 left_offset
= top_ind_min_y
- row
->y
;
1191 else if (row
->indicate_bottom_line_p
&& EQ (arrow_bot
, Qleft
))
1193 left
= LEFT_FRINGE (7, Qdown
, 0);
1194 if (bot_ind_max_y
>= 0)
1195 left_offset
= bot_ind_max_y
- (row
->y
+ row
->visible_height
);
1198 left
= NO_FRINGE_BITMAP
;
1200 /* Decide which bitmap to draw in the right fringe. */
1201 if (WINDOW_RIGHT_FRINGE_WIDTH (w
) == 0)
1202 right
= NO_FRINGE_BITMAP
;
1203 else if (row
->right_user_fringe_bitmap
!= NO_FRINGE_BITMAP
)
1205 right
= row
->right_user_fringe_bitmap
;
1206 right_face_id
= row
->right_user_fringe_face_id
;
1208 else if ((!row
->reversed_p
&& row
->truncated_on_right_p
)
1209 || (row
->reversed_p
&& row
->truncated_on_left_p
))
1210 right
= RIGHT_FRINGE (0, Qtruncation
, 0);
1211 else if (row
->indicate_bob_p
&& EQ (boundary_top
, Qright
))
1213 right
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qright
))
1214 ? RIGHT_FRINGE (1, Qtop_bottom
, top_row_ends_at_zv_p
)
1215 : RIGHT_FRINGE (2, Qtop
, 0));
1216 if (top_ind_min_y
>= 0)
1217 right_offset
= top_ind_min_y
- row
->y
;
1219 else if (row
->indicate_eob_p
&& EQ (boundary_bot
, Qright
))
1221 right
= RIGHT_FRINGE (3, Qbottom
, bot_row_ends_at_zv_p
);
1222 if (bot_ind_max_y
>= 0)
1223 right_offset
= bot_ind_max_y
- (row
->y
+ row
->visible_height
);
1225 else if ((!row
->reversed_p
&& row
->continued_p
)
1226 || (row
->reversed_p
&& MATRIX_ROW_CONTINUATION_LINE_P (row
)))
1227 right
= RIGHT_FRINGE (4, Qcontinuation
, 0);
1228 else if (row
->indicate_top_line_p
&& EQ (arrow_top
, Qright
))
1230 right
= RIGHT_FRINGE (6, Qup
, 0);
1231 if (top_ind_min_y
>= 0)
1232 right_offset
= top_ind_min_y
- row
->y
;
1234 else if (row
->indicate_bottom_line_p
&& EQ (arrow_bot
, Qright
))
1236 right
= RIGHT_FRINGE (7, Qdown
, 0);
1237 if (bot_ind_max_y
>= 0)
1238 right_offset
= bot_ind_max_y
- (row
->y
+ row
->visible_height
);
1240 else if (row
->indicate_empty_line_p
&& EQ (empty_pos
, Qright
))
1241 right
= RIGHT_FRINGE (5, Qempty_line
, 0);
1243 right
= NO_FRINGE_BITMAP
;
1245 if (row
->y
!= cur
->y
1246 || row
->visible_height
!= cur
->visible_height
1247 || row
->ends_at_zv_p
!= cur
->ends_at_zv_p
1248 || left
!= cur
->left_fringe_bitmap
1249 || right
!= cur
->right_fringe_bitmap
1250 || left_face_id
!= cur
->left_fringe_face_id
1251 || right_face_id
!= cur
->right_fringe_face_id
1252 || left_offset
!= cur
->left_fringe_offset
1253 || right_offset
!= cur
->right_fringe_offset
1254 || cur
->redraw_fringe_bitmaps_p
)
1256 redraw_p
= row
->redraw_fringe_bitmaps_p
= 1;
1257 if (!keep_current_p
)
1259 cur
->redraw_fringe_bitmaps_p
= 1;
1260 cur
->left_fringe_bitmap
= left
;
1261 cur
->right_fringe_bitmap
= right
;
1262 cur
->left_fringe_face_id
= left_face_id
;
1263 cur
->right_fringe_face_id
= right_face_id
;
1264 cur
->left_fringe_offset
= left_offset
;
1265 cur
->right_fringe_offset
= right_offset
;
1269 if (row
->overlay_arrow_bitmap
< 0)
1270 row
->overlay_arrow_bitmap
= get_logical_fringe_bitmap (w
, Qoverlay_arrow
, 0, 0);
1272 if (row
->overlay_arrow_bitmap
!= cur
->overlay_arrow_bitmap
)
1274 redraw_p
= row
->redraw_fringe_bitmaps_p
= cur
->redraw_fringe_bitmaps_p
= 1;
1275 cur
->overlay_arrow_bitmap
= row
->overlay_arrow_bitmap
;
1278 row
->left_fringe_bitmap
= left
;
1279 row
->right_fringe_bitmap
= right
;
1280 row
->left_fringe_face_id
= left_face_id
;
1281 row
->right_fringe_face_id
= right_face_id
;
1282 row
->left_fringe_offset
= left_offset
;
1283 row
->right_fringe_offset
= right_offset
;
1286 return redraw_p
&& !keep_current_p
;
1290 /* Compute actual fringe widths for frame F.
1292 If REDRAW is 1, redraw F if the fringe settings was actually
1293 modified and F is visible.
1295 Since the combined left and right fringe must occupy an integral
1296 number of columns, we may need to add some pixels to each fringe.
1297 Typically, we add an equal amount (+/- 1 pixel) to each fringe,
1298 but a negative width value is taken literally (after negating it).
1300 We never make the fringes narrower than specified.
1304 compute_fringe_widths (struct frame
*f
, int redraw
)
1306 int o_left
= FRAME_LEFT_FRINGE_WIDTH (f
);
1307 int o_right
= FRAME_RIGHT_FRINGE_WIDTH (f
);
1308 int o_cols
= FRAME_FRINGE_COLS (f
);
1310 Lisp_Object left_fringe
= Fassq (Qleft_fringe
, f
->param_alist
);
1311 Lisp_Object right_fringe
= Fassq (Qright_fringe
, f
->param_alist
);
1312 int left_fringe_width
, right_fringe_width
;
1314 if (!NILP (left_fringe
))
1315 left_fringe
= Fcdr (left_fringe
);
1316 if (!NILP (right_fringe
))
1317 right_fringe
= Fcdr (right_fringe
);
1319 left_fringe_width
= ((NILP (left_fringe
) || !INTEGERP (left_fringe
)) ? 8 :
1320 XINT (left_fringe
));
1321 right_fringe_width
= ((NILP (right_fringe
) || !INTEGERP (right_fringe
)) ? 8 :
1322 XINT (right_fringe
));
1324 if (left_fringe_width
|| right_fringe_width
)
1326 int left_wid
= left_fringe_width
>= 0 ? left_fringe_width
: -left_fringe_width
;
1327 int right_wid
= right_fringe_width
>= 0 ? right_fringe_width
: -right_fringe_width
;
1328 int conf_wid
= left_wid
+ right_wid
;
1329 int font_wid
= FRAME_COLUMN_WIDTH (f
);
1330 int cols
= (left_wid
+ right_wid
+ font_wid
-1) / font_wid
;
1331 int real_wid
= cols
* font_wid
;
1332 if (left_wid
&& right_wid
)
1334 if (left_fringe_width
< 0)
1336 /* Left fringe width is fixed, adjust right fringe if necessary */
1337 FRAME_LEFT_FRINGE_WIDTH (f
) = left_wid
;
1338 FRAME_RIGHT_FRINGE_WIDTH (f
) = real_wid
- left_wid
;
1340 else if (right_fringe_width
< 0)
1342 /* Right fringe width is fixed, adjust left fringe if necessary */
1343 FRAME_LEFT_FRINGE_WIDTH (f
) = real_wid
- right_wid
;
1344 FRAME_RIGHT_FRINGE_WIDTH (f
) = right_wid
;
1348 /* Adjust both fringes with an equal amount.
1349 Note that we are doing integer arithmetic here, so don't
1350 lose a pixel if the total width is an odd number. */
1351 int fill
= real_wid
- conf_wid
;
1352 FRAME_LEFT_FRINGE_WIDTH (f
) = left_wid
+ fill
/2;
1353 FRAME_RIGHT_FRINGE_WIDTH (f
) = right_wid
+ fill
- fill
/2;
1356 else if (left_fringe_width
)
1358 FRAME_LEFT_FRINGE_WIDTH (f
) = real_wid
;
1359 FRAME_RIGHT_FRINGE_WIDTH (f
) = 0;
1363 FRAME_LEFT_FRINGE_WIDTH (f
) = 0;
1364 FRAME_RIGHT_FRINGE_WIDTH (f
) = real_wid
;
1366 FRAME_FRINGE_COLS (f
) = cols
;
1370 FRAME_LEFT_FRINGE_WIDTH (f
) = 0;
1371 FRAME_RIGHT_FRINGE_WIDTH (f
) = 0;
1372 FRAME_FRINGE_COLS (f
) = 0;
1375 if (redraw
&& FRAME_VISIBLE_P (f
))
1376 if (o_left
!= FRAME_LEFT_FRINGE_WIDTH (f
) ||
1377 o_right
!= FRAME_RIGHT_FRINGE_WIDTH (f
) ||
1378 o_cols
!= FRAME_FRINGE_COLS (f
))
1383 /* Free resources used by a user-defined bitmap. */
1386 destroy_fringe_bitmap (int n
)
1388 struct fringe_bitmap
**fbp
;
1390 fringe_faces
[n
] = Qnil
;
1392 fbp
= &fringe_bitmaps
[n
];
1393 if (*fbp
&& (*fbp
)->dynamic
)
1395 /* XXX Is SELECTED_FRAME OK here? */
1396 struct redisplay_interface
*rif
= FRAME_RIF (SELECTED_FRAME ());
1397 if (rif
&& rif
->destroy_fringe_bitmap
)
1398 rif
->destroy_fringe_bitmap (n
);
1403 while (max_used_fringe_bitmap
> MAX_STANDARD_FRINGE_BITMAPS
1404 && fringe_bitmaps
[max_used_fringe_bitmap
- 1] == NULL
)
1405 max_used_fringe_bitmap
--;
1409 DEFUN ("destroy-fringe-bitmap", Fdestroy_fringe_bitmap
, Sdestroy_fringe_bitmap
,
1411 doc
: /* Destroy fringe bitmap BITMAP.
1412 If BITMAP overrides a standard fringe bitmap, the original bitmap is restored. */)
1413 (Lisp_Object bitmap
)
1417 CHECK_SYMBOL (bitmap
);
1418 n
= lookup_fringe_bitmap (bitmap
);
1422 destroy_fringe_bitmap (n
);
1424 if (n
>= MAX_STANDARD_FRINGE_BITMAPS
)
1426 Vfringe_bitmaps
= Fdelq (bitmap
, Vfringe_bitmaps
);
1427 /* It would be better to remove the fringe property. */
1428 Fput (bitmap
, Qfringe
, Qnil
);
1435 /* Initialize bitmap bit.
1437 On X, we bit-swap the built-in bitmaps and reduce bitmap
1438 from short to char array if width is <= 8 bits.
1440 On MAC with big-endian CPU, we need to byte-swap each short.
1442 On W32 and MAC (little endian), there's no need to do this.
1445 #if defined (HAVE_X_WINDOWS)
1446 static const unsigned char swap_nibble
[16] = {
1447 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
1448 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
1449 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
1450 0x3, 0xb, 0x7, 0xf}; /* 0011 1011 0111 1111 */
1451 #endif /* HAVE_X_WINDOWS */
1454 init_fringe_bitmap (int which
, struct fringe_bitmap
*fb
, int once_p
)
1456 if (once_p
|| fb
->dynamic
)
1458 #if defined (HAVE_X_WINDOWS)
1459 unsigned short *bits
= fb
->bits
;
1464 unsigned char *cbits
= (unsigned char *)fb
->bits
;
1465 for (j
= 0; j
< fb
->height
; j
++)
1467 unsigned short b
= *bits
++;
1469 c
= (unsigned char)((swap_nibble
[b
& 0xf] << 4)
1470 | (swap_nibble
[(b
>>4) & 0xf]));
1471 *cbits
++ = (c
>> (8 - fb
->width
));
1476 for (j
= 0; j
< fb
->height
; j
++)
1478 unsigned short b
= *bits
;
1479 b
= (unsigned short)((swap_nibble
[b
& 0xf] << 12)
1480 | (swap_nibble
[(b
>>4) & 0xf] << 8)
1481 | (swap_nibble
[(b
>>8) & 0xf] << 4)
1482 | (swap_nibble
[(b
>>12) & 0xf]));
1483 b
>>= (16 - fb
->width
);
1484 #ifdef WORDS_BIGENDIAN
1485 b
= ((b
>> 8) | (b
<< 8));
1490 #endif /* HAVE_X_WINDOWS */
1496 /* XXX Is SELECTED_FRAME OK here? */
1497 struct redisplay_interface
*rif
= FRAME_RIF (SELECTED_FRAME ());
1499 destroy_fringe_bitmap (which
);
1501 if (rif
&& rif
->define_fringe_bitmap
)
1502 rif
->define_fringe_bitmap (which
, fb
->bits
, fb
->height
, fb
->width
);
1504 fringe_bitmaps
[which
] = fb
;
1505 if (which
>= max_used_fringe_bitmap
)
1506 max_used_fringe_bitmap
= which
+ 1;
1511 DEFUN ("define-fringe-bitmap", Fdefine_fringe_bitmap
, Sdefine_fringe_bitmap
,
1513 doc
: /* Define fringe bitmap BITMAP from BITS of size HEIGHT x WIDTH.
1514 BITMAP is a symbol identifying the new fringe bitmap.
1515 BITS is either a string or a vector of integers.
1516 HEIGHT is height of bitmap. If HEIGHT is nil, use length of BITS.
1517 WIDTH must be an integer between 1 and 16, or nil which defaults to 8.
1518 Optional fifth arg ALIGN may be one of `top', `center', or `bottom',
1519 indicating the positioning of the bitmap relative to the rows where it
1520 is used; the default is to center the bitmap. Fifth arg may also be a
1521 list (ALIGN PERIODIC) where PERIODIC non-nil specifies that the bitmap
1523 If BITMAP already exists, the existing definition is replaced. */)
1524 (Lisp_Object bitmap
, Lisp_Object bits
, Lisp_Object height
, Lisp_Object width
, Lisp_Object align
)
1528 struct fringe_bitmap fb
, *xfb
;
1529 int fill1
= 0, fill2
= 0;
1531 CHECK_SYMBOL (bitmap
);
1535 else if (VECTORP (bits
))
1536 h
= XVECTOR (bits
)->size
;
1538 wrong_type_argument (Qsequencep
, bits
);
1544 CHECK_NUMBER (height
);
1545 fb
.height
= min (XINT (height
), 255);
1548 fill1
= (fb
.height
- h
) / 2;
1549 fill2
= fb
.height
- h
- fill1
;
1557 CHECK_NUMBER (width
);
1558 fb
.width
= min (XINT (width
), 255);
1562 fb
.align
= ALIGN_BITMAP_CENTER
;
1566 Lisp_Object period
= XCDR (align
);
1569 period
= XCAR (period
);
1572 fb
.period
= fb
.height
;
1576 align
= XCAR (align
);
1578 if (EQ (align
, Qtop
))
1579 fb
.align
= ALIGN_BITMAP_TOP
;
1580 else if (EQ (align
, Qbottom
))
1581 fb
.align
= ALIGN_BITMAP_BOTTOM
;
1582 else if (!NILP (align
) && !EQ (align
, Qcenter
))
1583 error ("Bad align argument");
1585 n
= lookup_fringe_bitmap (bitmap
);
1588 if (max_used_fringe_bitmap
< max_fringe_bitmaps
)
1589 n
= max_used_fringe_bitmap
++;
1592 for (n
= MAX_STANDARD_FRINGE_BITMAPS
;
1593 n
< max_fringe_bitmaps
;
1595 if (fringe_bitmaps
[n
] == NULL
)
1598 if (n
== max_fringe_bitmaps
)
1600 if ((max_fringe_bitmaps
+ 20) > MAX_FRINGE_BITMAPS
)
1601 error ("No free fringe bitmap slots");
1603 i
= max_fringe_bitmaps
;
1604 max_fringe_bitmaps
+= 20;
1606 = ((struct fringe_bitmap
**)
1607 xrealloc (fringe_bitmaps
, max_fringe_bitmaps
* sizeof (struct fringe_bitmap
*)));
1609 = (Lisp_Object
*) xrealloc (fringe_faces
, max_fringe_bitmaps
* sizeof (Lisp_Object
));
1611 for (; i
< max_fringe_bitmaps
; i
++)
1613 fringe_bitmaps
[i
] = NULL
;
1614 fringe_faces
[i
] = Qnil
;
1619 Vfringe_bitmaps
= Fcons (bitmap
, Vfringe_bitmaps
);
1620 Fput (bitmap
, Qfringe
, make_number (n
));
1625 xfb
= (struct fringe_bitmap
*) xmalloc (sizeof fb
1626 + fb
.height
* BYTES_PER_BITMAP_ROW
);
1627 fb
.bits
= b
= (unsigned short *) (xfb
+ 1);
1628 memset (b
, 0, fb
.height
);
1631 while (j
< fb
.height
)
1633 for (i
= 0; i
< fill1
&& j
< fb
.height
; i
++)
1635 for (i
= 0; i
< h
&& j
< fb
.height
; i
++)
1637 Lisp_Object elt
= Faref (bits
, make_number (i
));
1638 b
[j
++] = NUMBERP (elt
) ? XINT (elt
) : 0;
1640 for (i
= 0; i
< fill2
&& j
< fb
.height
; i
++)
1646 init_fringe_bitmap (n
, xfb
, 0);
1651 DEFUN ("set-fringe-bitmap-face", Fset_fringe_bitmap_face
, Sset_fringe_bitmap_face
,
1653 doc
: /* Set face for fringe bitmap BITMAP to FACE.
1654 If FACE is nil, reset face to default fringe face. */)
1655 (Lisp_Object bitmap
, Lisp_Object face
)
1660 CHECK_SYMBOL (bitmap
);
1661 n
= lookup_fringe_bitmap (bitmap
);
1663 error ("Undefined fringe bitmap");
1667 face_id
= lookup_derived_face (SELECTED_FRAME (), face
,
1670 error ("No such face");
1673 fringe_faces
[n
] = face
;
1678 DEFUN ("fringe-bitmaps-at-pos", Ffringe_bitmaps_at_pos
, Sfringe_bitmaps_at_pos
,
1680 doc
: /* Return fringe bitmaps of row containing position POS in window WINDOW.
1681 If WINDOW is nil, use selected window. If POS is nil, use value of point
1682 in that window. Return value is a list (LEFT RIGHT OV), where LEFT
1683 is the symbol for the bitmap in the left fringe (or nil if no bitmap),
1684 RIGHT is similar for the right fringe, and OV is non-nil if there is an
1685 overlay arrow in the left fringe.
1686 Return nil if POS is not visible in WINDOW. */)
1687 (Lisp_Object pos
, Lisp_Object window
)
1690 struct glyph_row
*row
;
1694 window
= selected_window
;
1695 CHECK_WINDOW (window
);
1696 w
= XWINDOW (window
);
1700 CHECK_NUMBER_COERCE_MARKER (pos
);
1701 textpos
= XINT (pos
);
1703 else if (w
== XWINDOW (selected_window
))
1706 textpos
= XMARKER (w
->pointm
)->charpos
;
1708 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1709 row
= row_containing_pos (w
, textpos
, row
, NULL
, 0);
1711 return list3 (get_fringe_bitmap_name (row
->left_fringe_bitmap
),
1712 get_fringe_bitmap_name (row
->right_fringe_bitmap
),
1713 (row
->overlay_arrow_bitmap
== 0 ? Qnil
1714 : row
->overlay_arrow_bitmap
< 0 ? Qt
1715 : get_fringe_bitmap_name (row
->overlay_arrow_bitmap
)));
1721 /***********************************************************************
1723 ***********************************************************************/
1726 syms_of_fringe (void)
1728 Qtruncation
= intern_c_string ("truncation");
1729 staticpro (&Qtruncation
);
1730 Qcontinuation
= intern_c_string ("continuation");
1731 staticpro (&Qcontinuation
);
1732 Qoverlay_arrow
= intern_c_string ("overlay-arrow");
1733 staticpro (&Qoverlay_arrow
);
1734 Qempty_line
= intern_c_string ("empty-line");
1735 staticpro (&Qempty_line
);
1736 Qtop_bottom
= intern_c_string ("top-bottom");
1737 staticpro (&Qtop_bottom
);
1738 Qhollow_small
= intern_c_string ("hollow-small");
1739 staticpro (&Qhollow_small
);
1741 defsubr (&Sdestroy_fringe_bitmap
);
1742 defsubr (&Sdefine_fringe_bitmap
);
1743 defsubr (&Sfringe_bitmaps_at_pos
);
1744 defsubr (&Sset_fringe_bitmap_face
);
1746 DEFVAR_LISP ("overflow-newline-into-fringe", Voverflow_newline_into_fringe
,
1747 doc
: /* *Non-nil means that newline may flow into the right fringe.
1748 This means that display lines which are exactly as wide as the window
1749 (not counting the final newline) will only occupy one screen line, by
1750 showing (or hiding) the final newline in the right fringe; when point
1751 is at the final newline, the cursor is shown in the right fringe.
1752 If nil, also continue lines which are exactly as wide as the window. */);
1753 Voverflow_newline_into_fringe
= Qt
;
1755 DEFVAR_LISP ("fringe-bitmaps", Vfringe_bitmaps
,
1756 doc
: /* List of fringe bitmap symbols. */);
1757 Vfringe_bitmaps
= Qnil
;
1760 /* Garbage collection hook */
1763 mark_fringe_data (void)
1767 for (i
= 0; i
< max_fringe_bitmaps
; i
++)
1768 if (!NILP (fringe_faces
[i
]))
1769 mark_object (fringe_faces
[i
]);
1772 /* Initialize this module when Emacs starts. */
1775 init_fringe_once (void)
1779 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< MAX_STANDARD_FRINGE_BITMAPS
; bt
++)
1780 init_fringe_bitmap(bt
, &standard_bitmaps
[bt
], 1);
1788 max_fringe_bitmaps
= MAX_STANDARD_FRINGE_BITMAPS
+ 20;
1791 = (struct fringe_bitmap
**) xmalloc (max_fringe_bitmaps
* sizeof (struct fringe_bitmap
*));
1793 = (Lisp_Object
*) xmalloc (max_fringe_bitmaps
* sizeof (Lisp_Object
));
1795 for (i
= 0; i
< max_fringe_bitmaps
; i
++)
1797 fringe_bitmaps
[i
] = NULL
;
1798 fringe_faces
[i
] = Qnil
;
1805 w32_init_fringe (struct redisplay_interface
*rif
)
1812 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< MAX_STANDARD_FRINGE_BITMAPS
; bt
++)
1814 struct fringe_bitmap
*fb
= &standard_bitmaps
[bt
];
1815 rif
->define_fringe_bitmap (bt
, fb
->bits
, fb
->height
, fb
->width
);
1820 w32_reset_fringes (void)
1822 /* Destroy row bitmaps. */
1824 struct redisplay_interface
*rif
= FRAME_RIF (SELECTED_FRAME ());
1829 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< max_used_fringe_bitmap
; bt
++)
1830 rif
->destroy_fringe_bitmap (bt
);
1833 #endif /* HAVE_NTGUI */
1835 #endif /* HAVE_WINDOW_SYSTEM */