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"
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 static 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
, 'A', 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 rif
->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
->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
, 0, 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,
870 (row
->overlay_arrow_bitmap
< 0
871 ? get_logical_cursor_bitmap (w
, Qoverlay_arrow
)
872 : row
->overlay_arrow_bitmap
));
876 /* Draw fringe bitmaps for glyph row ROW on window W. Call this
877 function with input blocked. */
880 draw_row_fringe_bitmaps (w
, row
)
882 struct glyph_row
*row
;
884 xassert (interrupt_input_blocked
);
886 /* If row is completely invisible, because of vscrolling, we
887 don't have to draw anything. */
888 if (row
->visible_height
<= 0)
891 if (WINDOW_LEFT_FRINGE_WIDTH (w
) != 0)
892 draw_fringe_bitmap (w
, row
, 1);
894 if (WINDOW_RIGHT_FRINGE_WIDTH (w
) != 0)
895 draw_fringe_bitmap (w
, row
, 0);
898 /* Draw the fringes of window W. Only fringes for rows marked for
899 update in redraw_fringe_bitmaps_p are drawn.
901 Return >0 if left or right fringe was redrawn in any way.
903 If NO_FRINGE is non-zero, also return >0 if either fringe has zero width.
905 A return value >0 indicates that the vertical line between windows
906 needs update (as it may be drawn in the fringe).
910 draw_window_fringes (w
, no_fringe
)
914 struct glyph_row
*row
;
915 int yb
= window_text_bottom_y (w
);
916 int nrows
= w
->current_matrix
->nrows
;
920 if (w
->pseudo_window_p
)
923 /* Must draw line if no fringe */
925 && (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0
926 || WINDOW_RIGHT_FRINGE_WIDTH (w
) == 0))
929 for (y
= 0, rn
= 0, row
= w
->current_matrix
->rows
;
930 y
< yb
&& rn
< nrows
;
931 y
+= row
->height
, ++row
, ++rn
)
933 if (!row
->redraw_fringe_bitmaps_p
)
935 draw_row_fringe_bitmaps (w
, row
);
936 row
->redraw_fringe_bitmaps_p
= 0;
944 /* Recalculate the bitmaps to show in the fringes of window W.
945 Only mark rows with modified bitmaps for update in redraw_fringe_bitmaps_p.
947 If KEEP_CURRENT_P is 0, update current_matrix too. */
950 update_window_fringes (w
, keep_current_p
)
954 struct glyph_row
*row
, *cur
= 0;
955 int yb
= window_text_bottom_y (w
);
956 int rn
, nrows
= w
->current_matrix
->nrows
;
959 Lisp_Object boundary_top
= Qnil
, boundary_bot
= Qnil
;
960 Lisp_Object arrow_top
= Qnil
, arrow_bot
= Qnil
;
961 Lisp_Object empty_pos
;
962 Lisp_Object ind
= Qnil
;
963 #define MAX_BITMAP_CACHE (8*4)
964 int bitmap_cache
[MAX_BITMAP_CACHE
];
966 if (w
->pseudo_window_p
)
969 if (!MINI_WINDOW_P (w
)
970 && (ind
= XBUFFER (w
->buffer
)->indicate_buffer_boundaries
, !NILP (ind
)))
972 if (EQ (ind
, Qleft
) || EQ (ind
, Qright
))
973 boundary_top
= boundary_bot
= arrow_top
= arrow_bot
= ind
;
974 else if (CONSP (ind
) && CONSP (XCAR (ind
)))
977 if (pos
= Fassq (Qt
, ind
), !NILP (pos
))
978 boundary_top
= boundary_bot
= arrow_top
= arrow_bot
= XCDR (pos
);
979 if (pos
= Fassq (Qtop
, ind
), !NILP (pos
))
980 boundary_top
= XCDR (pos
);
981 if (pos
= Fassq (Qbottom
, ind
), !NILP (pos
))
982 boundary_bot
= XCDR (pos
);
983 if (pos
= Fassq (Qup
, ind
), !NILP (pos
))
984 arrow_top
= XCDR (pos
);
985 if (pos
= Fassq (Qdown
, ind
), !NILP (pos
))
986 arrow_bot
= XCDR (pos
);
989 /* Anything else means boundary on left and no arrows. */
990 boundary_top
= boundary_bot
= Qleft
;
995 int done_top
= 0, done_bot
= 0;
998 y
< yb
&& rn
< nrows
;
999 y
+= row
->height
, ++rn
)
1001 unsigned indicate_bob_p
, indicate_top_line_p
;
1002 unsigned indicate_eob_p
, indicate_bottom_line_p
;
1004 row
= w
->desired_matrix
->rows
+ rn
;
1005 if (!row
->enabled_p
)
1006 row
= w
->current_matrix
->rows
+ rn
;
1008 indicate_bob_p
= row
->indicate_bob_p
;
1009 indicate_top_line_p
= row
->indicate_top_line_p
;
1010 indicate_eob_p
= row
->indicate_eob_p
;
1011 indicate_bottom_line_p
= row
->indicate_bottom_line_p
;
1013 row
->indicate_bob_p
= row
->indicate_top_line_p
= 0;
1014 row
->indicate_eob_p
= row
->indicate_bottom_line_p
= 0;
1016 if (!row
->mode_line_p
)
1020 if (MATRIX_ROW_START_CHARPOS (row
) <= BUF_BEGV (XBUFFER (w
->buffer
))
1021 && !MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (w
, row
))
1022 row
->indicate_bob_p
= !NILP (boundary_top
);
1024 row
->indicate_top_line_p
= !NILP (arrow_top
);
1030 if (MATRIX_ROW_END_CHARPOS (row
) >= BUF_ZV (XBUFFER (w
->buffer
))
1031 && !MATRIX_ROW_PARTIALLY_VISIBLE_AT_BOTTOM_P (w
, row
))
1032 row
->indicate_eob_p
= !NILP (boundary_bot
), done_bot
= 1;
1033 else if (y
+ row
->height
>= yb
)
1034 row
->indicate_bottom_line_p
= !NILP (arrow_bot
), done_bot
= 1;
1038 if (indicate_bob_p
!= row
->indicate_bob_p
1039 || indicate_top_line_p
!= row
->indicate_top_line_p
1040 || indicate_eob_p
!= row
->indicate_eob_p
1041 || indicate_bottom_line_p
!= row
->indicate_bottom_line_p
)
1042 row
->redraw_fringe_bitmaps_p
= 1;
1046 empty_pos
= XBUFFER (w
->buffer
)->indicate_empty_lines
;
1047 if (!NILP (empty_pos
) && !EQ (empty_pos
, Qright
))
1048 empty_pos
= WINDOW_LEFT_FRINGE_WIDTH (w
) == 0 ? Qright
: Qleft
;
1050 for (y
= 0; y
< MAX_BITMAP_CACHE
; y
++)
1051 bitmap_cache
[y
] = -1;
1053 #define LEFT_FRINGE(cache, which, partial_p) \
1054 (bitmap_cache[cache*4+partial_p] >= 0 \
1055 ? bitmap_cache[cache*4+partial_p] \
1056 : (bitmap_cache[cache*4+partial_p] = \
1057 get_logical_fringe_bitmap (w, which, 0, partial_p)))
1059 #define RIGHT_FRINGE(cache, which, partial_p) \
1060 (bitmap_cache[cache*4+2+partial_p] >= 0 \
1061 ? bitmap_cache[cache*4+2+partial_p] \
1062 : (bitmap_cache[cache*4+2+partial_p] = \
1063 get_logical_fringe_bitmap (w, which, 1, partial_p)))
1067 y
< yb
&& rn
< nrows
;
1068 y
+= row
->height
, rn
++)
1071 unsigned left_face_id
, right_face_id
;
1073 row
= w
->desired_matrix
->rows
+ rn
;
1074 cur
= w
->current_matrix
->rows
+ rn
;
1075 if (!row
->enabled_p
)
1078 left_face_id
= right_face_id
= DEFAULT_FACE_ID
;
1080 /* Decide which bitmap to draw in the left fringe. */
1081 if (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0)
1082 left
= NO_FRINGE_BITMAP
;
1083 else if (row
->left_user_fringe_bitmap
!= NO_FRINGE_BITMAP
)
1085 left
= row
->left_user_fringe_bitmap
;
1086 left_face_id
= row
->left_user_fringe_face_id
;
1088 else if (row
->truncated_on_left_p
)
1089 left
= LEFT_FRINGE(0, Qtruncation
, 0);
1090 else if (row
->indicate_bob_p
&& EQ (boundary_top
, Qleft
))
1091 left
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qleft
))
1092 ? LEFT_FRINGE (1, Qtop_bottom
, row
->ends_at_zv_p
)
1093 : LEFT_FRINGE (2, Qtop
, 0));
1094 else if (row
->indicate_eob_p
&& EQ (boundary_bot
, Qleft
))
1095 left
= LEFT_FRINGE (3, Qbottom
, row
->ends_at_zv_p
);
1096 else if (MATRIX_ROW_CONTINUATION_LINE_P (row
))
1097 left
= LEFT_FRINGE (4, Qcontinuation
, 0);
1098 else if (row
->indicate_empty_line_p
&& EQ (empty_pos
, Qleft
))
1099 left
= LEFT_FRINGE (5, Qempty_line
, 0);
1100 else if (row
->indicate_top_line_p
&& EQ (arrow_top
, Qleft
))
1101 left
= LEFT_FRINGE (6, Qup
, 0);
1102 else if (row
->indicate_bottom_line_p
&& EQ (arrow_bot
, Qleft
))
1103 left
= LEFT_FRINGE (7, Qdown
, 0);
1105 left
= NO_FRINGE_BITMAP
;
1107 /* Decide which bitmap to draw in the right fringe. */
1108 if (WINDOW_RIGHT_FRINGE_WIDTH (w
) == 0)
1109 right
= NO_FRINGE_BITMAP
;
1110 else if (row
->right_user_fringe_bitmap
!= NO_FRINGE_BITMAP
)
1112 right
= row
->right_user_fringe_bitmap
;
1113 right_face_id
= row
->right_user_fringe_face_id
;
1115 else if (row
->truncated_on_right_p
)
1116 right
= RIGHT_FRINGE (0, Qtruncation
, 0);
1117 else if (row
->indicate_bob_p
&& EQ (boundary_top
, Qright
))
1118 right
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qright
))
1119 ? RIGHT_FRINGE (1, Qtop_bottom
, row
->ends_at_zv_p
)
1120 : RIGHT_FRINGE (2, Qtop
, 0));
1121 else if (row
->indicate_eob_p
&& EQ (boundary_bot
, Qright
))
1122 right
= RIGHT_FRINGE (3, Qbottom
, row
->ends_at_zv_p
);
1123 else if (row
->continued_p
)
1124 right
= RIGHT_FRINGE (4, Qcontinuation
, 0);
1125 else if (row
->indicate_top_line_p
&& EQ (arrow_top
, Qright
))
1126 right
= RIGHT_FRINGE (6, Qup
, 0);
1127 else if (row
->indicate_bottom_line_p
&& EQ (arrow_bot
, Qright
))
1128 right
= RIGHT_FRINGE (7, Qdown
, 0);
1129 else if (row
->indicate_empty_line_p
&& EQ (empty_pos
, Qright
))
1130 right
= RIGHT_FRINGE (5, Qempty_line
, 0);
1132 right
= NO_FRINGE_BITMAP
;
1134 if (row
->y
!= cur
->y
1135 || row
->visible_height
!= cur
->visible_height
1136 || row
->ends_at_zv_p
!= cur
->ends_at_zv_p
1137 || left
!= cur
->left_fringe_bitmap
1138 || right
!= cur
->right_fringe_bitmap
1139 || left_face_id
!= cur
->left_fringe_face_id
1140 || right_face_id
!= cur
->right_fringe_face_id
1141 || cur
->redraw_fringe_bitmaps_p
)
1143 redraw_p
= row
->redraw_fringe_bitmaps_p
= 1;
1144 if (!keep_current_p
)
1146 cur
->redraw_fringe_bitmaps_p
= 1;
1147 cur
->left_fringe_bitmap
= left
;
1148 cur
->right_fringe_bitmap
= right
;
1149 cur
->left_fringe_face_id
= left_face_id
;
1150 cur
->right_fringe_face_id
= right_face_id
;
1154 if (row
->overlay_arrow_bitmap
!= cur
->overlay_arrow_bitmap
)
1156 redraw_p
= row
->redraw_fringe_bitmaps_p
= cur
->redraw_fringe_bitmaps_p
= 1;
1157 cur
->overlay_arrow_bitmap
= row
->overlay_arrow_bitmap
;
1160 row
->left_fringe_bitmap
= left
;
1161 row
->right_fringe_bitmap
= right
;
1162 row
->left_fringe_face_id
= left_face_id
;
1163 row
->right_fringe_face_id
= right_face_id
;
1165 if (rn
> 0 && row
->redraw_fringe_bitmaps_p
)
1166 row
[-1].redraw_fringe_bitmaps_p
= cur
[-1].redraw_fringe_bitmaps_p
= 1;
1169 return redraw_p
&& !keep_current_p
;
1173 /* Compute actual fringe widths for frame F.
1175 If REDRAW is 1, redraw F if the fringe settings was actually
1176 modified and F is visible.
1178 Since the combined left and right fringe must occupy an integral
1179 number of columns, we may need to add some pixels to each fringe.
1180 Typically, we add an equal amount (+/- 1 pixel) to each fringe,
1181 but a negative width value is taken literally (after negating it).
1183 We never make the fringes narrower than specified.
1187 compute_fringe_widths (f
, redraw
)
1191 int o_left
= FRAME_LEFT_FRINGE_WIDTH (f
);
1192 int o_right
= FRAME_RIGHT_FRINGE_WIDTH (f
);
1193 int o_cols
= FRAME_FRINGE_COLS (f
);
1195 Lisp_Object left_fringe
= Fassq (Qleft_fringe
, f
->param_alist
);
1196 Lisp_Object right_fringe
= Fassq (Qright_fringe
, f
->param_alist
);
1197 int left_fringe_width
, right_fringe_width
;
1199 if (!NILP (left_fringe
))
1200 left_fringe
= Fcdr (left_fringe
);
1201 if (!NILP (right_fringe
))
1202 right_fringe
= Fcdr (right_fringe
);
1204 left_fringe_width
= ((NILP (left_fringe
) || !INTEGERP (left_fringe
)) ? 8 :
1205 XINT (left_fringe
));
1206 right_fringe_width
= ((NILP (right_fringe
) || !INTEGERP (right_fringe
)) ? 8 :
1207 XINT (right_fringe
));
1209 if (left_fringe_width
|| right_fringe_width
)
1211 int left_wid
= left_fringe_width
>= 0 ? left_fringe_width
: -left_fringe_width
;
1212 int right_wid
= right_fringe_width
>= 0 ? right_fringe_width
: -right_fringe_width
;
1213 int conf_wid
= left_wid
+ right_wid
;
1214 int font_wid
= FRAME_COLUMN_WIDTH (f
);
1215 int cols
= (left_wid
+ right_wid
+ font_wid
-1) / font_wid
;
1216 int real_wid
= cols
* font_wid
;
1217 if (left_wid
&& right_wid
)
1219 if (left_fringe_width
< 0)
1221 /* Left fringe width is fixed, adjust right fringe if necessary */
1222 FRAME_LEFT_FRINGE_WIDTH (f
) = left_wid
;
1223 FRAME_RIGHT_FRINGE_WIDTH (f
) = real_wid
- left_wid
;
1225 else if (right_fringe_width
< 0)
1227 /* Right fringe width is fixed, adjust left fringe if necessary */
1228 FRAME_LEFT_FRINGE_WIDTH (f
) = real_wid
- right_wid
;
1229 FRAME_RIGHT_FRINGE_WIDTH (f
) = right_wid
;
1233 /* Adjust both fringes with an equal amount.
1234 Note that we are doing integer arithmetic here, so don't
1235 lose a pixel if the total width is an odd number. */
1236 int fill
= real_wid
- conf_wid
;
1237 FRAME_LEFT_FRINGE_WIDTH (f
) = left_wid
+ fill
/2;
1238 FRAME_RIGHT_FRINGE_WIDTH (f
) = right_wid
+ fill
- fill
/2;
1241 else if (left_fringe_width
)
1243 FRAME_LEFT_FRINGE_WIDTH (f
) = real_wid
;
1244 FRAME_RIGHT_FRINGE_WIDTH (f
) = 0;
1248 FRAME_LEFT_FRINGE_WIDTH (f
) = 0;
1249 FRAME_RIGHT_FRINGE_WIDTH (f
) = real_wid
;
1251 FRAME_FRINGE_COLS (f
) = cols
;
1255 FRAME_LEFT_FRINGE_WIDTH (f
) = 0;
1256 FRAME_RIGHT_FRINGE_WIDTH (f
) = 0;
1257 FRAME_FRINGE_COLS (f
) = 0;
1260 if (redraw
&& FRAME_VISIBLE_P (f
))
1261 if (o_left
!= FRAME_LEFT_FRINGE_WIDTH (f
) ||
1262 o_right
!= FRAME_RIGHT_FRINGE_WIDTH (f
) ||
1263 o_cols
!= FRAME_FRINGE_COLS (f
))
1268 /* Free resources used by a user-defined bitmap. */
1271 destroy_fringe_bitmap (n
)
1274 struct fringe_bitmap
**fbp
;
1276 fringe_faces
[n
] = Qnil
;
1278 fbp
= &fringe_bitmaps
[n
];
1279 if (*fbp
&& (*fbp
)->dynamic
)
1281 if (rif
&& rif
->destroy_fringe_bitmap
)
1282 rif
->destroy_fringe_bitmap (n
);
1287 while (max_used_fringe_bitmap
> MAX_STANDARD_FRINGE_BITMAPS
1288 && fringe_bitmaps
[max_used_fringe_bitmap
- 1] == NULL
)
1289 max_used_fringe_bitmap
--;
1293 DEFUN ("destroy-fringe-bitmap", Fdestroy_fringe_bitmap
, Sdestroy_fringe_bitmap
,
1295 doc
: /* Destroy fringe bitmap BITMAP.
1296 If BITMAP overrides a standard fringe bitmap, the original bitmap is restored. */)
1302 CHECK_SYMBOL (bitmap
);
1303 n
= lookup_fringe_bitmap (bitmap
);
1307 destroy_fringe_bitmap (n
);
1309 if (n
>= MAX_STANDARD_FRINGE_BITMAPS
)
1311 Vfringe_bitmaps
= Fdelq (bitmap
, Vfringe_bitmaps
);
1312 /* It would be better to remove the fringe property. */
1313 Fput (bitmap
, Qfringe
, Qnil
);
1320 /* Initialize bitmap bit.
1322 On X, we bit-swap the built-in bitmaps and reduce bitmap
1323 from short to char array if width is <= 8 bits.
1325 On MAC with big-endian CPU, we need to byte-swap each short.
1327 On W32 and MAC (little endian), there's no need to do this.
1331 init_fringe_bitmap (which
, fb
, once_p
)
1333 struct fringe_bitmap
*fb
;
1336 if (once_p
|| fb
->dynamic
)
1338 #if defined (HAVE_X_WINDOWS)
1339 static unsigned char swap_nibble
[16]
1340 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
1341 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
1342 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
1343 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
1344 unsigned short *bits
= fb
->bits
;
1349 unsigned char *cbits
= (unsigned char *)fb
->bits
;
1350 for (j
= 0; j
< fb
->height
; j
++)
1352 unsigned short b
= *bits
++;
1354 c
= (unsigned char)((swap_nibble
[b
& 0xf] << 4)
1355 | (swap_nibble
[(b
>>4) & 0xf]));
1356 *cbits
++ = (c
>> (8 - fb
->width
));
1361 for (j
= 0; j
< fb
->height
; j
++)
1363 unsigned short b
= *bits
;
1364 b
= (unsigned short)((swap_nibble
[b
& 0xf] << 12)
1365 | (swap_nibble
[(b
>>4) & 0xf] << 8)
1366 | (swap_nibble
[(b
>>8) & 0xf] << 4)
1367 | (swap_nibble
[(b
>>12) & 0xf]));
1368 *bits
++ = (b
>> (16 - fb
->width
));
1371 #endif /* HAVE_X_WINDOWS */
1373 #if defined (MAC_OS) && defined (WORDS_BIG_ENDIAN)
1374 unsigned short *bits
= fb
->bits
;
1376 for (j
= 0; j
< fb
->height
; j
++)
1378 unsigned short b
= *bits
;
1379 *bits
++ = ((b
>> 8) & 0xff) | ((b
& 0xff) << 8);
1381 #endif /* MAC_OS && WORDS_BIG_ENDIAN */
1386 destroy_fringe_bitmap (which
);
1388 if (rif
&& rif
->define_fringe_bitmap
)
1389 rif
->define_fringe_bitmap (which
, fb
->bits
, fb
->height
, fb
->width
);
1391 fringe_bitmaps
[which
] = fb
;
1392 if (which
>= max_used_fringe_bitmap
)
1393 max_used_fringe_bitmap
= which
+ 1;
1398 DEFUN ("define-fringe-bitmap", Fdefine_fringe_bitmap
, Sdefine_fringe_bitmap
,
1400 doc
: /* Define fringe bitmap BITMAP from BITS of size HEIGHT x WIDTH.
1401 BITMAP is a symbol or string naming the new fringe bitmap.
1402 BITS is either a string or a vector of integers.
1403 HEIGHT is height of bitmap. If HEIGHT is nil, use length of BITS.
1404 WIDTH must be an integer between 1 and 16, or nil which defaults to 8.
1405 Optional fifth arg ALIGN may be one of `top', `center', or `bottom',
1406 indicating the positioning of the bitmap relative to the rows where it
1407 is used; the default is to center the bitmap. Fourth arg may also be a
1408 list (ALIGN PERIODIC) where PERIODIC non-nil specifies that the bitmap
1410 If BITMAP already exists, the existing definition is replaced. */)
1411 (bitmap
, bits
, height
, width
, align
)
1412 Lisp_Object bitmap
, bits
, height
, width
, align
;
1416 struct fringe_bitmap fb
, *xfb
;
1417 int fill1
= 0, fill2
= 0;
1419 CHECK_SYMBOL (bitmap
);
1423 else if (VECTORP (bits
))
1424 h
= XVECTOR (bits
)->size
;
1426 bits
= wrong_type_argument (Qsequencep
, bits
);
1432 CHECK_NUMBER (height
);
1433 fb
.height
= min (XINT (height
), 255);
1436 fill1
= (fb
.height
- h
) / 2;
1437 fill2
= fb
.height
- h
- fill1
;
1445 CHECK_NUMBER (width
);
1446 fb
.width
= min (XINT (width
), 255);
1450 fb
.align
= ALIGN_BITMAP_CENTER
;
1454 Lisp_Object period
= XCDR (align
);
1457 period
= XCAR (period
);
1460 fb
.period
= fb
.height
;
1464 align
= XCAR (align
);
1466 if (EQ (align
, Qtop
))
1467 fb
.align
= ALIGN_BITMAP_TOP
;
1468 else if (EQ (align
, Qbottom
))
1469 fb
.align
= ALIGN_BITMAP_BOTTOM
;
1470 else if (!NILP (align
) && !EQ (align
, Qcenter
))
1471 error ("Bad align argument");
1473 n
= lookup_fringe_bitmap (bitmap
);
1476 if (max_used_fringe_bitmap
< max_fringe_bitmaps
)
1477 n
= max_used_fringe_bitmap
++;
1480 for (n
= MAX_STANDARD_FRINGE_BITMAPS
;
1481 n
< max_fringe_bitmaps
;
1483 if (fringe_bitmaps
[n
] == NULL
)
1486 if (n
== max_fringe_bitmaps
)
1488 if ((max_fringe_bitmaps
+ 20) > MAX_FRINGE_BITMAPS
)
1489 error ("No free fringe bitmap slots");
1491 i
= max_fringe_bitmaps
;
1492 max_fringe_bitmaps
+= 20;
1494 = ((struct fringe_bitmap
**)
1495 xrealloc (fringe_bitmaps
, max_fringe_bitmaps
* sizeof (struct fringe_bitmap
*)));
1497 = (Lisp_Object
*) xrealloc (fringe_faces
, max_fringe_bitmaps
* sizeof (Lisp_Object
));
1499 for (; i
< max_fringe_bitmaps
; i
++)
1501 fringe_bitmaps
[i
] = NULL
;
1502 fringe_faces
[i
] = Qnil
;
1507 Vfringe_bitmaps
= Fcons (bitmap
, Vfringe_bitmaps
);
1508 Fput (bitmap
, Qfringe
, make_number (n
));
1513 xfb
= (struct fringe_bitmap
*) xmalloc (sizeof fb
1514 + fb
.height
* BYTES_PER_BITMAP_ROW
);
1515 fb
.bits
= b
= (unsigned short *) (xfb
+ 1);
1516 bzero (b
, fb
.height
);
1519 while (j
< fb
.height
)
1521 for (i
= 0; i
< fill1
&& j
< fb
.height
; i
++)
1523 for (i
= 0; i
< h
&& j
< fb
.height
; i
++)
1525 Lisp_Object elt
= Faref (bits
, make_number (i
));
1526 b
[j
++] = NUMBERP (elt
) ? XINT (elt
) : 0;
1528 for (i
= 0; i
< fill2
&& j
< fb
.height
; i
++)
1534 init_fringe_bitmap (n
, xfb
, 0);
1539 DEFUN ("set-fringe-bitmap-face", Fset_fringe_bitmap_face
, Sset_fringe_bitmap_face
,
1541 doc
: /* Set face for fringe bitmap BITMAP to FACE.
1542 If FACE is nil, reset face to default fringe face. */)
1544 Lisp_Object bitmap
, face
;
1549 CHECK_SYMBOL (bitmap
);
1550 n
= lookup_fringe_bitmap (bitmap
);
1552 error ("Undefined fringe bitmap");
1556 face_id
= lookup_derived_face (SELECTED_FRAME (), face
,
1557 'A', FRINGE_FACE_ID
, 1);
1559 error ("No such face");
1562 fringe_faces
[n
] = face
;
1567 DEFUN ("fringe-bitmaps-at-pos", Ffringe_bitmaps_at_pos
, Sfringe_bitmaps_at_pos
,
1569 doc
: /* Return fringe bitmaps of row containing position POS in window WINDOW.
1570 If WINDOW is nil, use selected window. If POS is nil, use value of point
1571 in that window. Return value is a list (LEFT RIGHT OV), where LEFT
1572 is the symbol for the bitmap in the left fringe (or nil if no bitmap),
1573 RIGHT is similar for the right fringe, and OV is non-nil if there is an
1574 overlay arrow in the left fringe.
1575 Return nil if POS is not visible in WINDOW. */)
1577 Lisp_Object pos
, window
;
1580 struct glyph_row
*row
;
1584 window
= selected_window
;
1585 CHECK_WINDOW (window
);
1586 w
= XWINDOW (window
);
1590 CHECK_NUMBER_COERCE_MARKER (pos
);
1591 textpos
= XINT (pos
);
1593 else if (w
== XWINDOW (selected_window
))
1596 textpos
= XMARKER (w
->pointm
)->charpos
;
1598 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1599 row
= row_containing_pos (w
, textpos
, row
, NULL
, 0);
1601 return list3 (get_fringe_bitmap_name (row
->left_fringe_bitmap
),
1602 get_fringe_bitmap_name (row
->right_fringe_bitmap
),
1603 (row
->overlay_arrow_bitmap
== 0 ? Qnil
1604 : row
->overlay_arrow_bitmap
< 0 ? Qt
1605 : get_fringe_bitmap_name (row
->overlay_arrow_bitmap
)));
1611 /***********************************************************************
1613 ***********************************************************************/
1618 Qtruncation
= intern ("truncation");
1619 staticpro (&Qtruncation
);
1620 Qcontinuation
= intern ("continuation");
1621 staticpro (&Qcontinuation
);
1622 Qoverlay_arrow
= intern ("overlay-arrow");
1623 staticpro (&Qoverlay_arrow
);
1624 Qempty_line
= intern ("empty-line");
1625 staticpro (&Qempty_line
);
1626 Qtop_bottom
= intern ("top-bottom");
1627 staticpro (&Qtop_bottom
);
1628 Qhollow_small
= intern ("hollow-small");
1629 staticpro (&Qhollow_small
);
1631 defsubr (&Sdestroy_fringe_bitmap
);
1632 defsubr (&Sdefine_fringe_bitmap
);
1633 defsubr (&Sfringe_bitmaps_at_pos
);
1634 defsubr (&Sset_fringe_bitmap_face
);
1636 DEFVAR_LISP ("overflow-newline-into-fringe", &Voverflow_newline_into_fringe
,
1637 doc
: /* *Non-nil means that newline may flow into the right fringe.
1638 This means that display lines which are exactly as wide as the window
1639 (not counting the final newline) will only occupy one screen line, by
1640 showing (or hiding) the final newline in the right fringe; when point
1641 is at the final newline, the cursor is shown in the right fringe.
1642 If nil, also continue lines which are exactly as wide as the window. */);
1643 Voverflow_newline_into_fringe
= Qt
;
1645 DEFVAR_LISP ("fringe-bitmaps", &Vfringe_bitmaps
,
1646 doc
: /* List of fringe bitmap symbols. */);
1647 Vfringe_bitmaps
= Qnil
;
1650 /* Garbage collection hook */
1657 for (i
= 0; i
< max_fringe_bitmaps
; i
++)
1658 if (!NILP (fringe_faces
[i
]))
1659 mark_object (fringe_faces
[i
]);
1662 /* Initialize this module when Emacs starts. */
1669 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< MAX_STANDARD_FRINGE_BITMAPS
; bt
++)
1670 init_fringe_bitmap(bt
, &standard_bitmaps
[bt
], 1);
1678 max_fringe_bitmaps
= MAX_STANDARD_FRINGE_BITMAPS
+ 20;
1681 = (struct fringe_bitmap
**) xmalloc (max_fringe_bitmaps
* sizeof (struct fringe_bitmap
*));
1683 = (Lisp_Object
*) xmalloc (max_fringe_bitmaps
* sizeof (Lisp_Object
));
1685 for (i
= 0; i
< max_fringe_bitmaps
; i
++)
1687 fringe_bitmaps
[i
] = NULL
;
1688 fringe_faces
[i
] = Qnil
;
1702 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< MAX_STANDARD_FRINGE_BITMAPS
; bt
++)
1704 struct fringe_bitmap
*fb
= &standard_bitmaps
[bt
];
1705 rif
->define_fringe_bitmap (bt
, fb
->bits
, fb
->height
, fb
->width
);
1710 w32_reset_fringes ()
1712 /* Destroy row bitmaps. */
1718 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< max_used_fringe_bitmap
; bt
++)
1719 rif
->destroy_fringe_bitmap (bt
);
1722 #endif /* HAVE_NTGUI */
1724 #endif /* HAVE_WINDOW_SYSTEM */
1726 /* arch-tag: 04596920-43eb-473d-b319-82712338162d
1727 (do not change this comment) */