1 /* Fringe handling (split from xdisp.c).
2 Copyright (C) 1985,86,87,88,93,94,95,97,98,99,2000,01,02,03,04
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
28 #include "dispextern.h"
30 #include "blockinput.h"
32 #ifdef HAVE_WINDOW_SYSTEM
34 extern Lisp_Object Qfringe
;
35 extern Lisp_Object Qtop
, Qbottom
, Qcenter
;
36 extern Lisp_Object Qup
, Qdown
, Qleft
, Qright
;
38 /* Non-nil means that newline may flow into the right fringe. */
40 Lisp_Object Voverflow_newline_into_fringe
;
42 /* List of known fringe bitmap symbols.
44 The fringe bitmap number is stored in the `fringe' property on
45 those symbols. Names for the built-in bitmaps are installed by
49 Lisp_Object Vfringe_bitmaps
;
51 enum fringe_bitmap_type
55 LEFT_TRUNCATION_BITMAP
,
56 RIGHT_TRUNCATION_BITMAP
,
59 CONTINUED_LINE_BITMAP
,
60 CONTINUATION_LINE_BITMAP
,
62 TOP_LEFT_ANGLE_BITMAP
,
63 TOP_RIGHT_ANGLE_BITMAP
,
64 BOTTOM_LEFT_ANGLE_BITMAP
,
65 BOTTOM_RIGHT_ANGLE_BITMAP
,
68 FILLED_BOX_CURSOR_BITMAP
,
69 HOLLOW_BOX_CURSOR_BITMAP
,
74 MAX_STANDARD_FRINGE_BITMAPS
77 enum fringe_bitmap_align
79 ALIGN_BITMAP_CENTER
= 0,
95 /***********************************************************************
97 ***********************************************************************/
99 /* Undefined bitmap. A question mark. */
112 static unsigned short unknown_bits
[] = {
113 0x3c, 0x7e, 0x7e, 0x0c, 0x18, 0x18, 0x00, 0x18, 0x18};
115 /* An arrow like this: `<-'. */
126 static unsigned short left_arrow_bits
[] = {
127 0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
130 /* Right truncation arrow bitmap `->'. */
141 static unsigned short right_arrow_bits
[] = {
142 0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
145 /* Up arrow bitmap. */
156 static unsigned short up_arrow_bits
[] = {
157 0x18, 0x3c, 0x7e, 0xff, 0x18, 0x18, 0x18, 0x18};
160 /* Down arrow bitmap. */
171 static unsigned short down_arrow_bits
[] = {
172 0x18, 0x18, 0x18, 0x18, 0xff, 0x7e, 0x3c, 0x18};
174 /* Marker for continued lines. */
185 static unsigned short continued_bits
[] = {
186 0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
188 /* Marker for continuation lines. */
199 static unsigned short continuation_bits
[] = {
200 0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
202 /* Overlay arrow bitmap. A triangular arrow. */
213 static unsigned short ov_bits
[] = {
214 0xc0, 0xf0, 0xf8, 0xfc, 0xfc, 0xf8, 0xf0, 0xc0};
217 /* Reverse Overlay arrow bitmap. A triangular arrow. */
228 static unsigned short rev_ov_bits
[] = {
229 0x03, 0x0f, 0x1f, 0x3f, 0x3f, 0x1f, 0x0f, 0x03};
232 /* First line bitmap. An top-left angle. */
243 static unsigned short top_left_angle_bits
[] = {
244 0xfc, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00};
246 /* First line bitmap. An right-up angle. */
257 static unsigned short top_right_angle_bits
[] = {
258 0x3f, 0x3f, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00};
260 /* Last line bitmap. An left-down angle. */
271 static unsigned short bottom_left_angle_bits
[] = {
272 0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfc, 0xfc};
274 /* Last line bitmap. An right-down angle. */
285 static unsigned short bottom_right_angle_bits
[] = {
286 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x3f, 0x3f};
288 /* First/last line bitmap. An left bracket. */
301 static unsigned short left_bracket_bits
[] = {
302 0xfc, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfc, 0xfc};
304 /* First/last line bitmap. An right bracket. */
317 static unsigned short right_bracket_bits
[] = {
318 0x3f, 0x3f, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x3f, 0x3f};
320 /* Filled box cursor bitmap. A filled box; max 13 pixels high. */
336 static unsigned short filled_box_cursor_bits
[] = {
337 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe};
339 /* Hollow box cursor bitmap. A hollow box; max 13 pixels high. */
355 static unsigned short hollow_box_cursor_bits
[] = {
356 0xfe, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0xfe};
358 /* Bar cursor bitmap. A vertical bar; max 13 pixels high. */
374 static unsigned short bar_cursor_bits
[] = {
375 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0};
377 /* HBar cursor bitmap. A horisontal bar; 2 pixels high. */
382 static unsigned short hbar_cursor_bits
[] = {
386 /* Bitmap drawn to indicate lines not displaying text if
387 `indicate-empty-lines' is non-nil. */
396 static unsigned short zv_bits
[] = {
397 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
398 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
399 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
400 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
401 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
402 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
403 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
404 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00};
406 /* Hollow square bitmap. */
415 static unsigned short hollow_square_bits
[] = {
416 0x7e, 0x42, 0x42, 0x42, 0x42, 0x7e};
419 #define BYTES_PER_BITMAP_ROW (sizeof (unsigned short))
420 #define STANDARD_BITMAP_HEIGHT(bits) (sizeof (bits)/BYTES_PER_BITMAP_ROW)
421 #define FRBITS(bits) bits, STANDARD_BITMAP_HEIGHT (bits)
423 struct fringe_bitmap standard_bitmaps
[MAX_STANDARD_FRINGE_BITMAPS
] =
425 { NULL
, 0, 0, 0, 0, 0 }, /* NO_FRINGE_BITMAP */
426 { FRBITS (unknown_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
427 { FRBITS (left_arrow_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
428 { FRBITS (right_arrow_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
429 { FRBITS (up_arrow_bits
), 8, 0, ALIGN_BITMAP_TOP
, 0 },
430 { FRBITS (down_arrow_bits
), 8, 0, ALIGN_BITMAP_BOTTOM
, 0 },
431 { FRBITS (continued_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
432 { FRBITS (continuation_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
433 { FRBITS (ov_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
434 { FRBITS (top_left_angle_bits
), 8, 0, ALIGN_BITMAP_TOP
, 0 },
435 { FRBITS (top_right_angle_bits
), 8, 0, ALIGN_BITMAP_TOP
, 0 },
436 { FRBITS (bottom_left_angle_bits
), 8, 0, ALIGN_BITMAP_BOTTOM
, 0 },
437 { FRBITS (bottom_right_angle_bits
), 8, 0, ALIGN_BITMAP_BOTTOM
, 0 },
438 { FRBITS (left_bracket_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
439 { FRBITS (right_bracket_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
440 { FRBITS (filled_box_cursor_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
441 { FRBITS (hollow_box_cursor_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
442 { FRBITS (hollow_square_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
443 { FRBITS (bar_cursor_bits
), 8, 0, ALIGN_BITMAP_CENTER
, 0 },
444 { FRBITS (hbar_cursor_bits
), 8, 0, ALIGN_BITMAP_BOTTOM
, 0 },
445 { FRBITS (zv_bits
), 8, 3, ALIGN_BITMAP_TOP
, 0 },
448 static struct fringe_bitmap
*fringe_bitmaps
[MAX_FRINGE_BITMAPS
];
449 static unsigned fringe_faces
[MAX_FRINGE_BITMAPS
];
451 static int max_used_fringe_bitmap
= MAX_STANDARD_FRINGE_BITMAPS
;
454 /* Lookup bitmap number for symbol BITMAP.
455 Return 0 if not a bitmap. */
458 lookup_fringe_bitmap (bitmap
)
463 bitmap
= Fget (bitmap
, Qfringe
);
464 if (!INTEGERP (bitmap
))
468 if (bn
> NO_FRINGE_BITMAP
469 && bn
< max_used_fringe_bitmap
470 && (bn
< MAX_STANDARD_FRINGE_BITMAPS
471 || fringe_bitmaps
[bn
] != NULL
))
477 /* Get fringe bitmap name for bitmap number BN.
479 Found by traversing Vfringe_bitmaps comparing BN to the
480 fringe property for each symbol.
482 Return BN if not found in Vfringe_bitmaps. */
485 get_fringe_bitmap_name (bn
)
491 /* Zero means no bitmap -- return nil. */
495 bitmaps
= Vfringe_bitmaps
;
496 num
= make_number (bn
);
498 while (CONSP (bitmaps
))
500 Lisp_Object bitmap
= XCAR (bitmaps
);
501 if (EQ (num
, Fget (bitmap
, Qfringe
)))
503 bitmaps
= XCDR (bitmaps
);
510 /* Draw the bitmap WHICH in one of the left or right fringes of
511 window W. ROW is the glyph row for which to display the bitmap; it
512 determines the vertical position at which the bitmap has to be
514 LEFT_P is 1 for left fringe, 0 for right fringe.
518 draw_fringe_bitmap_1 (w
, row
, left_p
, overlay
, which
)
520 struct glyph_row
*row
;
522 enum fringe_bitmap_type which
;
524 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
525 struct draw_fringe_bitmap_params p
;
526 struct fringe_bitmap
*fb
;
528 int face_id
= DEFAULT_FACE_ID
;
531 p
.overlay_p
= (overlay
& 1) == 1;
532 p
.cursor_p
= (overlay
& 2) == 2;
534 if (which
!= NO_FRINGE_BITMAP
)
539 which
= row
->left_fringe_bitmap
;
540 face_id
= row
->left_fringe_face_id
;
544 which
= row
->right_fringe_bitmap
;
545 face_id
= row
->right_fringe_face_id
;
548 if (face_id
== DEFAULT_FACE_ID
)
549 face_id
= fringe_faces
[which
];
551 fb
= fringe_bitmaps
[which
];
553 fb
= &standard_bitmaps
[which
< MAX_STANDARD_FRINGE_BITMAPS
554 ? which
: UNDEF_FRINGE_BITMAP
];
558 /* Convert row to frame coordinates. */
559 p
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
566 p
.dh
= (period
> 0 ? (p
.y
% period
) : 0);
568 /* Clip bitmap if too high. */
569 if (p
.h
> row
->height
)
572 p
.face
= FACE_FROM_ID (f
, face_id
);
576 /* Why does this happen? ++kfs */
580 PREPARE_FACE_FOR_DISPLAY (f
, p
.face
);
582 /* Clear left fringe if no bitmap to draw or if bitmap doesn't fill
587 int wd
= WINDOW_LEFT_FRINGE_WIDTH (w
);
588 int x
= window_box_left (w
, (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
593 p
.x
= x
- p
.wd
- (wd
- p
.wd
) / 2;
595 if (p
.wd
< wd
|| row
->height
> p
.h
)
597 /* If W has a vertical border to its left, don't draw over it. */
598 wd
-= ((!WINDOW_LEFTMOST_P (w
)
599 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
607 int x
= window_box_right (w
,
608 (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
611 int wd
= WINDOW_RIGHT_FRINGE_WIDTH (w
);
614 p
.x
= x
+ (wd
- p
.wd
) / 2;
615 /* Clear right fringe if no bitmap to draw of if bitmap doesn't fill
617 if (p
.wd
< wd
|| row
->height
> p
.h
)
626 int header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
628 p
.by
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
, row
->y
));
629 p
.ny
= row
->visible_height
;
632 /* Adjust y to the offset in the row to start drawing the bitmap. */
635 case ALIGN_BITMAP_CENTER
:
636 p
.y
+= (row
->height
- p
.h
) / 2;
638 case ALIGN_BITMAP_BOTTOM
:
640 p
.y
+= (row
->visible_height
- p
.h
);
642 case ALIGN_BITMAP_TOP
:
646 rif
->draw_fringe_bitmap (w
, row
, &p
);
650 draw_fringe_bitmap (w
, row
, left_p
)
652 struct glyph_row
*row
;
657 if (!left_p
&& row
->cursor_in_fringe_p
)
659 int cursor
= NO_FRINGE_BITMAP
;
661 switch (w
->phys_cursor_type
)
663 case HOLLOW_BOX_CURSOR
:
664 if (row
->visible_height
>= STANDARD_BITMAP_HEIGHT (hollow_box_cursor_bits
))
665 cursor
= HOLLOW_BOX_CURSOR_BITMAP
;
667 cursor
= HOLLOW_SQUARE_BITMAP
;
669 case FILLED_BOX_CURSOR
:
670 cursor
= FILLED_BOX_CURSOR_BITMAP
;
673 cursor
= BAR_CURSOR_BITMAP
;
676 cursor
= HBAR_CURSOR_BITMAP
;
680 w
->phys_cursor_on_p
= 0;
681 row
->cursor_in_fringe_p
= 0;
684 if (cursor
!= NO_FRINGE_BITMAP
)
686 draw_fringe_bitmap_1 (w
, row
, 0, 2, cursor
);
687 overlay
= cursor
== FILLED_BOX_CURSOR_BITMAP
? 3 : 1;
691 draw_fringe_bitmap_1 (w
, row
, left_p
, overlay
, NO_FRINGE_BITMAP
);
693 if (left_p
&& row
->overlay_arrow_p
)
694 draw_fringe_bitmap_1 (w
, row
, 1, 1,
695 (w
->overlay_arrow_bitmap
696 ? w
->overlay_arrow_bitmap
697 : OVERLAY_ARROW_BITMAP
));
701 /* Draw fringe bitmaps for glyph row ROW on window W. Call this
702 function with input blocked. */
705 draw_row_fringe_bitmaps (w
, row
)
707 struct glyph_row
*row
;
709 xassert (interrupt_input_blocked
);
711 /* If row is completely invisible, because of vscrolling, we
712 don't have to draw anything. */
713 if (row
->visible_height
<= 0)
716 if (WINDOW_LEFT_FRINGE_WIDTH (w
) != 0)
717 draw_fringe_bitmap (w
, row
, 1);
719 if (WINDOW_RIGHT_FRINGE_WIDTH (w
) != 0)
720 draw_fringe_bitmap (w
, row
, 0);
723 /* Draw the fringes of window W. Only fringes for rows marked for
724 update in redraw_fringe_bitmaps_p are drawn. */
727 draw_window_fringes (w
)
730 struct glyph_row
*row
;
731 int yb
= window_text_bottom_y (w
);
732 int nrows
= w
->current_matrix
->nrows
;
735 if (w
->pseudo_window_p
)
738 for (y
= 0, rn
= 0, row
= w
->current_matrix
->rows
;
739 y
< yb
&& rn
< nrows
;
740 y
+= row
->height
, ++row
, ++rn
)
742 if (!row
->redraw_fringe_bitmaps_p
)
744 draw_row_fringe_bitmaps (w
, row
);
745 row
->redraw_fringe_bitmaps_p
= 0;
750 /* Recalculate the bitmaps to show in the fringes of window W.
751 If FORCE_P is 0, only mark rows with modified bitmaps for update in
752 redraw_fringe_bitmaps_p; else mark all rows for update. */
755 update_window_fringes (w
, force_p
)
759 struct glyph_row
*row
, *cur
= 0;
760 int yb
= window_text_bottom_y (w
);
761 int rn
, nrows
= w
->current_matrix
->nrows
;
764 Lisp_Object boundary_top
= Qnil
, boundary_bot
= Qnil
;
765 Lisp_Object arrow_top
= Qnil
, arrow_bot
= Qnil
;
766 Lisp_Object empty_pos
;
767 Lisp_Object ind
= Qnil
;
769 if (w
->pseudo_window_p
)
772 if (!MINI_WINDOW_P (w
)
773 && (ind
= XBUFFER (w
->buffer
)->indicate_buffer_boundaries
, !NILP (ind
)))
775 if (EQ (ind
, Qleft
) || EQ (ind
, Qright
))
776 boundary_top
= boundary_bot
= arrow_top
= arrow_bot
= ind
;
777 else if (CONSP (ind
) && CONSP (XCAR (ind
)))
780 if (pos
= Fassq (Qt
, ind
), !NILP (pos
))
781 boundary_top
= boundary_bot
= arrow_top
= arrow_bot
= XCDR (pos
);
782 if (pos
= Fassq (Qtop
, ind
), !NILP (pos
))
783 boundary_top
= XCDR (pos
);
784 if (pos
= Fassq (Qbottom
, ind
), !NILP (pos
))
785 boundary_bot
= XCDR (pos
);
786 if (pos
= Fassq (Qup
, ind
), !NILP (pos
))
787 arrow_top
= XCDR (pos
);
788 if (pos
= Fassq (Qdown
, ind
), !NILP (pos
))
789 arrow_bot
= XCDR (pos
);
797 int do_eob
= 1, do_bob
= 1;
800 y
< yb
&& rn
< nrows
;
801 y
+= row
->height
, ++rn
)
803 unsigned indicate_bob_p
, indicate_top_line_p
;
804 unsigned indicate_eob_p
, indicate_bottom_line_p
;
806 row
= w
->desired_matrix
->rows
+ rn
;
808 row
= w
->current_matrix
->rows
+ rn
;
810 indicate_bob_p
= row
->indicate_bob_p
;
811 indicate_top_line_p
= row
->indicate_top_line_p
;
812 indicate_eob_p
= row
->indicate_eob_p
;
813 indicate_bottom_line_p
= row
->indicate_bottom_line_p
;
815 row
->indicate_bob_p
= row
->indicate_top_line_p
= 0;
816 row
->indicate_eob_p
= row
->indicate_bottom_line_p
= 0;
818 if (!NILP (boundary_top
)
819 && MATRIX_ROW_START_CHARPOS (row
) <= BUF_BEGV (XBUFFER (w
->buffer
)))
820 row
->indicate_bob_p
= do_bob
, do_bob
= 0;
821 else if (!NILP (arrow_top
)
822 && (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0) == rn
)
823 row
->indicate_top_line_p
= 1;
825 if (!NILP (boundary_bot
)
826 && MATRIX_ROW_END_CHARPOS (row
) >= BUF_ZV (XBUFFER (w
->buffer
)))
827 row
->indicate_eob_p
= do_eob
, do_eob
= 0;
828 else if (!NILP (arrow_bot
)
829 && y
+ row
->height
>= yb
)
830 row
->indicate_bottom_line_p
= 1;
832 if (indicate_bob_p
!= row
->indicate_bob_p
833 || indicate_top_line_p
!= row
->indicate_top_line_p
834 || indicate_eob_p
!= row
->indicate_eob_p
835 || indicate_bottom_line_p
!= row
->indicate_bottom_line_p
)
836 row
->redraw_fringe_bitmaps_p
= 1;
840 empty_pos
= XBUFFER (w
->buffer
)->indicate_empty_lines
;
841 if (!NILP (empty_pos
) && !EQ (empty_pos
, Qright
))
842 empty_pos
= WINDOW_LEFT_FRINGE_WIDTH (w
) == 0 ? Qright
: Qleft
;
845 y
< yb
&& rn
< nrows
;
846 y
+= row
->height
, rn
++)
848 enum fringe_bitmap_type left
, right
;
849 unsigned left_face_id
, right_face_id
;
851 row
= w
->desired_matrix
->rows
+ rn
;
852 cur
= w
->current_matrix
->rows
+ rn
;
856 left_face_id
= right_face_id
= DEFAULT_FACE_ID
;
858 /* Decide which bitmap to draw in the left fringe. */
859 if (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0)
860 left
= NO_FRINGE_BITMAP
;
861 else if (row
->left_user_fringe_bitmap
!= NO_FRINGE_BITMAP
)
863 left
= row
->left_user_fringe_bitmap
;
864 left_face_id
= row
->left_user_fringe_face_id
;
866 else if (row
->indicate_bob_p
&& EQ (boundary_top
, Qleft
))
867 left
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qleft
))
868 ? LEFT_BRACKET_BITMAP
: TOP_LEFT_ANGLE_BITMAP
);
869 else if (row
->indicate_eob_p
&& EQ (boundary_bot
, Qleft
))
870 left
= BOTTOM_LEFT_ANGLE_BITMAP
;
871 else if (row
->truncated_on_left_p
)
872 left
= LEFT_TRUNCATION_BITMAP
;
873 else if (MATRIX_ROW_CONTINUATION_LINE_P (row
))
874 left
= CONTINUATION_LINE_BITMAP
;
875 else if (row
->indicate_empty_line_p
&& EQ (empty_pos
, Qleft
))
876 left
= ZV_LINE_BITMAP
;
877 else if (row
->indicate_top_line_p
&& EQ (arrow_top
, Qleft
))
878 left
= UP_ARROW_BITMAP
;
879 else if (row
->indicate_bottom_line_p
&& EQ (arrow_bot
, Qleft
))
880 left
= DOWN_ARROW_BITMAP
;
882 left
= NO_FRINGE_BITMAP
;
884 /* Decide which bitmap to draw in the right fringe. */
885 if (WINDOW_RIGHT_FRINGE_WIDTH (w
) == 0)
886 right
= NO_FRINGE_BITMAP
;
887 else if (row
->right_user_fringe_bitmap
!= NO_FRINGE_BITMAP
)
889 right
= row
->right_user_fringe_bitmap
;
890 right_face_id
= row
->right_user_fringe_face_id
;
892 else if (row
->indicate_bob_p
&& EQ (boundary_top
, Qright
))
893 right
= ((row
->indicate_eob_p
&& EQ (boundary_bot
, Qright
))
894 ? RIGHT_BRACKET_BITMAP
: TOP_RIGHT_ANGLE_BITMAP
);
895 else if (row
->indicate_eob_p
&& EQ (boundary_bot
, Qright
))
896 right
= BOTTOM_RIGHT_ANGLE_BITMAP
;
897 else if (row
->truncated_on_right_p
)
898 right
= RIGHT_TRUNCATION_BITMAP
;
899 else if (row
->continued_p
)
900 right
= CONTINUED_LINE_BITMAP
;
901 else if (row
->indicate_top_line_p
&& EQ (arrow_top
, Qright
))
902 right
= UP_ARROW_BITMAP
;
903 else if (row
->indicate_bottom_line_p
&& EQ (arrow_bot
, Qright
))
904 right
= DOWN_ARROW_BITMAP
;
905 else if (row
->indicate_empty_line_p
&& EQ (empty_pos
, Qright
))
906 right
= ZV_LINE_BITMAP
;
908 right
= NO_FRINGE_BITMAP
;
912 || row
->visible_height
!= cur
->visible_height
913 || left
!= cur
->left_fringe_bitmap
914 || right
!= cur
->right_fringe_bitmap
915 || left_face_id
!= cur
->left_fringe_face_id
916 || right_face_id
!= cur
->right_fringe_face_id
917 || cur
->redraw_fringe_bitmaps_p
)
919 redraw_p
= row
->redraw_fringe_bitmaps_p
= cur
->redraw_fringe_bitmaps_p
= 1;
920 cur
->left_fringe_bitmap
= left
;
921 cur
->right_fringe_bitmap
= right
;
922 cur
->left_fringe_face_id
= left_face_id
;
923 cur
->right_fringe_face_id
= right_face_id
;
926 if (row
->overlay_arrow_p
!= cur
->overlay_arrow_p
)
928 redraw_p
= row
->redraw_fringe_bitmaps_p
= cur
->redraw_fringe_bitmaps_p
= 1;
929 cur
->overlay_arrow_p
= row
->overlay_arrow_p
;
932 row
->left_fringe_bitmap
= left
;
933 row
->right_fringe_bitmap
= right
;
934 row
->left_fringe_face_id
= left_face_id
;
935 row
->right_fringe_face_id
= right_face_id
;
942 /* Compute actual fringe widths for frame F.
944 If REDRAW is 1, redraw F if the fringe settings was actually
945 modified and F is visible.
947 Since the combined left and right fringe must occupy an integral
948 number of columns, we may need to add some pixels to each fringe.
949 Typically, we add an equal amount (+/- 1 pixel) to each fringe,
950 but a negative width value is taken literally (after negating it).
952 We never make the fringes narrower than specified. It is planned
953 to make fringe bitmaps customizable and expandable, and at that
954 time, the user will typically specify the minimum number of pixels
955 needed for his bitmaps, so we shouldn't select anything less than
960 compute_fringe_widths (f
, redraw
)
964 int o_left
= FRAME_LEFT_FRINGE_WIDTH (f
);
965 int o_right
= FRAME_RIGHT_FRINGE_WIDTH (f
);
966 int o_cols
= FRAME_FRINGE_COLS (f
);
968 Lisp_Object left_fringe
= Fassq (Qleft_fringe
, f
->param_alist
);
969 Lisp_Object right_fringe
= Fassq (Qright_fringe
, f
->param_alist
);
970 int left_fringe_width
, right_fringe_width
;
972 if (!NILP (left_fringe
))
973 left_fringe
= Fcdr (left_fringe
);
974 if (!NILP (right_fringe
))
975 right_fringe
= Fcdr (right_fringe
);
977 left_fringe_width
= ((NILP (left_fringe
) || !INTEGERP (left_fringe
)) ? 8 :
979 right_fringe_width
= ((NILP (right_fringe
) || !INTEGERP (right_fringe
)) ? 8 :
980 XINT (right_fringe
));
982 if (left_fringe_width
|| right_fringe_width
)
984 int left_wid
= left_fringe_width
>= 0 ? left_fringe_width
: -left_fringe_width
;
985 int right_wid
= right_fringe_width
>= 0 ? right_fringe_width
: -right_fringe_width
;
986 int conf_wid
= left_wid
+ right_wid
;
987 int font_wid
= FRAME_COLUMN_WIDTH (f
);
988 int cols
= (left_wid
+ right_wid
+ font_wid
-1) / font_wid
;
989 int real_wid
= cols
* font_wid
;
990 if (left_wid
&& right_wid
)
992 if (left_fringe_width
< 0)
994 /* Left fringe width is fixed, adjust right fringe if necessary */
995 FRAME_LEFT_FRINGE_WIDTH (f
) = left_wid
;
996 FRAME_RIGHT_FRINGE_WIDTH (f
) = real_wid
- left_wid
;
998 else if (right_fringe_width
< 0)
1000 /* Right fringe width is fixed, adjust left fringe if necessary */
1001 FRAME_LEFT_FRINGE_WIDTH (f
) = real_wid
- right_wid
;
1002 FRAME_RIGHT_FRINGE_WIDTH (f
) = right_wid
;
1006 /* Adjust both fringes with an equal amount.
1007 Note that we are doing integer arithmetic here, so don't
1008 lose a pixel if the total width is an odd number. */
1009 int fill
= real_wid
- conf_wid
;
1010 FRAME_LEFT_FRINGE_WIDTH (f
) = left_wid
+ fill
/2;
1011 FRAME_RIGHT_FRINGE_WIDTH (f
) = right_wid
+ fill
- fill
/2;
1014 else if (left_fringe_width
)
1016 FRAME_LEFT_FRINGE_WIDTH (f
) = real_wid
;
1017 FRAME_RIGHT_FRINGE_WIDTH (f
) = 0;
1021 FRAME_LEFT_FRINGE_WIDTH (f
) = 0;
1022 FRAME_RIGHT_FRINGE_WIDTH (f
) = real_wid
;
1024 FRAME_FRINGE_COLS (f
) = cols
;
1028 FRAME_LEFT_FRINGE_WIDTH (f
) = 0;
1029 FRAME_RIGHT_FRINGE_WIDTH (f
) = 0;
1030 FRAME_FRINGE_COLS (f
) = 0;
1033 if (redraw
&& FRAME_VISIBLE_P (f
))
1034 if (o_left
!= FRAME_LEFT_FRINGE_WIDTH (f
) ||
1035 o_right
!= FRAME_RIGHT_FRINGE_WIDTH (f
) ||
1036 o_cols
!= FRAME_FRINGE_COLS (f
))
1041 /* Free resources used by a user-defined bitmap. */
1044 destroy_fringe_bitmap (n
)
1047 struct fringe_bitmap
**fbp
;
1049 fringe_faces
[n
] = FRINGE_FACE_ID
;
1051 fbp
= &fringe_bitmaps
[n
];
1052 if (*fbp
&& (*fbp
)->dynamic
)
1054 if (rif
&& rif
->destroy_fringe_bitmap
)
1055 rif
->destroy_fringe_bitmap (n
);
1060 while (max_used_fringe_bitmap
> MAX_STANDARD_FRINGE_BITMAPS
1061 && fringe_bitmaps
[max_used_fringe_bitmap
- 1] == NULL
)
1062 max_used_fringe_bitmap
--;
1066 DEFUN ("destroy-fringe-bitmap", Fdestroy_fringe_bitmap
, Sdestroy_fringe_bitmap
,
1068 doc
: /* Destroy fringe bitmap BITMAP.
1069 If BITMAP overrides a standard fringe bitmap, the original bitmap is restored. */)
1075 CHECK_SYMBOL (bitmap
);
1076 n
= lookup_fringe_bitmap (bitmap
);
1080 destroy_fringe_bitmap (n
);
1082 if (n
>= MAX_STANDARD_FRINGE_BITMAPS
)
1084 Vfringe_bitmaps
= Fdelq (bitmap
, Vfringe_bitmaps
);
1085 /* It would be better to remove the fringe property. */
1086 Fput (bitmap
, Qfringe
, Qnil
);
1093 /* Initialize bitmap bit.
1095 On X, we bit-swap the built-in bitmaps and reduce bitmap
1096 from short to char array if width is <= 8 bits.
1098 On MAC with big-endian CPU, we need to byte-swap each short.
1100 On W32 and MAC (little endian), there's no need to do this.
1104 init_fringe_bitmap (which
, fb
, once_p
)
1105 enum fringe_bitmap_type which
;
1106 struct fringe_bitmap
*fb
;
1109 if (once_p
|| fb
->dynamic
)
1111 #if defined (HAVE_X_WINDOWS)
1112 static unsigned char swap_nibble
[16]
1113 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
1114 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
1115 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
1116 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
1117 unsigned short *bits
= fb
->bits
;
1122 unsigned char *cbits
= (unsigned char *)fb
->bits
;
1123 for (j
= 0; j
< fb
->height
; j
++)
1125 unsigned short b
= *bits
++;
1127 c
= (unsigned char)((swap_nibble
[b
& 0xf] << 4)
1128 | (swap_nibble
[(b
>>4) & 0xf]));
1129 *cbits
++ = (c
>> (8 - fb
->width
));
1134 for (j
= 0; j
< fb
->height
; j
++)
1136 unsigned short b
= *bits
;
1137 b
= (unsigned short)((swap_nibble
[b
& 0xf] << 12)
1138 | (swap_nibble
[(b
>>4) & 0xf] << 8)
1139 | (swap_nibble
[(b
>>8) & 0xf] << 4)
1140 | (swap_nibble
[(b
>>12) & 0xf]));
1141 *bits
++ = (b
>> (16 - fb
->width
));
1144 #endif /* HAVE_X_WINDOWS */
1146 #if defined (MAC_OS) && defined (WORDS_BIG_ENDIAN)
1147 unsigned short *bits
= fb
->bits
;
1149 for (j
= 0; j
< fb
->height
; j
++)
1151 unsigned short b
= *bits
;
1152 *bits
++ = ((b
>> 8) & 0xff) | ((b
& 0xff) << 8);
1154 #endif /* MAC_OS && WORDS_BIG_ENDIAN */
1159 destroy_fringe_bitmap (which
);
1161 if (rif
&& rif
->define_fringe_bitmap
)
1162 rif
->define_fringe_bitmap (which
, fb
->bits
, fb
->height
, fb
->width
);
1164 fringe_bitmaps
[which
] = fb
;
1165 if (which
>= max_used_fringe_bitmap
)
1166 max_used_fringe_bitmap
= which
+ 1;
1171 DEFUN ("define-fringe-bitmap", Fdefine_fringe_bitmap
, Sdefine_fringe_bitmap
,
1173 doc
: /* Define fringe bitmap BITMAP from BITS of size HEIGHT x WIDTH.
1174 BITMAP is a symbol or string naming the new fringe bitmap.
1175 BITS is either a string or a vector of integers.
1176 HEIGHT is height of bitmap. If HEIGHT is nil, use length of BITS.
1177 WIDTH must be an integer between 1 and 16, or nil which defaults to 8.
1178 Optional fifth arg ALIGN may be one of `top', `center', or `bottom',
1179 indicating the positioning of the bitmap relative to the rows where it
1180 is used; the default is to center the bitmap. Fourth arg may also be a
1181 list (ALIGN PERIODIC) where PERIODIC non-nil specifies that the bitmap
1183 If BITMAP already exists, the existing definition is replaced. */)
1184 (bitmap
, bits
, height
, width
, align
)
1185 Lisp_Object bitmap
, bits
, height
, width
, align
;
1190 struct fringe_bitmap fb
, *xfb
;
1191 int fill1
= 0, fill2
= 0;
1193 CHECK_SYMBOL (bitmap
);
1195 n
= lookup_fringe_bitmap (bitmap
);
1197 if (!STRINGP (bits
) && !VECTORP (bits
))
1198 bits
= wrong_type_argument (Qstringp
, bits
);
1200 len
= Flength (bits
);
1203 h
= fb
.height
= XINT (len
);
1206 CHECK_NUMBER (height
);
1207 fb
.height
= min (XINT (height
), 255);
1208 if (fb
.height
> XINT (len
))
1211 fill1
= (fb
.height
- h
) / 2;
1212 fill2
= fb
.height
- h
- fill1
;
1220 CHECK_NUMBER (width
);
1221 fb
.width
= min (XINT (width
), 255);
1225 fb
.align
= ALIGN_BITMAP_CENTER
;
1229 Lisp_Object period
= XCDR (align
);
1232 period
= XCAR (period
);
1235 fb
.period
= fb
.height
;
1239 align
= XCAR (align
);
1241 if (EQ (align
, Qtop
))
1242 fb
.align
= ALIGN_BITMAP_TOP
;
1243 else if (EQ (align
, Qbottom
))
1244 fb
.align
= ALIGN_BITMAP_BOTTOM
;
1245 else if (!NILP (align
) && !EQ (align
, Qcenter
))
1246 error ("Bad align argument");
1250 if (max_used_fringe_bitmap
< MAX_FRINGE_BITMAPS
)
1251 n
= max_used_fringe_bitmap
++;
1254 for (n
= MAX_STANDARD_FRINGE_BITMAPS
;
1255 n
< MAX_FRINGE_BITMAPS
;
1257 if (fringe_bitmaps
[n
] == NULL
)
1259 if (n
== MAX_FRINGE_BITMAPS
)
1260 error ("Cannot define more fringe bitmaps");
1263 Vfringe_bitmaps
= Fcons (bitmap
, Vfringe_bitmaps
);
1264 Fput (bitmap
, Qfringe
, make_number (n
));
1269 xfb
= (struct fringe_bitmap
*) xmalloc (sizeof fb
1270 + fb
.height
* BYTES_PER_BITMAP_ROW
);
1271 fb
.bits
= b
= (unsigned short *) (xfb
+ 1);
1272 bzero (b
, fb
.height
);
1275 while (j
< fb
.height
)
1277 for (i
= 0; i
< fill1
&& j
< fb
.height
; i
++)
1279 for (i
= 0; i
< h
&& j
< fb
.height
; i
++)
1281 Lisp_Object elt
= Faref (bits
, make_number (i
));
1282 b
[j
++] = NUMBERP (elt
) ? XINT (elt
) : 0;
1284 for (i
= 0; i
< fill2
&& j
< fb
.height
; i
++)
1290 init_fringe_bitmap (n
, xfb
, 0);
1295 DEFUN ("set-fringe-bitmap-face", Fset_fringe_bitmap_face
, Sset_fringe_bitmap_face
,
1297 doc
: /* Set face for fringe bitmap BITMAP to FACE.
1298 If FACE is nil, reset face to default fringe face. */)
1300 Lisp_Object bitmap
, face
;
1305 CHECK_SYMBOL (bitmap
);
1306 n
= lookup_fringe_bitmap (bitmap
);
1308 error ("Undefined fringe bitmap");
1312 face_id
= lookup_named_face (SELECTED_FRAME (), face
, 'A');
1314 error ("No such face");
1317 face_id
= FRINGE_FACE_ID
;
1319 fringe_faces
[n
] = face_id
;
1324 DEFUN ("fringe-bitmaps-at-pos", Ffringe_bitmaps_at_pos
, Sfringe_bitmaps_at_pos
,
1326 doc
: /* Return fringe bitmaps of row containing position POS in window WINDOW.
1327 If WINDOW is nil, use selected window. If POS is nil, use value of point
1328 in that window. Return value is a cons (LEFT . RIGHT) where LEFT and RIGHT
1329 are the fringe bitmap numbers for the bitmaps in the left and right fringe,
1330 resp. If left or right fringe is empty, the corresponding element is nil.
1331 Return nil if POS is not visible in WINDOW. */)
1333 Lisp_Object pos
, window
;
1336 struct buffer
*old_buffer
= NULL
;
1337 struct glyph_row
*row
;
1341 window
= selected_window
;
1342 CHECK_WINDOW (window
);
1343 w
= XWINDOW (window
);
1347 CHECK_NUMBER_COERCE_MARKER (pos
);
1348 textpos
= XINT (pos
);
1350 else if (w
== XWINDOW (selected_window
))
1353 textpos
= XMARKER (w
->pointm
)->charpos
;
1355 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1356 row
= row_containing_pos (w
, textpos
, row
, NULL
, 0);
1358 return Fcons (get_fringe_bitmap_name (row
->left_fringe_bitmap
),
1359 get_fringe_bitmap_name (row
->right_fringe_bitmap
));
1365 /***********************************************************************
1367 ***********************************************************************/
1372 defsubr (&Sdestroy_fringe_bitmap
);
1373 defsubr (&Sdefine_fringe_bitmap
);
1374 defsubr (&Sfringe_bitmaps_at_pos
);
1375 defsubr (&Sset_fringe_bitmap_face
);
1377 DEFVAR_LISP ("overflow-newline-into-fringe", &Voverflow_newline_into_fringe
,
1378 doc
: /* *Non-nil means that newline may flow into the right fringe.
1379 This means that display lines which are exactly as wide as the window
1380 (not counting the final newline) will only occupy one screen line, by
1381 showing (or hiding) the final newline in the right fringe; when point
1382 is at the final newline, the cursor is shown in the right fringe.
1383 If nil, also continue lines which are exactly as wide as the window. */);
1384 Voverflow_newline_into_fringe
= Qt
;
1386 DEFVAR_LISP ("fringe-bitmaps", &Vfringe_bitmaps
,
1387 doc
: /* List of fringe bitmap symbols.
1388 You must (require 'fringe) to use fringe bitmap symbols in your programs." */);
1389 Vfringe_bitmaps
= Qnil
;
1392 /* Initialize this module when Emacs starts. */
1397 enum fringe_bitmap_type bt
;
1399 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< MAX_STANDARD_FRINGE_BITMAPS
; bt
++)
1400 init_fringe_bitmap(bt
, &standard_bitmaps
[bt
], 1);
1408 bzero (fringe_bitmaps
, sizeof fringe_bitmaps
);
1409 for (i
= 0; i
< MAX_FRINGE_BITMAPS
; i
++)
1410 fringe_faces
[i
] = FRINGE_FACE_ID
;
1418 enum fringe_bitmap_type bt
;
1423 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< MAX_STANDARD_FRINGE_BITMAPS
; bt
++)
1425 struct fringe_bitmap
*fb
= &standard_bitmaps
[bt
];
1426 rif
->define_fringe_bitmap (bt
, fb
->bits
, fb
->height
, fb
->width
);
1431 w32_reset_fringes ()
1433 /* Destroy row bitmaps. */
1439 for (bt
= NO_FRINGE_BITMAP
+ 1; bt
< max_used_fringe_bitmap
; bt
++)
1440 rif
->destroy_fringe_bitmap (bt
);
1443 #endif /* HAVE_NTGUI */
1445 #endif /* HAVE_WINDOW_SYSTEM */
1447 /* arch-tag: 04596920-43eb-473d-b319-82712338162d
1448 (do not change this comment) */