(Foverlay_buffer): Add EXFUN.
[emacs.git] / src / fringe.c
blobc245085af517fbccec0397eb8a9b3191f3241aa9
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 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, or (at your option)
11 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; 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. */
23 #include <config.h>
24 #include <stdio.h>
26 #include "lisp.h"
27 #include "frame.h"
28 #include "window.h"
29 #include "dispextern.h"
30 #include "buffer.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
47 loading fringe.el.
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,
95 ALIGN_BITMAP_TOP,
96 ALIGN_BITMAP_BOTTOM
99 struct fringe_bitmap
101 unsigned short *bits;
102 unsigned height : 8;
103 unsigned width : 8;
104 unsigned period : 8;
105 unsigned align : 2;
106 unsigned dynamic : 1;
110 /***********************************************************************
111 Fringe bitmaps
112 ***********************************************************************/
114 /* Undefined bitmap. A question mark. */
116 ..xxxx..
117 .xxxxxx.
118 xx....xx
119 xx....xx
120 ....xx..
121 ...xx...
122 ...xx...
123 ........
124 ...xx...
125 ...xx...
127 static unsigned short question_mark_bits[] = {
128 0x3c, 0x7e, 0x7e, 0x0c, 0x18, 0x18, 0x00, 0x18, 0x18};
130 /* An arrow like this: `<-'. */
132 ...xx...
133 ..xx....
134 .xx.....
135 xxxxxx..
136 xxxxxx..
137 .xx.....
138 ..xx....
139 ...xx...
141 static unsigned short left_arrow_bits[] = {
142 0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
145 /* Right truncation arrow bitmap `->'. */
147 ...xx...
148 ....xx..
149 .....xx.
150 ..xxxxxx
151 ..xxxxxx
152 .....xx.
153 ....xx..
154 ...xx...
156 static unsigned short right_arrow_bits[] = {
157 0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
160 /* Up arrow bitmap. */
162 ...xx...
163 ..xxxx..
164 .xxxxxx.
165 xxxxxxxx
166 ...xx...
167 ...xx...
168 ...xx...
169 ...xx...
171 static unsigned short up_arrow_bits[] = {
172 0x18, 0x3c, 0x7e, 0xff, 0x18, 0x18, 0x18, 0x18};
175 /* Down arrow bitmap. */
177 ...xx...
178 ...xx...
179 ...xx...
180 ...xx...
181 xxxxxxxx
182 .xxxxxx.
183 ..xxxx..
184 ...xx...
186 static unsigned short down_arrow_bits[] = {
187 0x18, 0x18, 0x18, 0x18, 0xff, 0x7e, 0x3c, 0x18};
189 /* Marker for continuation lines. */
191 ..xxxx..
192 .xxxxx..
193 xx......
194 xxx..x..
195 xxxxxx..
196 .xxxxx..
197 ..xxxx..
198 .xxxxx..
200 static unsigned short left_curly_arrow_bits[] = {
201 0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
203 /* Marker for continued lines. */
205 ..xxxx..
206 ..xxxxx.
207 ......xx
208 ..x..xxx
209 ..xxxxxx
210 ..xxxxx.
211 ..xxxx..
212 ..xxxxx.
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. */
219 ......xx
220 ....xxxx
221 ...xxxxx
222 ..xxxxxx
223 ..xxxxxx
224 ...xxxxx
225 ....xxxx
226 ......xx
228 static unsigned short left_triangle_bits[] = {
229 0x03, 0x0f, 0x1f, 0x3f, 0x3f, 0x1f, 0x0f, 0x03};
231 /* Overlay arrow bitmap. A triangular arrow. */
233 xx......
234 xxxx....
235 xxxxx...
236 xxxxxx..
237 xxxxxx..
238 xxxxx...
239 xxxx....
240 xx......
242 static unsigned short right_triangle_bits[] = {
243 0xc0, 0xf0, 0xf8, 0xfc, 0xfc, 0xf8, 0xf0, 0xc0};
245 /* First line bitmap. An top-left angle. */
247 xxxxxx..
248 xxxxxx..
249 xx......
250 xx......
251 xx......
252 xx......
253 xx......
254 ........
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. */
261 ..xxxxxx
262 ..xxxxxx
263 ......xx
264 ......xx
265 ......xx
266 ......xx
267 ......xx
268 ........
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. */
275 ........
276 xx......
277 xx......
278 xx......
279 xx......
280 xx......
281 xxxxxx..
282 xxxxxx..
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. */
289 ........
290 ......xx
291 ......xx
292 ......xx
293 ......xx
294 ......xx
295 ..xxxxxx
296 ..xxxxxx
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. */
303 xxxxxx..
304 xxxxxx..
305 xx......
306 xx......
307 xx......
308 xx......
309 xx......
310 xx......
311 xxxxxx..
312 xxxxxx..
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. */
319 ..xxxxxx
320 ..xxxxxx
321 ......xx
322 ......xx
323 ......xx
324 ......xx
325 ......xx
326 ......xx
327 ..xxxxxx
328 ..xxxxxx
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. */
335 xxxxxxx.
336 xxxxxxx.
337 xxxxxxx.
338 xxxxxxx.
339 xxxxxxx.
340 xxxxxxx.
341 xxxxxxx.
342 xxxxxxx.
343 xxxxxxx.
344 xxxxxxx.
345 xxxxxxx.
346 xxxxxxx.
347 xxxxxxx.
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. */
354 xxxxxxx.
355 x.....x.
356 x.....x.
357 x.....x.
358 x.....x.
359 x.....x.
360 x.....x.
361 x.....x.
362 x.....x.
363 x.....x.
364 x.....x.
365 x.....x.
366 xxxxxxx.
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. */
373 .xxxxxx.
374 .x....x.
375 .x....x.
376 .x....x.
377 .x....x.
378 .xxxxxx.
380 static unsigned short hollow_square_bits[] = {
381 0x7e, 0x42, 0x42, 0x42, 0x42, 0x7e};
383 /* Filled square bitmap. */
385 .xxxxxx.
386 .xxxxxx.
387 .xxxxxx.
388 .xxxxxx.
389 .xxxxxx.
390 .xxxxxx.
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. */
397 xx......
398 xx......
399 xx......
400 xx......
401 xx......
402 xx......
403 xx......
404 xx......
405 xx......
406 xx......
407 xx......
408 xx......
409 xx......
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. */
416 xxxxxxx.
417 xxxxxxx.
419 static unsigned short horizontal_bar_bits[] = {
420 0xfe, 0xfe};
423 /* Bitmap drawn to indicate lines not displaying text if
424 `indicate-empty-lines' is non-nil. */
426 ........
427 ..xxxx..
428 ........
429 ........
430 ..xxxx..
431 ........
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)
494 Lisp_Object bitmap;
496 int bn;
498 bitmap = Fget (bitmap, Qfringe);
499 if (!INTEGERP (bitmap))
500 return 0;
502 bn = XINT (bitmap);
503 if (bn > NO_FRINGE_BITMAP
504 && bn < max_used_fringe_bitmap
505 && (bn < MAX_STANDARD_FRINGE_BITMAPS
506 || fringe_bitmaps[bn] != NULL))
507 return bn;
509 return 0;
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. */
519 static Lisp_Object
520 get_fringe_bitmap_name (bn)
521 int bn;
523 Lisp_Object bitmaps;
524 Lisp_Object num;
526 /* Zero means no bitmap -- return nil. */
527 if (bn <= 0)
528 return Qnil;
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)))
537 return bitmap;
538 bitmaps = XCDR (bitmaps);
541 return num;
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
548 drawn.
549 LEFT_P is 1 for left fringe, 0 for right fringe.
552 static void
553 draw_fringe_bitmap_1 (w, row, left_p, overlay, which)
554 struct window *w;
555 struct glyph_row *row;
556 int left_p, overlay;
557 int which;
559 struct frame *f = XFRAME (WINDOW_FRAME (w));
560 struct draw_fringe_bitmap_params p;
561 struct fringe_bitmap *fb;
562 int period;
563 int face_id = DEFAULT_FACE_ID;
565 p.cursor_p = 0;
566 p.overlay_p = (overlay & 1) == 1;
567 p.cursor_p = (overlay & 2) == 2;
569 if (which != NO_FRINGE_BITMAP)
572 else if (left_p)
574 which = row->left_fringe_bitmap;
575 face_id = row->left_fringe_face_id;
577 else
579 which = row->right_fringe_bitmap;
580 face_id = row->right_fringe_face_id;
583 if (face_id == DEFAULT_FACE_ID)
585 Lisp_Object face;
587 if ((face = fringe_faces[which], NILP (face))
588 || (face_id = lookup_derived_face (f, face, 'A', FRINGE_FACE_ID, 0),
589 face_id < 0))
590 face_id = FRINGE_FACE_ID;
593 fb = fringe_bitmaps[which];
594 if (fb == NULL)
595 fb = &standard_bitmaps[which < MAX_STANDARD_FRINGE_BITMAPS
596 ? which : UNDEF_FRINGE_BITMAP];
598 period = fb->period;
600 /* Convert row to frame coordinates. */
601 p.y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
603 p.which = which;
604 p.bits = fb->bits;
605 p.wd = fb->width;
607 p.h = fb->height;
608 p.dh = (period > 0 ? (p.y % period) : 0);
609 p.h -= p.dh;
610 /* Clip bitmap if too high. */
611 if (p.h > row->height)
612 p.h = row->height;
614 p.face = FACE_FROM_ID (f, face_id);
616 if (p.face == NULL)
618 /* This could happen after clearing face cache.
619 But it shouldn't happen anymore. ++kfs */
620 return;
623 PREPARE_FACE_FOR_DISPLAY (f, p.face);
625 /* Clear left fringe if no bitmap to draw or if bitmap doesn't fill
626 the fringe. */
627 p.bx = -1;
628 if (left_p)
630 int wd = WINDOW_LEFT_FRINGE_WIDTH (w);
631 int x = window_box_left (w, (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
632 ? LEFT_MARGIN_AREA
633 : TEXT_AREA));
634 if (p.wd > wd)
635 p.wd = wd;
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))
643 ? 1 : 0);
644 p.bx = x - wd;
645 p.nx = wd;
648 else
650 int x = window_box_right (w,
651 (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
652 ? RIGHT_MARGIN_AREA
653 : TEXT_AREA));
654 int wd = WINDOW_RIGHT_FRINGE_WIDTH (w);
655 if (p.wd > wd)
656 p.wd = wd;
657 p.x = x + (wd - p.wd) / 2;
658 /* Clear right fringe if no bitmap to draw of if bitmap doesn't fill
659 the fringe. */
660 if (p.wd < wd || row->height > p.h)
662 p.bx = x;
663 p.nx = wd;
667 if (p.bx >= 0)
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. */
676 switch (fb->align)
678 case ALIGN_BITMAP_CENTER:
679 p.y += (row->height - p.h) / 2;
680 break;
681 case ALIGN_BITMAP_BOTTOM:
682 p.h = fb->height;
683 p.y += (row->visible_height - p.h);
684 break;
685 case ALIGN_BITMAP_TOP:
686 break;
689 rif->draw_fringe_bitmap (w, row, &p);
692 static int
693 get_logical_cursor_bitmap (w, cursor)
694 struct window *w;
695 Lisp_Object cursor;
697 Lisp_Object cmap, bm = Qnil;
699 if ((cmap = XBUFFER (w->buffer)->fringe_cursor_alist), !NILP (cmap))
701 bm = Fassq (cursor, cmap);
702 if (CONSP (bm))
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);
717 static int
718 get_logical_fringe_bitmap (w, bitmap, right_p, partial_p)
719 struct window *w;
720 Lisp_Object bitmap;
721 int right_p, partial_p;
723 Lisp_Object cmap, bm1 = Qnil, bm2 = Qnil, bm;
724 int ln1 = 0, ln2 = 0;
725 int ix1 = right_p;
726 int ix2 = ix1 + (partial_p ? 2 : 0);
728 /* Lookup in buffer-local fringe-indicator-alist before global alist.
730 Elements are:
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);
742 if (CONSP (bm1))
744 if ((bm1 = XCDR (bm1)), NILP (bm1))
745 return NO_FRINGE_BITMAP;
746 if (CONSP (bm1))
748 ln1 = XINT (Flength (bm1));
749 if (partial_p)
751 if (ln1 > ix2)
753 bm = Fnth (make_number (ix2), bm1);
754 if (!EQ (bm, Qt))
755 goto found;
758 else
760 if (ln1 > ix1)
762 bm = Fnth (make_number (ix1), bm1);
763 if (!EQ (bm, Qt))
764 goto found;
768 else if ((bm = bm1, !EQ (bm, Qt)))
769 goto found;
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);
777 if (CONSP (bm2))
779 if ((bm2 = XCDR (bm2)), !NILP (bm2))
781 if (CONSP (bm2))
783 ln2 = XINT (Flength (bm2));
784 if (partial_p)
786 if (ln2 > ix2)
788 bm = Fnth (make_number (ix2), bm2);
789 if (!EQ (bm, Qt))
790 goto found;
798 if (ln1 > ix1)
800 bm = Fnth (make_number (ix1), bm1);
801 if (!EQ (bm, Qt))
802 goto found;
805 if (ln2 > ix1)
807 bm = Fnth (make_number (ix1), bm2);
808 if (!EQ (bm, Qt))
809 goto found;
810 return NO_FRINGE_BITMAP;
812 else if ((bm = bm2, NILP (bm)))
813 return NO_FRINGE_BITMAP;
815 found:
816 return lookup_fringe_bitmap (bm);
820 void
821 draw_fringe_bitmap (w, row, left_p)
822 struct window *w;
823 struct glyph_row *row;
824 int left_p;
826 int overlay = 0;
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))
836 cursor = Qhollow;
837 else
838 cursor = Qhollow_small;
839 break;
840 case FILLED_BOX_CURSOR:
841 cursor = Qbox;
842 break;
843 case BAR_CURSOR:
844 cursor = Qbar;
845 break;
846 case HBAR_CURSOR:
847 cursor = Qhbar;
848 break;
849 case NO_CURSOR:
850 default:
851 w->phys_cursor_on_p = 0;
852 row->cursor_in_fringe_p = 0;
853 break;
855 if (!NILP (cursor))
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, row->overlay_arrow_bitmap);
873 /* Draw fringe bitmaps for glyph row ROW on window W. Call this
874 function with input blocked. */
876 void
877 draw_row_fringe_bitmaps (w, row)
878 struct window *w;
879 struct glyph_row *row;
881 xassert (interrupt_input_blocked);
883 /* If row is completely invisible, because of vscrolling, we
884 don't have to draw anything. */
885 if (row->visible_height <= 0)
886 return;
888 if (WINDOW_LEFT_FRINGE_WIDTH (w) != 0)
889 draw_fringe_bitmap (w, row, 1);
891 if (WINDOW_RIGHT_FRINGE_WIDTH (w) != 0)
892 draw_fringe_bitmap (w, row, 0);
895 /* Draw the fringes of window W. Only fringes for rows marked for
896 update in redraw_fringe_bitmaps_p are drawn.
898 Return >0 if left or right fringe was redrawn in any way.
900 If NO_FRINGE is non-zero, also return >0 if either fringe has zero width.
902 A return value >0 indicates that the vertical line between windows
903 needs update (as it may be drawn in the fringe).
907 draw_window_fringes (w, no_fringe)
908 struct window *w;
909 int no_fringe;
911 struct glyph_row *row;
912 int yb = window_text_bottom_y (w);
913 int nrows = w->current_matrix->nrows;
914 int y = 0, rn;
915 int updated = 0;
917 if (w->pseudo_window_p)
918 return 0;
920 /* Must draw line if no fringe */
921 if (no_fringe
922 && (WINDOW_LEFT_FRINGE_WIDTH (w) == 0
923 || WINDOW_RIGHT_FRINGE_WIDTH (w) == 0))
924 updated++;
926 for (y = 0, rn = 0, row = w->current_matrix->rows;
927 y < yb && rn < nrows;
928 y += row->height, ++row, ++rn)
930 if (!row->redraw_fringe_bitmaps_p)
931 continue;
932 draw_row_fringe_bitmaps (w, row);
933 row->redraw_fringe_bitmaps_p = 0;
934 updated++;
937 return updated;
941 /* Recalculate the bitmaps to show in the fringes of window W.
942 Only mark rows with modified bitmaps for update in redraw_fringe_bitmaps_p.
944 If KEEP_CURRENT_P is 0, update current_matrix too. */
947 update_window_fringes (w, keep_current_p)
948 struct window *w;
949 int keep_current_p;
951 struct glyph_row *row, *cur = 0;
952 int yb = window_text_bottom_y (w);
953 int rn, nrows = w->current_matrix->nrows;
954 int y;
955 int redraw_p = 0;
956 Lisp_Object boundary_top = Qnil, boundary_bot = Qnil;
957 Lisp_Object arrow_top = Qnil, arrow_bot = Qnil;
958 Lisp_Object empty_pos;
959 Lisp_Object ind = Qnil;
960 #define MAX_BITMAP_CACHE (8*4)
961 int bitmap_cache[MAX_BITMAP_CACHE];
963 if (w->pseudo_window_p)
964 return 0;
966 if (!MINI_WINDOW_P (w)
967 && (ind = XBUFFER (w->buffer)->indicate_buffer_boundaries, !NILP (ind)))
969 if (EQ (ind, Qleft) || EQ (ind, Qright))
970 boundary_top = boundary_bot = arrow_top = arrow_bot = ind;
971 else if (CONSP (ind) && CONSP (XCAR (ind)))
973 Lisp_Object pos;
974 if (pos = Fassq (Qt, ind), !NILP (pos))
975 boundary_top = boundary_bot = arrow_top = arrow_bot = XCDR (pos);
976 if (pos = Fassq (Qtop, ind), !NILP (pos))
977 boundary_top = XCDR (pos);
978 if (pos = Fassq (Qbottom, ind), !NILP (pos))
979 boundary_bot = XCDR (pos);
980 if (pos = Fassq (Qup, ind), !NILP (pos))
981 arrow_top = XCDR (pos);
982 if (pos = Fassq (Qdown, ind), !NILP (pos))
983 arrow_bot = XCDR (pos);
985 else
986 /* Anything else means boundary on left and no arrows. */
987 boundary_top = boundary_bot = Qleft;
990 if (!NILP (ind))
992 int done_top = 0, done_bot = 0;
994 for (y = 0, rn = 0;
995 y < yb && rn < nrows;
996 y += row->height, ++rn)
998 unsigned indicate_bob_p, indicate_top_line_p;
999 unsigned indicate_eob_p, indicate_bottom_line_p;
1001 row = w->desired_matrix->rows + rn;
1002 if (!row->enabled_p)
1003 row = w->current_matrix->rows + rn;
1005 indicate_bob_p = row->indicate_bob_p;
1006 indicate_top_line_p = row->indicate_top_line_p;
1007 indicate_eob_p = row->indicate_eob_p;
1008 indicate_bottom_line_p = row->indicate_bottom_line_p;
1010 row->indicate_bob_p = row->indicate_top_line_p = 0;
1011 row->indicate_eob_p = row->indicate_bottom_line_p = 0;
1013 if (!row->mode_line_p)
1015 if (!done_top)
1017 if (MATRIX_ROW_START_CHARPOS (row) <= BUF_BEGV (XBUFFER (w->buffer))
1018 && !MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (w, row))
1019 row->indicate_bob_p = !NILP (boundary_top);
1020 else
1021 row->indicate_top_line_p = !NILP (arrow_top);
1022 done_top = 1;
1025 if (!done_bot)
1027 if (MATRIX_ROW_END_CHARPOS (row) >= BUF_ZV (XBUFFER (w->buffer))
1028 && !MATRIX_ROW_PARTIALLY_VISIBLE_AT_BOTTOM_P (w, row))
1029 row->indicate_eob_p = !NILP (boundary_bot), done_bot = 1;
1030 else if (y + row->height >= yb)
1031 row->indicate_bottom_line_p = !NILP (arrow_bot), done_bot = 1;
1035 if (indicate_bob_p != row->indicate_bob_p
1036 || indicate_top_line_p != row->indicate_top_line_p
1037 || indicate_eob_p != row->indicate_eob_p
1038 || indicate_bottom_line_p != row->indicate_bottom_line_p)
1039 row->redraw_fringe_bitmaps_p = 1;
1043 empty_pos = XBUFFER (w->buffer)->indicate_empty_lines;
1044 if (!NILP (empty_pos) && !EQ (empty_pos, Qright))
1045 empty_pos = WINDOW_LEFT_FRINGE_WIDTH (w) == 0 ? Qright : Qleft;
1047 for (y = 0; y < MAX_BITMAP_CACHE; y++)
1048 bitmap_cache[y] = -1;
1050 #define LEFT_FRINGE(cache, which, partial_p) \
1051 (bitmap_cache[cache*4+partial_p] >= 0 \
1052 ? bitmap_cache[cache*4+partial_p] \
1053 : (bitmap_cache[cache*4+partial_p] = \
1054 get_logical_fringe_bitmap (w, which, 0, partial_p)))
1056 #define RIGHT_FRINGE(cache, which, partial_p) \
1057 (bitmap_cache[cache*4+2+partial_p] >= 0 \
1058 ? bitmap_cache[cache*4+2+partial_p] \
1059 : (bitmap_cache[cache*4+2+partial_p] = \
1060 get_logical_fringe_bitmap (w, which, 1, partial_p)))
1063 for (y = 0, rn = 0;
1064 y < yb && rn < nrows;
1065 y += row->height, rn++)
1067 int left, right;
1068 unsigned left_face_id, right_face_id;
1070 row = w->desired_matrix->rows + rn;
1071 cur = w->current_matrix->rows + rn;
1072 if (!row->enabled_p)
1073 row = cur;
1075 left_face_id = right_face_id = DEFAULT_FACE_ID;
1077 /* Decide which bitmap to draw in the left fringe. */
1078 if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
1079 left = NO_FRINGE_BITMAP;
1080 else if (row->left_user_fringe_bitmap != NO_FRINGE_BITMAP)
1082 left = row->left_user_fringe_bitmap;
1083 left_face_id = row->left_user_fringe_face_id;
1085 else if (row->truncated_on_left_p)
1086 left = LEFT_FRINGE(0, Qtruncation, 0);
1087 else if (row->indicate_bob_p && EQ (boundary_top, Qleft))
1088 left = ((row->indicate_eob_p && EQ (boundary_bot, Qleft))
1089 ? LEFT_FRINGE (1, Qtop_bottom, row->ends_at_zv_p)
1090 : LEFT_FRINGE (2, Qtop, 0));
1091 else if (row->indicate_eob_p && EQ (boundary_bot, Qleft))
1092 left = LEFT_FRINGE (3, Qbottom, row->ends_at_zv_p);
1093 else if (MATRIX_ROW_CONTINUATION_LINE_P (row))
1094 left = LEFT_FRINGE (4, Qcontinuation, 0);
1095 else if (row->indicate_empty_line_p && EQ (empty_pos, Qleft))
1096 left = LEFT_FRINGE (5, Qempty_line, 0);
1097 else if (row->indicate_top_line_p && EQ (arrow_top, Qleft))
1098 left = LEFT_FRINGE (6, Qup, 0);
1099 else if (row->indicate_bottom_line_p && EQ (arrow_bot, Qleft))
1100 left = LEFT_FRINGE (7, Qdown, 0);
1101 else
1102 left = NO_FRINGE_BITMAP;
1104 /* Decide which bitmap to draw in the right fringe. */
1105 if (WINDOW_RIGHT_FRINGE_WIDTH (w) == 0)
1106 right = NO_FRINGE_BITMAP;
1107 else if (row->right_user_fringe_bitmap != NO_FRINGE_BITMAP)
1109 right = row->right_user_fringe_bitmap;
1110 right_face_id = row->right_user_fringe_face_id;
1112 else if (row->truncated_on_right_p)
1113 right = RIGHT_FRINGE (0, Qtruncation, 0);
1114 else if (row->indicate_bob_p && EQ (boundary_top, Qright))
1115 right = ((row->indicate_eob_p && EQ (boundary_bot, Qright))
1116 ? RIGHT_FRINGE (1, Qtop_bottom, row->ends_at_zv_p)
1117 : RIGHT_FRINGE (2, Qtop, 0));
1118 else if (row->indicate_eob_p && EQ (boundary_bot, Qright))
1119 right = RIGHT_FRINGE (3, Qbottom, row->ends_at_zv_p);
1120 else if (row->continued_p)
1121 right = RIGHT_FRINGE (4, Qcontinuation, 0);
1122 else if (row->indicate_top_line_p && EQ (arrow_top, Qright))
1123 right = RIGHT_FRINGE (6, Qup, 0);
1124 else if (row->indicate_bottom_line_p && EQ (arrow_bot, Qright))
1125 right = RIGHT_FRINGE (7, Qdown, 0);
1126 else if (row->indicate_empty_line_p && EQ (empty_pos, Qright))
1127 right = RIGHT_FRINGE (5, Qempty_line, 0);
1128 else
1129 right = NO_FRINGE_BITMAP;
1131 if (row->y != cur->y
1132 || row->visible_height != cur->visible_height
1133 || row->ends_at_zv_p != cur->ends_at_zv_p
1134 || left != cur->left_fringe_bitmap
1135 || right != cur->right_fringe_bitmap
1136 || left_face_id != cur->left_fringe_face_id
1137 || right_face_id != cur->right_fringe_face_id
1138 || cur->redraw_fringe_bitmaps_p)
1140 redraw_p = row->redraw_fringe_bitmaps_p = 1;
1141 if (!keep_current_p)
1143 cur->redraw_fringe_bitmaps_p = 1;
1144 cur->left_fringe_bitmap = left;
1145 cur->right_fringe_bitmap = right;
1146 cur->left_fringe_face_id = left_face_id;
1147 cur->right_fringe_face_id = right_face_id;
1151 if (row->overlay_arrow_bitmap < 0)
1152 row->overlay_arrow_bitmap = get_logical_fringe_bitmap (w, Qoverlay_arrow, 0, 0);
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.
1186 void
1187 compute_fringe_widths (f, redraw)
1188 struct frame *f;
1189 int 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;
1231 else
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;
1246 else
1248 FRAME_LEFT_FRINGE_WIDTH (f) = 0;
1249 FRAME_RIGHT_FRINGE_WIDTH (f) = real_wid;
1251 FRAME_FRINGE_COLS (f) = cols;
1253 else
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))
1264 redraw_frame (f);
1268 /* Free resources used by a user-defined bitmap. */
1270 void
1271 destroy_fringe_bitmap (n)
1272 int 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);
1283 xfree (*fbp);
1284 *fbp = NULL;
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,
1294 1, 1, 0,
1295 doc: /* Destroy fringe bitmap BITMAP.
1296 If BITMAP overrides a standard fringe bitmap, the original bitmap is restored. */)
1297 (bitmap)
1298 Lisp_Object bitmap;
1300 int n;
1302 CHECK_SYMBOL (bitmap);
1303 n = lookup_fringe_bitmap (bitmap);
1304 if (!n)
1305 return Qnil;
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);
1316 return 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.
1330 #if defined (HAVE_X_WINDOWS)
1331 static unsigned char swap_nibble[16]
1332 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
1333 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
1334 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
1335 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
1336 #endif /* HAVE_X_WINDOWS */
1338 void
1339 init_fringe_bitmap (which, fb, once_p)
1340 int which;
1341 struct fringe_bitmap *fb;
1342 int once_p;
1344 if (once_p || fb->dynamic)
1346 #if defined (HAVE_X_WINDOWS)
1347 unsigned short *bits = fb->bits;
1348 int j;
1350 if (fb->width <= 8)
1352 unsigned char *cbits = (unsigned char *)fb->bits;
1353 for (j = 0; j < fb->height; j++)
1355 unsigned short b = *bits++;
1356 unsigned char c;
1357 c = (unsigned char)((swap_nibble[b & 0xf] << 4)
1358 | (swap_nibble[(b>>4) & 0xf]));
1359 *cbits++ = (c >> (8 - fb->width));
1362 else
1364 for (j = 0; j < fb->height; j++)
1366 unsigned short b = *bits;
1367 b = (unsigned short)((swap_nibble[b & 0xf] << 12)
1368 | (swap_nibble[(b>>4) & 0xf] << 8)
1369 | (swap_nibble[(b>>8) & 0xf] << 4)
1370 | (swap_nibble[(b>>12) & 0xf]));
1371 *bits++ = (b >> (16 - fb->width));
1374 #endif /* HAVE_X_WINDOWS */
1376 #if defined (MAC_OS) && defined (WORDS_BIG_ENDIAN)
1377 unsigned short *bits = fb->bits;
1378 int j;
1379 for (j = 0; j < fb->height; j++)
1381 unsigned short b = *bits;
1382 *bits++ = ((b >> 8) & 0xff) | ((b & 0xff) << 8);
1384 #endif /* MAC_OS && WORDS_BIG_ENDIAN */
1387 if (!once_p)
1389 destroy_fringe_bitmap (which);
1391 if (rif && rif->define_fringe_bitmap)
1392 rif->define_fringe_bitmap (which, fb->bits, fb->height, fb->width);
1394 fringe_bitmaps[which] = fb;
1395 if (which >= max_used_fringe_bitmap)
1396 max_used_fringe_bitmap = which + 1;
1401 DEFUN ("define-fringe-bitmap", Fdefine_fringe_bitmap, Sdefine_fringe_bitmap,
1402 2, 5, 0,
1403 doc: /* Define fringe bitmap BITMAP from BITS of size HEIGHT x WIDTH.
1404 BITMAP is a symbol identifying the new fringe bitmap.
1405 BITS is either a string or a vector of integers.
1406 HEIGHT is height of bitmap. If HEIGHT is nil, use length of BITS.
1407 WIDTH must be an integer between 1 and 16, or nil which defaults to 8.
1408 Optional fifth arg ALIGN may be one of `top', `center', or `bottom',
1409 indicating the positioning of the bitmap relative to the rows where it
1410 is used; the default is to center the bitmap. Fourth arg may also be a
1411 list (ALIGN PERIODIC) where PERIODIC non-nil specifies that the bitmap
1412 should be repeated.
1413 If BITMAP already exists, the existing definition is replaced. */)
1414 (bitmap, bits, height, width, align)
1415 Lisp_Object bitmap, bits, height, width, align;
1417 int n, h, i, j;
1418 unsigned short *b;
1419 struct fringe_bitmap fb, *xfb;
1420 int fill1 = 0, fill2 = 0;
1422 CHECK_SYMBOL (bitmap);
1424 if (STRINGP (bits))
1425 h = SCHARS (bits);
1426 else if (VECTORP (bits))
1427 h = XVECTOR (bits)->size;
1428 else
1429 wrong_type_argument (Qsequencep, bits);
1431 if (NILP (height))
1432 fb.height = h;
1433 else
1435 CHECK_NUMBER (height);
1436 fb.height = min (XINT (height), 255);
1437 if (fb.height > h)
1439 fill1 = (fb.height - h) / 2;
1440 fill2 = fb.height - h - fill1;
1444 if (NILP (width))
1445 fb.width = 8;
1446 else
1448 CHECK_NUMBER (width);
1449 fb.width = min (XINT (width), 255);
1452 fb.period = 0;
1453 fb.align = ALIGN_BITMAP_CENTER;
1455 if (CONSP (align))
1457 Lisp_Object period = XCDR (align);
1458 if (CONSP (period))
1460 period = XCAR (period);
1461 if (!NILP (period))
1463 fb.period = fb.height;
1464 fb.height = 255;
1467 align = XCAR (align);
1469 if (EQ (align, Qtop))
1470 fb.align = ALIGN_BITMAP_TOP;
1471 else if (EQ (align, Qbottom))
1472 fb.align = ALIGN_BITMAP_BOTTOM;
1473 else if (!NILP (align) && !EQ (align, Qcenter))
1474 error ("Bad align argument");
1476 n = lookup_fringe_bitmap (bitmap);
1477 if (!n)
1479 if (max_used_fringe_bitmap < max_fringe_bitmaps)
1480 n = max_used_fringe_bitmap++;
1481 else
1483 for (n = MAX_STANDARD_FRINGE_BITMAPS;
1484 n < max_fringe_bitmaps;
1485 n++)
1486 if (fringe_bitmaps[n] == NULL)
1487 break;
1489 if (n == max_fringe_bitmaps)
1491 if ((max_fringe_bitmaps + 20) > MAX_FRINGE_BITMAPS)
1492 error ("No free fringe bitmap slots");
1494 i = max_fringe_bitmaps;
1495 max_fringe_bitmaps += 20;
1496 fringe_bitmaps
1497 = ((struct fringe_bitmap **)
1498 xrealloc (fringe_bitmaps, max_fringe_bitmaps * sizeof (struct fringe_bitmap *)));
1499 fringe_faces
1500 = (Lisp_Object *) xrealloc (fringe_faces, max_fringe_bitmaps * sizeof (Lisp_Object));
1502 for (; i < max_fringe_bitmaps; i++)
1504 fringe_bitmaps[i] = NULL;
1505 fringe_faces[i] = Qnil;
1510 Vfringe_bitmaps = Fcons (bitmap, Vfringe_bitmaps);
1511 Fput (bitmap, Qfringe, make_number (n));
1514 fb.dynamic = 1;
1516 xfb = (struct fringe_bitmap *) xmalloc (sizeof fb
1517 + fb.height * BYTES_PER_BITMAP_ROW);
1518 fb.bits = b = (unsigned short *) (xfb + 1);
1519 bzero (b, fb.height);
1521 j = 0;
1522 while (j < fb.height)
1524 for (i = 0; i < fill1 && j < fb.height; i++)
1525 b[j++] = 0;
1526 for (i = 0; i < h && j < fb.height; i++)
1528 Lisp_Object elt = Faref (bits, make_number (i));
1529 b[j++] = NUMBERP (elt) ? XINT (elt) : 0;
1531 for (i = 0; i < fill2 && j < fb.height; i++)
1532 b[j++] = 0;
1535 *xfb = fb;
1537 init_fringe_bitmap (n, xfb, 0);
1539 return bitmap;
1542 DEFUN ("set-fringe-bitmap-face", Fset_fringe_bitmap_face, Sset_fringe_bitmap_face,
1543 1, 2, 0,
1544 doc: /* Set face for fringe bitmap BITMAP to FACE.
1545 If FACE is nil, reset face to default fringe face. */)
1546 (bitmap, face)
1547 Lisp_Object bitmap, face;
1549 int n;
1550 int face_id;
1552 CHECK_SYMBOL (bitmap);
1553 n = lookup_fringe_bitmap (bitmap);
1554 if (!n)
1555 error ("Undefined fringe bitmap");
1557 if (!NILP (face))
1559 face_id = lookup_derived_face (SELECTED_FRAME (), face,
1560 'A', FRINGE_FACE_ID, 1);
1561 if (face_id < 0)
1562 error ("No such face");
1565 fringe_faces[n] = face;
1567 return Qnil;
1570 DEFUN ("fringe-bitmaps-at-pos", Ffringe_bitmaps_at_pos, Sfringe_bitmaps_at_pos,
1571 0, 2, 0,
1572 doc: /* Return fringe bitmaps of row containing position POS in window WINDOW.
1573 If WINDOW is nil, use selected window. If POS is nil, use value of point
1574 in that window. Return value is a list (LEFT RIGHT OV), where LEFT
1575 is the symbol for the bitmap in the left fringe (or nil if no bitmap),
1576 RIGHT is similar for the right fringe, and OV is non-nil if there is an
1577 overlay arrow in the left fringe.
1578 Return nil if POS is not visible in WINDOW. */)
1579 (pos, window)
1580 Lisp_Object pos, window;
1582 struct window *w;
1583 struct glyph_row *row;
1584 int textpos;
1586 if (NILP (window))
1587 window = selected_window;
1588 CHECK_WINDOW (window);
1589 w = XWINDOW (window);
1591 if (!NILP (pos))
1593 CHECK_NUMBER_COERCE_MARKER (pos);
1594 textpos = XINT (pos);
1596 else if (w == XWINDOW (selected_window))
1597 textpos = PT;
1598 else
1599 textpos = XMARKER (w->pointm)->charpos;
1601 row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
1602 row = row_containing_pos (w, textpos, row, NULL, 0);
1603 if (row)
1604 return list3 (get_fringe_bitmap_name (row->left_fringe_bitmap),
1605 get_fringe_bitmap_name (row->right_fringe_bitmap),
1606 (row->overlay_arrow_bitmap == 0 ? Qnil
1607 : row->overlay_arrow_bitmap < 0 ? Qt
1608 : get_fringe_bitmap_name (row->overlay_arrow_bitmap)));
1609 else
1610 return Qnil;
1614 /***********************************************************************
1615 Initialization
1616 ***********************************************************************/
1618 void
1619 syms_of_fringe ()
1621 Qtruncation = intern ("truncation");
1622 staticpro (&Qtruncation);
1623 Qcontinuation = intern ("continuation");
1624 staticpro (&Qcontinuation);
1625 Qoverlay_arrow = intern ("overlay-arrow");
1626 staticpro (&Qoverlay_arrow);
1627 Qempty_line = intern ("empty-line");
1628 staticpro (&Qempty_line);
1629 Qtop_bottom = intern ("top-bottom");
1630 staticpro (&Qtop_bottom);
1631 Qhollow_small = intern ("hollow-small");
1632 staticpro (&Qhollow_small);
1634 defsubr (&Sdestroy_fringe_bitmap);
1635 defsubr (&Sdefine_fringe_bitmap);
1636 defsubr (&Sfringe_bitmaps_at_pos);
1637 defsubr (&Sset_fringe_bitmap_face);
1639 DEFVAR_LISP ("overflow-newline-into-fringe", &Voverflow_newline_into_fringe,
1640 doc: /* *Non-nil means that newline may flow into the right fringe.
1641 This means that display lines which are exactly as wide as the window
1642 (not counting the final newline) will only occupy one screen line, by
1643 showing (or hiding) the final newline in the right fringe; when point
1644 is at the final newline, the cursor is shown in the right fringe.
1645 If nil, also continue lines which are exactly as wide as the window. */);
1646 Voverflow_newline_into_fringe = Qt;
1648 DEFVAR_LISP ("fringe-bitmaps", &Vfringe_bitmaps,
1649 doc: /* List of fringe bitmap symbols. */);
1650 Vfringe_bitmaps = Qnil;
1653 /* Garbage collection hook */
1655 void
1656 mark_fringe_data ()
1658 int i;
1660 for (i = 0; i < max_fringe_bitmaps; i++)
1661 if (!NILP (fringe_faces[i]))
1662 mark_object (fringe_faces[i]);
1665 /* Initialize this module when Emacs starts. */
1667 void
1668 init_fringe_once ()
1670 int bt;
1672 for (bt = NO_FRINGE_BITMAP + 1; bt < MAX_STANDARD_FRINGE_BITMAPS; bt++)
1673 init_fringe_bitmap(bt, &standard_bitmaps[bt], 1);
1676 void
1677 init_fringe ()
1679 int i;
1681 max_fringe_bitmaps = MAX_STANDARD_FRINGE_BITMAPS + 20;
1683 fringe_bitmaps
1684 = (struct fringe_bitmap **) xmalloc (max_fringe_bitmaps * sizeof (struct fringe_bitmap *));
1685 fringe_faces
1686 = (Lisp_Object *) xmalloc (max_fringe_bitmaps * sizeof (Lisp_Object));
1688 for (i = 0; i < max_fringe_bitmaps; i++)
1690 fringe_bitmaps[i] = NULL;
1691 fringe_faces[i] = Qnil;
1695 #if defined (HAVE_NTGUI) || defined (MAC_OS)
1697 void
1698 #ifdef HAVE_NTGUI
1699 w32_init_fringe ()
1700 #else /* MAC_OS */
1701 mac_init_fringe ()
1702 #endif
1704 int bt;
1706 if (!rif)
1707 return;
1709 for (bt = NO_FRINGE_BITMAP + 1; bt < MAX_STANDARD_FRINGE_BITMAPS; bt++)
1711 struct fringe_bitmap *fb = &standard_bitmaps[bt];
1712 rif->define_fringe_bitmap (bt, fb->bits, fb->height, fb->width);
1715 #endif
1717 #ifdef HAVE_NTGUI
1718 void
1719 w32_reset_fringes ()
1721 /* Destroy row bitmaps. */
1722 int bt;
1724 if (!rif)
1725 return;
1727 for (bt = NO_FRINGE_BITMAP + 1; bt < max_used_fringe_bitmap; bt++)
1728 rif->destroy_fringe_bitmap (bt);
1731 #endif /* HAVE_NTGUI */
1733 #endif /* HAVE_WINDOW_SYSTEM */
1735 /* arch-tag: 04596920-43eb-473d-b319-82712338162d
1736 (do not change this comment) */