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 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 extern Lisp_Object Qfringe
;
36 extern Lisp_Object Qtop
, Qbottom
, Qcenter
;
37 extern Lisp_Object Qup
, Qdown
, Qleft
, Qright
;
39 /* Non-nil means that newline may flow into the right fringe. */
41 Lisp_Object Voverflow_newline_into_fringe
;
43 /* List of known fringe bitmap symbols.
45 The fringe bitmap number is stored in the `fringe' property on
46 those symbols. Names for the built-in bitmaps are installed by
50 Lisp_Object Vfringe_bitmaps
;
52 /* Fringe bitmaps are represented in three different ways:
54 Logical bitmaps are used internally to denote things like
55 'end-of-buffer', 'left-truncation', 'overlay-arrow', etc.
57 Physical bitmaps specify the visual appearence of the bitmap,
58 e.g. 'bottom-left-angle', 'left-arrow', 'left-triangle', etc.
59 User defined bitmaps are physical bitmaps.
61 Internally, fringe bitmaps for a specific display row are
62 represented as a simple integer that is used as an index
63 into the table of all defined bitmaps. This index is stored
64 in the `fringe' property of the physical bitmap symbol.
66 Logical bitmaps are mapped to physical bitmaps through the
67 buffer-local `fringe-indicator-alist' variable.
69 Each element of this alist is a cons (LOGICAL . PHYSICAL)
70 mapping a logical bitmap to a physical bitmap.
71 PHYSICAL is either a symbol to use in both left and right fringe,
72 or a cons of two symbols (LEFT . RIGHT) denoting different
73 bitmaps to use in left and right fringe.
75 LOGICAL is first looked up in the window's buffer's buffer-local
76 value of the fringe-indicator-alist variable, and if not present,
77 in the global value of fringe-indicator-alist.
79 If LOGICAL is not present in either alist, or the PHYSICAL value
80 found is nil, no bitmap is shown for the logical bitmap.
82 The `left-fringe' and `right-fringe' display properties
83 must specify physical bitmap symbols.
86 extern Lisp_Object Qunknown
;
87 Lisp_Object Qtruncation
, Qcontinuation
, Qoverlay_arrow
;
88 Lisp_Object Qempty_line
, Qtop_bottom
;
89 extern Lisp_Object Qbar
, Qhbar
, Qbox
, Qhollow
;
90 Lisp_Object Qhollow_small
;
92 enum fringe_bitmap_align
94 ALIGN_BITMAP_CENTER
= 0,
101 unsigned short *bits
;
106 unsigned dynamic
: 1;
110 /***********************************************************************
112 ***********************************************************************/
114 /* Undefined bitmap. A question mark. */
127 static unsigned short question_mark_bits
[] = {
128 0x3c, 0x7e, 0x7e, 0x0c, 0x18, 0x18, 0x00, 0x18, 0x18};
130 /* An arrow like this: `<-'. */
141 static unsigned short left_arrow_bits
[] = {
142 0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
145 /* Right truncation arrow bitmap `->'. */
156 static unsigned short right_arrow_bits
[] = {
157 0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
160 /* Up arrow bitmap. */
171 static unsigned short up_arrow_bits
[] = {
172 0x18, 0x3c, 0x7e, 0xff, 0x18, 0x18, 0x18, 0x18};
175 /* Down arrow bitmap. */
186 static unsigned short down_arrow_bits
[] = {
187 0x18, 0x18, 0x18, 0x18, 0xff, 0x7e, 0x3c, 0x18};
189 /* Marker for continuation lines. */
200 static unsigned short left_curly_arrow_bits
[] = {
201 0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
203 /* Marker for continued lines. */
214 static unsigned short right_curly_arrow_bits
[] = {
215 0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
217 /* Reverse Overlay arrow bitmap. A triangular arrow. */
228 static unsigned short left_triangle_bits
[] = {
229 0x03, 0x0f, 0x1f, 0x3f, 0x3f, 0x1f, 0x0f, 0x03};
231 /* Overlay arrow bitmap. A triangular arrow. */
242 static unsigned short right_triangle_bits
[] = {
243 0xc0, 0xf0, 0xf8, 0xfc, 0xfc, 0xf8, 0xf0, 0xc0};
245 /* First line bitmap. An top-left angle. */
256 static unsigned short top_left_angle_bits
[] = {
257 0xfc, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00};
259 /* First line bitmap. An right-up angle. */
270 static unsigned short top_right_angle_bits
[] = {
271 0x3f, 0x3f, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00};
273 /* Last line bitmap. An left-down angle. */
284 static unsigned short bottom_left_angle_bits
[] = {
285 0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfc, 0xfc};
287 /* Last line bitmap. An right-down angle. */
298 static unsigned short bottom_right_angle_bits
[] = {
299 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x3f, 0x3f};
301 /* First/last line bitmap. An left bracket. */
314 static unsigned short left_bracket_bits
[] = {
315 0xfc, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfc, 0xfc};
317 /* First/last line bitmap. An right bracket. */
330 static unsigned short right_bracket_bits
[] = {
331 0x3f, 0x3f, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x3f, 0x3f};
333 /* Filled box cursor bitmap. A filled box; max 13 pixels high. */
349 static unsigned short filled_rectangle_bits
[] = {
350 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe};
352 /* Hollow box cursor bitmap. A hollow box; max 13 pixels high. */
368 static unsigned short hollow_rectangle_bits
[] = {
369 0xfe, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0xfe};
371 /* Hollow square bitmap. */
380 static unsigned short hollow_square_bits
[] = {
381 0x7e, 0x42, 0x42, 0x42, 0x42, 0x7e};
383 /* Filled square bitmap. */
392 static unsigned short filled_square_bits
[] = {
393 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e};
395 /* Bar cursor bitmap. A vertical bar; max 13 pixels high. */
411 static unsigned short vertical_bar_bits
[] = {
412 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0};
414 /* HBar cursor bitmap. A horizontal bar; 2 pixels high. */
419 static unsigned short horizontal_bar_bits
[] = {
423 /* Bitmap drawn to indicate lines not displaying text if
424 `indicate-empty-lines' is non-nil. */
433 static unsigned short empty_line_bits
[] = {
434 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
435 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
436 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
437 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
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};
444 #define BYTES_PER_BITMAP_ROW (sizeof (unsigned short))
445 #define STANDARD_BITMAP_HEIGHT(bits) (sizeof (bits)/BYTES_PER_BITMAP_ROW)
446 #define FRBITS(bits) bits, STANDARD_BITMAP_HEIGHT (bits)
448 /* NOTE: The order of these bitmaps must match the sequence
449 used in fringe.el to define the corresponding symbols. */
451 struct fringe_bitmap standard_bitmaps
[] =
453 { NULL
, 0, 0, 0, 0, 0 }, /* NO_FRINGE_BITMAP */
454 { FRBITS (question_mark_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
455 { FRBITS (left_arrow_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
456 { FRBITS (right_arrow_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
457 { FRBITS (up_arrow_bits
), 8, 0, ALIGN_BITMAP_TOP
, 0 },
458 { FRBITS (down_arrow_bits
), 8, 0, ALIGN_BITMAP_BOTTOM
, 0 },
459 { FRBITS (left_curly_arrow_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
460 { FRBITS (right_curly_arrow_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
461 { FRBITS (left_triangle_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
462 { FRBITS (right_triangle_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
463 { FRBITS (top_left_angle_bits
), 8, 0, ALIGN_BITMAP_TOP
, 0 },
464 { FRBITS (top_right_angle_bits
), 8, 0, ALIGN_BITMAP_TOP
, 0 },
465 { FRBITS (bottom_left_angle_bits
), 8, 0, ALIGN_BITMAP_BOTTOM
, 0 },
466 { FRBITS (bottom_right_angle_bits
), 8, 0, ALIGN_BITMAP_BOTTOM
, 0 },
467 { FRBITS (left_bracket_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
468 { FRBITS (right_bracket_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
469 { FRBITS (filled_rectangle_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
470 { FRBITS (hollow_rectangle_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
471 { FRBITS (filled_square_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
472 { FRBITS (hollow_square_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
473 { FRBITS (vertical_bar_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
474 { FRBITS (horizontal_bar_bits
), 8, 0, ALIGN_BITMAP_BOTTOM
, 0 },
475 { FRBITS (empty_line_bits
), 8, 3, ALIGN_BITMAP_TOP
, 0 },
478 #define NO_FRINGE_BITMAP 0
479 #define UNDEF_FRINGE_BITMAP 1
480 #define MAX_STANDARD_FRINGE_BITMAPS (sizeof(standard_bitmaps)/sizeof(standard_bitmaps[0]))
482 static struct fringe_bitmap
**fringe_bitmaps
;
483 static Lisp_Object
*fringe_faces
;
484 static int max_fringe_bitmaps
;
486 int max_used_fringe_bitmap
= MAX_STANDARD_FRINGE_BITMAPS
;
489 /* Lookup bitmap number for symbol BITMAP.
490 Return 0 if not a bitmap. */
493 lookup_fringe_bitmap (bitmap
)
498 bitmap
= Fget (bitmap
, Qfringe
);
499 if (!INTEGERP (bitmap
))
503 if (bn
> NO_FRINGE_BITMAP
504 && bn
< max_used_fringe_bitmap
505 && (bn
< MAX_STANDARD_FRINGE_BITMAPS
506 || fringe_bitmaps
[bn
] != NULL
))
512 /* Get fringe bitmap name for bitmap number BN.
514 Found by traversing Vfringe_bitmaps comparing BN to the
515 fringe property for each symbol.
517 Return BN if not found in Vfringe_bitmaps. */
520 get_fringe_bitmap_name (bn
)
526 /* Zero means no bitmap -- return nil. */
530 bitmaps
= Vfringe_bitmaps
;
531 num
= make_number (bn
);
533 while (CONSP (bitmaps
))
535 Lisp_Object bitmap
= XCAR (bitmaps
);
536 if (EQ (num
, Fget (bitmap
, Qfringe
)))
538 bitmaps
= XCDR (bitmaps
);
545 /* Draw the bitmap WHICH in one of the left or right fringes of
546 window W. ROW is the glyph row for which to display the bitmap; it
547 determines the vertical position at which the bitmap has to be
549 LEFT_P is 1 for left fringe, 0 for right fringe.
553 draw_fringe_bitmap_1 (w
, row
, left_p
, overlay
, which
)
555 struct glyph_row
*row
;
559 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
560 struct draw_fringe_bitmap_params p
;
561 struct fringe_bitmap
*fb
;
563 int face_id
= DEFAULT_FACE_ID
;
566 p
.overlay_p
= (overlay
& 1) == 1;
567 p
.cursor_p
= (overlay
& 2) == 2;
569 if (which
!= NO_FRINGE_BITMAP
)
574 which
= row
->left_fringe_bitmap
;
575 face_id
= row
->left_fringe_face_id
;
579 which
= row
->right_fringe_bitmap
;
580 face_id
= row
->right_fringe_face_id
;
583 if (face_id
== DEFAULT_FACE_ID
)
587 if ((face
= fringe_faces
[which
], NILP (face
))
588 || (face_id
= lookup_derived_face (f
, face
, FRINGE_FACE_ID
, 0),
590 face_id
= FRINGE_FACE_ID
;
593 fb
= fringe_bitmaps
[which
];
595 fb
= &standard_bitmaps
[which
< MAX_STANDARD_FRINGE_BITMAPS
596 ? which
: UNDEF_FRINGE_BITMAP
];
600 /* Convert row to frame coordinates. */
601 p
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
608 p
.dh
= (period
> 0 ? (p
.y
% period
) : 0);
610 /* Clip bitmap if too high. */
611 if (p
.h
> row
->height
)
614 p
.face
= FACE_FROM_ID (f
, face_id
);
618 /* This could happen after clearing face cache.
619 But it shouldn't happen anymore. ++kfs */
623 PREPARE_FACE_FOR_DISPLAY (f
, p
.face
);
625 /* Clear left fringe if no bitmap to draw or if bitmap doesn't fill
630 int wd
= WINDOW_LEFT_FRINGE_WIDTH (w
);
631 int x
= window_box_left (w
, (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
636 p
.x
= x
- p
.wd
- (wd
- p
.wd
) / 2;
638 if (p
.wd
< wd
|| row
->height
> p
.h
)
640 /* If W has a vertical border to its left, don't draw over it. */
641 wd
-= ((!WINDOW_LEFTMOST_P (w
)
642 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
650 int x
= window_box_right (w
,
651 (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
654 int wd
= WINDOW_RIGHT_FRINGE_WIDTH (w
);
657 p
.x
= x
+ (wd
- p
.wd
) / 2;
658 /* Clear right fringe if no bitmap to draw of if bitmap doesn't fill
660 if (p
.wd
< wd
|| row
->height
> p
.h
)
669 int header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
671 p
.by
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
, row
->y
));
672 p
.ny
= row
->visible_height
;
675 /* Adjust y to the offset in the row to start drawing the bitmap. */
678 case ALIGN_BITMAP_CENTER
:
679 p
.y
+= (row
->height
- p
.h
) / 2;
681 case ALIGN_BITMAP_BOTTOM
:
683 p
.y
+= (row
->visible_height
- p
.h
);
685 case ALIGN_BITMAP_TOP
:
689 FRAME_RIF (f
)->draw_fringe_bitmap (w
, row
, &p
);
693 get_logical_cursor_bitmap (w
, cursor
)
697 Lisp_Object cmap
, bm
= Qnil
;
699 if ((cmap
= XBUFFER (w
->buffer
)->fringe_cursor_alist
), !NILP (cmap
))
701 bm
= Fassq (cursor
, cmap
);
704 if ((bm
= XCDR (bm
)), NILP (bm
))
705 return NO_FRINGE_BITMAP
;
706 return lookup_fringe_bitmap (bm
);
709 if (EQ (cmap
, buffer_defaults
.fringe_cursor_alist
))
710 return NO_FRINGE_BITMAP
;
711 bm
= Fassq (cursor
, buffer_defaults
.fringe_cursor_alist
);
712 if (!CONSP (bm
) || ((bm
= XCDR (bm
)), NILP (bm
)))
713 return NO_FRINGE_BITMAP
;
714 return lookup_fringe_bitmap (bm
);
718 get_logical_fringe_bitmap (w
, bitmap
, right_p
, partial_p
)
721 int right_p
, partial_p
;
723 Lisp_Object cmap
, bm1
= Qnil
, bm2
= Qnil
, bm
;
724 int ln1
= 0, ln2
= 0;
726 int ix2
= ix1
+ (partial_p
? 2 : 0);
728 /* Lookup in buffer-local fringe-indicator-alist before global alist.
731 BITMAP -- use for all
732 (L R) -- use for left right (whether partial or not)
733 (L R PL PR) -- use for left rigth partial-left partial-right
734 If any value in local binding is not present or t, use global value.
736 If partial, lookup partial bitmap in default value if not found here.
737 If not partial, or no partial spec is present, use non-partial bitmap. */
739 if ((cmap
= XBUFFER (w
->buffer
)->fringe_indicator_alist
), !NILP (cmap
))
741 bm1
= Fassq (bitmap
, cmap
);
744 if ((bm1
= XCDR (bm1
)), NILP (bm1
))
745 return NO_FRINGE_BITMAP
;
748 ln1
= XINT (Flength (bm1
));
753 bm
= Fnth (make_number (ix2
), bm1
);
762 bm
= Fnth (make_number (ix1
), bm1
);
768 else if ((bm
= bm1
, !EQ (bm
, Qt
)))
773 if (!EQ (cmap
, buffer_defaults
.fringe_indicator_alist
)
774 && !NILP (buffer_defaults
.fringe_indicator_alist
))
776 bm2
= Fassq (bitmap
, buffer_defaults
.fringe_indicator_alist
);
779 if ((bm2
= XCDR (bm2
)), !NILP (bm2
))
783 ln2
= XINT (Flength (bm2
));
788 bm
= Fnth (make_number (ix2
), bm2
);
800 bm
= Fnth (make_number (ix1
), bm1
);
807 bm
= Fnth (make_number (ix1
), bm2
);
810 return NO_FRINGE_BITMAP
;
812 else if ((bm
= bm2
, NILP (bm
)))
813 return NO_FRINGE_BITMAP
;
816 return lookup_fringe_bitmap (bm
);
821 draw_fringe_bitmap (w
, row
, left_p
)
823 struct glyph_row
*row
;
828 if (left_p
== row
->reversed_p
&& row
->cursor_in_fringe_p
)
830 Lisp_Object cursor
= Qnil
;
832 switch (w
->phys_cursor_type
)
834 case HOLLOW_BOX_CURSOR
:
835 if (row
->visible_height
>= STANDARD_BITMAP_HEIGHT (hollow_rectangle_bits
))
838 cursor
= Qhollow_small
;
840 case FILLED_BOX_CURSOR
:
851 w
->phys_cursor_on_p
= 0;
852 row
->cursor_in_fringe_p
= 0;
857 int bm
= get_logical_cursor_bitmap (w
, cursor
);
858 if (bm
!= NO_FRINGE_BITMAP
)
860 draw_fringe_bitmap_1 (w
, row
, left_p
, 2, bm
);
861 overlay
= EQ (cursor
, Qbox
) ? 3 : 1;
866 draw_fringe_bitmap_1 (w
, row
, left_p
, overlay
, NO_FRINGE_BITMAP
);
868 if (left_p
&& row
->overlay_arrow_bitmap
!= NO_FRINGE_BITMAP
)
869 draw_fringe_bitmap_1 (w
, row
, 1, 1, row
->overlay_arrow_bitmap
);
873 /* Draw fringe bitmaps for glyph row ROW on window W. Call this
874 function with input blocked. */
877 draw_row_fringe_bitmaps (w
, row
)
879 struct glyph_row
*row
;
881 xassert (interrupt_input_blocked
);
883 /* If row is completely invisible, because of vscrolling, we
884 don't have to draw anything. */
885 if (row
->visible_height
<= 0)
888 if (WINDOW_LEFT_FRINGE_WIDTH (w
) != 0)
889 draw_fringe_bitmap (w
, row
, 1);
891 if (WINDOW_RIGHT_FRINGE_WIDTH (w
) != 0)
892 draw_fringe_bitmap (w
, row
, 0);
895 /* Draw the fringes of window W. Only fringes for rows marked for
896 update in redraw_fringe_bitmaps_p are drawn.
898 Return >0 if left or right fringe was redrawn in any way.
900 If NO_FRINGE is non-zero, also return >0 if either fringe has zero width.
902 A return value >0 indicates that the vertical line between windows
903 needs update (as it may be drawn in the fringe).
907 draw_window_fringes (w
, no_fringe
)
911 struct glyph_row
*row
;
912 int yb
= window_text_bottom_y (w
);
913 int nrows
= w
->current_matrix
->nrows
;
917 if (w
->pseudo_window_p
)
920 /* Must draw line if no fringe */
922 && (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0
923 || WINDOW_RIGHT_FRINGE_WIDTH (w
) == 0))
926 for (y
= 0, rn
= 0, row
= w
->current_matrix
->rows
;
927 y
< yb
&& rn
< nrows
;
928 y
+= row
->height
, ++row
, ++rn
)
930 if (!row
->redraw_fringe_bitmaps_p
)
932 draw_row_fringe_bitmaps (w
, row
);
933 row
->redraw_fringe_bitmaps_p
= 0;
941 /* Recalculate the bitmaps to show in the fringes of window W.
942 Only mark rows with modified bitmaps for update in redraw_fringe_bitmaps_p.
944 If KEEP_CURRENT_P is 0, update current_matrix too. */
947 update_window_fringes (w
, keep_current_p
)
951 struct glyph_row
*row
, *cur
= 0;
952 int yb
= window_text_bottom_y (w
);
953 int rn
, nrows
= w
->current_matrix
->nrows
;
956 Lisp_Object boundary_top
= Qnil
, boundary_bot
= Qnil
;
957 Lisp_Object arrow_top
= Qnil
, arrow_bot
= Qnil
;
958 Lisp_Object empty_pos
;
959 Lisp_Object ind
= Qnil
;
960 #define MAX_BITMAP_CACHE (8*4)
961 int bitmap_cache
[MAX_BITMAP_CACHE
];
963 if (w
->pseudo_window_p
)
966 if (!MINI_WINDOW_P (w
)
967 && (ind
= XBUFFER (w
->buffer
)->indicate_buffer_boundaries
, !NILP (ind
)))
969 if (EQ (ind
, Qleft
) || EQ (ind
, Qright
))
970 boundary_top
= boundary_bot
= arrow_top
= arrow_bot
= ind
;
971 else if (CONSP (ind
) && CONSP (XCAR (ind
)))
974 if (pos
= Fassq (Qt
, ind
), !NILP (pos
))
975 boundary_top
= boundary_bot
= arrow_top
= arrow_bot
= XCDR (pos
);
976 if (pos
= Fassq (Qtop
, ind
), !NILP (pos
))
977 boundary_top
= XCDR (pos
);
978 if (pos
= Fassq (Qbottom
, ind
), !NILP (pos
))
979 boundary_bot
= XCDR (pos
);
980 if (pos
= Fassq (Qup
, ind
), !NILP (pos
))
981 arrow_top
= XCDR (pos
);
982 if (pos
= Fassq (Qdown
, ind
), !NILP (pos
))
983 arrow_bot
= XCDR (pos
);
986 /* Anything else means boundary on left and no arrows. */
987 boundary_top
= boundary_bot
= Qleft
;
992 int done_top
= 0, done_bot
= 0;
995 y
< yb
&& rn
< nrows
;
996 y
+= row
->height
, ++rn
)
998 unsigned indicate_bob_p
, indicate_top_line_p
;
999 unsigned indicate_eob_p
, indicate_bottom_line_p
;
1001 row
= w
->desired_matrix
->rows
+ rn
;
1002 if (!row
->enabled_p
)
1003 row
= w
->current_matrix
->rows
+ rn
;
1005 indicate_bob_p
= row
->indicate_bob_p
;
1006 indicate_top_line_p
= row
->indicate_top_line_p
;
1007 indicate_eob_p
= row
->indicate_eob_p
;
1008 indicate_bottom_line_p
= row
->indicate_bottom_line_p
;
1010 row
->indicate_bob_p
= row
->indicate_top_line_p
= 0;
1011 row
->indicate_eob_p
= row
->indicate_bottom_line_p
= 0;
1013 if (!row
->mode_line_p
)
1017 if (MATRIX_ROW_START_CHARPOS (row
) <= BUF_BEGV (XBUFFER (w
->buffer
))
1018 && !MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (w
, row
))
1019 row
->indicate_bob_p
= !NILP (boundary_top
);
1021 row
->indicate_top_line_p
= !NILP (arrow_top
);
1027 if (MATRIX_ROW_END_CHARPOS (row
) >= BUF_ZV (XBUFFER (w
->buffer
))
1028 && !MATRIX_ROW_PARTIALLY_VISIBLE_AT_BOTTOM_P (w
, row
))
1029 row
->indicate_eob_p
= !NILP (boundary_bot
), done_bot
= 1;
1030 else if (y
+ row
->height
>= yb
)
1031 row
->indicate_bottom_line_p
= !NILP (arrow_bot
), done_bot
= 1;
1035 if (indicate_bob_p
!= row
->indicate_bob_p
1036 || indicate_top_line_p
!= row
->indicate_top_line_p
1037 || indicate_eob_p
!= row
->indicate_eob_p
1038 || indicate_bottom_line_p
!= row
->indicate_bottom_line_p
)
1039 row
->redraw_fringe_bitmaps_p
= 1;
1043 empty_pos
= XBUFFER (w
->buffer
)->indicate_empty_lines
;
1044 if (!NILP (empty_pos
) && !EQ (empty_pos
, Qright
))
1045 empty_pos
= WINDOW_LEFT_FRINGE_WIDTH (w
) == 0 ? Qright
: Qleft
;
1047 for (y
= 0; y
< MAX_BITMAP_CACHE
; y
++)
1048 bitmap_cache
[y
] = -1;
1050 #define LEFT_FRINGE(cache, which, partial_p) \
1051 (bitmap_cache[cache*4+partial_p] >= 0 \
1052 ? bitmap_cache[cache*4+partial_p] \
1053 : (bitmap_cache[cache*4+partial_p] = \
1054 get_logical_fringe_bitmap (w, which, 0, partial_p)))
1056 #define RIGHT_FRINGE(cache, which, partial_p) \
1057 (bitmap_cache[cache*4+2+partial_p] >= 0 \
1058 ? bitmap_cache[cache*4+2+partial_p] \
1059 : (bitmap_cache[cache*4+2+partial_p] = \
1060 get_logical_fringe_bitmap (w, which, 1, partial_p)))
1064 y
< yb
&& rn
< nrows
;
1065 y
+= row
->height
, rn
++)
1068 unsigned left_face_id
, right_face_id
;
1070 row
= w
->desired_matrix
->rows
+ rn
;
1071 cur
= w
->current_matrix
->rows
+ rn
;
1072 if (!row
->enabled_p
)
1075 left_face_id
= right_face_id
= DEFAULT_FACE_ID
;
1077 /* Decide which bitmap to draw in the left fringe. */
1078 if (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0)
1079 left
= NO_FRINGE_BITMAP
;
1080 else if (row
->left_user_fringe_bitmap
!= NO_FRINGE_BITMAP
)
1082 left
= row
->left_user_fringe_bitmap
;
1083 left_face_id
= row
->left_user_fringe_face_id
;
1085 else if (row
->truncated_on_left_p
)
1086 left
= LEFT_FRINGE(0, Qtruncation
, 0);
1087 else if (row
->indicate_bob_p
&& EQ (boundary_top
, Qleft
))
1088 left
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qleft
))
1089 ? LEFT_FRINGE (1, Qtop_bottom
, row
->ends_at_zv_p
)
1090 : LEFT_FRINGE (2, Qtop
, 0));
1091 else if (row
->indicate_eob_p
&& EQ (boundary_bot
, Qleft
))
1092 left
= LEFT_FRINGE (3, Qbottom
, row
->ends_at_zv_p
);
1093 else if ((!row
->reversed_p
&& MATRIX_ROW_CONTINUATION_LINE_P (row
))
1094 || (row
->reversed_p
&& row
->continued_p
))
1095 left
= LEFT_FRINGE (4, Qcontinuation
, 0);
1096 else if (row
->indicate_empty_line_p
&& EQ (empty_pos
, Qleft
))
1097 left
= LEFT_FRINGE (5, Qempty_line
, 0);
1098 else if (row
->indicate_top_line_p
&& EQ (arrow_top
, Qleft
))
1099 left
= LEFT_FRINGE (6, Qup
, 0);
1100 else if (row
->indicate_bottom_line_p
&& EQ (arrow_bot
, Qleft
))
1101 left
= LEFT_FRINGE (7, Qdown
, 0);
1103 left
= NO_FRINGE_BITMAP
;
1105 /* Decide which bitmap to draw in the right fringe. */
1106 if (WINDOW_RIGHT_FRINGE_WIDTH (w
) == 0)
1107 right
= NO_FRINGE_BITMAP
;
1108 else if (row
->right_user_fringe_bitmap
!= NO_FRINGE_BITMAP
)
1110 right
= row
->right_user_fringe_bitmap
;
1111 right_face_id
= row
->right_user_fringe_face_id
;
1113 else if (row
->truncated_on_right_p
)
1114 right
= RIGHT_FRINGE (0, Qtruncation
, 0);
1115 else if (row
->indicate_bob_p
&& EQ (boundary_top
, Qright
))
1116 right
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qright
))
1117 ? RIGHT_FRINGE (1, Qtop_bottom
, row
->ends_at_zv_p
)
1118 : RIGHT_FRINGE (2, Qtop
, 0));
1119 else if (row
->indicate_eob_p
&& EQ (boundary_bot
, Qright
))
1120 right
= RIGHT_FRINGE (3, Qbottom
, row
->ends_at_zv_p
);
1121 else if ((!row
->reversed_p
&& row
->continued_p
)
1122 || (row
->reversed_p
&& MATRIX_ROW_CONTINUATION_LINE_P (row
)))
1123 right
= RIGHT_FRINGE (4, Qcontinuation
, 0);
1124 else if (row
->indicate_top_line_p
&& EQ (arrow_top
, Qright
))
1125 right
= RIGHT_FRINGE (6, Qup
, 0);
1126 else if (row
->indicate_bottom_line_p
&& EQ (arrow_bot
, Qright
))
1127 right
= RIGHT_FRINGE (7, Qdown
, 0);
1128 else if (row
->indicate_empty_line_p
&& EQ (empty_pos
, Qright
))
1129 right
= RIGHT_FRINGE (5, Qempty_line
, 0);
1131 right
= NO_FRINGE_BITMAP
;
1133 if (row
->y
!= cur
->y
1134 || row
->visible_height
!= cur
->visible_height
1135 || row
->ends_at_zv_p
!= cur
->ends_at_zv_p
1136 || left
!= cur
->left_fringe_bitmap
1137 || right
!= cur
->right_fringe_bitmap
1138 || left_face_id
!= cur
->left_fringe_face_id
1139 || right_face_id
!= cur
->right_fringe_face_id
1140 || cur
->redraw_fringe_bitmaps_p
)
1142 redraw_p
= row
->redraw_fringe_bitmaps_p
= 1;
1143 if (!keep_current_p
)
1145 cur
->redraw_fringe_bitmaps_p
= 1;
1146 cur
->left_fringe_bitmap
= left
;
1147 cur
->right_fringe_bitmap
= right
;
1148 cur
->left_fringe_face_id
= left_face_id
;
1149 cur
->right_fringe_face_id
= right_face_id
;
1153 if (row
->overlay_arrow_bitmap
< 0)
1154 row
->overlay_arrow_bitmap
= get_logical_fringe_bitmap (w
, Qoverlay_arrow
, 0, 0);
1156 if (row
->overlay_arrow_bitmap
!= cur
->overlay_arrow_bitmap
)
1158 redraw_p
= row
->redraw_fringe_bitmaps_p
= cur
->redraw_fringe_bitmaps_p
= 1;
1159 cur
->overlay_arrow_bitmap
= row
->overlay_arrow_bitmap
;
1162 row
->left_fringe_bitmap
= left
;
1163 row
->right_fringe_bitmap
= right
;
1164 row
->left_fringe_face_id
= left_face_id
;
1165 row
->right_fringe_face_id
= right_face_id
;
1167 if (rn
> 0 && row
->redraw_fringe_bitmaps_p
)
1168 row
[-1].redraw_fringe_bitmaps_p
= cur
[-1].redraw_fringe_bitmaps_p
= 1;
1171 return redraw_p
&& !keep_current_p
;
1175 /* Compute actual fringe widths for frame F.
1177 If REDRAW is 1, redraw F if the fringe settings was actually
1178 modified and F is visible.
1180 Since the combined left and right fringe must occupy an integral
1181 number of columns, we may need to add some pixels to each fringe.
1182 Typically, we add an equal amount (+/- 1 pixel) to each fringe,
1183 but a negative width value is taken literally (after negating it).
1185 We never make the fringes narrower than specified.
1189 compute_fringe_widths (f
, redraw
)
1193 int o_left
= FRAME_LEFT_FRINGE_WIDTH (f
);
1194 int o_right
= FRAME_RIGHT_FRINGE_WIDTH (f
);
1195 int o_cols
= FRAME_FRINGE_COLS (f
);
1197 Lisp_Object left_fringe
= Fassq (Qleft_fringe
, f
->param_alist
);
1198 Lisp_Object right_fringe
= Fassq (Qright_fringe
, f
->param_alist
);
1199 int left_fringe_width
, right_fringe_width
;
1201 if (!NILP (left_fringe
))
1202 left_fringe
= Fcdr (left_fringe
);
1203 if (!NILP (right_fringe
))
1204 right_fringe
= Fcdr (right_fringe
);
1206 left_fringe_width
= ((NILP (left_fringe
) || !INTEGERP (left_fringe
)) ? 8 :
1207 XINT (left_fringe
));
1208 right_fringe_width
= ((NILP (right_fringe
) || !INTEGERP (right_fringe
)) ? 8 :
1209 XINT (right_fringe
));
1211 if (left_fringe_width
|| right_fringe_width
)
1213 int left_wid
= left_fringe_width
>= 0 ? left_fringe_width
: -left_fringe_width
;
1214 int right_wid
= right_fringe_width
>= 0 ? right_fringe_width
: -right_fringe_width
;
1215 int conf_wid
= left_wid
+ right_wid
;
1216 int font_wid
= FRAME_COLUMN_WIDTH (f
);
1217 int cols
= (left_wid
+ right_wid
+ font_wid
-1) / font_wid
;
1218 int real_wid
= cols
* font_wid
;
1219 if (left_wid
&& right_wid
)
1221 if (left_fringe_width
< 0)
1223 /* Left fringe width is fixed, adjust right fringe if necessary */
1224 FRAME_LEFT_FRINGE_WIDTH (f
) = left_wid
;
1225 FRAME_RIGHT_FRINGE_WIDTH (f
) = real_wid
- left_wid
;
1227 else if (right_fringe_width
< 0)
1229 /* Right fringe width is fixed, adjust left fringe if necessary */
1230 FRAME_LEFT_FRINGE_WIDTH (f
) = real_wid
- right_wid
;
1231 FRAME_RIGHT_FRINGE_WIDTH (f
) = right_wid
;
1235 /* Adjust both fringes with an equal amount.
1236 Note that we are doing integer arithmetic here, so don't
1237 lose a pixel if the total width is an odd number. */
1238 int fill
= real_wid
- conf_wid
;
1239 FRAME_LEFT_FRINGE_WIDTH (f
) = left_wid
+ fill
/2;
1240 FRAME_RIGHT_FRINGE_WIDTH (f
) = right_wid
+ fill
- fill
/2;
1243 else if (left_fringe_width
)
1245 FRAME_LEFT_FRINGE_WIDTH (f
) = real_wid
;
1246 FRAME_RIGHT_FRINGE_WIDTH (f
) = 0;
1250 FRAME_LEFT_FRINGE_WIDTH (f
) = 0;
1251 FRAME_RIGHT_FRINGE_WIDTH (f
) = real_wid
;
1253 FRAME_FRINGE_COLS (f
) = cols
;
1257 FRAME_LEFT_FRINGE_WIDTH (f
) = 0;
1258 FRAME_RIGHT_FRINGE_WIDTH (f
) = 0;
1259 FRAME_FRINGE_COLS (f
) = 0;
1262 if (redraw
&& FRAME_VISIBLE_P (f
))
1263 if (o_left
!= FRAME_LEFT_FRINGE_WIDTH (f
) ||
1264 o_right
!= FRAME_RIGHT_FRINGE_WIDTH (f
) ||
1265 o_cols
!= FRAME_FRINGE_COLS (f
))
1270 /* Free resources used by a user-defined bitmap. */
1273 destroy_fringe_bitmap (n
)
1276 struct fringe_bitmap
**fbp
;
1278 fringe_faces
[n
] = Qnil
;
1280 fbp
= &fringe_bitmaps
[n
];
1281 if (*fbp
&& (*fbp
)->dynamic
)
1283 /* XXX Is SELECTED_FRAME OK here? */
1284 struct redisplay_interface
*rif
= FRAME_RIF (SELECTED_FRAME ());
1285 if (rif
&& rif
->destroy_fringe_bitmap
)
1286 rif
->destroy_fringe_bitmap (n
);
1291 while (max_used_fringe_bitmap
> MAX_STANDARD_FRINGE_BITMAPS
1292 && fringe_bitmaps
[max_used_fringe_bitmap
- 1] == NULL
)
1293 max_used_fringe_bitmap
--;
1297 DEFUN ("destroy-fringe-bitmap", Fdestroy_fringe_bitmap
, Sdestroy_fringe_bitmap
,
1299 doc
: /* Destroy fringe bitmap BITMAP.
1300 If BITMAP overrides a standard fringe bitmap, the original bitmap is restored. */)
1306 CHECK_SYMBOL (bitmap
);
1307 n
= lookup_fringe_bitmap (bitmap
);
1311 destroy_fringe_bitmap (n
);
1313 if (n
>= MAX_STANDARD_FRINGE_BITMAPS
)
1315 Vfringe_bitmaps
= Fdelq (bitmap
, Vfringe_bitmaps
);
1316 /* It would be better to remove the fringe property. */
1317 Fput (bitmap
, Qfringe
, Qnil
);
1324 /* Initialize bitmap bit.
1326 On X, we bit-swap the built-in bitmaps and reduce bitmap
1327 from short to char array if width is <= 8 bits.
1329 On MAC with big-endian CPU, we need to byte-swap each short.
1331 On W32 and MAC (little endian), there's no need to do this.
1334 #if defined (HAVE_X_WINDOWS)
1335 static const unsigned char swap_nibble
[16] = {
1336 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
1337 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
1338 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
1339 0x3, 0xb, 0x7, 0xf}; /* 0011 1011 0111 1111 */
1340 #endif /* HAVE_X_WINDOWS */
1343 init_fringe_bitmap (which
, fb
, once_p
)
1345 struct fringe_bitmap
*fb
;
1348 if (once_p
|| fb
->dynamic
)
1350 #if defined (HAVE_X_WINDOWS)
1351 unsigned short *bits
= fb
->bits
;
1356 unsigned char *cbits
= (unsigned char *)fb
->bits
;
1357 for (j
= 0; j
< fb
->height
; j
++)
1359 unsigned short b
= *bits
++;
1361 c
= (unsigned char)((swap_nibble
[b
& 0xf] << 4)
1362 | (swap_nibble
[(b
>>4) & 0xf]));
1363 *cbits
++ = (c
>> (8 - fb
->width
));
1368 for (j
= 0; j
< fb
->height
; j
++)
1370 unsigned short b
= *bits
;
1371 b
= (unsigned short)((swap_nibble
[b
& 0xf] << 12)
1372 | (swap_nibble
[(b
>>4) & 0xf] << 8)
1373 | (swap_nibble
[(b
>>8) & 0xf] << 4)
1374 | (swap_nibble
[(b
>>12) & 0xf]));
1375 b
>>= (16 - fb
->width
);
1376 #ifdef WORDS_BIG_ENDIAN
1377 b
= ((b
>> 8) | (b
<< 8));
1382 #endif /* HAVE_X_WINDOWS */
1388 /* XXX Is SELECTED_FRAME OK here? */
1389 struct redisplay_interface
*rif
= FRAME_RIF (SELECTED_FRAME ());
1391 destroy_fringe_bitmap (which
);
1393 if (rif
&& rif
->define_fringe_bitmap
)
1394 rif
->define_fringe_bitmap (which
, fb
->bits
, fb
->height
, fb
->width
);
1396 fringe_bitmaps
[which
] = fb
;
1397 if (which
>= max_used_fringe_bitmap
)
1398 max_used_fringe_bitmap
= which
+ 1;
1403 DEFUN ("define-fringe-bitmap", Fdefine_fringe_bitmap
, Sdefine_fringe_bitmap
,
1405 doc
: /* Define fringe bitmap BITMAP from BITS of size HEIGHT x WIDTH.
1406 BITMAP is a symbol identifying the new fringe bitmap.
1407 BITS is either a string or a vector of integers.
1408 HEIGHT is height of bitmap. If HEIGHT is nil, use length of BITS.
1409 WIDTH must be an integer between 1 and 16, or nil which defaults to 8.
1410 Optional fifth arg ALIGN may be one of `top', `center', or `bottom',
1411 indicating the positioning of the bitmap relative to the rows where it
1412 is used; the default is to center the bitmap. Fifth arg may also be a
1413 list (ALIGN PERIODIC) where PERIODIC non-nil specifies that the bitmap
1415 If BITMAP already exists, the existing definition is replaced. */)
1416 (bitmap
, bits
, height
, width
, align
)
1417 Lisp_Object bitmap
, bits
, height
, width
, align
;
1421 struct fringe_bitmap fb
, *xfb
;
1422 int fill1
= 0, fill2
= 0;
1424 CHECK_SYMBOL (bitmap
);
1428 else if (VECTORP (bits
))
1429 h
= XVECTOR (bits
)->size
;
1431 wrong_type_argument (Qsequencep
, bits
);
1437 CHECK_NUMBER (height
);
1438 fb
.height
= min (XINT (height
), 255);
1441 fill1
= (fb
.height
- h
) / 2;
1442 fill2
= fb
.height
- h
- fill1
;
1450 CHECK_NUMBER (width
);
1451 fb
.width
= min (XINT (width
), 255);
1455 fb
.align
= ALIGN_BITMAP_CENTER
;
1459 Lisp_Object period
= XCDR (align
);
1462 period
= XCAR (period
);
1465 fb
.period
= fb
.height
;
1469 align
= XCAR (align
);
1471 if (EQ (align
, Qtop
))
1472 fb
.align
= ALIGN_BITMAP_TOP
;
1473 else if (EQ (align
, Qbottom
))
1474 fb
.align
= ALIGN_BITMAP_BOTTOM
;
1475 else if (!NILP (align
) && !EQ (align
, Qcenter
))
1476 error ("Bad align argument");
1478 n
= lookup_fringe_bitmap (bitmap
);
1481 if (max_used_fringe_bitmap
< max_fringe_bitmaps
)
1482 n
= max_used_fringe_bitmap
++;
1485 for (n
= MAX_STANDARD_FRINGE_BITMAPS
;
1486 n
< max_fringe_bitmaps
;
1488 if (fringe_bitmaps
[n
] == NULL
)
1491 if (n
== max_fringe_bitmaps
)
1493 if ((max_fringe_bitmaps
+ 20) > MAX_FRINGE_BITMAPS
)
1494 error ("No free fringe bitmap slots");
1496 i
= max_fringe_bitmaps
;
1497 max_fringe_bitmaps
+= 20;
1499 = ((struct fringe_bitmap
**)
1500 xrealloc (fringe_bitmaps
, max_fringe_bitmaps
* sizeof (struct fringe_bitmap
*)));
1502 = (Lisp_Object
*) xrealloc (fringe_faces
, max_fringe_bitmaps
* sizeof (Lisp_Object
));
1504 for (; i
< max_fringe_bitmaps
; i
++)
1506 fringe_bitmaps
[i
] = NULL
;
1507 fringe_faces
[i
] = Qnil
;
1512 Vfringe_bitmaps
= Fcons (bitmap
, Vfringe_bitmaps
);
1513 Fput (bitmap
, Qfringe
, make_number (n
));
1518 xfb
= (struct fringe_bitmap
*) xmalloc (sizeof fb
1519 + fb
.height
* BYTES_PER_BITMAP_ROW
);
1520 fb
.bits
= b
= (unsigned short *) (xfb
+ 1);
1521 bzero (b
, fb
.height
);
1524 while (j
< fb
.height
)
1526 for (i
= 0; i
< fill1
&& j
< fb
.height
; i
++)
1528 for (i
= 0; i
< h
&& j
< fb
.height
; i
++)
1530 Lisp_Object elt
= Faref (bits
, make_number (i
));
1531 b
[j
++] = NUMBERP (elt
) ? XINT (elt
) : 0;
1533 for (i
= 0; i
< fill2
&& j
< fb
.height
; i
++)
1539 init_fringe_bitmap (n
, xfb
, 0);
1544 DEFUN ("set-fringe-bitmap-face", Fset_fringe_bitmap_face
, Sset_fringe_bitmap_face
,
1546 doc
: /* Set face for fringe bitmap BITMAP to FACE.
1547 If FACE is nil, reset face to default fringe face. */)
1549 Lisp_Object bitmap
, face
;
1554 CHECK_SYMBOL (bitmap
);
1555 n
= lookup_fringe_bitmap (bitmap
);
1557 error ("Undefined fringe bitmap");
1561 face_id
= lookup_derived_face (SELECTED_FRAME (), face
,
1564 error ("No such face");
1567 fringe_faces
[n
] = face
;
1572 DEFUN ("fringe-bitmaps-at-pos", Ffringe_bitmaps_at_pos
, Sfringe_bitmaps_at_pos
,
1574 doc
: /* Return fringe bitmaps of row containing position POS in window WINDOW.
1575 If WINDOW is nil, use selected window. If POS is nil, use value of point
1576 in that window. Return value is a list (LEFT RIGHT OV), where LEFT
1577 is the symbol for the bitmap in the left fringe (or nil if no bitmap),
1578 RIGHT is similar for the right fringe, and OV is non-nil if there is an
1579 overlay arrow in the left fringe.
1580 Return nil if POS is not visible in WINDOW. */)
1582 Lisp_Object pos
, window
;
1585 struct glyph_row
*row
;
1589 window
= selected_window
;
1590 CHECK_WINDOW (window
);
1591 w
= XWINDOW (window
);
1595 CHECK_NUMBER_COERCE_MARKER (pos
);
1596 textpos
= XINT (pos
);
1598 else if (w
== XWINDOW (selected_window
))
1601 textpos
= XMARKER (w
->pointm
)->charpos
;
1603 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1604 row
= row_containing_pos (w
, textpos
, row
, NULL
, 0);
1606 return list3 (get_fringe_bitmap_name (row
->left_fringe_bitmap
),
1607 get_fringe_bitmap_name (row
->right_fringe_bitmap
),
1608 (row
->overlay_arrow_bitmap
== 0 ? Qnil
1609 : row
->overlay_arrow_bitmap
< 0 ? Qt
1610 : get_fringe_bitmap_name (row
->overlay_arrow_bitmap
)));
1616 /***********************************************************************
1618 ***********************************************************************/
1623 Qtruncation
= intern_c_string ("truncation");
1624 staticpro (&Qtruncation
);
1625 Qcontinuation
= intern_c_string ("continuation");
1626 staticpro (&Qcontinuation
);
1627 Qoverlay_arrow
= intern_c_string ("overlay-arrow");
1628 staticpro (&Qoverlay_arrow
);
1629 Qempty_line
= intern_c_string ("empty-line");
1630 staticpro (&Qempty_line
);
1631 Qtop_bottom
= intern_c_string ("top-bottom");
1632 staticpro (&Qtop_bottom
);
1633 Qhollow_small
= intern_c_string ("hollow-small");
1634 staticpro (&Qhollow_small
);
1636 defsubr (&Sdestroy_fringe_bitmap
);
1637 defsubr (&Sdefine_fringe_bitmap
);
1638 defsubr (&Sfringe_bitmaps_at_pos
);
1639 defsubr (&Sset_fringe_bitmap_face
);
1641 DEFVAR_LISP ("overflow-newline-into-fringe", &Voverflow_newline_into_fringe
,
1642 doc
: /* *Non-nil means that newline may flow into the right fringe.
1643 This means that display lines which are exactly as wide as the window
1644 (not counting the final newline) will only occupy one screen line, by
1645 showing (or hiding) the final newline in the right fringe; when point
1646 is at the final newline, the cursor is shown in the right fringe.
1647 If nil, also continue lines which are exactly as wide as the window. */);
1648 Voverflow_newline_into_fringe
= Qt
;
1650 DEFVAR_LISP ("fringe-bitmaps", &Vfringe_bitmaps
,
1651 doc
: /* List of fringe bitmap symbols. */);
1652 Vfringe_bitmaps
= Qnil
;
1655 /* Garbage collection hook */
1662 for (i
= 0; i
< max_fringe_bitmaps
; i
++)
1663 if (!NILP (fringe_faces
[i
]))
1664 mark_object (fringe_faces
[i
]);
1667 /* Initialize this module when Emacs starts. */
1674 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< MAX_STANDARD_FRINGE_BITMAPS
; bt
++)
1675 init_fringe_bitmap(bt
, &standard_bitmaps
[bt
], 1);
1683 max_fringe_bitmaps
= MAX_STANDARD_FRINGE_BITMAPS
+ 20;
1686 = (struct fringe_bitmap
**) xmalloc (max_fringe_bitmaps
* sizeof (struct fringe_bitmap
*));
1688 = (Lisp_Object
*) xmalloc (max_fringe_bitmaps
* sizeof (Lisp_Object
));
1690 for (i
= 0; i
< max_fringe_bitmaps
; i
++)
1692 fringe_bitmaps
[i
] = NULL
;
1693 fringe_faces
[i
] = Qnil
;
1700 w32_init_fringe (struct redisplay_interface
*rif
)
1707 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< MAX_STANDARD_FRINGE_BITMAPS
; bt
++)
1709 struct fringe_bitmap
*fb
= &standard_bitmaps
[bt
];
1710 rif
->define_fringe_bitmap (bt
, fb
->bits
, fb
->height
, fb
->width
);
1715 w32_reset_fringes ()
1717 /* Destroy row bitmaps. */
1719 struct redisplay_interface
*rif
= FRAME_RIF (SELECTED_FRAME ());
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) */