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 (Lisp_Object bitmap
)
497 bitmap
= Fget (bitmap
, Qfringe
);
498 if (!INTEGERP (bitmap
))
502 if (bn
> NO_FRINGE_BITMAP
503 && bn
< max_used_fringe_bitmap
504 && (bn
< MAX_STANDARD_FRINGE_BITMAPS
505 || fringe_bitmaps
[bn
] != NULL
))
511 /* Get fringe bitmap name for bitmap number BN.
513 Found by traversing Vfringe_bitmaps comparing BN to the
514 fringe property for each symbol.
516 Return BN if not found in Vfringe_bitmaps. */
519 get_fringe_bitmap_name (int bn
)
524 /* Zero means no bitmap -- return nil. */
528 bitmaps
= Vfringe_bitmaps
;
529 num
= make_number (bn
);
531 while (CONSP (bitmaps
))
533 Lisp_Object bitmap
= XCAR (bitmaps
);
534 if (EQ (num
, Fget (bitmap
, Qfringe
)))
536 bitmaps
= XCDR (bitmaps
);
543 /* Draw the bitmap WHICH in one of the left or right fringes of
544 window W. ROW is the glyph row for which to display the bitmap; it
545 determines the vertical position at which the bitmap has to be
547 LEFT_P is 1 for left fringe, 0 for right fringe.
551 draw_fringe_bitmap_1 (struct window
*w
, struct glyph_row
*row
, int left_p
, int overlay
, int which
)
553 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
554 struct draw_fringe_bitmap_params p
;
555 struct fringe_bitmap
*fb
;
557 int face_id
= DEFAULT_FACE_ID
;
558 int offset
, header_line_height
;
560 p
.overlay_p
= (overlay
& 1) == 1;
561 p
.cursor_p
= (overlay
& 2) == 2;
563 if (which
!= NO_FRINGE_BITMAP
)
569 which
= row
->left_fringe_bitmap
;
570 face_id
= row
->left_fringe_face_id
;
571 offset
= row
->left_fringe_offset
;
575 which
= row
->right_fringe_bitmap
;
576 face_id
= row
->right_fringe_face_id
;
577 offset
= row
->right_fringe_offset
;
580 if (face_id
== DEFAULT_FACE_ID
)
582 Lisp_Object face
= fringe_faces
[which
];
583 face_id
= NILP (face
) ? lookup_named_face (f
, Qfringe
, 0)
584 : lookup_derived_face (f
, face
, FRINGE_FACE_ID
, 0);
586 face_id
= FRINGE_FACE_ID
;
589 fb
= fringe_bitmaps
[which
];
591 fb
= &standard_bitmaps
[which
< MAX_STANDARD_FRINGE_BITMAPS
592 ? which
: UNDEF_FRINGE_BITMAP
];
596 /* Convert row to frame coordinates. */
597 p
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
) + offset
;
604 p
.dh
= (period
> 0 ? (p
.y
% period
) : 0);
607 /* Adjust y to the offset in the row to start drawing the bitmap. */
610 case ALIGN_BITMAP_CENTER
:
611 p
.y
+= (row
->height
- p
.h
) / 2;
613 case ALIGN_BITMAP_BOTTOM
:
614 p
.y
+= (row
->visible_height
- p
.h
);
616 case ALIGN_BITMAP_TOP
:
620 p
.face
= FACE_FROM_ID (f
, face_id
);
624 /* This could happen after clearing face cache.
625 But it shouldn't happen anymore. ++kfs */
629 PREPARE_FACE_FOR_DISPLAY (f
, p
.face
);
631 /* Clear left fringe if no bitmap to draw or if bitmap doesn't fill
634 header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
635 p
.by
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
, row
->y
));
636 p
.ny
= row
->visible_height
;
639 int wd
= WINDOW_LEFT_FRINGE_WIDTH (w
);
640 int x
= window_box_left (w
, (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
645 p
.x
= x
- p
.wd
- (wd
- p
.wd
) / 2;
647 if (p
.wd
< wd
|| p
.y
> p
.by
|| p
.y
+ p
.h
< p
.by
+ p
.ny
)
649 /* If W has a vertical border to its left, don't draw over it. */
650 wd
-= ((!WINDOW_LEFTMOST_P (w
)
651 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
659 int x
= window_box_right (w
,
660 (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
663 int wd
= WINDOW_RIGHT_FRINGE_WIDTH (w
);
666 p
.x
= x
+ (wd
- p
.wd
) / 2;
667 /* Clear right fringe if no bitmap to draw of if bitmap doesn't fill
669 if (p
.wd
< wd
|| p
.y
> p
.by
|| p
.y
+ p
.h
< p
.by
+ p
.ny
)
676 FRAME_RIF (f
)->draw_fringe_bitmap (w
, row
, &p
);
680 get_logical_cursor_bitmap (struct window
*w
, Lisp_Object cursor
)
682 Lisp_Object cmap
, bm
= Qnil
;
684 if ((cmap
= XBUFFER (w
->buffer
)->fringe_cursor_alist
), !NILP (cmap
))
686 bm
= Fassq (cursor
, cmap
);
689 if ((bm
= XCDR (bm
)), NILP (bm
))
690 return NO_FRINGE_BITMAP
;
691 return lookup_fringe_bitmap (bm
);
694 if (EQ (cmap
, buffer_defaults
.fringe_cursor_alist
))
695 return NO_FRINGE_BITMAP
;
696 bm
= Fassq (cursor
, buffer_defaults
.fringe_cursor_alist
);
697 if (!CONSP (bm
) || ((bm
= XCDR (bm
)), NILP (bm
)))
698 return NO_FRINGE_BITMAP
;
699 return lookup_fringe_bitmap (bm
);
703 get_logical_fringe_bitmap (struct window
*w
, Lisp_Object bitmap
, int right_p
, int partial_p
)
705 Lisp_Object cmap
, bm1
= Qnil
, bm2
= Qnil
, bm
;
706 int ln1
= 0, ln2
= 0;
708 int ix2
= ix1
+ (partial_p
? 2 : 0);
710 /* Lookup in buffer-local fringe-indicator-alist before global alist.
713 BITMAP -- use for all
714 (L R) -- use for left right (whether partial or not)
715 (L R PL PR) -- use for left right partial-left partial-right
716 If any value in local binding is not present or t, use global value.
718 If partial, lookup partial bitmap in default value if not found here.
719 If not partial, or no partial spec is present, use non-partial bitmap. */
721 if ((cmap
= XBUFFER (w
->buffer
)->fringe_indicator_alist
), !NILP (cmap
))
723 bm1
= Fassq (bitmap
, cmap
);
726 if ((bm1
= XCDR (bm1
)), NILP (bm1
))
727 return NO_FRINGE_BITMAP
;
730 ln1
= XINT (Flength (bm1
));
735 bm
= Fnth (make_number (ix2
), bm1
);
744 bm
= Fnth (make_number (ix1
), bm1
);
750 else if ((bm
= bm1
, !EQ (bm
, Qt
)))
755 if (!EQ (cmap
, buffer_defaults
.fringe_indicator_alist
)
756 && !NILP (buffer_defaults
.fringe_indicator_alist
))
758 bm2
= Fassq (bitmap
, buffer_defaults
.fringe_indicator_alist
);
761 if ((bm2
= XCDR (bm2
)), !NILP (bm2
))
765 ln2
= XINT (Flength (bm2
));
770 bm
= Fnth (make_number (ix2
), bm2
);
782 bm
= Fnth (make_number (ix1
), bm1
);
789 bm
= Fnth (make_number (ix1
), bm2
);
792 return NO_FRINGE_BITMAP
;
794 else if ((bm
= bm2
, NILP (bm
)))
795 return NO_FRINGE_BITMAP
;
798 return lookup_fringe_bitmap (bm
);
803 draw_fringe_bitmap (struct window
*w
, struct glyph_row
*row
, int left_p
)
807 if (left_p
== row
->reversed_p
&& row
->cursor_in_fringe_p
)
809 Lisp_Object cursor
= Qnil
;
811 switch (w
->phys_cursor_type
)
813 case HOLLOW_BOX_CURSOR
:
814 if (row
->visible_height
>= STANDARD_BITMAP_HEIGHT (hollow_rectangle_bits
))
817 cursor
= Qhollow_small
;
819 case FILLED_BOX_CURSOR
:
830 w
->phys_cursor_on_p
= 0;
831 row
->cursor_in_fringe_p
= 0;
836 int bm
= get_logical_cursor_bitmap (w
, cursor
);
837 if (bm
!= NO_FRINGE_BITMAP
)
839 draw_fringe_bitmap_1 (w
, row
, left_p
, 2, bm
);
840 overlay
= EQ (cursor
, Qbox
) ? 3 : 1;
845 draw_fringe_bitmap_1 (w
, row
, left_p
, overlay
, NO_FRINGE_BITMAP
);
847 if (left_p
&& row
->overlay_arrow_bitmap
!= NO_FRINGE_BITMAP
)
848 draw_fringe_bitmap_1 (w
, row
, 1, 1, row
->overlay_arrow_bitmap
);
852 /* Draw fringe bitmaps for glyph row ROW on window W. Call this
853 function with input blocked. */
856 draw_row_fringe_bitmaps (struct window
*w
, struct glyph_row
*row
)
858 xassert (interrupt_input_blocked
);
860 /* If row is completely invisible, because of vscrolling, we
861 don't have to draw anything. */
862 if (row
->visible_height
<= 0)
865 if (WINDOW_LEFT_FRINGE_WIDTH (w
) != 0)
866 draw_fringe_bitmap (w
, row
, 1);
868 if (WINDOW_RIGHT_FRINGE_WIDTH (w
) != 0)
869 draw_fringe_bitmap (w
, row
, 0);
872 /* Draw the fringes of window W. Only fringes for rows marked for
873 update in redraw_fringe_bitmaps_p are drawn.
875 Return >0 if left or right fringe was redrawn in any way.
877 If NO_FRINGE is non-zero, also return >0 if either fringe has zero width.
879 A return value >0 indicates that the vertical line between windows
880 needs update (as it may be drawn in the fringe).
884 draw_window_fringes (struct window
*w
, int no_fringe
)
886 struct glyph_row
*row
;
887 int yb
= window_text_bottom_y (w
);
888 int nrows
= w
->current_matrix
->nrows
;
892 if (w
->pseudo_window_p
)
895 /* Must draw line if no fringe */
897 && (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0
898 || WINDOW_RIGHT_FRINGE_WIDTH (w
) == 0))
901 for (y
= w
->vscroll
, rn
= 0, row
= w
->current_matrix
->rows
;
902 y
< yb
&& rn
< nrows
;
903 y
+= row
->height
, ++row
, ++rn
)
905 if (!row
->redraw_fringe_bitmaps_p
)
907 draw_row_fringe_bitmaps (w
, row
);
908 row
->redraw_fringe_bitmaps_p
= 0;
916 /* Recalculate the bitmaps to show in the fringes of window W.
917 Only mark rows with modified bitmaps for update in redraw_fringe_bitmaps_p.
919 If KEEP_CURRENT_P is 0, update current_matrix too. */
922 update_window_fringes (struct window
*w
, int keep_current_p
)
924 struct glyph_row
*row
, *cur
= 0;
925 int yb
= window_text_bottom_y (w
);
926 int rn
, nrows
= w
->current_matrix
->nrows
;
929 Lisp_Object boundary_top
= Qnil
, boundary_bot
= Qnil
;
930 Lisp_Object arrow_top
= Qnil
, arrow_bot
= Qnil
;
931 Lisp_Object empty_pos
;
932 Lisp_Object ind
= Qnil
;
933 #define MAX_BITMAP_CACHE (8*4)
934 int bitmap_cache
[MAX_BITMAP_CACHE
];
935 int top_ind_rn
, bot_ind_rn
;
936 int top_ind_min_y
, bot_ind_max_y
;
937 int top_row_ends_at_zv_p
, bot_row_ends_at_zv_p
;
939 if (w
->pseudo_window_p
)
942 if (!MINI_WINDOW_P (w
)
943 && (ind
= XBUFFER (w
->buffer
)->indicate_buffer_boundaries
, !NILP (ind
)))
945 if (EQ (ind
, Qleft
) || EQ (ind
, Qright
))
946 boundary_top
= boundary_bot
= arrow_top
= arrow_bot
= ind
;
947 else if (CONSP (ind
) && CONSP (XCAR (ind
)))
950 if (pos
= Fassq (Qt
, ind
), !NILP (pos
))
951 boundary_top
= boundary_bot
= arrow_top
= arrow_bot
= XCDR (pos
);
952 if (pos
= Fassq (Qtop
, ind
), !NILP (pos
))
953 boundary_top
= XCDR (pos
);
954 if (pos
= Fassq (Qbottom
, ind
), !NILP (pos
))
955 boundary_bot
= XCDR (pos
);
956 if (pos
= Fassq (Qup
, ind
), !NILP (pos
))
957 arrow_top
= XCDR (pos
);
958 if (pos
= Fassq (Qdown
, ind
), !NILP (pos
))
959 arrow_bot
= XCDR (pos
);
962 /* Anything else means boundary on left and no arrows. */
963 boundary_top
= boundary_bot
= Qleft
;
966 top_ind_rn
= bot_ind_rn
= -1;
969 for (y
= w
->vscroll
, rn
= 0;
970 y
< yb
&& rn
< nrows
;
971 y
+= row
->height
, ++rn
)
973 unsigned indicate_bob_p
, indicate_top_line_p
;
974 unsigned indicate_eob_p
, indicate_bottom_line_p
;
976 row
= w
->desired_matrix
->rows
+ rn
;
978 row
= w
->current_matrix
->rows
+ rn
;
980 indicate_bob_p
= row
->indicate_bob_p
;
981 indicate_top_line_p
= row
->indicate_top_line_p
;
982 indicate_eob_p
= row
->indicate_eob_p
;
983 indicate_bottom_line_p
= row
->indicate_bottom_line_p
;
985 row
->indicate_bob_p
= row
->indicate_top_line_p
= 0;
986 row
->indicate_eob_p
= row
->indicate_bottom_line_p
= 0;
988 if (!row
->mode_line_p
)
990 if (top_ind_rn
< 0 && row
->visible_height
> 0)
992 if (MATRIX_ROW_START_CHARPOS (row
) <= BUF_BEGV (XBUFFER (w
->buffer
))
993 && !MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (w
, row
))
994 row
->indicate_bob_p
= !NILP (boundary_top
);
996 row
->indicate_top_line_p
= !NILP (arrow_top
);
1002 if (MATRIX_ROW_END_CHARPOS (row
) >= BUF_ZV (XBUFFER (w
->buffer
))
1003 && !MATRIX_ROW_PARTIALLY_VISIBLE_AT_BOTTOM_P (w
, row
))
1004 row
->indicate_eob_p
= !NILP (boundary_bot
), bot_ind_rn
= rn
;
1005 else if (y
+ row
->height
>= yb
)
1006 row
->indicate_bottom_line_p
= !NILP (arrow_bot
), bot_ind_rn
= rn
;
1012 empty_pos
= XBUFFER (w
->buffer
)->indicate_empty_lines
;
1013 if (!NILP (empty_pos
) && !EQ (empty_pos
, Qright
))
1014 empty_pos
= WINDOW_LEFT_FRINGE_WIDTH (w
) == 0 ? Qright
: Qleft
;
1016 for (y
= 0; y
< MAX_BITMAP_CACHE
; y
++)
1017 bitmap_cache
[y
] = -1;
1019 #define LEFT_FRINGE(cache, which, partial_p) \
1020 (bitmap_cache[cache*4+partial_p] >= 0 \
1021 ? bitmap_cache[cache*4+partial_p] \
1022 : (bitmap_cache[cache*4+partial_p] = \
1023 get_logical_fringe_bitmap (w, which, 0, partial_p)))
1025 #define RIGHT_FRINGE(cache, which, partial_p) \
1026 (bitmap_cache[cache*4+2+partial_p] >= 0 \
1027 ? bitmap_cache[cache*4+2+partial_p] \
1028 : (bitmap_cache[cache*4+2+partial_p] = \
1029 get_logical_fringe_bitmap (w, which, 1, partial_p)))
1032 /* Extend top-aligned top indicator (or bottom-aligned bottom
1033 indicator) to adjacent rows if it doesn't fit in one row. */
1034 top_ind_min_y
= bot_ind_max_y
= -1;
1035 if (top_ind_rn
>= 0)
1037 int bn
= NO_FRINGE_BITMAP
;
1039 row
= w
->desired_matrix
->rows
+ top_ind_rn
;
1040 if (!row
->enabled_p
)
1041 row
= w
->current_matrix
->rows
+ top_ind_rn
;
1043 top_row_ends_at_zv_p
= row
->ends_at_zv_p
;
1044 if (row
->indicate_bob_p
)
1046 if (EQ (boundary_top
, Qleft
))
1047 bn
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qleft
))
1048 ? LEFT_FRINGE (1, Qtop_bottom
, row
->ends_at_zv_p
)
1049 : LEFT_FRINGE (2, Qtop
, 0));
1051 bn
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qright
))
1052 ? RIGHT_FRINGE (1, Qtop_bottom
, row
->ends_at_zv_p
)
1053 : RIGHT_FRINGE (2, Qtop
, 0));
1055 else if (row
->indicate_top_line_p
)
1057 if (EQ (arrow_top
, Qleft
))
1058 bn
= LEFT_FRINGE (6, Qup
, 0);
1060 bn
= RIGHT_FRINGE (6, Qup
, 0);
1063 if (bn
!= NO_FRINGE_BITMAP
)
1065 struct fringe_bitmap
*fb
;
1067 fb
= fringe_bitmaps
[bn
];
1069 fb
= &standard_bitmaps
[bn
< MAX_STANDARD_FRINGE_BITMAPS
1070 ? bn
: UNDEF_FRINGE_BITMAP
];
1071 if (fb
->align
== ALIGN_BITMAP_TOP
&& fb
->period
== 0)
1073 struct glyph_row
*row1
;
1076 top_ind_min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
1077 top_ind_max_y
= top_ind_min_y
+ fb
->height
;
1078 if (top_ind_max_y
> yb
)
1081 for (y
= row
->y
+ row
->height
, rn
= top_ind_rn
+ 1;
1082 y
< top_ind_max_y
&& rn
< nrows
;
1083 y
+= row1
->height
, rn
++)
1085 if (bot_ind_rn
>= 0 && rn
>= bot_ind_rn
)
1088 row1
= w
->desired_matrix
->rows
+ rn
;
1089 if (!row1
->enabled_p
)
1090 row1
= w
->current_matrix
->rows
+ rn
;
1092 row1
->indicate_bob_p
= row
->indicate_bob_p
;
1093 row1
->indicate_top_line_p
= row
->indicate_top_line_p
;
1098 if (bot_ind_rn
>= 0)
1100 int bn
= NO_FRINGE_BITMAP
;
1102 row
= w
->desired_matrix
->rows
+ bot_ind_rn
;
1103 if (!row
->enabled_p
)
1104 row
= w
->current_matrix
->rows
+ bot_ind_rn
;
1106 bot_row_ends_at_zv_p
= row
->ends_at_zv_p
;
1107 if (row
->indicate_eob_p
)
1109 if (EQ (boundary_bot
, Qleft
))
1110 bn
= LEFT_FRINGE (3, Qbottom
, row
->ends_at_zv_p
);
1112 bn
= RIGHT_FRINGE (3, Qbottom
, row
->ends_at_zv_p
);
1114 else if (row
->indicate_bottom_line_p
)
1116 if (EQ (arrow_bot
, Qleft
))
1117 bn
= LEFT_FRINGE (7, Qdown
, 0);
1119 bn
= RIGHT_FRINGE (7, Qdown
, 0);
1122 if (bn
!= NO_FRINGE_BITMAP
)
1124 struct fringe_bitmap
*fb
;
1126 fb
= fringe_bitmaps
[bn
];
1128 fb
= &standard_bitmaps
[bn
< MAX_STANDARD_FRINGE_BITMAPS
1129 ? bn
: UNDEF_FRINGE_BITMAP
];
1130 if (fb
->align
== ALIGN_BITMAP_BOTTOM
&& fb
->period
== 0)
1132 struct glyph_row
*row1
;
1135 bot_ind_max_y
= row
->y
+ row
->visible_height
;
1136 bot_ind_min_y
= bot_ind_max_y
- fb
->height
;
1137 if (bot_ind_min_y
< WINDOW_HEADER_LINE_HEIGHT (w
))
1138 bot_ind_min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
1140 for (y
= row
->y
, rn
= bot_ind_rn
- 1;
1141 y
>= bot_ind_min_y
&& rn
>= 0;
1142 y
-= row1
->height
, rn
--)
1144 if (top_ind_rn
>= 0 && rn
<= top_ind_rn
)
1147 row1
= w
->desired_matrix
->rows
+ rn
;
1148 if (!row1
->enabled_p
)
1149 row1
= w
->current_matrix
->rows
+ rn
;
1151 row1
->indicate_eob_p
= row
->indicate_eob_p
;
1152 row1
->indicate_bottom_line_p
= row
->indicate_bottom_line_p
;
1158 for (y
= w
->vscroll
, rn
= 0;
1159 y
< yb
&& rn
< nrows
;
1160 y
+= row
->height
, rn
++)
1163 unsigned left_face_id
, right_face_id
;
1164 int left_offset
, right_offset
;
1166 row
= w
->desired_matrix
->rows
+ rn
;
1167 cur
= w
->current_matrix
->rows
+ rn
;
1168 if (!row
->enabled_p
)
1171 left_face_id
= right_face_id
= DEFAULT_FACE_ID
;
1172 left_offset
= right_offset
= 0;
1174 /* Decide which bitmap to draw in the left fringe. */
1175 if (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0)
1176 left
= NO_FRINGE_BITMAP
;
1177 else if (row
->left_user_fringe_bitmap
!= NO_FRINGE_BITMAP
)
1179 left
= row
->left_user_fringe_bitmap
;
1180 left_face_id
= row
->left_user_fringe_face_id
;
1182 else if ((!row
->reversed_p
&& row
->truncated_on_left_p
)
1183 || (row
->reversed_p
&& row
->truncated_on_right_p
))
1184 left
= LEFT_FRINGE(0, Qtruncation
, 0);
1185 else if (row
->indicate_bob_p
&& EQ (boundary_top
, Qleft
))
1187 left
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qleft
))
1188 ? LEFT_FRINGE (1, Qtop_bottom
, top_row_ends_at_zv_p
)
1189 : LEFT_FRINGE (2, Qtop
, 0));
1190 if (top_ind_min_y
>= 0)
1191 left_offset
= top_ind_min_y
- row
->y
;
1193 else if (row
->indicate_eob_p
&& EQ (boundary_bot
, Qleft
))
1195 left
= LEFT_FRINGE (3, Qbottom
, bot_row_ends_at_zv_p
);
1196 if (bot_ind_max_y
>= 0)
1197 left_offset
= bot_ind_max_y
- (row
->y
+ row
->visible_height
);
1199 else if (MATRIX_ROW_CONTINUATION_LINE_P (row
))
1200 left
= LEFT_FRINGE (4, Qcontinuation
, 0);
1201 else if (row
->indicate_empty_line_p
&& EQ (empty_pos
, Qleft
))
1202 left
= LEFT_FRINGE (5, Qempty_line
, 0);
1203 else if (row
->indicate_top_line_p
&& EQ (arrow_top
, Qleft
))
1205 left
= LEFT_FRINGE (6, Qup
, 0);
1206 if (top_ind_min_y
>= 0)
1207 left_offset
= top_ind_min_y
- row
->y
;
1209 else if (row
->indicate_bottom_line_p
&& EQ (arrow_bot
, Qleft
))
1211 left
= LEFT_FRINGE (7, Qdown
, 0);
1212 if (bot_ind_max_y
>= 0)
1213 left_offset
= bot_ind_max_y
- (row
->y
+ row
->visible_height
);
1216 left
= NO_FRINGE_BITMAP
;
1218 /* Decide which bitmap to draw in the right fringe. */
1219 if (WINDOW_RIGHT_FRINGE_WIDTH (w
) == 0)
1220 right
= NO_FRINGE_BITMAP
;
1221 else if (row
->right_user_fringe_bitmap
!= NO_FRINGE_BITMAP
)
1223 right
= row
->right_user_fringe_bitmap
;
1224 right_face_id
= row
->right_user_fringe_face_id
;
1226 else if ((!row
->reversed_p
&& row
->truncated_on_right_p
)
1227 || (row
->reversed_p
&& row
->truncated_on_left_p
))
1228 right
= RIGHT_FRINGE (0, Qtruncation
, 0);
1229 else if (row
->indicate_bob_p
&& EQ (boundary_top
, Qright
))
1231 right
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qright
))
1232 ? RIGHT_FRINGE (1, Qtop_bottom
, top_row_ends_at_zv_p
)
1233 : RIGHT_FRINGE (2, Qtop
, 0));
1234 if (top_ind_min_y
>= 0)
1235 right_offset
= top_ind_min_y
- row
->y
;
1237 else if (row
->indicate_eob_p
&& EQ (boundary_bot
, Qright
))
1239 right
= RIGHT_FRINGE (3, Qbottom
, bot_row_ends_at_zv_p
);
1240 if (bot_ind_max_y
>= 0)
1241 right_offset
= bot_ind_max_y
- (row
->y
+ row
->visible_height
);
1243 else if (row
->continued_p
)
1244 right
= RIGHT_FRINGE (4, Qcontinuation
, 0);
1245 else if (row
->indicate_top_line_p
&& EQ (arrow_top
, Qright
))
1247 right
= RIGHT_FRINGE (6, Qup
, 0);
1248 if (top_ind_min_y
>= 0)
1249 right_offset
= top_ind_min_y
- row
->y
;
1251 else if (row
->indicate_bottom_line_p
&& EQ (arrow_bot
, Qright
))
1253 right
= RIGHT_FRINGE (7, Qdown
, 0);
1254 if (bot_ind_max_y
>= 0)
1255 right_offset
= bot_ind_max_y
- (row
->y
+ row
->visible_height
);
1257 else if (row
->indicate_empty_line_p
&& EQ (empty_pos
, Qright
))
1258 right
= RIGHT_FRINGE (5, Qempty_line
, 0);
1260 right
= NO_FRINGE_BITMAP
;
1262 if (row
->y
!= cur
->y
1263 || row
->visible_height
!= cur
->visible_height
1264 || row
->ends_at_zv_p
!= cur
->ends_at_zv_p
1265 || left
!= cur
->left_fringe_bitmap
1266 || right
!= cur
->right_fringe_bitmap
1267 || left_face_id
!= cur
->left_fringe_face_id
1268 || right_face_id
!= cur
->right_fringe_face_id
1269 || left_offset
!= cur
->left_fringe_offset
1270 || right_offset
!= cur
->right_fringe_offset
1271 || cur
->redraw_fringe_bitmaps_p
)
1273 redraw_p
= row
->redraw_fringe_bitmaps_p
= 1;
1274 if (!keep_current_p
)
1276 cur
->redraw_fringe_bitmaps_p
= 1;
1277 cur
->left_fringe_bitmap
= left
;
1278 cur
->right_fringe_bitmap
= right
;
1279 cur
->left_fringe_face_id
= left_face_id
;
1280 cur
->right_fringe_face_id
= right_face_id
;
1281 cur
->left_fringe_offset
= left_offset
;
1282 cur
->right_fringe_offset
= right_offset
;
1286 if (row
->overlay_arrow_bitmap
< 0)
1287 row
->overlay_arrow_bitmap
= get_logical_fringe_bitmap (w
, Qoverlay_arrow
, 0, 0);
1289 if (row
->overlay_arrow_bitmap
!= cur
->overlay_arrow_bitmap
)
1291 redraw_p
= row
->redraw_fringe_bitmaps_p
= cur
->redraw_fringe_bitmaps_p
= 1;
1292 cur
->overlay_arrow_bitmap
= row
->overlay_arrow_bitmap
;
1295 row
->left_fringe_bitmap
= left
;
1296 row
->right_fringe_bitmap
= right
;
1297 row
->left_fringe_face_id
= left_face_id
;
1298 row
->right_fringe_face_id
= right_face_id
;
1299 row
->left_fringe_offset
= left_offset
;
1300 row
->right_fringe_offset
= right_offset
;
1303 return redraw_p
&& !keep_current_p
;
1307 /* Compute actual fringe widths for frame F.
1309 If REDRAW is 1, redraw F if the fringe settings was actually
1310 modified and F is visible.
1312 Since the combined left and right fringe must occupy an integral
1313 number of columns, we may need to add some pixels to each fringe.
1314 Typically, we add an equal amount (+/- 1 pixel) to each fringe,
1315 but a negative width value is taken literally (after negating it).
1317 We never make the fringes narrower than specified.
1321 compute_fringe_widths (struct frame
*f
, int redraw
)
1323 int o_left
= FRAME_LEFT_FRINGE_WIDTH (f
);
1324 int o_right
= FRAME_RIGHT_FRINGE_WIDTH (f
);
1325 int o_cols
= FRAME_FRINGE_COLS (f
);
1327 Lisp_Object left_fringe
= Fassq (Qleft_fringe
, f
->param_alist
);
1328 Lisp_Object right_fringe
= Fassq (Qright_fringe
, f
->param_alist
);
1329 int left_fringe_width
, right_fringe_width
;
1331 if (!NILP (left_fringe
))
1332 left_fringe
= Fcdr (left_fringe
);
1333 if (!NILP (right_fringe
))
1334 right_fringe
= Fcdr (right_fringe
);
1336 left_fringe_width
= ((NILP (left_fringe
) || !INTEGERP (left_fringe
)) ? 8 :
1337 XINT (left_fringe
));
1338 right_fringe_width
= ((NILP (right_fringe
) || !INTEGERP (right_fringe
)) ? 8 :
1339 XINT (right_fringe
));
1341 if (left_fringe_width
|| right_fringe_width
)
1343 int left_wid
= left_fringe_width
>= 0 ? left_fringe_width
: -left_fringe_width
;
1344 int right_wid
= right_fringe_width
>= 0 ? right_fringe_width
: -right_fringe_width
;
1345 int conf_wid
= left_wid
+ right_wid
;
1346 int font_wid
= FRAME_COLUMN_WIDTH (f
);
1347 int cols
= (left_wid
+ right_wid
+ font_wid
-1) / font_wid
;
1348 int real_wid
= cols
* font_wid
;
1349 if (left_wid
&& right_wid
)
1351 if (left_fringe_width
< 0)
1353 /* Left fringe width is fixed, adjust right fringe if necessary */
1354 FRAME_LEFT_FRINGE_WIDTH (f
) = left_wid
;
1355 FRAME_RIGHT_FRINGE_WIDTH (f
) = real_wid
- left_wid
;
1357 else if (right_fringe_width
< 0)
1359 /* Right fringe width is fixed, adjust left fringe if necessary */
1360 FRAME_LEFT_FRINGE_WIDTH (f
) = real_wid
- right_wid
;
1361 FRAME_RIGHT_FRINGE_WIDTH (f
) = right_wid
;
1365 /* Adjust both fringes with an equal amount.
1366 Note that we are doing integer arithmetic here, so don't
1367 lose a pixel if the total width is an odd number. */
1368 int fill
= real_wid
- conf_wid
;
1369 FRAME_LEFT_FRINGE_WIDTH (f
) = left_wid
+ fill
/2;
1370 FRAME_RIGHT_FRINGE_WIDTH (f
) = right_wid
+ fill
- fill
/2;
1373 else if (left_fringe_width
)
1375 FRAME_LEFT_FRINGE_WIDTH (f
) = real_wid
;
1376 FRAME_RIGHT_FRINGE_WIDTH (f
) = 0;
1380 FRAME_LEFT_FRINGE_WIDTH (f
) = 0;
1381 FRAME_RIGHT_FRINGE_WIDTH (f
) = real_wid
;
1383 FRAME_FRINGE_COLS (f
) = cols
;
1387 FRAME_LEFT_FRINGE_WIDTH (f
) = 0;
1388 FRAME_RIGHT_FRINGE_WIDTH (f
) = 0;
1389 FRAME_FRINGE_COLS (f
) = 0;
1392 if (redraw
&& FRAME_VISIBLE_P (f
))
1393 if (o_left
!= FRAME_LEFT_FRINGE_WIDTH (f
) ||
1394 o_right
!= FRAME_RIGHT_FRINGE_WIDTH (f
) ||
1395 o_cols
!= FRAME_FRINGE_COLS (f
))
1400 /* Free resources used by a user-defined bitmap. */
1403 destroy_fringe_bitmap (int n
)
1405 struct fringe_bitmap
**fbp
;
1407 fringe_faces
[n
] = Qnil
;
1409 fbp
= &fringe_bitmaps
[n
];
1410 if (*fbp
&& (*fbp
)->dynamic
)
1412 /* XXX Is SELECTED_FRAME OK here? */
1413 struct redisplay_interface
*rif
= FRAME_RIF (SELECTED_FRAME ());
1414 if (rif
&& rif
->destroy_fringe_bitmap
)
1415 rif
->destroy_fringe_bitmap (n
);
1420 while (max_used_fringe_bitmap
> MAX_STANDARD_FRINGE_BITMAPS
1421 && fringe_bitmaps
[max_used_fringe_bitmap
- 1] == NULL
)
1422 max_used_fringe_bitmap
--;
1426 DEFUN ("destroy-fringe-bitmap", Fdestroy_fringe_bitmap
, Sdestroy_fringe_bitmap
,
1428 doc
: /* Destroy fringe bitmap BITMAP.
1429 If BITMAP overrides a standard fringe bitmap, the original bitmap is restored. */)
1430 (Lisp_Object bitmap
)
1434 CHECK_SYMBOL (bitmap
);
1435 n
= lookup_fringe_bitmap (bitmap
);
1439 destroy_fringe_bitmap (n
);
1441 if (n
>= MAX_STANDARD_FRINGE_BITMAPS
)
1443 Vfringe_bitmaps
= Fdelq (bitmap
, Vfringe_bitmaps
);
1444 /* It would be better to remove the fringe property. */
1445 Fput (bitmap
, Qfringe
, Qnil
);
1452 /* Initialize bitmap bit.
1454 On X, we bit-swap the built-in bitmaps and reduce bitmap
1455 from short to char array if width is <= 8 bits.
1457 On MAC with big-endian CPU, we need to byte-swap each short.
1459 On W32 and MAC (little endian), there's no need to do this.
1462 #if defined (HAVE_X_WINDOWS)
1463 static const unsigned char swap_nibble
[16] = {
1464 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
1465 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
1466 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
1467 0x3, 0xb, 0x7, 0xf}; /* 0011 1011 0111 1111 */
1468 #endif /* HAVE_X_WINDOWS */
1471 init_fringe_bitmap (int which
, struct fringe_bitmap
*fb
, int once_p
)
1473 if (once_p
|| fb
->dynamic
)
1475 #if defined (HAVE_X_WINDOWS)
1476 unsigned short *bits
= fb
->bits
;
1481 unsigned char *cbits
= (unsigned char *)fb
->bits
;
1482 for (j
= 0; j
< fb
->height
; j
++)
1484 unsigned short b
= *bits
++;
1486 c
= (unsigned char)((swap_nibble
[b
& 0xf] << 4)
1487 | (swap_nibble
[(b
>>4) & 0xf]));
1488 *cbits
++ = (c
>> (8 - fb
->width
));
1493 for (j
= 0; j
< fb
->height
; j
++)
1495 unsigned short b
= *bits
;
1496 b
= (unsigned short)((swap_nibble
[b
& 0xf] << 12)
1497 | (swap_nibble
[(b
>>4) & 0xf] << 8)
1498 | (swap_nibble
[(b
>>8) & 0xf] << 4)
1499 | (swap_nibble
[(b
>>12) & 0xf]));
1500 b
>>= (16 - fb
->width
);
1501 #ifdef WORDS_BIG_ENDIAN
1502 b
= ((b
>> 8) | (b
<< 8));
1507 #endif /* HAVE_X_WINDOWS */
1513 /* XXX Is SELECTED_FRAME OK here? */
1514 struct redisplay_interface
*rif
= FRAME_RIF (SELECTED_FRAME ());
1516 destroy_fringe_bitmap (which
);
1518 if (rif
&& rif
->define_fringe_bitmap
)
1519 rif
->define_fringe_bitmap (which
, fb
->bits
, fb
->height
, fb
->width
);
1521 fringe_bitmaps
[which
] = fb
;
1522 if (which
>= max_used_fringe_bitmap
)
1523 max_used_fringe_bitmap
= which
+ 1;
1528 DEFUN ("define-fringe-bitmap", Fdefine_fringe_bitmap
, Sdefine_fringe_bitmap
,
1530 doc
: /* Define fringe bitmap BITMAP from BITS of size HEIGHT x WIDTH.
1531 BITMAP is a symbol identifying the new fringe bitmap.
1532 BITS is either a string or a vector of integers.
1533 HEIGHT is height of bitmap. If HEIGHT is nil, use length of BITS.
1534 WIDTH must be an integer between 1 and 16, or nil which defaults to 8.
1535 Optional fifth arg ALIGN may be one of `top', `center', or `bottom',
1536 indicating the positioning of the bitmap relative to the rows where it
1537 is used; the default is to center the bitmap. Fifth arg may also be a
1538 list (ALIGN PERIODIC) where PERIODIC non-nil specifies that the bitmap
1540 If BITMAP already exists, the existing definition is replaced. */)
1541 (Lisp_Object bitmap
, Lisp_Object bits
, Lisp_Object height
, Lisp_Object width
, Lisp_Object align
)
1545 struct fringe_bitmap fb
, *xfb
;
1546 int fill1
= 0, fill2
= 0;
1548 CHECK_SYMBOL (bitmap
);
1552 else if (VECTORP (bits
))
1553 h
= XVECTOR (bits
)->size
;
1555 wrong_type_argument (Qsequencep
, bits
);
1561 CHECK_NUMBER (height
);
1562 fb
.height
= min (XINT (height
), 255);
1565 fill1
= (fb
.height
- h
) / 2;
1566 fill2
= fb
.height
- h
- fill1
;
1574 CHECK_NUMBER (width
);
1575 fb
.width
= min (XINT (width
), 255);
1579 fb
.align
= ALIGN_BITMAP_CENTER
;
1583 Lisp_Object period
= XCDR (align
);
1586 period
= XCAR (period
);
1589 fb
.period
= fb
.height
;
1593 align
= XCAR (align
);
1595 if (EQ (align
, Qtop
))
1596 fb
.align
= ALIGN_BITMAP_TOP
;
1597 else if (EQ (align
, Qbottom
))
1598 fb
.align
= ALIGN_BITMAP_BOTTOM
;
1599 else if (!NILP (align
) && !EQ (align
, Qcenter
))
1600 error ("Bad align argument");
1602 n
= lookup_fringe_bitmap (bitmap
);
1605 if (max_used_fringe_bitmap
< max_fringe_bitmaps
)
1606 n
= max_used_fringe_bitmap
++;
1609 for (n
= MAX_STANDARD_FRINGE_BITMAPS
;
1610 n
< max_fringe_bitmaps
;
1612 if (fringe_bitmaps
[n
] == NULL
)
1615 if (n
== max_fringe_bitmaps
)
1617 if ((max_fringe_bitmaps
+ 20) > MAX_FRINGE_BITMAPS
)
1618 error ("No free fringe bitmap slots");
1620 i
= max_fringe_bitmaps
;
1621 max_fringe_bitmaps
+= 20;
1623 = ((struct fringe_bitmap
**)
1624 xrealloc (fringe_bitmaps
, max_fringe_bitmaps
* sizeof (struct fringe_bitmap
*)));
1626 = (Lisp_Object
*) xrealloc (fringe_faces
, max_fringe_bitmaps
* sizeof (Lisp_Object
));
1628 for (; i
< max_fringe_bitmaps
; i
++)
1630 fringe_bitmaps
[i
] = NULL
;
1631 fringe_faces
[i
] = Qnil
;
1636 Vfringe_bitmaps
= Fcons (bitmap
, Vfringe_bitmaps
);
1637 Fput (bitmap
, Qfringe
, make_number (n
));
1642 xfb
= (struct fringe_bitmap
*) xmalloc (sizeof fb
1643 + fb
.height
* BYTES_PER_BITMAP_ROW
);
1644 fb
.bits
= b
= (unsigned short *) (xfb
+ 1);
1645 memset (b
, 0, fb
.height
);
1648 while (j
< fb
.height
)
1650 for (i
= 0; i
< fill1
&& j
< fb
.height
; i
++)
1652 for (i
= 0; i
< h
&& j
< fb
.height
; i
++)
1654 Lisp_Object elt
= Faref (bits
, make_number (i
));
1655 b
[j
++] = NUMBERP (elt
) ? XINT (elt
) : 0;
1657 for (i
= 0; i
< fill2
&& j
< fb
.height
; i
++)
1663 init_fringe_bitmap (n
, xfb
, 0);
1668 DEFUN ("set-fringe-bitmap-face", Fset_fringe_bitmap_face
, Sset_fringe_bitmap_face
,
1670 doc
: /* Set face for fringe bitmap BITMAP to FACE.
1671 If FACE is nil, reset face to default fringe face. */)
1672 (Lisp_Object bitmap
, Lisp_Object face
)
1677 CHECK_SYMBOL (bitmap
);
1678 n
= lookup_fringe_bitmap (bitmap
);
1680 error ("Undefined fringe bitmap");
1684 face_id
= lookup_derived_face (SELECTED_FRAME (), face
,
1687 error ("No such face");
1690 fringe_faces
[n
] = face
;
1695 DEFUN ("fringe-bitmaps-at-pos", Ffringe_bitmaps_at_pos
, Sfringe_bitmaps_at_pos
,
1697 doc
: /* Return fringe bitmaps of row containing position POS in window WINDOW.
1698 If WINDOW is nil, use selected window. If POS is nil, use value of point
1699 in that window. Return value is a list (LEFT RIGHT OV), where LEFT
1700 is the symbol for the bitmap in the left fringe (or nil if no bitmap),
1701 RIGHT is similar for the right fringe, and OV is non-nil if there is an
1702 overlay arrow in the left fringe.
1703 Return nil if POS is not visible in WINDOW. */)
1704 (Lisp_Object pos
, Lisp_Object window
)
1707 struct glyph_row
*row
;
1711 window
= selected_window
;
1712 CHECK_WINDOW (window
);
1713 w
= XWINDOW (window
);
1717 CHECK_NUMBER_COERCE_MARKER (pos
);
1718 textpos
= XINT (pos
);
1720 else if (w
== XWINDOW (selected_window
))
1723 textpos
= XMARKER (w
->pointm
)->charpos
;
1725 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1726 row
= row_containing_pos (w
, textpos
, row
, NULL
, 0);
1728 return list3 (get_fringe_bitmap_name (row
->left_fringe_bitmap
),
1729 get_fringe_bitmap_name (row
->right_fringe_bitmap
),
1730 (row
->overlay_arrow_bitmap
== 0 ? Qnil
1731 : row
->overlay_arrow_bitmap
< 0 ? Qt
1732 : get_fringe_bitmap_name (row
->overlay_arrow_bitmap
)));
1738 /***********************************************************************
1740 ***********************************************************************/
1743 syms_of_fringe (void)
1745 Qtruncation
= intern_c_string ("truncation");
1746 staticpro (&Qtruncation
);
1747 Qcontinuation
= intern_c_string ("continuation");
1748 staticpro (&Qcontinuation
);
1749 Qoverlay_arrow
= intern_c_string ("overlay-arrow");
1750 staticpro (&Qoverlay_arrow
);
1751 Qempty_line
= intern_c_string ("empty-line");
1752 staticpro (&Qempty_line
);
1753 Qtop_bottom
= intern_c_string ("top-bottom");
1754 staticpro (&Qtop_bottom
);
1755 Qhollow_small
= intern_c_string ("hollow-small");
1756 staticpro (&Qhollow_small
);
1758 defsubr (&Sdestroy_fringe_bitmap
);
1759 defsubr (&Sdefine_fringe_bitmap
);
1760 defsubr (&Sfringe_bitmaps_at_pos
);
1761 defsubr (&Sset_fringe_bitmap_face
);
1763 DEFVAR_LISP ("overflow-newline-into-fringe", &Voverflow_newline_into_fringe
,
1764 doc
: /* *Non-nil means that newline may flow into the right fringe.
1765 This means that display lines which are exactly as wide as the window
1766 (not counting the final newline) will only occupy one screen line, by
1767 showing (or hiding) the final newline in the right fringe; when point
1768 is at the final newline, the cursor is shown in the right fringe.
1769 If nil, also continue lines which are exactly as wide as the window. */);
1770 Voverflow_newline_into_fringe
= Qt
;
1772 DEFVAR_LISP ("fringe-bitmaps", &Vfringe_bitmaps
,
1773 doc
: /* List of fringe bitmap symbols. */);
1774 Vfringe_bitmaps
= Qnil
;
1777 /* Garbage collection hook */
1780 mark_fringe_data (void)
1784 for (i
= 0; i
< max_fringe_bitmaps
; i
++)
1785 if (!NILP (fringe_faces
[i
]))
1786 mark_object (fringe_faces
[i
]);
1789 /* Initialize this module when Emacs starts. */
1792 init_fringe_once (void)
1796 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< MAX_STANDARD_FRINGE_BITMAPS
; bt
++)
1797 init_fringe_bitmap(bt
, &standard_bitmaps
[bt
], 1);
1805 max_fringe_bitmaps
= MAX_STANDARD_FRINGE_BITMAPS
+ 20;
1808 = (struct fringe_bitmap
**) xmalloc (max_fringe_bitmaps
* sizeof (struct fringe_bitmap
*));
1810 = (Lisp_Object
*) xmalloc (max_fringe_bitmaps
* sizeof (Lisp_Object
));
1812 for (i
= 0; i
< max_fringe_bitmaps
; i
++)
1814 fringe_bitmaps
[i
] = NULL
;
1815 fringe_faces
[i
] = Qnil
;
1822 w32_init_fringe (struct redisplay_interface
*rif
)
1829 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< MAX_STANDARD_FRINGE_BITMAPS
; bt
++)
1831 struct fringe_bitmap
*fb
= &standard_bitmaps
[bt
];
1832 rif
->define_fringe_bitmap (bt
, fb
->bits
, fb
->height
, fb
->width
);
1837 w32_reset_fringes ()
1839 /* Destroy row bitmaps. */
1841 struct redisplay_interface
*rif
= FRAME_RIF (SELECTED_FRAME ());
1846 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< max_used_fringe_bitmap
; bt
++)
1847 rif
->destroy_fringe_bitmap (bt
);
1850 #endif /* HAVE_NTGUI */
1852 #endif /* HAVE_WINDOW_SYSTEM */
1854 /* arch-tag: 04596920-43eb-473d-b319-82712338162d
1855 (do not change this comment) */