1 /* Synchronize redisplay structures and output changes.
2 Copyright (C) 1994, 1995 Board of Trustees, University of Illinois.
3 Copyright (C) 1995, 1996 Ben Wing.
4 Copyright (C) 1996 Chuck Thompson.
5 Copyright (C) 1999 Andy Piper.
7 This file is part of XEmacs.
9 XEmacs is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 2, or (at your option) any
14 XEmacs is distributed in the hope that it will be useful, but WITHOUT
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with XEmacs; see the file COPYING. If not, write to
21 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* Synched up with: Not in FSF. */
26 /* This file has been Mule-ized. */
28 /* Author: Chuck Thompson */
30 /* Heavily hacked for modularity, gutter and subwindow support by Andy
41 #include "redisplay.h"
44 static int compare_runes (struct window *w, struct rune *crb,
46 static void redraw_cursor_in_window (struct window *w,
47 int run_end_begin_glyphs);
48 static void redisplay_output_display_block (struct window *w, struct display_line *dl,
49 int block, int start, int end, int start_pixpos,
50 int cursor_start, int cursor_width,
52 static void redisplay_normalize_display_box (struct display_box* dest,
53 struct display_glyph_area* src);
54 static int redisplay_display_boxes_in_window_p (struct window* w,
55 struct display_box* db,
56 struct display_glyph_area* dga);
57 static void redisplay_clear_clipped_region (Lisp_Object locale, face_index findex,
58 struct display_box* dest,
59 struct display_glyph_area* glyphsrc,
60 int fullheight_p, Lisp_Object);
62 /*****************************************************************************
65 Synchronize the given rune blocks.
66 ****************************************************************************/
68 sync_rune_structs (struct window *w, rune_dynarr *cra, rune_dynarr *dra)
71 int max_move = ((Dynarr_length (dra) > Dynarr_largest (cra))
72 ? Dynarr_largest (cra)
73 : Dynarr_length (dra));
77 /* #### Doing this directly breaks the encapsulation. But, the
78 running time of this function has a measurable impact on
79 redisplay performance so avoiding all excess overhead is a
80 good thing. Is all of this true? */
81 memcpy (cra->base, dra->base, sizeof (struct rune) * max_move);
82 Dynarr_set_size (cra, max_move);
87 for (rune_elt = max_move; rune_elt < Dynarr_length (dra); rune_elt++)
90 struct rune *drb = Dynarr_atp (dra, rune_elt);
93 memcpy (crb, drb, sizeof (struct rune));
94 Dynarr_add (cra, *crb);
98 /*****************************************************************************
99 sync_display_line_structs
101 For the given LINE in window W, make the current display line equal
102 the desired display line.
103 ****************************************************************************/
105 sync_display_line_structs (struct window *w, int line, int do_blocks,
106 display_line_dynarr *cdla,
107 display_line_dynarr *ddla)
109 int cdla_len = Dynarr_length (cdla);
111 struct display_line dl, *clp, *dlp;
114 dlp = Dynarr_atp (ddla, line);
115 if (line >= Dynarr_largest (cdla))
118 clp->display_blocks = Dynarr_new (display_block);
122 clp = Dynarr_atp (cdla, line);
123 if (clp->display_blocks)
124 Dynarr_reset (clp->display_blocks);
125 if (clp->left_glyphs)
127 Dynarr_free (clp->left_glyphs);
128 clp->left_glyphs = 0;
130 if (clp->right_glyphs)
132 Dynarr_free (clp->right_glyphs);
133 clp->right_glyphs = 0;
137 display_block_dynarr *tdb = clp->display_blocks;
139 memcpy (clp, dlp, sizeof (struct display_line));
140 clp->display_blocks = tdb;
141 clp->left_glyphs = 0;
142 clp->right_glyphs = 0;
145 if (!do_blocks && line >= cdla_len)
147 Dynarr_add (cdla, *clp);
151 for (db_elt = 0; db_elt < Dynarr_length (dlp->display_blocks); db_elt++)
153 struct display_block db, *cdb;
154 struct display_block *ddb = Dynarr_atp (dlp->display_blocks, db_elt);
156 if (db_elt >= Dynarr_largest (clp->display_blocks))
159 memcpy (cdb, ddb, sizeof (struct display_block));
160 cdb->runes = Dynarr_new (rune);
161 Dynarr_add (clp->display_blocks, *cdb);
167 cdb = Dynarr_atp (clp->display_blocks, db_elt);
169 memcpy (cdb, ddb, sizeof (struct display_block));
171 Dynarr_increment (clp->display_blocks);
174 sync_rune_structs (w, cdb->runes, ddb->runes);
177 if (line >= cdla_len)
178 Dynarr_add (cdla, *clp);
181 /*****************************************************************************
184 Compare to runes to see if each of their fields is equal. If so,
185 return true otherwise return false.
186 ****************************************************************************/
188 compare_runes (struct window *w, struct rune *crb, struct rune *drb)
190 /* Do not compare the values of bufpos and endpos. They do not
191 affect the display characteristics. */
193 if ((crb->findex != drb->findex) ||
194 (WINDOW_FACE_CACHEL_DIRTY (w, drb->findex)))
196 else if (crb->xpos != drb->xpos)
198 else if (crb->width != drb->width)
200 else if (crb->cursor_type != drb->cursor_type)
202 else if (crb->type != drb->type)
204 else if (crb->type == RUNE_CHAR &&
205 (crb->object.chr.ch != drb->object.chr.ch))
207 else if (crb->type == RUNE_HLINE &&
208 (crb->object.hline.thickness != drb->object.hline.thickness ||
209 crb->object.hline.yoffset != drb->object.hline.yoffset))
211 else if (crb->type == RUNE_DGLYPH &&
212 (!EQ (crb->object.dglyph.glyph, drb->object.dglyph.glyph) ||
213 !EQ (crb->object.dglyph.extent, drb->object.dglyph.extent) ||
214 crb->object.dglyph.xoffset != drb->object.dglyph.xoffset))
216 /* Only check dirtiness if we know something has changed. */
217 else if (crb->type == RUNE_DGLYPH &&
218 XFRAME (w->frame)->glyphs_changed)
220 glyph_index gindex = get_glyph_cachel_index (w, drb->object.dglyph.glyph);
221 /* Although doing the cachel lookup for every comparison is
222 very expensive.we have to do it to make sure the cache is
224 if (GLYPH_CACHEL_DIRTYP (w, gindex))
233 /*****************************************************************************
234 get_next_display_block
236 Return the next display starting at or overlapping START_POS. Return
237 the start of the next region in NEXT_START.
238 ****************************************************************************/
240 get_next_display_block (layout_bounds bounds, display_block_dynarr *dba,
241 int start_pos, int *next_start)
243 int next_display_block = NO_BLOCK;
247 /* If we don't find a display block covering or starting at
248 start_pos, then we return the starting point of the next display
249 block or the next division boundary, whichever is closer to
253 if (start_pos >= bounds.left_out && start_pos < bounds.left_in)
254 *next_start = bounds.left_in;
255 else if (start_pos < bounds.left_white)
256 *next_start = bounds.left_white;
257 else if (start_pos < bounds.right_white)
258 *next_start = bounds.right_white;
259 else if (start_pos < bounds.right_in)
260 *next_start = bounds.right_in;
261 else if (start_pos <= bounds.right_out)
262 *next_start = bounds.right_out;
267 for (block = 0; block < Dynarr_length (dba); block++)
269 struct display_block *db = Dynarr_atp (dba, block);
271 if (db->start_pos <= start_pos && db->end_pos > start_pos)
273 if ((int) db->type > priority)
276 next_display_block = block;
278 *next_start = db->end_pos;
281 else if (next_start && db->start_pos > start_pos)
283 if (db->start_pos < *next_start)
284 *next_start = db->start_pos;
288 return next_display_block;
291 /*****************************************************************************
292 get_cursor_size_and_location
294 Return the information defining the pixel location of the cursor.
295 ****************************************************************************/
297 get_cursor_size_and_location (struct window *w, struct display_block *db,
299 int *cursor_start, int *cursor_width,
304 int defheight, defwidth;
306 if (Dynarr_length (db->runes) <= cursor_location)
309 XSETWINDOW (window, w);
311 rb = Dynarr_atp (db->runes, cursor_location);
312 *cursor_start = rb->xpos;
314 default_face_height_and_width (window, &defheight, &defwidth);
315 *cursor_height = defheight;
317 if (rb->type == RUNE_BLANK)
318 *cursor_width = defwidth;
320 *cursor_width = rb->width;
323 /*****************************************************************************
324 compare_display_blocks
326 Given two display blocks, output only those areas where they differ.
327 ****************************************************************************/
329 compare_display_blocks (struct window *w, struct display_line *cdl,
330 struct display_line *ddl, int c_block, int d_block,
331 int start_pixpos, int cursor_start, int cursor_width,
334 struct frame *f = XFRAME (w->frame);
335 struct display_block *cdb, *ddb;
341 cdb = Dynarr_atp (cdl->display_blocks, c_block);
342 ddb = Dynarr_atp (ddl->display_blocks, d_block);
344 assert (cdb->type == ddb->type);
347 stop_pos = min (Dynarr_length (cdb->runes), Dynarr_length (ddb->runes));
350 (!Dynarr_length (ddb->runes)
352 : (Dynarr_atp (ddb->runes, Dynarr_length (ddb->runes) - 1)->xpos +
353 Dynarr_atp (ddb->runes, Dynarr_length (ddb->runes) - 1)->width));
355 /* If the new block type is not text and the cursor status is
356 changing and it overlaps the position of this block then force a
357 full redraw of the block in order to make sure that the cursor is
359 if (ddb->type != TEXT
361 /* I'm not sure exactly what this code wants to do, but it's
362 * not right--it doesn't update when cursor_elt changes from, e.g.,
363 * 0 to 8, and the new or old cursor loc overlaps this block.
364 * I've replaced it with the more conservative test below.
365 * -dkindred@cs.cmu.edu 23-Mar-1997 */
366 && ((cdl->cursor_elt == -1 && ddl->cursor_elt != -1)
367 || (cdl->cursor_elt != -1 && ddl->cursor_elt == -1))
368 && (ddl->cursor_elt == -1 ||
371 && (cursor_start + cursor_width) >= start_pixpos
372 && cursor_start <= block_end))
374 && (cdl->cursor_elt != ddl->cursor_elt)
379 if (f->windows_structure_changed ||
380 /* #### Why is this so? We have face cachels so that we don't
381 have to recalculate all the display blocks when faces
382 change. I have fixed this for glyphs and am inclined to think
383 that faces should "Just Work", but I'm not feeling brave
384 today. Maybe its because the face cachels represent merged
385 faces rather than simply instantiations in a particular
388 cdl->ypos != ddl->ypos ||
389 cdl->ascent != ddl->ascent ||
390 cdl->descent != ddl->descent ||
391 cdl->clip != ddl->clip ||
401 while (start_pos < 0 && elt < stop_pos)
403 if (!compare_runes (w, Dynarr_atp (cdb->runes, elt),
404 Dynarr_atp (ddb->runes, elt)))
414 /* If nothing has changed in the area where the blocks overlap, but
415 there are new blocks in the desired block, then adjust the start
416 point accordingly. */
417 if (elt == stop_pos && stop_pos < Dynarr_length (ddb->runes))
418 start_pos = stop_pos;
423 if ((Dynarr_length (ddb->runes) != Dynarr_length (cdb->runes))
426 stop_pos = Dynarr_length (ddb->runes);
430 /* If the lines have the same number of runes and we are not
431 forcing a full redraw because the display line has
432 changed position then we try and optimize how much of the
433 line we actually redraw by scanning backwards from the
434 end for the first changed rune. This optimization is
435 almost always triggered by face changes. */
437 int elt = Dynarr_length (ddb->runes) - 1;
439 while (elt > start_pos)
441 if (!compare_runes (w, Dynarr_atp (cdb->runes, elt),
442 Dynarr_atp (ddb->runes, elt)))
450 redisplay_output_display_block (w, ddl, d_block, start_pos,
451 stop_pos, start_pixpos,
452 cursor_start, cursor_width,
460 /*****************************************************************************
463 Clear the lefthand outside border.
464 ****************************************************************************/
466 clear_left_border (struct window *w, int y, int height)
468 struct frame *f = XFRAME (w->frame);
471 XSETWINDOW (window, w);
472 redisplay_clear_region (window, DEFAULT_INDEX,
473 FRAME_LEFT_BORDER_START (f), y,
474 FRAME_BORDER_WIDTH (f), height);
477 /*****************************************************************************
480 Clear the righthand outside border.
481 ****************************************************************************/
483 clear_right_border (struct window *w, int y, int height)
485 struct frame *f = XFRAME (w->frame);
488 XSETWINDOW (window, w);
489 redisplay_clear_region (window, DEFAULT_INDEX,
490 FRAME_RIGHT_BORDER_START (f),
491 y, FRAME_BORDER_WIDTH (f), height);
494 /*****************************************************************************
497 Ensure that the contents of the given display line is correct
498 on-screen. The force_ parameters are used by redisplay_move_cursor
499 to correctly update cursor locations and only cursor locations.
500 ****************************************************************************/
502 output_display_line (struct window *w, display_line_dynarr *cdla,
503 display_line_dynarr *ddla, int line, int force_start,
507 struct frame *f = XFRAME (w->frame);
508 struct buffer *b = XBUFFER (w->buffer);
509 struct buffer *old_b = window_display_buffer (w);
510 struct display_line *cdl, *ddl;
511 display_block_dynarr *cdba, *ddba;
512 int start_pixpos, end_pixpos;
513 int cursor_start, cursor_width, cursor_height;
515 int force = (force_start >= 0 || force_end >= 0);
516 int clear_border = 0;
519 if (cdla && line < Dynarr_length (cdla))
521 cdl = Dynarr_atp (cdla, line);
522 cdba = cdl->display_blocks;
530 ddl = Dynarr_atp (ddla, line); /* assert line < Dynarr_length (ddla) */
531 ddba = ddl->display_blocks;
533 if (force_start >= 0 && force_start >= ddl->bounds.left_out)
534 start_pixpos = force_start;
536 start_pixpos = ddl->bounds.left_out;
538 if (force_end >= 0 && force_end < ddl->bounds.right_out)
539 end_pixpos = force_end;
541 end_pixpos = ddl->bounds.right_out;
543 /* Get the cursor parameters. */
544 if (ddl->cursor_elt != -1)
546 struct display_block *db;
548 /* If the lines cursor parameter is not -1 then it indicates
549 which rune in the TEXT block contains the cursor. This means
550 that there must be at least one display block. The TEXT
551 block, if present, must always be the first display block. */
552 assert (Dynarr_length (ddba) != 0);
554 db = Dynarr_atp (ddba, 0);
555 assert (db->type == TEXT);
557 get_cursor_size_and_location (w, db, ddl->cursor_elt, &cursor_start,
558 &cursor_width, &cursor_height);
562 cursor_start = cursor_width = cursor_height = 0;
565 /* The modeline should only have a single block and it had better be
569 /* The shadow thickness check is necessary if only the sign of
571 if (cdba && !w->shadow_thickness_changed)
573 must_sync |= compare_display_blocks (w, cdl, ddl, 0, 0,
574 start_pixpos, 0, 0, 0);
578 redisplay_output_display_block (w, ddl, 0, 0, -1, start_pixpos,
587 while (!ddl->modeline && start_pixpos < end_pixpos)
590 int next_start_pixpos;
592 block = get_next_display_block (ddl->bounds, ddba, start_pixpos,
595 /* If we didn't find a block then we should blank the area
596 between start_pos and next_start if necessary. */
597 if (block == NO_BLOCK)
599 /* We only erase those areas which were actually previously
600 covered by a display block unless the window structure
601 changed. In that case we clear all areas since the current
602 structures may actually represent a different buffer. */
603 while (start_pixpos < next_start_pixpos)
609 old_block = get_next_display_block (ddl->bounds, cdba,
610 start_pixpos, &block_end);
613 old_block = NO_BLOCK;
614 block_end = next_start_pixpos;
617 if (!cdba || old_block != NO_BLOCK || b != old_b ||
618 f->windows_structure_changed ||
621 (cdl && (cdl->ypos != ddl->ypos ||
622 cdl->ascent != ddl->ascent ||
623 cdl->descent != ddl->descent ||
624 cdl->top_clip != ddl->top_clip ||
625 cdl->clip != ddl->clip)))
627 int x, y, width, height;
632 y = DISPLAY_LINE_YPOS (ddl);
633 width = min (next_start_pixpos, block_end) - x;
634 height = DISPLAY_LINE_HEIGHT (ddl);
636 if (x < ddl->bounds.left_in)
638 findex = ddl->left_margin_findex ?
639 ddl->left_margin_findex
640 : get_builtin_face_cache_index (w, Vleft_margin_face);
642 else if (x < ddl->bounds.right_in)
644 /* no check here because DEFAULT_INDEX == 0 anyway */
645 findex = ddl->default_findex;
647 else if (x < ddl->bounds.right_out)
649 findex = ddl->right_margin_findex ?
650 ddl->right_margin_findex
651 : get_builtin_face_cache_index (w, Vright_margin_face);
654 findex = (face_index) -1;
656 if (findex != (face_index) -1)
660 XSETWINDOW (window, w);
662 /* Clear the empty area. */
663 redisplay_clear_region (window, findex, x, y, width, height);
665 /* Mark that we should clear the border. This is
666 necessary because italic fonts may leave
667 droppings in the border. */
672 start_pixpos = min (next_start_pixpos, block_end);
677 struct display_block *cdb, *ddb;
682 old_block = get_next_display_block (ddl->bounds, cdba,
683 start_pixpos, &block_end);
685 old_block = NO_BLOCK;
687 ddb = Dynarr_atp (ddba, block);
688 cdb = (old_block != NO_BLOCK ? Dynarr_atp (cdba, old_block) : 0);
690 /* If there was formerly no block over the current
691 region or if it was a block of a different type, then
692 output the entire ddb. Otherwise, compare cdb and
693 ddb and output only the changed region. */
694 if (!force && cdb && ddb->type == cdb->type
695 /* If there was no buffer being display before the
696 compare anyway as we might be outputting a gutter. */
698 (b == old_b || !old_b))
700 must_sync |= compare_display_blocks (w, cdl, ddl, old_block,
702 cursor_start, cursor_width,
711 for (elt = 0; elt < Dynarr_length (ddb->runes); elt++)
713 struct rune *rb = Dynarr_atp (ddb->runes, elt);
715 if (start_pixpos >= rb->xpos
716 && start_pixpos < rb->xpos + rb->width)
719 if (end_pixpos > rb->xpos
720 && end_pixpos <= rb->xpos + rb->width)
723 if (last_elt > Dynarr_length (ddb->runes))
724 last_elt = Dynarr_length (ddb->runes);
730 redisplay_output_display_block (w, ddl, block, first_elt,
733 cursor_start, cursor_width,
737 start_pixpos = next_start_pixpos;
741 /* Clear the internal border if we are next to it and the window
742 structure or frame size has changed or if something caused
743 clear_border to be tripped. */
744 /* #### Doing this on f->clear sucks but is necessary because of
745 window-local background values. */
746 if (f->windows_structure_changed || f->faces_changed || clear_border
749 int y = DISPLAY_LINE_YPOS (ddl);
750 int height = DISPLAY_LINE_HEIGHT (ddl);
752 /* If we are in the gutter then we musn't clear the borders. */
753 if (y >= WINDOW_TEXT_TOP (w) && (y + height) <= WINDOW_TEXT_BOTTOM (w))
757 y -= MODELINE_SHADOW_THICKNESS (w);
758 height += (2 * MODELINE_SHADOW_THICKNESS (w));
761 if (window_is_leftmost (w))
762 clear_left_border (w, y, height);
763 if (window_is_rightmost (w))
764 clear_right_border (w, y, height);
769 sync_display_line_structs (w, line, must_sync, cdla, ddla);
772 /*****************************************************************************
773 redisplay_move_cursor
775 For the given window W, move the cursor to NEW_POINT. Returns a
776 boolean indicating success or failure.
777 ****************************************************************************/
779 #define ADJ_BUFPOS (rb->bufpos + dl->offset)
780 #define ADJ_ENDPOS (rb->endpos + dl->offset)
783 redisplay_move_cursor (struct window *w, Bufpos new_point, int no_output_end)
785 struct frame *f = XFRAME (w->frame);
786 struct device *d = XDEVICE (f->device);
788 display_line_dynarr *cla = window_display_lines (w, CURRENT_DISP);
789 struct display_line *dl;
790 struct display_block *db;
792 int x = w->last_point_x[CURRENT_DISP];
793 int y = w->last_point_y[CURRENT_DISP];
796 * Bail if cursor_in_echo_area is non-zero and we're fiddling with
797 * the cursor in a non-active minibuffer window, since that is a
798 * special case that is handled elsewhere and this function need
799 * not handle it. Return 1 so the caller will assume we
802 if (cursor_in_echo_area && MINI_WINDOW_P (w) &&
803 w != XWINDOW (FRAME_SELECTED_WINDOW (f)))
806 if (y < 0 || y >= Dynarr_length (cla))
809 dl = Dynarr_atp (cla, y);
810 db = get_display_block_from_line (dl, TEXT);
812 if (x < 0 || x >= Dynarr_length (db->runes))
815 rb = Dynarr_atp (db->runes, x);
817 if (rb->cursor_type == CURSOR_OFF)
819 else if (ADJ_BUFPOS == new_point
820 || (ADJ_ENDPOS && (new_point >= ADJ_BUFPOS)
821 && (new_point <= ADJ_ENDPOS)))
823 w->last_point_x[CURRENT_DISP] = x;
824 w->last_point_y[CURRENT_DISP] = y;
825 Fset_marker (w->last_point[CURRENT_DISP], make_int (ADJ_BUFPOS),
832 DEVMETH (d, output_begin, (d));
834 /* #### This is a gross kludge. Cursor handling is such a royal
836 if (rb->type == RUNE_DGLYPH &&
837 (EQ (rb->object.dglyph.glyph, Vtruncation_glyph) ||
838 EQ (rb->object.dglyph.glyph, Vcontinuation_glyph)))
839 rb->cursor_type = NO_CURSOR;
841 rb->cursor_type = CURSOR_OFF;
843 output_display_line (w, 0, cla, y, rb->xpos, rb->xpos + rb->width);
846 w->last_point_x[CURRENT_DISP] = -1;
847 w->last_point_y[CURRENT_DISP] = -1;
848 Fset_marker (w->last_point[CURRENT_DISP], Qnil, w->buffer);
850 /* If this isn't the selected frame, then erasing the old cursor is
851 all we actually had to do. */
852 if (w != XWINDOW (FRAME_SELECTED_WINDOW (device_selected_frame (d))))
855 DEVMETH (d, output_end, (d));
860 /* This should only occur in the minibuffer. */
863 w->last_point_x[CURRENT_DISP] = 0;
864 w->last_point_y[CURRENT_DISP] = y;
865 Fset_marker (w->last_point[CURRENT_DISP], Qzero, w->buffer);
867 rb = Dynarr_atp (db->runes, 0);
868 rb->cursor_type = CURSOR_ON;
871 output_display_line (w, 0, cla, y, rb->xpos, rb->xpos + rb->width);
874 DEVMETH (d, output_end, (d));
883 if (ADJ_BUFPOS < new_point)
889 else /* (rb->bufpos + dl->offset) > new_point */
906 while ((up ? (cur_dl < Dynarr_length (cla)) : (cur_dl >= 0)))
908 dl = Dynarr_atp (cla, cur_dl);
909 db = get_display_block_from_line (dl, TEXT);
912 cur_rb = Dynarr_length (db->runes) - 1;
914 while ((!scroll_on_clipped_lines || !dl->clip) &&
915 (up ? (cur_rb < Dynarr_length (db->runes)) : (cur_rb >= 0)))
917 rb = Dynarr_atp (db->runes, cur_rb);
919 if (rb->cursor_type != IGNORE_CURSOR
920 && rb->cursor_type != NO_CURSOR &&
921 (ADJ_BUFPOS == new_point
922 || (ADJ_ENDPOS && (new_point >= ADJ_BUFPOS)
923 && (new_point <= ADJ_BUFPOS))))
925 rb->cursor_type = CURSOR_ON;
926 dl->cursor_elt = cur_rb;
929 output_display_line (w, 0, cla, cur_dl, rb->xpos,
930 rb->xpos + rb->width);
932 w->last_point_x[CURRENT_DISP] = cur_rb;
933 w->last_point_y[CURRENT_DISP] = cur_dl;
934 Fset_marker (w->last_point[CURRENT_DISP],
935 make_int (ADJ_BUFPOS), w->buffer);
938 DEVMETH (d, output_end, (d));
942 (up ? cur_rb++ : cur_rb--);
945 (up ? (cur_rb = 0) : (first = 0));
946 (up ? cur_dl++ : cur_dl--);
951 DEVMETH (d, output_end, (d));
957 /*****************************************************************************
958 redraw_cursor_in_window
960 For the given window W, redraw the cursor if it is contained within
962 ****************************************************************************/
964 redraw_cursor_in_window (struct window *w, int run_end_begin_meths)
966 struct frame *f = XFRAME (w->frame);
967 struct device *d = XDEVICE (f->device);
969 display_line_dynarr *dla = window_display_lines (w, CURRENT_DISP);
970 struct display_line *dl;
971 struct display_block *db;
974 int x = w->last_point_x[CURRENT_DISP];
975 int y = w->last_point_y[CURRENT_DISP];
977 if (cursor_in_echo_area && MINI_WINDOW_P (w) &&
978 !echo_area_active (f) && minibuf_level == 0)
980 MAYBE_DEVMETH (d, set_final_cursor_coords, (f, w->pixel_top, 0));
983 if (y < 0 || y >= Dynarr_length (dla))
986 if (MINI_WINDOW_P (w) && f != device_selected_frame (d) &&
987 !is_surrogate_for_selected_frame (f))
990 dl = Dynarr_atp (dla, y);
991 db = get_display_block_from_line (dl, TEXT);
993 if (x < 0 || x >= Dynarr_length (db->runes))
996 rb = Dynarr_atp (db->runes, x);
998 /* Don't call the output routine if the block isn't actually the
1000 if (rb->cursor_type == CURSOR_ON)
1002 MAYBE_DEVMETH (d, set_final_cursor_coords,
1003 (f, dl->ypos - 1, rb->xpos));
1005 if (run_end_begin_meths)
1006 DEVMETH (d, output_begin, (d));
1008 output_display_line (w, 0, dla, y, rb->xpos, rb->xpos + rb->width);
1010 if (run_end_begin_meths)
1011 DEVMETH (d, output_end, (d));
1015 /*****************************************************************************
1016 redisplay_redraw_cursor
1018 For the given frame F, redraw the cursor on the selected window.
1019 This is used to update the cursor after focus changes.
1020 ****************************************************************************/
1022 redisplay_redraw_cursor (struct frame *f, int run_end_begin_meths)
1026 if (!cursor_in_echo_area)
1027 window = FRAME_SELECTED_WINDOW (f);
1028 else if (FRAME_HAS_MINIBUF_P (f))
1029 window = FRAME_MINIBUF_WINDOW (f);
1033 redraw_cursor_in_window (XWINDOW (window), run_end_begin_meths);
1036 /****************************************************************************
1037 redisplay_output_display_block
1039 Given a display line, a block number for that start line, output all
1040 runes between start and end in the specified display block.
1041 ****************************************************************************/
1043 redisplay_output_display_block (struct window *w, struct display_line *dl, int block,
1044 int start, int end, int start_pixpos, int cursor_start,
1045 int cursor_width, int cursor_height)
1047 struct frame *f = XFRAME (w->frame);
1048 struct device *d = XDEVICE (f->device);
1049 struct display_block *db = Dynarr_atp (dl->display_blocks, block);
1050 rune_dynarr *rba = db->runes;
1053 rb = Dynarr_atp (rba, start);
1056 /* Nothing to do so don't do anything. */
1059 xpos = max (start_pixpos, rb->xpos);
1062 end = Dynarr_length (rba);
1064 rb = Dynarr_atp (rba, end - 1);
1065 width = rb->xpos + rb->width - xpos;
1066 /* now actually output the block. */
1067 DEVMETH (d, output_display_block, (w, dl, block, start,
1069 cursor_start, cursor_width,
1073 /****************************************************************************
1074 redisplay_unmap_subwindows
1076 Remove subwindows from the area in the box defined by the given
1078 ****************************************************************************/
1079 static void redisplay_unmap_subwindows (struct frame* f, int x, int y, int width, int height,
1080 Lisp_Object ignored_window)
1084 for (elt = 0; elt < Dynarr_length (f->subwindow_cachels); elt++)
1086 struct subwindow_cachel *cachel =
1087 Dynarr_atp (f->subwindow_cachels, elt);
1089 if (cachel->being_displayed
1091 cachel->x + cachel->width > x && cachel->x < x + width
1093 cachel->y + cachel->height > y && cachel->y < y + height
1095 !EQ (cachel->subwindow, ignored_window))
1097 unmap_subwindow (cachel->subwindow);
1102 /****************************************************************************
1103 redisplay_unmap_subwindows_maybe
1105 Potentially subwindows from the area in the box defined by the given
1107 ****************************************************************************/
1108 void redisplay_unmap_subwindows_maybe (struct frame* f, int x, int y, int width, int height)
1110 if (Dynarr_length (FRAME_SUBWINDOW_CACHE (f)))
1112 redisplay_unmap_subwindows (f, x, y, width, height, Qnil);
1116 static void redisplay_unmap_subwindows_except_us (struct frame* f, int x, int y, int width,
1117 int height, Lisp_Object subwindow)
1119 if (Dynarr_length (FRAME_SUBWINDOW_CACHE (f)))
1121 redisplay_unmap_subwindows (f, x, y, width, height, subwindow);
1125 /****************************************************************************
1126 redisplay_output_subwindow
1128 output a subwindow. This code borrows heavily from the pixmap stuff,
1129 although is much simpler not needing to account for partial
1130 pixmaps, backgrounds etc.
1131 ****************************************************************************/
1133 redisplay_output_subwindow (struct window *w,
1134 Lisp_Object image_instance,
1135 struct display_box* db, struct display_glyph_area* dga,
1136 face_index findex, int cursor_start, int cursor_width,
1139 struct Lisp_Image_Instance *p = XIMAGE_INSTANCE (image_instance);
1141 struct display_glyph_area sdga;
1143 dga->height = IMAGE_INSTANCE_SUBWINDOW_HEIGHT (p);
1144 dga->width = IMAGE_INSTANCE_SUBWINDOW_WIDTH (p);
1146 /* This makes the glyph area fit into the display area. */
1147 if (!redisplay_normalize_glyph_area (db, dga))
1150 XSETWINDOW (window, w);
1152 /* Clear the area the subwindow is going into. */
1153 redisplay_clear_clipped_region (window, findex,
1154 db, dga, 0, image_instance);
1156 /* This shrinks the display box to exactly enclose the glyph
1158 redisplay_normalize_display_box (db, dga);
1160 /* if we can't view the whole window we can't view any of it. We
1161 have to be careful here since we may be being asked to display
1162 part of a subwindow, the rest of which is on-screen as well. We
1163 need to allow this case and map the entire subwindow. We also
1164 need to be careful since the subwindow could be outside the
1165 window in the gutter or modeline - we also need to allow these
1167 sdga.xoffset = -dga->xoffset;
1168 sdga.yoffset = -dga->yoffset;
1169 sdga.height = IMAGE_INSTANCE_SUBWINDOW_HEIGHT (p);
1170 sdga.width = IMAGE_INSTANCE_SUBWINDOW_WIDTH (p);
1172 if (redisplay_display_boxes_in_window_p (w, db, &sdga) < 0)
1174 map_subwindow (image_instance, db->xpos, db->ypos, dga);
1178 sdga.xoffset = sdga.yoffset = 0;
1179 map_subwindow (image_instance, db->xpos - dga->xoffset,
1180 db->ypos - dga->yoffset, &sdga);
1184 /****************************************************************************
1185 redisplay_output_layout
1187 Output a widget hierarchy. This can safely call itself recursively.
1188 ****************************************************************************/
1190 redisplay_output_layout (struct window *w,
1191 Lisp_Object image_instance,
1192 struct display_box* db, struct display_glyph_area* dga,
1193 face_index findex, int cursor_start, int cursor_width,
1196 struct Lisp_Image_Instance *p = XIMAGE_INSTANCE (image_instance);
1197 Lisp_Object window, rest;
1198 Emchar_dynarr *buf = Dynarr_new (Emchar);
1199 struct frame *f = XFRAME (w->frame);
1200 struct device *d = XDEVICE (f->device);
1201 int layout_height, layout_width;
1202 /* We bogusly don't take f->extents_changed and f->glyphs_changed
1203 into account. This is because if we do we always redisplay the
1204 entire layout. So far I have seen no ill effects to we'll see. */
1205 int frame_changed = (f->buffers_changed ||
1209 f->modeline_changed ||
1210 f->subwindows_changed ||
1211 f->windows_changed ||
1212 f->windows_structure_changed);
1214 XSETWINDOW (window, w);
1216 layout_height = glyph_height (image_instance, Qnil, findex, window);
1217 layout_width = glyph_width (image_instance, Qnil, findex, window);
1219 dga->height = layout_height;
1220 dga->width = layout_width;
1222 /* This makes the glyph area fit into the display area. */
1223 if (!redisplay_normalize_glyph_area (db, dga))
1226 /* Highly dodgy optimization. We want to only output the whole
1227 layout if we really have to. */
1228 if (frame_changed || IMAGE_INSTANCE_DIRTYP (p))
1230 /* First clear the area we are drawing into. This is the easiest
1231 thing to do since we have many gaps that we have to make sure are
1233 redisplay_clear_clipped_region (window, findex, db, dga, 1, Qnil);
1235 /* Output a border if required */
1236 if (!NILP (IMAGE_INSTANCE_LAYOUT_BORDER (p)))
1239 enum edge_style style;
1240 int ypos = db->ypos;
1241 int height = dga->height;
1243 if (dga->xoffset >= 0)
1245 if (dga->width - dga->xoffset == layout_width)
1246 edges |= EDGE_RIGHT;
1247 if (dga->yoffset >= 0)
1249 if (dga->height - dga->yoffset == layout_height)
1250 edges |= EDGE_BOTTOM;
1252 if (EQ (IMAGE_INSTANCE_LAYOUT_BORDER (p), Qetched_in))
1253 style = EDGE_ETCHED_IN;
1254 else if (EQ (IMAGE_INSTANCE_LAYOUT_BORDER (p), Qetched_out))
1255 style = EDGE_ETCHED_OUT;
1256 else if (EQ (IMAGE_INSTANCE_LAYOUT_BORDER (p), Qbevel_in))
1257 style = EDGE_BEVEL_IN;
1258 else if (INTP (IMAGE_INSTANCE_LAYOUT_BORDER (p)))
1260 style = EDGE_ETCHED_IN;
1261 if (edges & EDGE_TOP)
1263 ypos += XINT (IMAGE_INSTANCE_LAYOUT_BORDER (p));
1264 height -= XINT (IMAGE_INSTANCE_LAYOUT_BORDER (p));
1268 style = EDGE_BEVEL_OUT;
1270 MAYBE_DEVMETH (d, bevel_area,
1271 (w, findex, db->xpos,
1273 dga->width, height, 2, edges, style));
1277 /* This shrinks the display box to exactly enclose the glyph
1279 redisplay_normalize_display_box (db, dga);
1281 /* Flip through the widgets in the layout displaying as necessary */
1282 LIST_LOOP (rest, IMAGE_INSTANCE_LAYOUT_CHILDREN (p))
1284 Lisp_Object child = XCAR (rest);
1286 struct display_box cdb;
1287 /* For losing HP-UX */
1288 cdb.xpos = db->xpos;
1289 cdb.ypos = db->ypos;
1290 cdb.width = db->width;
1291 cdb.height = db->height;
1293 /* First determine if the image is visible at all */
1294 if (IMAGE_INSTANCEP (child))
1296 struct Lisp_Image_Instance* childii = XIMAGE_INSTANCE (child);
1297 /* The enclosing layout offsets are +ve at this point */
1298 struct display_glyph_area cdga;
1299 cdga.xoffset = IMAGE_INSTANCE_XOFFSET (childii) - dga->xoffset;
1300 cdga.yoffset = IMAGE_INSTANCE_YOFFSET (childii) - dga->yoffset;
1301 cdga.width = glyph_width (child, Qnil, findex, window);
1302 cdga.height = glyph_height (child, Qnil, findex, window);
1304 /* Although normalization is done by the output routines
1305 we have to do it here so that they don't try and
1306 clear all of db. This is true below also. */
1307 if (redisplay_normalize_glyph_area (&cdb, &cdga))
1309 redisplay_normalize_display_box (&cdb, &cdga);
1310 /* Since the display boxes will now be totally in the
1311 window if they are visible at all we can now check this easily. */
1312 if (cdb.xpos < db->xpos || cdb.ypos < db->ypos
1313 || cdb.xpos + cdb.width > db->xpos + db->width
1314 || cdb.ypos + cdb.height > db->ypos + db->height)
1316 /* We have to invert the offset here as normalization
1317 will have made them positive which the output
1318 routines will treat as a truely +ve offset. */
1319 cdga.xoffset = -cdga.xoffset;
1320 cdga.yoffset = -cdga.yoffset;
1322 switch (IMAGE_INSTANCE_TYPE (childii))
1326 /* #### This is well hacked and could use some
1328 if (redisplay_normalize_glyph_area (&cdb, &cdga)
1330 (frame_changed || IMAGE_INSTANCE_DIRTYP (childii)))
1332 struct display_line dl; /* this is fake */
1333 Lisp_Object string =
1334 IMAGE_INSTANCE_TEXT_STRING (childii);
1335 convert_bufbyte_string_into_emchar_dynarr
1336 (XSTRING_DATA (string), XSTRING_LENGTH (string), buf);
1338 redisplay_normalize_display_box (&cdb, &cdga);
1339 /* Offsets are now +ve again so be careful
1340 when fixing up the display line. */
1342 /* Munge boxes into display lines. */
1343 dl.ypos = (cdb.ypos - cdga.yoffset)
1344 + glyph_ascent (child, Qnil, findex, window);
1345 dl.ascent = glyph_ascent (child, Qnil, findex, window);
1346 dl.descent = glyph_descent (child, Qnil, findex, window);
1347 dl.top_clip = cdga.yoffset;
1348 dl.clip = (dl.ypos + dl.descent) - (cdb.ypos + cdb.height);
1349 /* output_string doesn't understand offsets in
1350 the same way as other routines - we have to
1351 add the offset to the width so that we
1352 output the full string. */
1353 MAYBE_DEVMETH (d, output_string, (w, &dl, buf, cdb.xpos,
1354 cdga.xoffset, cdb.xpos,
1355 cdga.width + cdga.xoffset,
1356 findex, 0, 0, 0, 0));
1362 case IMAGE_MONO_PIXMAP:
1363 case IMAGE_COLOR_PIXMAP:
1364 if (frame_changed || IMAGE_INSTANCE_DIRTYP (childii))
1365 redisplay_output_pixmap (w, child, &cdb, &cdga, findex,
1370 case IMAGE_SUBWINDOW:
1371 if (frame_changed || IMAGE_INSTANCE_DIRTYP (childii))
1372 redisplay_output_subwindow (w, child, &cdb, &cdga, findex,
1377 redisplay_output_layout (w, child, &cdb, &cdga, findex,
1382 /* nothing is as nothing does */
1395 /****************************************************************************
1396 redisplay_output_pixmap
1400 ****************************************************************************/
1402 redisplay_output_pixmap (struct window *w,
1403 Lisp_Object image_instance,
1404 struct display_box* db, struct display_glyph_area* dga,
1405 face_index findex, int cursor_start, int cursor_width,
1406 int cursor_height, int offset_bitmap)
1408 struct frame *f = XFRAME (w->frame);
1409 struct device *d = XDEVICE (f->device);
1410 struct Lisp_Image_Instance *p = XIMAGE_INSTANCE (image_instance);
1412 XSETWINDOW (window, w);
1414 dga->height = IMAGE_INSTANCE_PIXMAP_HEIGHT (p);
1415 dga->width = IMAGE_INSTANCE_PIXMAP_WIDTH (p);
1417 /* This makes the glyph area fit into the display area. */
1418 if (!redisplay_normalize_glyph_area (db, dga))
1421 /* Clear the area the pixmap is going into. The pixmap itself will
1422 always take care of the full width. We don't want to clear where
1423 it is going to go in order to avoid flicker. So, all we have to
1424 take care of is any area above or below the pixmap. If the pixmap
1425 has a mask in which case we have to clear the whole damn thing
1426 since we can't yet clear just the area not included in the
1430 redisplay_clear_clipped_region (window, findex,
1432 (int)IMAGE_INSTANCE_PIXMAP_MASK (p),
1435 /* This shrinks the display box to exactly enclose the glyph
1437 redisplay_normalize_display_box (db, dga);
1439 assert (db->xpos >= 0 && db->ypos >= 0);
1441 MAYBE_DEVMETH (d, output_pixmap, (w, image_instance,
1443 findex, cursor_start,
1444 cursor_width, cursor_height,
1448 /****************************************************************************
1449 redisplay_clear_region
1451 Clear the area in the box defined by the given parameters using the
1452 given face. This has been generalised so that subwindows can be
1453 coped with effectively.
1454 ****************************************************************************/
1456 redisplay_clear_region (Lisp_Object locale, face_index findex, int x, int y,
1457 int width, int height)
1459 struct window *w = NULL;
1460 struct frame *f = NULL;
1462 Lisp_Object background_pixmap = Qunbound;
1463 Lisp_Object fcolor = Qnil, bcolor = Qnil;
1465 if (!width || !height)
1468 if (WINDOWP (locale))
1470 w = XWINDOW (locale);
1471 f = XFRAME (w->frame);
1473 else if (FRAMEP (locale))
1476 f = XFRAME (locale);
1481 d = XDEVICE (f->device);
1483 /* if we have subwindows in the region we have to unmap them */
1484 redisplay_unmap_subwindows_maybe (f, x, y, width, height);
1486 /* #### This isn't quite right for when this function is called
1487 from the toolbar code. */
1489 /* Don't use a backing pixmap in the border area */
1490 if (x >= FRAME_LEFT_BORDER_END (f)
1491 && x < FRAME_RIGHT_BORDER_START (f)
1492 && y >= FRAME_TOP_BORDER_END (f)
1493 && y < FRAME_BOTTOM_BORDER_START (f))
1499 temp = WINDOW_FACE_CACHEL_BACKGROUND_PIXMAP (w, findex);
1501 if (IMAGE_INSTANCEP (temp)
1502 && IMAGE_INSTANCE_PIXMAP_TYPE_P (XIMAGE_INSTANCE (temp)))
1504 /* #### maybe we could implement such that a string
1505 can be a background pixmap? */
1506 background_pixmap = temp;
1511 temp = FACE_BACKGROUND_PIXMAP (Vdefault_face, locale);
1513 if (IMAGE_INSTANCEP (temp)
1514 && IMAGE_INSTANCE_PIXMAP_TYPE_P (XIMAGE_INSTANCE (temp)))
1516 background_pixmap = temp;
1521 if (!UNBOUNDP (background_pixmap) &&
1522 XIMAGE_INSTANCE_PIXMAP_DEPTH (background_pixmap) == 0)
1526 fcolor = WINDOW_FACE_CACHEL_FOREGROUND (w, findex);
1527 bcolor = WINDOW_FACE_CACHEL_BACKGROUND (w, findex);
1531 fcolor = FACE_FOREGROUND (Vdefault_face, locale);
1532 bcolor = FACE_BACKGROUND (Vdefault_face, locale);
1538 WINDOW_FACE_CACHEL_BACKGROUND (w, findex) :
1539 FACE_BACKGROUND (Vdefault_face, locale));
1543 if (UNBOUNDP (background_pixmap))
1544 background_pixmap = Qnil;
1546 DEVMETH (d, clear_region,
1547 (locale, d, f, findex, x, y, width, height, fcolor, bcolor, background_pixmap));
1550 /****************************************************************************
1551 redisplay_clear_clipped_region
1553 Clear the area in the dest display_box not covered by the src
1554 display_glyph_area using the given face. This is a common occurance
1555 for images shorter than the display line. Clipping can be played
1556 around with by altering these. glyphsrc should be normalized.
1557 ****************************************************************************/
1559 redisplay_clear_clipped_region (Lisp_Object window, face_index findex,
1560 struct display_box* dest, struct display_glyph_area* glyphsrc,
1561 int fullheight_p, Lisp_Object ignored_subwindow)
1563 /* assume dest->xpos >= 0 */
1565 struct frame* f = XFRAME (XWINDOW (window)->frame);
1567 if (glyphsrc->xoffset > 0)
1569 clear_x = dest->xpos + glyphsrc->xoffset;
1573 clear_x = dest->xpos;
1576 /* If we need the whole height cleared then just do it. */
1579 redisplay_clear_region (window, findex, clear_x, dest->ypos,
1580 glyphsrc->width, dest->height);
1584 int yoffset = (glyphsrc->yoffset > 0 ? glyphsrc->yoffset : 0);
1586 /* We need to make sure that subwindows are unmapped from the
1588 redisplay_unmap_subwindows_except_us (f, clear_x, dest->ypos,
1589 glyphsrc->width, dest->height,
1591 /* first the top box */
1594 redisplay_clear_region (window, findex, clear_x, dest->ypos,
1595 glyphsrc->width, yoffset);
1598 /* Then the bottom box */
1599 if (yoffset + glyphsrc->height < dest->height)
1601 redisplay_clear_region (window, findex, clear_x,
1602 dest->ypos + yoffset + glyphsrc->height,
1604 dest->height - (yoffset + glyphsrc->height));
1610 /*****************************************************************************
1611 redisplay_normalize_glyph_area
1612 redisplay_normalize_display_box
1614 Calculate the visible box for displaying src in dest.
1615 ****************************************************************************/
1617 redisplay_normalize_glyph_area (struct display_box* dest,
1618 struct display_glyph_area* glyphsrc)
1620 if (dest->xpos + glyphsrc->xoffset > dest->xpos + dest->width
1622 dest->ypos + glyphsrc->yoffset > dest->ypos + dest->height
1624 -glyphsrc->xoffset >= glyphsrc->width
1626 -glyphsrc->yoffset >= glyphsrc->height)
1628 /* It's all clipped out */
1632 /* Horizontal offsets. This works because xoffset can be -ve as well as +ve */
1633 if (dest->xpos + glyphsrc->xoffset + glyphsrc->width > dest->xpos + dest->width)
1635 if (glyphsrc->xoffset > 0)
1636 glyphsrc->width = dest->width - glyphsrc->xoffset;
1638 glyphsrc->width = dest->width;
1641 if (glyphsrc->xoffset < 0)
1642 glyphsrc->width += glyphsrc->xoffset;
1644 /* Vertical offsets. This works because yoffset can be -ve as well as +ve */
1645 if (dest->ypos + glyphsrc->yoffset + glyphsrc->height > dest->ypos + dest->height)
1647 if (glyphsrc->yoffset > 0)
1648 glyphsrc->height = dest->height - glyphsrc->yoffset;
1650 glyphsrc->height = dest->height;
1653 if (glyphsrc->yoffset < 0)
1654 glyphsrc->height += glyphsrc->yoffset;
1660 redisplay_normalize_display_box (struct display_box* dest,
1661 struct display_glyph_area* glyphsrc)
1663 /* Adjust the destination area. At the end of this the destination
1664 area will exactly enclose the glyph area. The only remaining
1665 adjustment will be offsets into the glyph area. */
1667 /* Horizontal adjustment. */
1668 if (glyphsrc->xoffset > 0)
1670 dest->xpos += glyphsrc->xoffset;
1671 dest->width -= glyphsrc->xoffset;
1672 glyphsrc->xoffset = 0;
1675 glyphsrc->xoffset = -glyphsrc->xoffset;
1677 if (glyphsrc->width < dest->width)
1678 dest->width = glyphsrc->width;
1680 /* Vertical adjustment. */
1681 if (glyphsrc->yoffset > 0)
1683 dest->ypos += glyphsrc->yoffset;
1684 dest->height -= glyphsrc->yoffset;
1685 glyphsrc->yoffset = 0;
1688 glyphsrc->yoffset = -glyphsrc->yoffset;
1690 if (glyphsrc->height < dest->height)
1691 dest->height = glyphsrc->height;
1694 /*****************************************************************************
1695 redisplay_display_boxes_in_window_p
1697 Determine whether the require display_glyph_area is completely inside
1698 the window. 0 means the display_box is not in the window. 1 means the
1699 display_box and the display_glyph_area are in the window. -1 means
1700 the display_box is in the window but the display_glyph_area is not.
1701 ****************************************************************************/
1703 redisplay_display_boxes_in_window_p (struct window* w,
1704 struct display_box* db,
1705 struct display_glyph_area* dga)
1707 int left = WINDOW_TEXT_LEFT (w);
1708 int right = WINDOW_TEXT_RIGHT (w);
1709 int top = WINDOW_TEXT_TOP (w);
1710 int bottom = WINDOW_TEXT_BOTTOM (w);
1712 if (db->xpos < left || db->ypos < top
1713 || db->xpos + db->width > right
1714 || db->ypos + db->height > bottom)
1715 /* We are not displaying in a window at all */
1718 if (db->xpos + dga->xoffset >= left
1720 db->ypos + dga->yoffset >= top
1722 db->xpos + dga->xoffset + dga->width <= right
1724 db->ypos + dga->yoffset + dga->height <= bottom)
1730 /*****************************************************************************
1731 redisplay_calculate_display_boxes
1733 Convert from rune/display_line co-ordinates to display_box
1735 ****************************************************************************/
1737 redisplay_calculate_display_boxes (struct display_line *dl, int xpos,
1738 int xoffset, int start_pixpos, int width,
1739 struct display_box* dest,
1740 struct display_glyph_area* src)
1743 dest->ypos = DISPLAY_LINE_YPOS (dl);
1744 dest->width = width;
1745 dest->height = DISPLAY_LINE_HEIGHT (dl);
1747 src->xoffset = -xoffset;
1748 src->yoffset = -dl->top_clip;
1752 if (start_pixpos >=0 && start_pixpos > xpos)
1754 /* Oops, we're asking for a start outside of the displayable
1756 if (start_pixpos > xpos + width)
1758 dest->xpos = start_pixpos;
1759 dest->width -= (start_pixpos - xpos);
1760 /* Offsets are -ve when we want to clip pixels off the displayed
1762 src->xoffset -= (start_pixpos - xpos);
1768 /*****************************************************************************
1769 redisplay_clear_top_of_window
1771 If window is topmost, clear the internal border above it.
1772 ****************************************************************************/
1774 redisplay_clear_top_of_window (struct window *w)
1777 XSETWINDOW (window, w);
1779 if (!NILP (Fwindow_highest_p (window)))
1781 struct frame *f = XFRAME (w->frame);
1782 int x, y, width, height;
1785 width = w->pixel_width;
1787 if (window_is_leftmost (w))
1789 x -= FRAME_BORDER_WIDTH (f);
1790 width += FRAME_BORDER_WIDTH (f);
1792 if (window_is_rightmost (w))
1793 width += FRAME_BORDER_WIDTH (f);
1795 y = FRAME_TOP_BORDER_START (f) - 1;
1796 height = FRAME_BORDER_HEIGHT (f) + 1;
1798 redisplay_clear_region (window, DEFAULT_INDEX, x, y, width, height);
1802 /*****************************************************************************
1803 redisplay_clear_to_window_end
1805 Clear the area between ypos1 and ypos2. Each margin area and the
1806 text area is handled separately since they may each have their own
1808 ****************************************************************************/
1810 redisplay_clear_to_window_end (struct window *w, int ypos1, int ypos2)
1812 struct frame *f = XFRAME (w->frame);
1813 struct device *d = XDEVICE (f->device);
1815 if (HAS_DEVMETH_P (d, clear_to_window_end))
1816 DEVMETH (d, clear_to_window_end, (w, ypos1, ypos2));
1819 int height = ypos2 - ypos1;
1824 int bflag = 0 ; /* (window_needs_vertical_divider (w) ? 0 : 1);*/
1825 layout_bounds bounds;
1827 bounds = calculate_display_line_boundaries (w, bflag);
1828 XSETWINDOW (window, w);
1830 if (window_is_leftmost (w))
1831 redisplay_clear_region (window, DEFAULT_INDEX, FRAME_LEFT_BORDER_START (f),
1832 ypos1, FRAME_BORDER_WIDTH (f), height);
1834 if (bounds.left_in - bounds.left_out > 0)
1835 redisplay_clear_region (window,
1836 get_builtin_face_cache_index (w, Vleft_margin_face),
1837 bounds.left_out, ypos1,
1838 bounds.left_in - bounds.left_out, height);
1840 if (bounds.right_in - bounds.left_in > 0)
1841 redisplay_clear_region (window,
1843 bounds.left_in, ypos1,
1844 bounds.right_in - bounds.left_in, height);
1846 if (bounds.right_out - bounds.right_in > 0)
1847 redisplay_clear_region (window,
1848 get_builtin_face_cache_index (w, Vright_margin_face),
1849 bounds.right_in, ypos1,
1850 bounds.right_out - bounds.right_in, height);
1852 if (window_is_rightmost (w))
1853 redisplay_clear_region (window, DEFAULT_INDEX, FRAME_RIGHT_BORDER_START (f),
1854 ypos1, FRAME_BORDER_WIDTH (f), height);
1859 /*****************************************************************************
1860 redisplay_clear_bottom_of_window
1862 Clear window from right below the last display line to right above
1863 the modeline. The calling function can limit the area actually
1864 erased by setting min_start and/or max_end to positive values.
1865 ****************************************************************************/
1867 redisplay_clear_bottom_of_window (struct window *w, display_line_dynarr *ddla,
1868 int min_start, int max_end)
1870 struct frame *f = XFRAME (w->frame);
1872 int ddla_len = Dynarr_length (ddla);
1874 ypos2 = WINDOW_TEXT_BOTTOM (w);
1875 #ifdef HAVE_SCROLLBARS
1876 /* This adjustment is to catch the intersection of any scrollbars. */
1877 if (f->windows_structure_changed && NILP (w->scrollbar_on_top_p))
1878 ypos2 += window_scrollbar_height (w);
1883 if (ddla_len == 1 && Dynarr_atp (ddla, 0)->modeline)
1885 ypos1 = WINDOW_TEXT_TOP (w);
1886 #ifdef HAVE_SCROLLBARS
1887 /* This adjustment is to catch the intersection of any scrollbars. */
1888 if (f->windows_structure_changed && !NILP (w->scrollbar_on_top_p))
1889 ypos1 -= window_scrollbar_height (w);
1894 struct display_line *dl = Dynarr_atp (ddla, ddla_len - 1);
1895 ypos1 = dl->ypos + dl->descent - dl->clip;
1899 ypos1 = WINDOW_TEXT_TOP (w);
1901 /* #### See if this can be made conditional on the frame
1903 if (MINI_WINDOW_P (w))
1904 ypos2 += FRAME_BORDER_HEIGHT (f);
1906 if (min_start >= 0 && ypos1 < min_start)
1908 if (max_end >= 0 && ypos2 > max_end)
1914 redisplay_clear_to_window_end (w, ypos1, ypos2);
1917 /*****************************************************************************
1918 redisplay_update_line
1920 This is used during incremental updates to update a single line and
1921 correct the offsets on all lines below it. At the moment
1922 update_values is false if we are only updating the modeline.
1923 ****************************************************************************/
1925 redisplay_update_line (struct window *w, int first_line, int last_line,
1928 struct frame *f = XFRAME (w->frame);
1929 struct device *d = XDEVICE (f->device);
1931 display_line_dynarr *cdla = window_display_lines (w, CURRENT_DISP);
1932 display_line_dynarr *ddla = window_display_lines (w, DESIRED_DISP);
1934 DEVMETH (d, output_begin, (d));
1936 while (first_line <= last_line)
1938 Charcount old_len = (Dynarr_atp (cdla, first_line)->end_bufpos -
1939 Dynarr_atp (cdla, first_line)->bufpos);
1940 Charcount new_len = (Dynarr_atp (ddla, first_line)->end_bufpos -
1941 Dynarr_atp (ddla, first_line)->bufpos);
1943 assert (Dynarr_length (cdla) == Dynarr_length (ddla));
1945 /* Output the changes. */
1946 output_display_line (w, cdla, ddla, first_line, -1, -1);
1948 /* Update the offsets. */
1951 int cur_line = first_line + 1;
1952 while (cur_line < Dynarr_length (cdla))
1954 Dynarr_atp (cdla, cur_line)->offset += (new_len - old_len);
1955 Dynarr_atp (ddla, cur_line)->offset += (new_len - old_len);
1960 /* Update the window_end_pos and other settings. */
1963 w->window_end_pos[CURRENT_DISP] -= (new_len - old_len);
1965 if (Dynarr_atp (ddla, first_line)->cursor_elt != -1)
1967 w->last_point_x[CURRENT_DISP] = w->last_point_x[DESIRED_DISP];
1968 w->last_point_y[CURRENT_DISP] = w->last_point_y[DESIRED_DISP];
1975 /* Update the window max line length. We have to scan the entire
1976 set of display lines otherwise we might not detect if the max is
1977 supposed to shrink. */
1982 w->max_line_len = 0;
1983 while (line < Dynarr_length (ddla))
1985 struct display_line *dl = Dynarr_atp (ddla, line);
1988 w->max_line_len = max (dl->num_chars, w->max_line_len);
1994 w->last_modified[CURRENT_DISP] = w->last_modified[DESIRED_DISP];
1995 w->last_facechange[CURRENT_DISP] = w->last_facechange[DESIRED_DISP];
1996 Fset_marker (w->last_point[CURRENT_DISP],
1997 Fmarker_position (w->last_point[DESIRED_DISP]), w->buffer);
1998 Fset_marker (w->last_start[CURRENT_DISP],
1999 Fmarker_position (w->last_start[DESIRED_DISP]), w->buffer);
2001 /* We don't bother updating the vertical scrollbars here. This
2002 gives us a performance increase while having minimal loss of
2003 quality to the scrollbar slider size and position since when this
2004 function is called we know that the changes to the buffer were
2005 very localized. We have to update the horizontal scrollbars,
2006 though, because this routine could cause a change which has a
2007 larger impact on their sizing. */
2008 /* #### See if we can get away with only calling this if
2009 max_line_len is greater than the window_char_width. */
2010 #if defined(HAVE_SCROLLBARS) && defined(HAVE_X_WINDOWS)
2012 extern int stupid_vertical_scrollbar_drag_hack;
2014 update_window_scrollbars (w, NULL, 1, stupid_vertical_scrollbar_drag_hack);
2015 stupid_vertical_scrollbar_drag_hack = 1;
2019 /* This has to be done after we've updated the values. We don't
2020 call output_end for tty frames. Redisplay will do this after all
2021 tty windows have been updated. This cuts down on cursor
2023 if (FRAME_TTY_P (f))
2024 redisplay_redraw_cursor (f, 0);
2026 DEVMETH (d, output_end, (d));
2029 /*****************************************************************************
2030 redisplay_output_window
2032 For the given window W, ensure that the current display lines are
2033 equal to the desired display lines, outputing changes as necessary.
2035 #### Fuck me. This just isn't going to cut it for tty's. The output
2036 decisions for them must be based on the contents of the entire frame
2037 because that is how the available output capabilities think. The
2038 solution is relatively simple. Create redisplay_output_frame. This
2039 will basically merge all of the separate window display structs into
2040 a single one for the frame. This combination structure will be able
2041 to be passed to the same output_display_line which works for windows
2042 on X frames and the right things will happen. It just takes time to
2044 ****************************************************************************/
2046 redisplay_output_window (struct window *w)
2048 struct frame *f = XFRAME (w->frame);
2049 struct device *d = XDEVICE (f->device);
2051 display_line_dynarr *cdla = window_display_lines (w, CURRENT_DISP);
2052 display_line_dynarr *ddla = window_display_lines (w, DESIRED_DISP);
2054 int cdla_len = Dynarr_length (cdla);
2055 int ddla_len = Dynarr_length (ddla);
2058 int need_to_clear_bottom = 0;
2059 int need_to_clear_start = -1;
2060 int need_to_clear_end = -1;
2062 /* Backgrounds may have changed or windows may have gone away
2063 leaving dividers lying around. */
2064 if (f->faces_changed
2065 || f->windows_structure_changed
2066 || w->shadow_thickness_changed)
2067 need_to_clear_bottom = 1;
2069 /* The first thing we do is determine if we are going to need to
2070 clear the bottom of the window. We only need to do this if the
2071 bottom of the current display lines is below the bottom of the
2072 desired display lines. Note that the number of lines is
2073 irrelevant. Only the position matters. We also clear to the
2074 bottom of the window if the modeline has shifted position. */
2075 /* #### We can't blindly not clear the bottom if f->clear is true
2076 since there might be a window-local background. However, for
2077 those cases where there isn't, clearing the end of the window in
2079 if (!need_to_clear_bottom)
2081 struct display_line *cdl, *ddl;
2083 /* If the modeline has changed position or size, clear the bottom
2085 if (!need_to_clear_bottom)
2090 cdl = Dynarr_atp (cdla, 0);
2092 ddl = Dynarr_atp (ddla, 0);
2095 need_to_clear_bottom = 1;
2096 else if ((!cdl->modeline && ddl->modeline)
2097 || (cdl->modeline && !ddl->modeline))
2098 need_to_clear_bottom = 1;
2099 else if (cdl->ypos != ddl->ypos ||
2100 cdl->ascent != ddl->ascent ||
2101 cdl->descent != ddl->descent ||
2102 cdl->clip != ddl->clip)
2103 need_to_clear_bottom = 1;
2105 /* #### This kludge is to make sure the modeline shadows get
2106 redrawn if the modeline position shifts. */
2107 if (need_to_clear_bottom)
2108 w->shadow_thickness_changed = 1;
2111 if (!need_to_clear_bottom)
2116 cdl = Dynarr_atp (cdla, cdla_len - 1);
2118 ddl = Dynarr_atp (ddla, ddla_len - 1);
2121 need_to_clear_bottom = 1;
2124 int cdl_bottom, ddl_bottom;
2126 cdl_bottom = cdl->ypos + cdl->descent;
2127 ddl_bottom = ddl->ypos + ddl->descent;
2129 if (cdl_bottom > ddl_bottom)
2131 need_to_clear_bottom = 1;
2132 need_to_clear_start = ddl_bottom;
2133 need_to_clear_end = cdl_bottom;
2139 /* Perform any output initialization. */
2140 DEVMETH (d, output_begin, (d));
2142 /* If the window's structure has changed clear the internal border
2143 above it if it is topmost (the function will check). */
2144 if (f->windows_structure_changed)
2145 redisplay_clear_top_of_window (w);
2147 /* Output each line. */
2148 for (line = 0; line < Dynarr_length (ddla); line++)
2150 output_display_line (w, cdla, ddla, line, -1, -1);
2153 /* If the number of display lines has shrunk, adjust. */
2154 if (cdla_len > ddla_len)
2156 Dynarr_length (cdla) = ddla_len;
2159 /* Output a vertical divider between windows, if necessary. */
2160 if (window_needs_vertical_divider (w)
2161 && (f->windows_structure_changed || f->clear))
2163 DEVMETH (d, output_vertical_divider, (w, f->windows_structure_changed));
2166 /* Clear the rest of the window, if necessary. */
2167 if (need_to_clear_bottom)
2169 redisplay_clear_bottom_of_window (w, ddla, need_to_clear_start,
2173 w->window_end_pos[CURRENT_DISP] = w->window_end_pos[DESIRED_DISP];
2174 Fset_marker (w->start[CURRENT_DISP],
2175 make_int (marker_position (w->start[DESIRED_DISP])),
2177 Fset_marker (w->pointm[CURRENT_DISP],
2178 make_int (marker_position (w->pointm[DESIRED_DISP])),
2180 w->last_modified[CURRENT_DISP] = w->last_modified[DESIRED_DISP];
2181 w->last_facechange[CURRENT_DISP] = w->last_facechange[DESIRED_DISP];
2182 Fset_marker (w->last_start[CURRENT_DISP],
2183 Fmarker_position (w->last_start[DESIRED_DISP]), w->buffer);
2184 Fset_marker (w->last_point[CURRENT_DISP],
2185 Fmarker_position (w->last_point[DESIRED_DISP]), w->buffer);
2186 w->last_point_x[CURRENT_DISP] = w->last_point_x[DESIRED_DISP];
2187 w->last_point_y[CURRENT_DISP] = w->last_point_y[DESIRED_DISP];
2188 w->shadow_thickness_changed = 0;
2190 set_window_display_buffer (w, XBUFFER (w->buffer));
2191 find_window_mirror (w)->truncate_win = window_truncation_on (w);
2193 /* Overkill on invalidating the cache. It is very bad for it to not
2194 get invalidated when it should be. */
2195 INVALIDATE_DEVICE_PIXEL_TO_GLYPH_CACHE (d);
2197 /* We don't call output_end for tty frames. Redisplay will do this
2198 after all tty windows have been updated. This cuts down on
2200 if (FRAME_TTY_P (f))
2201 redisplay_redraw_cursor (f, 0);
2203 DEVMETH (d, output_end, (d));
2205 #ifdef HAVE_SCROLLBARS
2206 update_window_scrollbars (w, NULL, !MINI_WINDOW_P (w), 0);
2210 /*****************************************************************************
2213 Draw a 3d border around the modeline on window W.
2214 ****************************************************************************/
2216 bevel_modeline (struct window *w, struct display_line *dl)
2218 struct frame *f = XFRAME (w->frame);
2219 struct device *d = XDEVICE (f->device);
2220 int x, y, width, height;
2221 int shadow_thickness = MODELINE_SHADOW_THICKNESS (w);
2222 enum edge_style style;
2224 x = WINDOW_MODELINE_LEFT (w);
2225 width = WINDOW_MODELINE_RIGHT (w) - x;
2226 y = dl->ypos - dl->ascent - shadow_thickness;
2227 height = dl->ascent + dl->descent + 2 * shadow_thickness;
2229 if (XINT (w->modeline_shadow_thickness) < 0)
2231 style = EDGE_BEVEL_IN;
2235 style = EDGE_BEVEL_OUT;
2238 MAYBE_DEVMETH (d, bevel_area,
2239 (w, MODELINE_INDEX, x, y, width, height, shadow_thickness,