1 /* Fringe handling (split from xdisp.c).
2 Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995, 1997,
3 1998, 1999, 2000, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006 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 2, or (at your option)
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; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
29 #include "dispextern.h"
31 #include "blockinput.h"
32 #include "termhooks.h"
34 #ifdef HAVE_WINDOW_SYSTEM
36 extern Lisp_Object Qfringe
;
37 extern Lisp_Object Qtop
, Qbottom
, Qcenter
;
38 extern Lisp_Object Qup
, Qdown
, Qleft
, Qright
;
40 /* Non-nil means that newline may flow into the right fringe. */
42 Lisp_Object Voverflow_newline_into_fringe
;
44 /* List of known fringe bitmap symbols.
46 The fringe bitmap number is stored in the `fringe' property on
47 those symbols. Names for the built-in bitmaps are installed by
51 Lisp_Object Vfringe_bitmaps
;
53 /* Fringe bitmaps are represented in three different ways:
55 Logical bitmaps are used internally to denote things like
56 'end-of-buffer', 'left-truncation', 'overlay-arrow', etc.
58 Physical bitmaps specify the visual appearence of the bitmap,
59 e.g. 'bottom-left-angle', 'left-arrow', 'left-triangle', etc.
60 User defined bitmaps are physical bitmaps.
62 Internally, fringe bitmaps for a specific display row are
63 represented as a simple integer that is used as an index
64 into the table of all defined bitmaps. This index is stored
65 in the `fringe' property of the physical bitmap symbol.
67 Logical bitmaps are mapped to physical bitmaps through the
68 buffer-local `fringe-indicator-alist' variable.
70 Each element of this alist is a cons (LOGICAL . PHYSICAL)
71 mapping a logical bitmap to a physical bitmap.
72 PHYSICAL is either a symbol to use in both left and right fringe,
73 or a cons of two symbols (LEFT . RIGHT) denoting different
74 bitmaps to use in left and right fringe.
76 LOGICAL is first looked up in the window's buffer's buffer-local
77 value of the fringe-indicator-alist variable, and if not present,
78 in the global value of fringe-indicator-alist.
80 If LOGICAL is not present in either alist, or the PHYSICAL value
81 found is nil, no bitmap is shown for the logical bitmap.
83 The `left-fringe' and `right-fringe' display properties
84 must specify physical bitmap symbols.
87 extern Lisp_Object Qunknown
;
88 Lisp_Object Qtruncation
, Qcontinuation
, Qoverlay_arrow
;
89 Lisp_Object Qempty_line
, Qtop_bottom
;
90 extern Lisp_Object Qbar
, Qhbar
, Qbox
, Qhollow
;
91 Lisp_Object Qhollow_small
;
93 enum fringe_bitmap_align
95 ALIGN_BITMAP_CENTER
= 0,
102 unsigned short *bits
;
107 unsigned dynamic
: 1;
111 /***********************************************************************
113 ***********************************************************************/
115 /* Undefined bitmap. A question mark. */
128 static unsigned short question_mark_bits
[] = {
129 0x3c, 0x7e, 0x7e, 0x0c, 0x18, 0x18, 0x00, 0x18, 0x18};
131 /* An arrow like this: `<-'. */
142 static unsigned short left_arrow_bits
[] = {
143 0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
146 /* Right truncation arrow bitmap `->'. */
157 static unsigned short right_arrow_bits
[] = {
158 0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
161 /* Up arrow bitmap. */
172 static unsigned short up_arrow_bits
[] = {
173 0x18, 0x3c, 0x7e, 0xff, 0x18, 0x18, 0x18, 0x18};
176 /* Down arrow bitmap. */
187 static unsigned short down_arrow_bits
[] = {
188 0x18, 0x18, 0x18, 0x18, 0xff, 0x7e, 0x3c, 0x18};
190 /* Marker for continuation lines. */
201 static unsigned short left_curly_arrow_bits
[] = {
202 0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
204 /* Marker for continued lines. */
215 static unsigned short right_curly_arrow_bits
[] = {
216 0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
218 /* Reverse Overlay arrow bitmap. A triangular arrow. */
229 static unsigned short left_triangle_bits
[] = {
230 0x03, 0x0f, 0x1f, 0x3f, 0x3f, 0x1f, 0x0f, 0x03};
232 /* Overlay arrow bitmap. A triangular arrow. */
243 static unsigned short right_triangle_bits
[] = {
244 0xc0, 0xf0, 0xf8, 0xfc, 0xfc, 0xf8, 0xf0, 0xc0};
246 /* First line bitmap. An top-left angle. */
257 static unsigned short top_left_angle_bits
[] = {
258 0xfc, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00};
260 /* First line bitmap. An right-up angle. */
271 static unsigned short top_right_angle_bits
[] = {
272 0x3f, 0x3f, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00};
274 /* Last line bitmap. An left-down angle. */
285 static unsigned short bottom_left_angle_bits
[] = {
286 0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfc, 0xfc};
288 /* Last line bitmap. An right-down angle. */
299 static unsigned short bottom_right_angle_bits
[] = {
300 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x3f, 0x3f};
302 /* First/last line bitmap. An left bracket. */
315 static unsigned short left_bracket_bits
[] = {
316 0xfc, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfc, 0xfc};
318 /* First/last line bitmap. An right bracket. */
331 static unsigned short right_bracket_bits
[] = {
332 0x3f, 0x3f, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x3f, 0x3f};
334 /* Filled box cursor bitmap. A filled box; max 13 pixels high. */
350 static unsigned short filled_rectangle_bits
[] = {
351 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe};
353 /* Hollow box cursor bitmap. A hollow box; max 13 pixels high. */
369 static unsigned short hollow_rectangle_bits
[] = {
370 0xfe, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0xfe};
372 /* Hollow square bitmap. */
381 static unsigned short hollow_square_bits
[] = {
382 0x7e, 0x42, 0x42, 0x42, 0x42, 0x7e};
384 /* Filled square bitmap. */
393 static unsigned short filled_square_bits
[] = {
394 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e};
396 /* Bar cursor bitmap. A vertical bar; max 13 pixels high. */
412 static unsigned short vertical_bar_bits
[] = {
413 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0};
415 /* HBar cursor bitmap. A horizontal bar; 2 pixels high. */
420 static unsigned short horizontal_bar_bits
[] = {
424 /* Bitmap drawn to indicate lines not displaying text if
425 `indicate-empty-lines' is non-nil. */
434 static unsigned short empty_line_bits
[] = {
435 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
436 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
437 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
438 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
439 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
440 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
441 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
442 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00};
445 #define BYTES_PER_BITMAP_ROW (sizeof (unsigned short))
446 #define STANDARD_BITMAP_HEIGHT(bits) (sizeof (bits)/BYTES_PER_BITMAP_ROW)
447 #define FRBITS(bits) bits, STANDARD_BITMAP_HEIGHT (bits)
449 /* NOTE: The order of these bitmaps must match the sequence
450 used in fringe.el to define the corresponding symbols. */
452 struct fringe_bitmap standard_bitmaps
[] =
454 { NULL
, 0, 0, 0, 0, 0 }, /* NO_FRINGE_BITMAP */
455 { FRBITS (question_mark_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
456 { FRBITS (left_arrow_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
457 { FRBITS (right_arrow_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
458 { FRBITS (up_arrow_bits
), 8, 0, ALIGN_BITMAP_TOP
, 0 },
459 { FRBITS (down_arrow_bits
), 8, 0, ALIGN_BITMAP_BOTTOM
, 0 },
460 { FRBITS (left_curly_arrow_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
461 { FRBITS (right_curly_arrow_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
462 { FRBITS (left_triangle_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
463 { FRBITS (right_triangle_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
464 { FRBITS (top_left_angle_bits
), 8, 0, ALIGN_BITMAP_TOP
, 0 },
465 { FRBITS (top_right_angle_bits
), 8, 0, ALIGN_BITMAP_TOP
, 0 },
466 { FRBITS (bottom_left_angle_bits
), 8, 0, ALIGN_BITMAP_BOTTOM
, 0 },
467 { FRBITS (bottom_right_angle_bits
), 8, 0, ALIGN_BITMAP_BOTTOM
, 0 },
468 { FRBITS (left_bracket_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
469 { FRBITS (right_bracket_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
470 { FRBITS (filled_rectangle_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
471 { FRBITS (hollow_rectangle_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
472 { FRBITS (filled_square_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
473 { FRBITS (hollow_square_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
474 { FRBITS (vertical_bar_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
475 { FRBITS (horizontal_bar_bits
), 8, 0, ALIGN_BITMAP_BOTTOM
, 0 },
476 { FRBITS (empty_line_bits
), 8, 3, ALIGN_BITMAP_TOP
, 0 },
479 #define NO_FRINGE_BITMAP 0
480 #define UNDEF_FRINGE_BITMAP 1
481 #define MAX_STANDARD_FRINGE_BITMAPS (sizeof(standard_bitmaps)/sizeof(standard_bitmaps[0]))
483 static struct fringe_bitmap
**fringe_bitmaps
;
484 static Lisp_Object
*fringe_faces
;
485 static int max_fringe_bitmaps
;
487 static int max_used_fringe_bitmap
= MAX_STANDARD_FRINGE_BITMAPS
;
490 /* Lookup bitmap number for symbol BITMAP.
491 Return 0 if not a bitmap. */
494 lookup_fringe_bitmap (bitmap
)
499 bitmap
= Fget (bitmap
, Qfringe
);
500 if (!INTEGERP (bitmap
))
504 if (bn
> NO_FRINGE_BITMAP
505 && bn
< max_used_fringe_bitmap
506 && (bn
< MAX_STANDARD_FRINGE_BITMAPS
507 || fringe_bitmaps
[bn
] != NULL
))
513 /* Get fringe bitmap name for bitmap number BN.
515 Found by traversing Vfringe_bitmaps comparing BN to the
516 fringe property for each symbol.
518 Return BN if not found in Vfringe_bitmaps. */
521 get_fringe_bitmap_name (bn
)
527 /* Zero means no bitmap -- return nil. */
531 bitmaps
= Vfringe_bitmaps
;
532 num
= make_number (bn
);
534 while (CONSP (bitmaps
))
536 Lisp_Object bitmap
= XCAR (bitmaps
);
537 if (EQ (num
, Fget (bitmap
, Qfringe
)))
539 bitmaps
= XCDR (bitmaps
);
546 /* Draw the bitmap WHICH in one of the left or right fringes of
547 window W. ROW is the glyph row for which to display the bitmap; it
548 determines the vertical position at which the bitmap has to be
550 LEFT_P is 1 for left fringe, 0 for right fringe.
554 draw_fringe_bitmap_1 (w
, row
, left_p
, overlay
, which
)
556 struct glyph_row
*row
;
560 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
561 struct draw_fringe_bitmap_params p
;
562 struct fringe_bitmap
*fb
;
564 int face_id
= DEFAULT_FACE_ID
;
567 p
.overlay_p
= (overlay
& 1) == 1;
568 p
.cursor_p
= (overlay
& 2) == 2;
570 if (which
!= NO_FRINGE_BITMAP
)
575 which
= row
->left_fringe_bitmap
;
576 face_id
= row
->left_fringe_face_id
;
580 which
= row
->right_fringe_bitmap
;
581 face_id
= row
->right_fringe_face_id
;
584 if (face_id
== DEFAULT_FACE_ID
)
588 if ((face
= fringe_faces
[which
], NILP (face
))
589 || (face_id
= lookup_derived_face (f
, face
, 'A', FRINGE_FACE_ID
, 0),
591 face_id
= FRINGE_FACE_ID
;
594 fb
= fringe_bitmaps
[which
];
596 fb
= &standard_bitmaps
[which
< MAX_STANDARD_FRINGE_BITMAPS
597 ? which
: UNDEF_FRINGE_BITMAP
];
601 /* Convert row to frame coordinates. */
602 p
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
609 p
.dh
= (period
> 0 ? (p
.y
% period
) : 0);
611 /* Clip bitmap if too high. */
612 if (p
.h
> row
->height
)
615 p
.face
= FACE_FROM_ID (f
, face_id
);
619 /* This could happen after clearing face cache.
620 But it shouldn't happen anymore. ++kfs */
624 PREPARE_FACE_FOR_DISPLAY (f
, p
.face
);
626 /* Clear left fringe if no bitmap to draw or if bitmap doesn't fill
631 int wd
= WINDOW_LEFT_FRINGE_WIDTH (w
);
632 int x
= window_box_left (w
, (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
637 p
.x
= x
- p
.wd
- (wd
- p
.wd
) / 2;
639 if (p
.wd
< wd
|| row
->height
> p
.h
)
641 /* If W has a vertical border to its left, don't draw over it. */
642 wd
-= ((!WINDOW_LEFTMOST_P (w
)
643 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
651 int x
= window_box_right (w
,
652 (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
655 int wd
= WINDOW_RIGHT_FRINGE_WIDTH (w
);
658 p
.x
= x
+ (wd
- p
.wd
) / 2;
659 /* Clear right fringe if no bitmap to draw of if bitmap doesn't fill
661 if (p
.wd
< wd
|| row
->height
> p
.h
)
670 int header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
672 p
.by
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
, row
->y
));
673 p
.ny
= row
->visible_height
;
676 /* Adjust y to the offset in the row to start drawing the bitmap. */
679 case ALIGN_BITMAP_CENTER
:
680 p
.y
+= (row
->height
- p
.h
) / 2;
682 case ALIGN_BITMAP_BOTTOM
:
684 p
.y
+= (row
->visible_height
- p
.h
);
686 case ALIGN_BITMAP_TOP
:
690 FRAME_RIF (f
)->draw_fringe_bitmap (w
, row
, &p
);
694 get_logical_cursor_bitmap (w
, cursor
)
698 Lisp_Object cmap
, bm
= Qnil
;
700 if ((cmap
= XBUFFER (w
->buffer
)->fringe_cursor_alist
), !NILP (cmap
))
702 bm
= Fassq (cursor
, cmap
);
705 if ((bm
= XCDR (bm
)), NILP (bm
))
706 return NO_FRINGE_BITMAP
;
707 return lookup_fringe_bitmap (bm
);
710 if (EQ (cmap
, buffer_defaults
.fringe_cursor_alist
))
711 return NO_FRINGE_BITMAP
;
712 bm
= Fassq (cursor
, buffer_defaults
.fringe_cursor_alist
);
713 if (!CONSP (bm
) || ((bm
= XCDR (bm
)), NILP (bm
)))
714 return NO_FRINGE_BITMAP
;
715 return lookup_fringe_bitmap (bm
);
719 get_logical_fringe_bitmap (w
, bitmap
, right_p
, partial_p
)
722 int right_p
, partial_p
;
724 Lisp_Object cmap
, bm1
= Qnil
, bm2
= Qnil
, bm
;
725 int ln1
= 0, ln2
= 0;
727 int ix2
= ix1
+ (partial_p
? 2 : 0);
729 /* Lookup in buffer-local fringe-indicator-alist before global alist.
732 BITMAP -- use for all
733 (L R) -- use for left right (whether partial or not)
734 (L R PL PR) -- use for left rigth partial-left partial-right
735 If any value in local binding is not present or t, use global value.
737 If partial, lookup partial bitmap in default value if not found here.
738 If not partial, or no partial spec is present, use non-partial bitmap. */
740 if ((cmap
= XBUFFER (w
->buffer
)->fringe_indicator_alist
), !NILP (cmap
))
742 bm1
= Fassq (bitmap
, cmap
);
745 if ((bm1
= XCDR (bm1
)), NILP (bm1
))
746 return NO_FRINGE_BITMAP
;
749 ln1
= XINT (Flength (bm1
));
754 bm
= Fnth (make_number (ix2
), bm1
);
763 bm
= Fnth (make_number (ix1
), bm1
);
769 else if ((bm
= bm1
, !EQ (bm
, Qt
)))
774 if (!EQ (cmap
, buffer_defaults
.fringe_indicator_alist
)
775 && !NILP (buffer_defaults
.fringe_indicator_alist
))
777 bm2
= Fassq (bitmap
, buffer_defaults
.fringe_indicator_alist
);
780 if ((bm2
= XCDR (bm2
)), !NILP (bm2
))
784 ln2
= XINT (Flength (bm2
));
789 bm
= Fnth (make_number (ix2
), bm2
);
801 bm
= Fnth (make_number (ix1
), bm1
);
808 bm
= Fnth (make_number (ix1
), bm2
);
811 return NO_FRINGE_BITMAP
;
813 else if ((bm
= bm2
, NILP (bm
)))
814 return NO_FRINGE_BITMAP
;
817 return lookup_fringe_bitmap (bm
);
822 draw_fringe_bitmap (w
, row
, left_p
)
824 struct glyph_row
*row
;
829 if (!left_p
&& row
->cursor_in_fringe_p
)
831 Lisp_Object cursor
= Qnil
;
833 switch (w
->phys_cursor_type
)
835 case HOLLOW_BOX_CURSOR
:
836 if (row
->visible_height
>= STANDARD_BITMAP_HEIGHT (hollow_rectangle_bits
))
839 cursor
= Qhollow_small
;
841 case FILLED_BOX_CURSOR
:
852 w
->phys_cursor_on_p
= 0;
853 row
->cursor_in_fringe_p
= 0;
858 int bm
= get_logical_cursor_bitmap (w
, cursor
);
859 if (bm
!= NO_FRINGE_BITMAP
)
861 draw_fringe_bitmap_1 (w
, row
, 0, 2, bm
);
862 overlay
= EQ (cursor
, Qbox
) ? 3 : 1;
867 draw_fringe_bitmap_1 (w
, row
, left_p
, overlay
, NO_FRINGE_BITMAP
);
869 if (left_p
&& row
->overlay_arrow_bitmap
!= NO_FRINGE_BITMAP
)
870 draw_fringe_bitmap_1 (w
, row
, 1, 1,
871 (row
->overlay_arrow_bitmap
< 0
872 ? get_logical_cursor_bitmap (w
, Qoverlay_arrow
)
873 : row
->overlay_arrow_bitmap
));
877 /* Draw fringe bitmaps for glyph row ROW on window W. Call this
878 function with input blocked. */
881 draw_row_fringe_bitmaps (w
, row
)
883 struct glyph_row
*row
;
885 xassert (interrupt_input_blocked
);
887 /* If row is completely invisible, because of vscrolling, we
888 don't have to draw anything. */
889 if (row
->visible_height
<= 0)
892 if (WINDOW_LEFT_FRINGE_WIDTH (w
) != 0)
893 draw_fringe_bitmap (w
, row
, 1);
895 if (WINDOW_RIGHT_FRINGE_WIDTH (w
) != 0)
896 draw_fringe_bitmap (w
, row
, 0);
899 /* Draw the fringes of window W. Only fringes for rows marked for
900 update in redraw_fringe_bitmaps_p are drawn.
902 Return >0 if left or right fringe was redrawn in any way.
904 If NO_FRINGE is non-zero, also return >0 if either fringe has zero width.
906 A return value >0 indicates that the vertical line between windows
907 needs update (as it may be drawn in the fringe).
911 draw_window_fringes (w
, no_fringe
)
915 struct glyph_row
*row
;
916 int yb
= window_text_bottom_y (w
);
917 int nrows
= w
->current_matrix
->nrows
;
921 if (w
->pseudo_window_p
)
924 /* Must draw line if no fringe */
926 && (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0
927 || WINDOW_RIGHT_FRINGE_WIDTH (w
) == 0))
930 for (y
= 0, rn
= 0, row
= w
->current_matrix
->rows
;
931 y
< yb
&& rn
< nrows
;
932 y
+= row
->height
, ++row
, ++rn
)
934 if (!row
->redraw_fringe_bitmaps_p
)
936 draw_row_fringe_bitmaps (w
, row
);
937 row
->redraw_fringe_bitmaps_p
= 0;
945 /* Recalculate the bitmaps to show in the fringes of window W.
946 Only mark rows with modified bitmaps for update in redraw_fringe_bitmaps_p.
948 If KEEP_CURRENT_P is 0, update current_matrix too. */
951 update_window_fringes (w
, keep_current_p
)
955 struct glyph_row
*row
, *cur
= 0;
956 int yb
= window_text_bottom_y (w
);
957 int rn
, nrows
= w
->current_matrix
->nrows
;
960 Lisp_Object boundary_top
= Qnil
, boundary_bot
= Qnil
;
961 Lisp_Object arrow_top
= Qnil
, arrow_bot
= Qnil
;
962 Lisp_Object empty_pos
;
963 Lisp_Object ind
= Qnil
;
964 #define MAX_BITMAP_CACHE (8*4)
965 int bitmap_cache
[MAX_BITMAP_CACHE
];
967 if (w
->pseudo_window_p
)
970 if (!MINI_WINDOW_P (w
)
971 && (ind
= XBUFFER (w
->buffer
)->indicate_buffer_boundaries
, !NILP (ind
)))
973 if (EQ (ind
, Qleft
) || EQ (ind
, Qright
))
974 boundary_top
= boundary_bot
= arrow_top
= arrow_bot
= ind
;
975 else if (CONSP (ind
) && CONSP (XCAR (ind
)))
978 if (pos
= Fassq (Qt
, ind
), !NILP (pos
))
979 boundary_top
= boundary_bot
= arrow_top
= arrow_bot
= XCDR (pos
);
980 if (pos
= Fassq (Qtop
, ind
), !NILP (pos
))
981 boundary_top
= XCDR (pos
);
982 if (pos
= Fassq (Qbottom
, ind
), !NILP (pos
))
983 boundary_bot
= XCDR (pos
);
984 if (pos
= Fassq (Qup
, ind
), !NILP (pos
))
985 arrow_top
= XCDR (pos
);
986 if (pos
= Fassq (Qdown
, ind
), !NILP (pos
))
987 arrow_bot
= XCDR (pos
);
990 /* Anything else means boundary on left and no arrows. */
991 boundary_top
= boundary_bot
= Qleft
;
996 int done_top
= 0, done_bot
= 0;
999 y
< yb
&& rn
< nrows
;
1000 y
+= row
->height
, ++rn
)
1002 unsigned indicate_bob_p
, indicate_top_line_p
;
1003 unsigned indicate_eob_p
, indicate_bottom_line_p
;
1005 row
= w
->desired_matrix
->rows
+ rn
;
1006 if (!row
->enabled_p
)
1007 row
= w
->current_matrix
->rows
+ rn
;
1009 indicate_bob_p
= row
->indicate_bob_p
;
1010 indicate_top_line_p
= row
->indicate_top_line_p
;
1011 indicate_eob_p
= row
->indicate_eob_p
;
1012 indicate_bottom_line_p
= row
->indicate_bottom_line_p
;
1014 row
->indicate_bob_p
= row
->indicate_top_line_p
= 0;
1015 row
->indicate_eob_p
= row
->indicate_bottom_line_p
= 0;
1017 if (!row
->mode_line_p
)
1021 if (MATRIX_ROW_START_CHARPOS (row
) <= BUF_BEGV (XBUFFER (w
->buffer
))
1022 && !MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (w
, row
))
1023 row
->indicate_bob_p
= !NILP (boundary_top
);
1025 row
->indicate_top_line_p
= !NILP (arrow_top
);
1031 if (MATRIX_ROW_END_CHARPOS (row
) >= BUF_ZV (XBUFFER (w
->buffer
))
1032 && !MATRIX_ROW_PARTIALLY_VISIBLE_AT_BOTTOM_P (w
, row
))
1033 row
->indicate_eob_p
= !NILP (boundary_bot
), done_bot
= 1;
1034 else if (y
+ row
->height
>= yb
)
1035 row
->indicate_bottom_line_p
= !NILP (arrow_bot
), done_bot
= 1;
1039 if (indicate_bob_p
!= row
->indicate_bob_p
1040 || indicate_top_line_p
!= row
->indicate_top_line_p
1041 || indicate_eob_p
!= row
->indicate_eob_p
1042 || indicate_bottom_line_p
!= row
->indicate_bottom_line_p
)
1043 row
->redraw_fringe_bitmaps_p
= 1;
1047 empty_pos
= XBUFFER (w
->buffer
)->indicate_empty_lines
;
1048 if (!NILP (empty_pos
) && !EQ (empty_pos
, Qright
))
1049 empty_pos
= WINDOW_LEFT_FRINGE_WIDTH (w
) == 0 ? Qright
: Qleft
;
1051 for (y
= 0; y
< MAX_BITMAP_CACHE
; y
++)
1052 bitmap_cache
[y
] = -1;
1054 #define LEFT_FRINGE(cache, which, partial_p) \
1055 (bitmap_cache[cache*4+partial_p] >= 0 \
1056 ? bitmap_cache[cache*4+partial_p] \
1057 : (bitmap_cache[cache*4+partial_p] = \
1058 get_logical_fringe_bitmap (w, which, 0, partial_p)))
1060 #define RIGHT_FRINGE(cache, which, partial_p) \
1061 (bitmap_cache[cache*4+2+partial_p] >= 0 \
1062 ? bitmap_cache[cache*4+2+partial_p] \
1063 : (bitmap_cache[cache*4+2+partial_p] = \
1064 get_logical_fringe_bitmap (w, which, 1, partial_p)))
1068 y
< yb
&& rn
< nrows
;
1069 y
+= row
->height
, rn
++)
1072 unsigned left_face_id
, right_face_id
;
1074 row
= w
->desired_matrix
->rows
+ rn
;
1075 cur
= w
->current_matrix
->rows
+ rn
;
1076 if (!row
->enabled_p
)
1079 left_face_id
= right_face_id
= DEFAULT_FACE_ID
;
1081 /* Decide which bitmap to draw in the left fringe. */
1082 if (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0)
1083 left
= NO_FRINGE_BITMAP
;
1084 else if (row
->left_user_fringe_bitmap
!= NO_FRINGE_BITMAP
)
1086 left
= row
->left_user_fringe_bitmap
;
1087 left_face_id
= row
->left_user_fringe_face_id
;
1089 else if (row
->truncated_on_left_p
)
1090 left
= LEFT_FRINGE(0, Qtruncation
, 0);
1091 else if (row
->indicate_bob_p
&& EQ (boundary_top
, Qleft
))
1092 left
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qleft
))
1093 ? LEFT_FRINGE (1, Qtop_bottom
, row
->ends_at_zv_p
)
1094 : LEFT_FRINGE (2, Qtop
, 0));
1095 else if (row
->indicate_eob_p
&& EQ (boundary_bot
, Qleft
))
1096 left
= LEFT_FRINGE (3, Qbottom
, row
->ends_at_zv_p
);
1097 else if (MATRIX_ROW_CONTINUATION_LINE_P (row
))
1098 left
= LEFT_FRINGE (4, Qcontinuation
, 0);
1099 else if (row
->indicate_empty_line_p
&& EQ (empty_pos
, Qleft
))
1100 left
= LEFT_FRINGE (5, Qempty_line
, 0);
1101 else if (row
->indicate_top_line_p
&& EQ (arrow_top
, Qleft
))
1102 left
= LEFT_FRINGE (6, Qup
, 0);
1103 else if (row
->indicate_bottom_line_p
&& EQ (arrow_bot
, Qleft
))
1104 left
= LEFT_FRINGE (7, Qdown
, 0);
1106 left
= NO_FRINGE_BITMAP
;
1108 /* Decide which bitmap to draw in the right fringe. */
1109 if (WINDOW_RIGHT_FRINGE_WIDTH (w
) == 0)
1110 right
= NO_FRINGE_BITMAP
;
1111 else if (row
->right_user_fringe_bitmap
!= NO_FRINGE_BITMAP
)
1113 right
= row
->right_user_fringe_bitmap
;
1114 right_face_id
= row
->right_user_fringe_face_id
;
1116 else if (row
->truncated_on_right_p
)
1117 right
= RIGHT_FRINGE (0, Qtruncation
, 0);
1118 else if (row
->indicate_bob_p
&& EQ (boundary_top
, Qright
))
1119 right
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qright
))
1120 ? RIGHT_FRINGE (1, Qtop_bottom
, row
->ends_at_zv_p
)
1121 : RIGHT_FRINGE (2, Qtop
, 0));
1122 else if (row
->indicate_eob_p
&& EQ (boundary_bot
, Qright
))
1123 right
= RIGHT_FRINGE (3, Qbottom
, row
->ends_at_zv_p
);
1124 else if (row
->continued_p
)
1125 right
= RIGHT_FRINGE (4, Qcontinuation
, 0);
1126 else if (row
->indicate_top_line_p
&& EQ (arrow_top
, Qright
))
1127 right
= RIGHT_FRINGE (6, Qup
, 0);
1128 else if (row
->indicate_bottom_line_p
&& EQ (arrow_bot
, Qright
))
1129 right
= RIGHT_FRINGE (7, Qdown
, 0);
1130 else if (row
->indicate_empty_line_p
&& EQ (empty_pos
, Qright
))
1131 right
= RIGHT_FRINGE (5, Qempty_line
, 0);
1133 right
= NO_FRINGE_BITMAP
;
1135 if (row
->y
!= cur
->y
1136 || row
->visible_height
!= cur
->visible_height
1137 || row
->ends_at_zv_p
!= cur
->ends_at_zv_p
1138 || left
!= cur
->left_fringe_bitmap
1139 || right
!= cur
->right_fringe_bitmap
1140 || left_face_id
!= cur
->left_fringe_face_id
1141 || right_face_id
!= cur
->right_fringe_face_id
1142 || cur
->redraw_fringe_bitmaps_p
)
1144 redraw_p
= row
->redraw_fringe_bitmaps_p
= 1;
1145 if (!keep_current_p
)
1147 cur
->redraw_fringe_bitmaps_p
= 1;
1148 cur
->left_fringe_bitmap
= left
;
1149 cur
->right_fringe_bitmap
= right
;
1150 cur
->left_fringe_face_id
= left_face_id
;
1151 cur
->right_fringe_face_id
= right_face_id
;
1155 if (row
->overlay_arrow_bitmap
!= cur
->overlay_arrow_bitmap
)
1157 redraw_p
= row
->redraw_fringe_bitmaps_p
= cur
->redraw_fringe_bitmaps_p
= 1;
1158 cur
->overlay_arrow_bitmap
= row
->overlay_arrow_bitmap
;
1161 row
->left_fringe_bitmap
= left
;
1162 row
->right_fringe_bitmap
= right
;
1163 row
->left_fringe_face_id
= left_face_id
;
1164 row
->right_fringe_face_id
= right_face_id
;
1166 if (rn
> 0 && row
->redraw_fringe_bitmaps_p
)
1167 row
[-1].redraw_fringe_bitmaps_p
= cur
[-1].redraw_fringe_bitmaps_p
= 1;
1170 return redraw_p
&& !keep_current_p
;
1174 /* Compute actual fringe widths for frame F.
1176 If REDRAW is 1, redraw F if the fringe settings was actually
1177 modified and F is visible.
1179 Since the combined left and right fringe must occupy an integral
1180 number of columns, we may need to add some pixels to each fringe.
1181 Typically, we add an equal amount (+/- 1 pixel) to each fringe,
1182 but a negative width value is taken literally (after negating it).
1184 We never make the fringes narrower than specified.
1188 compute_fringe_widths (f
, redraw
)
1192 int o_left
= FRAME_LEFT_FRINGE_WIDTH (f
);
1193 int o_right
= FRAME_RIGHT_FRINGE_WIDTH (f
);
1194 int o_cols
= FRAME_FRINGE_COLS (f
);
1196 Lisp_Object left_fringe
= Fassq (Qleft_fringe
, f
->param_alist
);
1197 Lisp_Object right_fringe
= Fassq (Qright_fringe
, f
->param_alist
);
1198 int left_fringe_width
, right_fringe_width
;
1200 if (!NILP (left_fringe
))
1201 left_fringe
= Fcdr (left_fringe
);
1202 if (!NILP (right_fringe
))
1203 right_fringe
= Fcdr (right_fringe
);
1205 left_fringe_width
= ((NILP (left_fringe
) || !INTEGERP (left_fringe
)) ? 8 :
1206 XINT (left_fringe
));
1207 right_fringe_width
= ((NILP (right_fringe
) || !INTEGERP (right_fringe
)) ? 8 :
1208 XINT (right_fringe
));
1210 if (left_fringe_width
|| right_fringe_width
)
1212 int left_wid
= left_fringe_width
>= 0 ? left_fringe_width
: -left_fringe_width
;
1213 int right_wid
= right_fringe_width
>= 0 ? right_fringe_width
: -right_fringe_width
;
1214 int conf_wid
= left_wid
+ right_wid
;
1215 int font_wid
= FRAME_COLUMN_WIDTH (f
);
1216 int cols
= (left_wid
+ right_wid
+ font_wid
-1) / font_wid
;
1217 int real_wid
= cols
* font_wid
;
1218 if (left_wid
&& right_wid
)
1220 if (left_fringe_width
< 0)
1222 /* Left fringe width is fixed, adjust right fringe if necessary */
1223 FRAME_LEFT_FRINGE_WIDTH (f
) = left_wid
;
1224 FRAME_RIGHT_FRINGE_WIDTH (f
) = real_wid
- left_wid
;
1226 else if (right_fringe_width
< 0)
1228 /* Right fringe width is fixed, adjust left fringe if necessary */
1229 FRAME_LEFT_FRINGE_WIDTH (f
) = real_wid
- right_wid
;
1230 FRAME_RIGHT_FRINGE_WIDTH (f
) = right_wid
;
1234 /* Adjust both fringes with an equal amount.
1235 Note that we are doing integer arithmetic here, so don't
1236 lose a pixel if the total width is an odd number. */
1237 int fill
= real_wid
- conf_wid
;
1238 FRAME_LEFT_FRINGE_WIDTH (f
) = left_wid
+ fill
/2;
1239 FRAME_RIGHT_FRINGE_WIDTH (f
) = right_wid
+ fill
- fill
/2;
1242 else if (left_fringe_width
)
1244 FRAME_LEFT_FRINGE_WIDTH (f
) = real_wid
;
1245 FRAME_RIGHT_FRINGE_WIDTH (f
) = 0;
1249 FRAME_LEFT_FRINGE_WIDTH (f
) = 0;
1250 FRAME_RIGHT_FRINGE_WIDTH (f
) = real_wid
;
1252 FRAME_FRINGE_COLS (f
) = cols
;
1256 FRAME_LEFT_FRINGE_WIDTH (f
) = 0;
1257 FRAME_RIGHT_FRINGE_WIDTH (f
) = 0;
1258 FRAME_FRINGE_COLS (f
) = 0;
1261 if (redraw
&& FRAME_VISIBLE_P (f
))
1262 if (o_left
!= FRAME_LEFT_FRINGE_WIDTH (f
) ||
1263 o_right
!= FRAME_RIGHT_FRINGE_WIDTH (f
) ||
1264 o_cols
!= FRAME_FRINGE_COLS (f
))
1269 /* Free resources used by a user-defined bitmap. */
1272 destroy_fringe_bitmap (n
)
1275 struct fringe_bitmap
**fbp
;
1277 fringe_faces
[n
] = Qnil
;
1279 fbp
= &fringe_bitmaps
[n
];
1280 if (*fbp
&& (*fbp
)->dynamic
)
1282 /* XXX Is SELECTED_FRAME OK here? */
1283 struct redisplay_interface
*rif
= FRAME_RIF (SELECTED_FRAME ());
1284 if (rif
&& rif
->destroy_fringe_bitmap
)
1285 rif
->destroy_fringe_bitmap (n
);
1290 while (max_used_fringe_bitmap
> MAX_STANDARD_FRINGE_BITMAPS
1291 && fringe_bitmaps
[max_used_fringe_bitmap
- 1] == NULL
)
1292 max_used_fringe_bitmap
--;
1296 DEFUN ("destroy-fringe-bitmap", Fdestroy_fringe_bitmap
, Sdestroy_fringe_bitmap
,
1298 doc
: /* Destroy fringe bitmap BITMAP.
1299 If BITMAP overrides a standard fringe bitmap, the original bitmap is restored. */)
1305 CHECK_SYMBOL (bitmap
);
1306 n
= lookup_fringe_bitmap (bitmap
);
1310 destroy_fringe_bitmap (n
);
1312 if (n
>= MAX_STANDARD_FRINGE_BITMAPS
)
1314 Vfringe_bitmaps
= Fdelq (bitmap
, Vfringe_bitmaps
);
1315 /* It would be better to remove the fringe property. */
1316 Fput (bitmap
, Qfringe
, Qnil
);
1323 /* Initialize bitmap bit.
1325 On X, we bit-swap the built-in bitmaps and reduce bitmap
1326 from short to char array if width is <= 8 bits.
1328 On MAC with big-endian CPU, we need to byte-swap each short.
1330 On W32 and MAC (little endian), there's no need to do this.
1334 init_fringe_bitmap (which
, fb
, once_p
)
1336 struct fringe_bitmap
*fb
;
1339 if (once_p
|| fb
->dynamic
)
1341 #if defined (HAVE_X_WINDOWS)
1342 static unsigned char swap_nibble
[16]
1343 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
1344 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
1345 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
1346 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
1347 unsigned short *bits
= fb
->bits
;
1352 unsigned char *cbits
= (unsigned char *)fb
->bits
;
1353 for (j
= 0; j
< fb
->height
; j
++)
1355 unsigned short b
= *bits
++;
1357 c
= (unsigned char)((swap_nibble
[b
& 0xf] << 4)
1358 | (swap_nibble
[(b
>>4) & 0xf]));
1359 *cbits
++ = (c
>> (8 - fb
->width
));
1364 for (j
= 0; j
< fb
->height
; j
++)
1366 unsigned short b
= *bits
;
1367 b
= (unsigned short)((swap_nibble
[b
& 0xf] << 12)
1368 | (swap_nibble
[(b
>>4) & 0xf] << 8)
1369 | (swap_nibble
[(b
>>8) & 0xf] << 4)
1370 | (swap_nibble
[(b
>>12) & 0xf]));
1371 *bits
++ = (b
>> (16 - fb
->width
));
1374 #endif /* HAVE_X_WINDOWS */
1376 #if defined (MAC_OS) && defined (WORDS_BIG_ENDIAN)
1377 unsigned short *bits
= fb
->bits
;
1379 for (j
= 0; j
< fb
->height
; j
++)
1381 unsigned short b
= *bits
;
1382 *bits
++ = ((b
>> 8) & 0xff) | ((b
& 0xff) << 8);
1384 #endif /* MAC_OS && WORDS_BIG_ENDIAN */
1389 /* XXX Is SELECTED_FRAME OK here? */
1390 struct redisplay_interface
*rif
= FRAME_RIF (SELECTED_FRAME ());
1392 destroy_fringe_bitmap (which
);
1394 if (rif
&& rif
->define_fringe_bitmap
)
1395 rif
->define_fringe_bitmap (which
, fb
->bits
, fb
->height
, fb
->width
);
1397 fringe_bitmaps
[which
] = fb
;
1398 if (which
>= max_used_fringe_bitmap
)
1399 max_used_fringe_bitmap
= which
+ 1;
1404 DEFUN ("define-fringe-bitmap", Fdefine_fringe_bitmap
, Sdefine_fringe_bitmap
,
1406 doc
: /* Define fringe bitmap BITMAP from BITS of size HEIGHT x WIDTH.
1407 BITMAP is a symbol or string naming the new fringe bitmap.
1408 BITS is either a string or a vector of integers.
1409 HEIGHT is height of bitmap. If HEIGHT is nil, use length of BITS.
1410 WIDTH must be an integer between 1 and 16, or nil which defaults to 8.
1411 Optional fifth arg ALIGN may be one of `top', `center', or `bottom',
1412 indicating the positioning of the bitmap relative to the rows where it
1413 is used; the default is to center the bitmap. Fourth arg may also be a
1414 list (ALIGN PERIODIC) where PERIODIC non-nil specifies that the bitmap
1416 If BITMAP already exists, the existing definition is replaced. */)
1417 (bitmap
, bits
, height
, width
, align
)
1418 Lisp_Object bitmap
, bits
, height
, width
, align
;
1422 struct fringe_bitmap fb
, *xfb
;
1423 int fill1
= 0, fill2
= 0;
1425 CHECK_SYMBOL (bitmap
);
1429 else if (VECTORP (bits
))
1430 h
= XVECTOR (bits
)->size
;
1432 bits
= wrong_type_argument (Qsequencep
, bits
);
1438 CHECK_NUMBER (height
);
1439 fb
.height
= min (XINT (height
), 255);
1442 fill1
= (fb
.height
- h
) / 2;
1443 fill2
= fb
.height
- h
- fill1
;
1451 CHECK_NUMBER (width
);
1452 fb
.width
= min (XINT (width
), 255);
1456 fb
.align
= ALIGN_BITMAP_CENTER
;
1460 Lisp_Object period
= XCDR (align
);
1463 period
= XCAR (period
);
1466 fb
.period
= fb
.height
;
1470 align
= XCAR (align
);
1472 if (EQ (align
, Qtop
))
1473 fb
.align
= ALIGN_BITMAP_TOP
;
1474 else if (EQ (align
, Qbottom
))
1475 fb
.align
= ALIGN_BITMAP_BOTTOM
;
1476 else if (!NILP (align
) && !EQ (align
, Qcenter
))
1477 error ("Bad align argument");
1479 n
= lookup_fringe_bitmap (bitmap
);
1482 if (max_used_fringe_bitmap
< max_fringe_bitmaps
)
1483 n
= max_used_fringe_bitmap
++;
1486 for (n
= MAX_STANDARD_FRINGE_BITMAPS
;
1487 n
< max_fringe_bitmaps
;
1489 if (fringe_bitmaps
[n
] == NULL
)
1492 if (n
== max_fringe_bitmaps
)
1494 if ((max_fringe_bitmaps
+ 20) > MAX_FRINGE_BITMAPS
)
1495 error ("No free fringe bitmap slots");
1497 i
= max_fringe_bitmaps
;
1498 max_fringe_bitmaps
+= 20;
1500 = ((struct fringe_bitmap
**)
1501 xrealloc (fringe_bitmaps
, max_fringe_bitmaps
* sizeof (struct fringe_bitmap
*)));
1503 = (Lisp_Object
*) xrealloc (fringe_faces
, max_fringe_bitmaps
* sizeof (Lisp_Object
));
1505 for (; i
< max_fringe_bitmaps
; i
++)
1507 fringe_bitmaps
[i
] = NULL
;
1508 fringe_faces
[i
] = Qnil
;
1513 Vfringe_bitmaps
= Fcons (bitmap
, Vfringe_bitmaps
);
1514 Fput (bitmap
, Qfringe
, make_number (n
));
1519 xfb
= (struct fringe_bitmap
*) xmalloc (sizeof fb
1520 + fb
.height
* BYTES_PER_BITMAP_ROW
);
1521 fb
.bits
= b
= (unsigned short *) (xfb
+ 1);
1522 bzero (b
, fb
.height
);
1525 while (j
< fb
.height
)
1527 for (i
= 0; i
< fill1
&& j
< fb
.height
; i
++)
1529 for (i
= 0; i
< h
&& j
< fb
.height
; i
++)
1531 Lisp_Object elt
= Faref (bits
, make_number (i
));
1532 b
[j
++] = NUMBERP (elt
) ? XINT (elt
) : 0;
1534 for (i
= 0; i
< fill2
&& j
< fb
.height
; i
++)
1540 init_fringe_bitmap (n
, xfb
, 0);
1545 DEFUN ("set-fringe-bitmap-face", Fset_fringe_bitmap_face
, Sset_fringe_bitmap_face
,
1547 doc
: /* Set face for fringe bitmap BITMAP to FACE.
1548 If FACE is nil, reset face to default fringe face. */)
1550 Lisp_Object bitmap
, face
;
1555 CHECK_SYMBOL (bitmap
);
1556 n
= lookup_fringe_bitmap (bitmap
);
1558 error ("Undefined fringe bitmap");
1562 face_id
= lookup_derived_face (SELECTED_FRAME (), face
,
1563 'A', FRINGE_FACE_ID
, 1);
1565 error ("No such face");
1568 fringe_faces
[n
] = face
;
1573 DEFUN ("fringe-bitmaps-at-pos", Ffringe_bitmaps_at_pos
, Sfringe_bitmaps_at_pos
,
1575 doc
: /* Return fringe bitmaps of row containing position POS in window WINDOW.
1576 If WINDOW is nil, use selected window. If POS is nil, use value of point
1577 in that window. Return value is a list (LEFT RIGHT OV), where LEFT
1578 is the symbol for the bitmap in the left fringe (or nil if no bitmap),
1579 RIGHT is similar for the right fringe, and OV is non-nil if there is an
1580 overlay arrow in the left fringe.
1581 Return nil if POS is not visible in WINDOW. */)
1583 Lisp_Object pos
, window
;
1586 struct glyph_row
*row
;
1590 window
= selected_window
;
1591 CHECK_WINDOW (window
);
1592 w
= XWINDOW (window
);
1596 CHECK_NUMBER_COERCE_MARKER (pos
);
1597 textpos
= XINT (pos
);
1599 else if (w
== XWINDOW (selected_window
))
1602 textpos
= XMARKER (w
->pointm
)->charpos
;
1604 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1605 row
= row_containing_pos (w
, textpos
, row
, NULL
, 0);
1607 return list3 (get_fringe_bitmap_name (row
->left_fringe_bitmap
),
1608 get_fringe_bitmap_name (row
->right_fringe_bitmap
),
1609 (row
->overlay_arrow_bitmap
== 0 ? Qnil
1610 : row
->overlay_arrow_bitmap
< 0 ? Qt
1611 : get_fringe_bitmap_name (row
->overlay_arrow_bitmap
)));
1617 /***********************************************************************
1619 ***********************************************************************/
1624 Qtruncation
= intern ("truncation");
1625 staticpro (&Qtruncation
);
1626 Qcontinuation
= intern ("continuation");
1627 staticpro (&Qcontinuation
);
1628 Qoverlay_arrow
= intern ("overlay-arrow");
1629 staticpro (&Qoverlay_arrow
);
1630 Qempty_line
= intern ("empty-line");
1631 staticpro (&Qempty_line
);
1632 Qtop_bottom
= intern ("top-bottom");
1633 staticpro (&Qtop_bottom
);
1634 Qhollow_small
= intern ("hollow-small");
1635 staticpro (&Qhollow_small
);
1637 defsubr (&Sdestroy_fringe_bitmap
);
1638 defsubr (&Sdefine_fringe_bitmap
);
1639 defsubr (&Sfringe_bitmaps_at_pos
);
1640 defsubr (&Sset_fringe_bitmap_face
);
1642 DEFVAR_LISP ("overflow-newline-into-fringe", &Voverflow_newline_into_fringe
,
1643 doc
: /* *Non-nil means that newline may flow into the right fringe.
1644 This means that display lines which are exactly as wide as the window
1645 (not counting the final newline) will only occupy one screen line, by
1646 showing (or hiding) the final newline in the right fringe; when point
1647 is at the final newline, the cursor is shown in the right fringe.
1648 If nil, also continue lines which are exactly as wide as the window. */);
1649 Voverflow_newline_into_fringe
= Qt
;
1651 DEFVAR_LISP ("fringe-bitmaps", &Vfringe_bitmaps
,
1652 doc
: /* List of fringe bitmap symbols. */);
1653 Vfringe_bitmaps
= Qnil
;
1656 /* Garbage collection hook */
1663 for (i
= 0; i
< max_fringe_bitmaps
; i
++)
1664 if (!NILP (fringe_faces
[i
]))
1665 mark_object (fringe_faces
[i
]);
1668 /* Initialize this module when Emacs starts. */
1675 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< MAX_STANDARD_FRINGE_BITMAPS
; bt
++)
1676 init_fringe_bitmap(bt
, &standard_bitmaps
[bt
], 1);
1684 max_fringe_bitmaps
= MAX_STANDARD_FRINGE_BITMAPS
+ 20;
1687 = (struct fringe_bitmap
**) xmalloc (max_fringe_bitmaps
* sizeof (struct fringe_bitmap
*));
1689 = (Lisp_Object
*) xmalloc (max_fringe_bitmaps
* sizeof (Lisp_Object
));
1691 for (i
= 0; i
< max_fringe_bitmaps
; i
++)
1693 fringe_bitmaps
[i
] = NULL
;
1694 fringe_faces
[i
] = Qnil
;
1708 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< MAX_STANDARD_FRINGE_BITMAPS
; bt
++)
1710 struct fringe_bitmap
*fb
= &standard_bitmaps
[bt
];
1711 rif
->define_fringe_bitmap (bt
, fb
->bits
, fb
->height
, fb
->width
);
1716 w32_reset_fringes ()
1718 /* Destroy row bitmaps. */
1724 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< max_used_fringe_bitmap
; bt
++)
1725 rif
->destroy_fringe_bitmap (bt
);
1728 #endif /* HAVE_NTGUI */
1730 #endif /* HAVE_WINDOW_SYSTEM */
1732 /* arch-tag: 04596920-43eb-473d-b319-82712338162d
1733 (do not change this comment) */