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, 2002 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"
45 static int compare_runes (struct window *w, struct rune *crb,
47 static void redraw_cursor_in_window (struct window *w,
48 int run_end_begin_glyphs);
49 static void redisplay_output_display_block (struct window *w, struct display_line *dl,
50 int block, int start, int end, int start_pixpos,
51 int cursor_start, int cursor_width,
53 static void redisplay_normalize_display_box (struct display_box* dest,
54 struct display_glyph_area* src);
55 static int redisplay_display_boxes_in_window_p (struct window* w,
56 struct display_box* db,
57 struct display_glyph_area* dga);
58 static void redisplay_clear_clipped_region (Lisp_Object locale, face_index findex,
59 struct display_box* dest,
60 struct display_glyph_area* glyphsrc,
61 int fullheight_p, Lisp_Object);
63 /*****************************************************************************
66 Synchronize the given rune blocks.
67 ****************************************************************************/
69 sync_rune_structs (struct window *w, rune_dynarr *cra, rune_dynarr *dra)
72 int max_move = ((Dynarr_length (dra) > Dynarr_largest (cra))
73 ? Dynarr_largest (cra)
74 : Dynarr_length (dra));
78 /* #### Doing this directly breaks the encapsulation. But, the
79 running time of this function has a measurable impact on
80 redisplay performance so avoiding all excess overhead is a
81 good thing. Is all of this true? */
82 memcpy (cra->base, dra->base, sizeof (struct rune) * max_move);
83 Dynarr_set_size (cra, max_move);
88 for (rune_elt = max_move; rune_elt < Dynarr_length (dra); rune_elt++)
91 struct rune *drb = Dynarr_atp (dra, rune_elt);
94 memcpy (crb, drb, sizeof (struct rune));
95 Dynarr_add (cra, *crb);
99 /*****************************************************************************
100 sync_display_line_structs
102 For the given LINE in window W, make the current display line equal
103 the desired display line.
104 ****************************************************************************/
106 sync_display_line_structs (struct window *w, int line, int do_blocks,
107 display_line_dynarr *cdla,
108 display_line_dynarr *ddla)
110 int cdla_len = Dynarr_length (cdla);
112 struct display_line dl, *clp, *dlp;
115 dlp = Dynarr_atp (ddla, line);
116 if (line >= Dynarr_largest (cdla))
119 clp->display_blocks = Dynarr_new (display_block);
123 clp = Dynarr_atp (cdla, line);
124 if (clp->display_blocks)
125 Dynarr_reset (clp->display_blocks);
126 if (clp->left_glyphs)
128 Dynarr_free (clp->left_glyphs);
129 clp->left_glyphs = 0;
131 if (clp->right_glyphs)
133 Dynarr_free (clp->right_glyphs);
134 clp->right_glyphs = 0;
138 display_block_dynarr *tdb = clp->display_blocks;
140 memcpy (clp, dlp, sizeof (struct display_line));
141 clp->display_blocks = tdb;
142 clp->left_glyphs = 0;
143 clp->right_glyphs = 0;
146 if (!do_blocks && line >= cdla_len)
148 Dynarr_add (cdla, *clp);
152 for (db_elt = 0; db_elt < Dynarr_length (dlp->display_blocks); db_elt++)
154 struct display_block db, *cdb;
155 struct display_block *ddb = Dynarr_atp (dlp->display_blocks, db_elt);
157 if (db_elt >= Dynarr_largest (clp->display_blocks))
160 memcpy (cdb, ddb, sizeof (struct display_block));
161 cdb->runes = Dynarr_new (rune);
162 Dynarr_add (clp->display_blocks, *cdb);
168 cdb = Dynarr_atp (clp->display_blocks, db_elt);
170 memcpy (cdb, ddb, sizeof (struct display_block));
172 Dynarr_increment (clp->display_blocks);
175 sync_rune_structs (w, cdb->runes, ddb->runes);
178 if (line >= cdla_len)
179 Dynarr_add (cdla, *clp);
182 /*****************************************************************************
185 Compare two runes to see if each of their fields is equal. If so,
186 return true otherwise return false.
187 ****************************************************************************/
189 compare_runes (struct window *w, struct rune *crb, struct rune *drb)
191 /* Do not compare the values of bufpos and endpos. They do not
192 affect the display characteristics. */
194 /* Note: (hanoi 6) spends 95% of its time in redisplay, and about
195 30% here. Not using bitfields for rune.type alone gives a redisplay
198 #### In profile arcs run of a normal Gnus session this function
199 is run 6.76 million times, only to return 1 in 6.73 million of
202 In addition a quick look GCC sparc assembly shows that GCC is not
203 doing a good job here.
204 1. The function is not inlined (too complicated?)
205 2. It seems to be reloading the crb and drb variables all the
207 3. It doesn't seem to notice that the second half of these if's
208 are really a switch statement.
212 #### It would really be worth it to arrange for this function to
213 be (almost) a single call to memcmp. */
215 if (crb->xpos != drb->xpos)
217 else if (crb->width != drb->width)
219 else if (crb->cursor_type != drb->cursor_type)
221 else if (crb->type != drb->type)
223 else if (crb->type == RUNE_CHAR &&
224 (crb->object.chr.ch != drb->object.chr.ch))
226 else if (crb->type == RUNE_HLINE &&
227 (crb->object.hline.thickness != drb->object.hline.thickness ||
228 crb->object.hline.yoffset != drb->object.hline.yoffset))
230 else if (crb->type == RUNE_DGLYPH &&
231 (!EQ (crb->object.dglyph.glyph, drb->object.dglyph.glyph) ||
232 !EQ (crb->object.dglyph.extent, drb->object.dglyph.extent) ||
233 crb->object.dglyph.xoffset != drb->object.dglyph.xoffset ||
234 crb->object.dglyph.yoffset != drb->object.dglyph.yoffset ||
235 crb->object.dglyph.ascent != drb->object.dglyph.ascent ||
236 crb->object.dglyph.descent != drb->object.dglyph.descent))
238 /* Only check dirtiness if we know something has changed. */
239 else if (crb->type == RUNE_DGLYPH &&
240 (XGLYPH_DIRTYP (crb->object.dglyph.glyph) ||
241 crb->findex != drb->findex))
243 /* We need some way of telling redisplay_output_layout () that the
244 only reason we are outputting it is because something has
245 changed internally. That way we can optimize whether we need
246 to clear the layout first and also only output the components
247 that have changed. The image_instance dirty flag and
248 display_hash are no good to us because these will invariably
249 have been set anyway if the layout has changed. So it looks
250 like we need yet another change flag that we can set here and
251 then clear in redisplay_output_layout (). */
252 Lisp_Object window, image;
253 Lisp_Image_Instance* ii;
254 XSETWINDOW (window, w);
255 image = glyph_image_instance (crb->object.dglyph.glyph,
256 window, ERROR_ME_NOT, 1);
258 if (!IMAGE_INSTANCEP (image))
260 ii = XIMAGE_INSTANCE (image);
262 if (TEXT_IMAGE_INSTANCEP (image) &&
263 (crb->findex != drb->findex ||
264 WINDOW_FACE_CACHEL_DIRTY (w, drb->findex)))
267 /* It is quite common for the two glyphs to be EQ since in many
268 cases they will actually be the same object. This does not
269 mean, however, that nothing has changed. We therefore need to
270 check the current hash of the glyph against the last recorded
271 display hash and the pending display items. See
272 update_subwindow (). */
273 if (image_instance_changed (image) ||
274 crb->findex != drb->findex ||
275 WINDOW_FACE_CACHEL_DIRTY (w, drb->findex))
277 /* Now we are going to re-output the glyph, but since
278 this is for some internal reason not related to geometry
279 changes, send a hint to the output routines that they can
280 take some short cuts. This is most useful for
281 layouts. This flag should get reset by the output
284 #### It is possible for us to get here when the
285 face_cachel is dirty. I do not know what the implications
287 IMAGE_INSTANCE_OPTIMIZE_OUTPUT (ii) = 1;
293 /* We now do this last so that glyph checks can do their own thing
294 for face changes. Face changes quite often happen when we are
295 trying to output something in the gutter, this would normally
296 lead to a lot of flashing. The indices can quite often be
297 different and yet the faces are the same, we do not want to
298 re-output in this instance. */
299 else if (crb->findex != drb->findex ||
300 WINDOW_FACE_CACHEL_DIRTY (w, drb->findex))
306 /*****************************************************************************
307 get_next_display_block
309 Return the next display starting at or overlapping START_POS. Return
310 the start of the next region in NEXT_START.
311 ****************************************************************************/
313 get_next_display_block (layout_bounds bounds, display_block_dynarr *dba,
314 int start_pos, int *next_start)
316 int next_display_block = NO_BLOCK;
320 /* If we don't find a display block covering or starting at
321 start_pos, then we return the starting point of the next display
322 block or the next division boundary, whichever is closer to
326 if (start_pos >= bounds.left_out && start_pos < bounds.left_in)
327 *next_start = bounds.left_in;
328 else if (start_pos < bounds.left_white)
329 *next_start = bounds.left_white;
330 else if (start_pos < bounds.right_white)
331 *next_start = bounds.right_white;
332 else if (start_pos < bounds.right_in)
333 *next_start = bounds.right_in;
334 else if (start_pos <= bounds.right_out)
335 *next_start = bounds.right_out;
340 for (block = 0; block < Dynarr_length (dba); block++)
342 struct display_block *db = Dynarr_atp (dba, block);
344 if (db->start_pos <= start_pos && db->end_pos > start_pos)
346 if ((int) db->type > priority)
349 next_display_block = block;
351 *next_start = db->end_pos;
354 else if (next_start && db->start_pos > start_pos)
356 if (db->start_pos < *next_start)
357 *next_start = db->start_pos;
361 return next_display_block;
364 /*****************************************************************************
365 get_cursor_size_and_location
367 Return the information defining the pixel location of the cursor.
368 ****************************************************************************/
370 get_cursor_size_and_location (struct window *w, struct display_block *db,
372 int *cursor_start, int *cursor_width,
377 int defheight, defwidth;
379 if (Dynarr_length (db->runes) <= cursor_location)
382 XSETWINDOW (window, w);
384 rb = Dynarr_atp (db->runes, cursor_location);
385 *cursor_start = rb->xpos;
387 default_face_height_and_width (window, &defheight, &defwidth);
388 *cursor_height = defheight;
390 if (rb->type == RUNE_BLANK)
391 *cursor_width = defwidth;
393 *cursor_width = rb->width;
396 /*****************************************************************************
397 compare_display_blocks
399 Given two display blocks, output only those areas where they differ.
400 ****************************************************************************/
402 compare_display_blocks (struct window *w, struct display_line *cdl,
403 struct display_line *ddl, int c_block, int d_block,
404 int start_pixpos, int cursor_start, int cursor_width,
407 struct frame *f = XFRAME (w->frame);
408 struct display_block *cdb, *ddb;
414 cdb = Dynarr_atp (cdl->display_blocks, c_block);
415 ddb = Dynarr_atp (ddl->display_blocks, d_block);
417 assert (cdb->type == ddb->type);
420 stop_pos = min (Dynarr_length (cdb->runes), Dynarr_length (ddb->runes));
423 (!Dynarr_length (ddb->runes)
425 : (Dynarr_atp (ddb->runes, Dynarr_length (ddb->runes) - 1)->xpos +
426 Dynarr_atp (ddb->runes, Dynarr_length (ddb->runes) - 1)->width));
428 /* If the new block type is not text and the cursor status is
429 changing and it overlaps the position of this block then force a
430 full redraw of the block in order to make sure that the cursor is
432 if (ddb->type != TEXT
434 /* I'm not sure exactly what this code wants to do, but it's
435 * not right--it doesn't update when cursor_elt changes from, e.g.,
436 * 0 to 8, and the new or old cursor loc overlaps this block.
437 * I've replaced it with the more conservative test below.
438 * -dkindred@cs.cmu.edu 23-Mar-1997 */
439 && ((cdl->cursor_elt == -1 && ddl->cursor_elt != -1)
440 || (cdl->cursor_elt != -1 && ddl->cursor_elt == -1))
441 && (ddl->cursor_elt == -1 ||
444 && (cursor_start + cursor_width) >= start_pixpos
445 && cursor_start <= block_end))
447 && (cdl->cursor_elt != ddl->cursor_elt)
452 if (f->windows_structure_changed ||
453 /* #### Why is this so? We have face cachels so that we don't
454 have to recalculate all the display blocks when faces
455 change. I have fixed this for glyphs and am inclined to think
456 that faces should "Just Work", but I'm not feeling brave
457 today. Maybe its because the face cachels represent merged
458 faces rather than simply instantiations in a particular
461 cdl->ypos != ddl->ypos ||
462 cdl->ascent != ddl->ascent ||
463 cdl->descent != ddl->descent ||
464 cdl->clip != ddl->clip ||
474 while (start_pos < 0 && elt < stop_pos)
476 if (!compare_runes (w, Dynarr_atp (cdb->runes, elt),
477 Dynarr_atp (ddb->runes, elt)))
487 /* If nothing has changed in the area where the blocks overlap, but
488 there are new blocks in the desired block, then adjust the start
489 point accordingly. */
490 if (elt == stop_pos && stop_pos < Dynarr_length (ddb->runes))
491 start_pos = stop_pos;
496 if ((Dynarr_length (ddb->runes) != Dynarr_length (cdb->runes))
499 stop_pos = Dynarr_length (ddb->runes);
503 /* If the lines have the same number of runes and we are not
504 forcing a full redraw because the display line has
505 changed position then we try and optimize how much of the
506 line we actually redraw by scanning backwards from the
507 end for the first changed rune. This optimization is
508 almost always triggered by face changes. */
510 int elt = Dynarr_length (ddb->runes) - 1;
512 while (elt > start_pos)
514 if (!compare_runes (w, Dynarr_atp (cdb->runes, elt),
515 Dynarr_atp (ddb->runes, elt)))
523 redisplay_output_display_block (w, ddl, d_block, start_pos,
524 stop_pos, start_pixpos,
525 cursor_start, cursor_width,
533 /*****************************************************************************
536 Clear the lefthand outside border.
537 ****************************************************************************/
539 clear_left_border (struct window *w, int y, int height)
541 struct frame *f = XFRAME (w->frame);
544 XSETWINDOW (window, w);
545 redisplay_clear_region (window, DEFAULT_INDEX,
546 FRAME_LEFT_BORDER_START (f), y,
547 FRAME_BORDER_WIDTH (f), height);
550 /*****************************************************************************
553 Clear the righthand outside border.
554 ****************************************************************************/
556 clear_right_border (struct window *w, int y, int height)
558 struct frame *f = XFRAME (w->frame);
561 XSETWINDOW (window, w);
562 redisplay_clear_region (window, DEFAULT_INDEX,
563 FRAME_RIGHT_BORDER_START (f),
564 y, FRAME_BORDER_WIDTH (f), height);
567 /*****************************************************************************
570 Ensure that the contents of the given display line is correct
571 on-screen. The force_ parameters are used by redisplay_move_cursor
572 to correctly update cursor locations and only cursor locations.
573 ****************************************************************************/
575 output_display_line (struct window *w, display_line_dynarr *cdla,
576 display_line_dynarr *ddla, int line, int force_start,
580 struct frame *f = XFRAME (w->frame);
581 struct buffer *b = XBUFFER (w->buffer);
582 struct buffer *old_b = window_display_buffer (w);
583 struct display_line *cdl, *ddl;
584 display_block_dynarr *cdba, *ddba;
585 int start_pixpos, end_pixpos;
586 int cursor_start, cursor_width, cursor_height;
588 int force = (force_start >= 0 || force_end >= 0);
589 int clear_border = 0;
592 if (cdla && line < Dynarr_length (cdla))
594 cdl = Dynarr_atp (cdla, line);
595 cdba = cdl->display_blocks;
603 ddl = Dynarr_atp (ddla, line); /* assert line < Dynarr_length (ddla) */
604 ddba = ddl->display_blocks;
606 if (force_start >= 0 && force_start >= ddl->bounds.left_out)
607 start_pixpos = force_start;
609 start_pixpos = ddl->bounds.left_out;
611 if (force_end >= 0 && force_end < ddl->bounds.right_out)
612 end_pixpos = force_end;
614 end_pixpos = ddl->bounds.right_out;
616 /* Get the cursor parameters. */
617 if (ddl->cursor_elt != -1)
619 struct display_block *db;
621 /* If the lines cursor parameter is not -1 then it indicates
622 which rune in the TEXT block contains the cursor. This means
623 that there must be at least one display block. The TEXT
624 block, if present, must always be the first display block. */
625 assert (Dynarr_length (ddba) != 0);
627 db = Dynarr_atp (ddba, 0);
628 assert (db->type == TEXT);
630 get_cursor_size_and_location (w, db, ddl->cursor_elt, &cursor_start,
631 &cursor_width, &cursor_height);
635 cursor_start = cursor_width = cursor_height = 0;
638 /* The modeline should only have a single block and it had better be
642 /* The shadow thickness check is necessary if only the sign of
644 if (cdba && !w->shadow_thickness_changed)
646 must_sync |= compare_display_blocks (w, cdl, ddl, 0, 0,
647 start_pixpos, 0, 0, 0);
651 redisplay_output_display_block (w, ddl, 0, 0, -1, start_pixpos,
660 while (!ddl->modeline && start_pixpos < end_pixpos)
663 int next_start_pixpos;
665 block = get_next_display_block (ddl->bounds, ddba, start_pixpos,
668 /* If we didn't find a block then we should blank the area
669 between start_pos and next_start if necessary. */
670 if (block == NO_BLOCK)
672 /* We only erase those areas which were actually previously
673 covered by a display block unless the window structure
674 changed. In that case we clear all areas since the current
675 structures may actually represent a different buffer. */
676 while (start_pixpos < next_start_pixpos)
682 old_block = get_next_display_block (ddl->bounds, cdba,
683 start_pixpos, &block_end);
686 old_block = NO_BLOCK;
687 block_end = next_start_pixpos;
690 if (!cdba || old_block != NO_BLOCK || b != old_b ||
691 f->windows_structure_changed ||
694 (cdl && (cdl->ypos != ddl->ypos ||
695 cdl->ascent != ddl->ascent ||
696 cdl->descent != ddl->descent ||
697 cdl->top_clip != ddl->top_clip ||
698 cdl->clip != ddl->clip)))
700 int x, y, width, height;
705 y = DISPLAY_LINE_YPOS (ddl);
706 width = min (next_start_pixpos, block_end) - x;
707 height = DISPLAY_LINE_HEIGHT (ddl);
709 if (x < ddl->bounds.left_in)
711 findex = ddl->left_margin_findex ?
712 ddl->left_margin_findex
713 : get_builtin_face_cache_index (w, Vleft_margin_face);
715 else if (x < ddl->bounds.right_in)
717 /* no check here because DEFAULT_INDEX == 0 anyway */
718 findex = ddl->default_findex;
720 else if (x < ddl->bounds.right_out)
722 findex = ddl->right_margin_findex ?
723 ddl->right_margin_findex
724 : get_builtin_face_cache_index (w, Vright_margin_face);
727 findex = (face_index) -1;
729 if (findex != (face_index) -1)
733 XSETWINDOW (window, w);
735 /* Clear the empty area. */
736 redisplay_clear_region (window, findex, x, y, width, height);
738 /* Mark that we should clear the border. This is
739 necessary because italic fonts may leave
740 droppings in the border. */
745 start_pixpos = min (next_start_pixpos, block_end);
750 struct display_block *cdb, *ddb;
755 old_block = get_next_display_block (ddl->bounds, cdba,
756 start_pixpos, &block_end);
758 old_block = NO_BLOCK;
760 ddb = Dynarr_atp (ddba, block);
761 cdb = (old_block != NO_BLOCK ? Dynarr_atp (cdba, old_block) : 0);
763 /* If there was formerly no block over the current
764 region or if it was a block of a different type, then
765 output the entire ddb. Otherwise, compare cdb and
766 ddb and output only the changed region. */
767 if (!force && cdb && ddb->type == cdb->type
768 /* If there was no buffer being display before the
769 compare anyway as we might be outputting a gutter. */
771 (b == old_b || !old_b))
773 must_sync |= compare_display_blocks (w, cdl, ddl, old_block,
775 cursor_start, cursor_width,
784 for (elt = 0; elt < Dynarr_length (ddb->runes); elt++)
786 struct rune *rb = Dynarr_atp (ddb->runes, elt);
788 if (start_pixpos >= rb->xpos
789 && start_pixpos < rb->xpos + rb->width)
792 if (end_pixpos > rb->xpos
793 && end_pixpos <= rb->xpos + rb->width)
796 if (last_elt > Dynarr_length (ddb->runes))
797 last_elt = Dynarr_length (ddb->runes);
803 redisplay_output_display_block (w, ddl, block, first_elt,
806 cursor_start, cursor_width,
810 start_pixpos = next_start_pixpos;
814 /* Clear the internal border if we are next to it and the window
815 structure or frame size has changed or if something caused
816 clear_border to be tripped. */
817 /* #### Doing this on f->clear sucks but is necessary because of
818 window-local background values. */
819 if (f->windows_structure_changed || f->faces_changed || clear_border
822 int y = DISPLAY_LINE_YPOS (ddl);
823 int height = DISPLAY_LINE_HEIGHT (ddl);
825 /* If we are in the gutter then we musn't clear the borders. */
826 if (y >= WINDOW_TEXT_TOP (w) && (y + height) <= WINDOW_TEXT_BOTTOM (w))
830 y -= MODELINE_SHADOW_THICKNESS (w);
831 height += (2 * MODELINE_SHADOW_THICKNESS (w));
834 if (window_is_leftmost (w))
835 clear_left_border (w, y, height);
836 if (window_is_rightmost (w))
837 clear_right_border (w, y, height);
842 sync_display_line_structs (w, line, must_sync, cdla, ddla);
845 /*****************************************************************************
846 redisplay_move_cursor
848 For the given window W, move the cursor to NEW_POINT. Returns a
849 boolean indicating success or failure.
850 ****************************************************************************/
852 #define ADJ_BUFPOS (rb->bufpos + dl->offset)
853 #define ADJ_ENDPOS (rb->endpos + dl->offset)
856 redisplay_move_cursor (struct window *w, Bufpos new_point, int no_output_end)
858 struct frame *f = XFRAME (w->frame);
859 struct device *d = XDEVICE (f->device);
861 display_line_dynarr *cla = window_display_lines (w, CURRENT_DISP);
862 struct display_line *dl;
863 struct display_block *db;
865 int x = w->last_point_x[CURRENT_DISP];
866 int y = w->last_point_y[CURRENT_DISP];
869 * Bail if cursor_in_echo_area is non-zero and we're fiddling with
870 * the cursor in a non-active minibuffer window, since that is a
871 * special case that is handled elsewhere and this function need
872 * not handle it. Return 1 so the caller will assume we
875 if (cursor_in_echo_area && MINI_WINDOW_P (w) &&
876 w != XWINDOW (FRAME_SELECTED_WINDOW (f)))
879 if (y < 0 || y >= Dynarr_length (cla))
882 dl = Dynarr_atp (cla, y);
883 db = get_display_block_from_line (dl, TEXT);
885 if (x < 0 || x >= Dynarr_length (db->runes))
888 rb = Dynarr_atp (db->runes, x);
890 if (rb->cursor_type == CURSOR_OFF)
892 else if (ADJ_BUFPOS == new_point
893 || (ADJ_ENDPOS && (new_point >= ADJ_BUFPOS)
894 && (new_point <= ADJ_ENDPOS)))
896 w->last_point_x[CURRENT_DISP] = x;
897 w->last_point_y[CURRENT_DISP] = y;
898 Fset_marker (w->last_point[CURRENT_DISP], make_int (ADJ_BUFPOS),
906 MAYBE_DEVMETH (d, frame_output_begin, (f));
907 MAYBE_DEVMETH (d, window_output_begin, (w));
909 rb->cursor_type = CURSOR_OFF;
911 output_display_line (w, 0, cla, y, rb->xpos, rb->xpos + rb->width);
914 w->last_point_x[CURRENT_DISP] = -1;
915 w->last_point_y[CURRENT_DISP] = -1;
916 Fset_marker (w->last_point[CURRENT_DISP], Qnil, w->buffer);
918 /* If this isn't the selected frame, then erasing the old cursor is
919 all we actually had to do. */
920 if (w != XWINDOW (FRAME_SELECTED_WINDOW (device_selected_frame (d))))
924 MAYBE_DEVMETH (d, window_output_end, (w));
925 MAYBE_DEVMETH (d, frame_output_end, (f));
931 /* This should only occur in the minibuffer. */
934 w->last_point_x[CURRENT_DISP] = 0;
935 w->last_point_y[CURRENT_DISP] = y;
936 Fset_marker (w->last_point[CURRENT_DISP], Qzero, w->buffer);
938 rb = Dynarr_atp (db->runes, 0);
939 rb->cursor_type = CURSOR_ON;
942 output_display_line (w, 0, cla, y, rb->xpos, rb->xpos + rb->width);
946 MAYBE_DEVMETH (d, window_output_end, (w));
947 MAYBE_DEVMETH (d, frame_output_end, (f));
957 if (ADJ_BUFPOS < new_point)
963 else /* (rb->bufpos + dl->offset) > new_point */
980 while (up ? (cur_dl < Dynarr_length (cla)) : (cur_dl >= 0))
982 dl = Dynarr_atp (cla, cur_dl);
983 db = get_display_block_from_line (dl, TEXT);
986 cur_rb = Dynarr_length (db->runes) - 1;
988 while ((!scroll_on_clipped_lines || !dl->clip) &&
989 (up ? (cur_rb < Dynarr_length (db->runes)) : (cur_rb >= 0)))
991 rb = Dynarr_atp (db->runes, cur_rb);
993 if (rb->cursor_type != IGNORE_CURSOR
994 && rb->cursor_type != NO_CURSOR &&
995 (ADJ_BUFPOS == new_point
996 || (ADJ_ENDPOS && (new_point >= ADJ_BUFPOS)
997 && (new_point <= ADJ_BUFPOS))))
999 rb->cursor_type = CURSOR_ON;
1000 dl->cursor_elt = cur_rb;
1003 output_display_line (w, 0, cla, cur_dl, rb->xpos,
1004 rb->xpos + rb->width);
1006 w->last_point_x[CURRENT_DISP] = cur_rb;
1007 w->last_point_y[CURRENT_DISP] = cur_dl;
1008 Fset_marker (w->last_point[CURRENT_DISP],
1009 make_int (ADJ_BUFPOS), w->buffer);
1013 MAYBE_DEVMETH (d, window_output_end, (w));
1014 MAYBE_DEVMETH (d, frame_output_end, (f));
1019 (up ? cur_rb++ : cur_rb--);
1022 (up ? (cur_rb = 0) : (first = 0));
1023 (up ? cur_dl++ : cur_dl--);
1029 MAYBE_DEVMETH (d, window_output_end, (w));
1030 MAYBE_DEVMETH (d, frame_output_end, (f));
1037 /*****************************************************************************
1038 redraw_cursor_in_window
1040 For the given window W, redraw the cursor if it is contained within
1042 ****************************************************************************/
1044 redraw_cursor_in_window (struct window *w, int run_end_begin_meths)
1046 struct frame *f = XFRAME (w->frame);
1047 struct device *d = XDEVICE (f->device);
1049 display_line_dynarr *dla = window_display_lines (w, CURRENT_DISP);
1050 struct display_line *dl;
1051 struct display_block *db;
1054 int x = w->last_point_x[CURRENT_DISP];
1055 int y = w->last_point_y[CURRENT_DISP];
1057 if (cursor_in_echo_area && MINI_WINDOW_P (w) &&
1058 !echo_area_active (f) && minibuf_level == 0)
1060 MAYBE_DEVMETH (d, set_final_cursor_coords, (f, w->pixel_top, 0));
1063 if (y < 0 || y >= Dynarr_length (dla))
1066 if (MINI_WINDOW_P (w) && f != device_selected_frame (d) &&
1067 !is_surrogate_for_selected_frame (f))
1070 dl = Dynarr_atp (dla, y);
1071 db = get_display_block_from_line (dl, TEXT);
1073 if (x < 0 || x >= Dynarr_length (db->runes))
1076 rb = Dynarr_atp (db->runes, x);
1078 /* Don't call the output routine if the block isn't actually the
1080 if (rb->cursor_type == CURSOR_ON)
1082 MAYBE_DEVMETH (d, set_final_cursor_coords,
1083 (f, dl->ypos - 1, rb->xpos));
1085 if (run_end_begin_meths)
1087 MAYBE_DEVMETH (d, frame_output_begin, (f));
1088 MAYBE_DEVMETH (d, window_output_begin, (w));
1091 output_display_line (w, 0, dla, y, rb->xpos, rb->xpos + rb->width);
1093 if (run_end_begin_meths)
1095 MAYBE_DEVMETH (d, window_output_end, (w));
1096 MAYBE_DEVMETH (d, frame_output_end, (f));
1101 /*****************************************************************************
1102 redisplay_redraw_cursor
1104 For the given frame F, redraw the cursor on the selected window.
1105 This is used to update the cursor after focus changes.
1106 ****************************************************************************/
1108 redisplay_redraw_cursor (struct frame *f, int run_end_begin_meths)
1112 if (!cursor_in_echo_area)
1113 window = FRAME_SELECTED_WINDOW (f);
1114 else if (FRAME_HAS_MINIBUF_P (f))
1115 window = FRAME_MINIBUF_WINDOW (f);
1119 redraw_cursor_in_window (XWINDOW (window), run_end_begin_meths);
1122 /****************************************************************************
1123 redisplay_output_display_block
1125 Given a display line, a block number for that start line, output all
1126 runes between start and end in the specified display block.
1127 ****************************************************************************/
1129 redisplay_output_display_block (struct window *w, struct display_line *dl, int block,
1130 int start, int end, int start_pixpos, int cursor_start,
1131 int cursor_width, int cursor_height)
1133 struct frame *f = XFRAME (w->frame);
1134 struct device *d = XDEVICE (f->device);
1135 /* Temporarily disabled until generalization is done. */
1137 struct display_block *db = Dynarr_atp (dl->display_blocks, block);
1138 rune_dynarr *rba = db->runes;
1141 rb = Dynarr_atp (rba, start);
1144 /* Nothing to do so don't do anything. */
1147 xpos = max (start_pixpos, rb->xpos);
1150 end = Dynarr_length (rba);
1152 rb = Dynarr_atp (rba, end - 1);
1153 width = rb->xpos + rb->width - xpos;
1155 /* now actually output the block. */
1156 DEVMETH (d, output_display_block, (w, dl, block, start,
1158 cursor_start, cursor_width,
1162 /****************************************************************************
1163 redisplay_unmap_subwindows
1165 Remove subwindows from the area in the box defined by the given
1167 ****************************************************************************/
1169 redisplay_unmap_subwindows (struct frame* f, int x, int y, int width, int height,
1170 Lisp_Object ignored_window)
1174 LIST_LOOP (rest, XWEAK_LIST_LIST (FRAME_SUBWINDOW_CACHE (f)))
1176 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (XCAR (rest));
1177 if (IMAGE_INSTANCE_SUBWINDOW_DISPLAYEDP (ii)
1179 IMAGE_INSTANCE_DISPLAY_X (ii)
1180 + IMAGE_INSTANCE_DISPLAY_WIDTH (ii) > (unsigned) x
1182 IMAGE_INSTANCE_DISPLAY_X (ii) < (unsigned) (x + width)
1184 IMAGE_INSTANCE_DISPLAY_Y (ii)
1185 + IMAGE_INSTANCE_DISPLAY_HEIGHT (ii) > (unsigned) y
1187 IMAGE_INSTANCE_DISPLAY_Y (ii) < (unsigned) (y + height)
1189 !EQ (XCAR (rest), ignored_window))
1191 unmap_subwindow (XCAR (rest));
1196 /****************************************************************************
1197 redisplay_unmap_subwindows_maybe
1199 Potentially subwindows from the area in the box defined by the given
1201 ****************************************************************************/
1202 void redisplay_unmap_subwindows_maybe (struct frame* f, int x, int y, int width, int height)
1204 if (!NILP (XWEAK_LIST_LIST (FRAME_SUBWINDOW_CACHE (f))))
1206 redisplay_unmap_subwindows (f, x, y, width, height, Qnil);
1210 static void redisplay_unmap_subwindows_except_us (struct frame* f, int x, int y, int width,
1211 int height, Lisp_Object subwindow)
1213 if (!NILP (XWEAK_LIST_LIST (FRAME_SUBWINDOW_CACHE (f))))
1215 redisplay_unmap_subwindows (f, x, y, width, height, subwindow);
1219 /****************************************************************************
1220 redisplay_output_subwindow
1222 output a subwindow. This code borrows heavily from the pixmap stuff,
1223 although is much simpler not needing to account for partial
1224 pixmaps, backgrounds etc.
1225 ****************************************************************************/
1227 redisplay_output_subwindow (struct window *w,
1228 Lisp_Object image_instance,
1229 struct display_box* db, struct display_glyph_area* dga,
1230 face_index findex, int cursor_start, int cursor_width,
1233 Lisp_Image_Instance *p = XIMAGE_INSTANCE (image_instance);
1235 struct display_glyph_area sdga;
1237 dga->height = IMAGE_INSTANCE_HEIGHT (p);
1238 dga->width = IMAGE_INSTANCE_WIDTH (p);
1240 /* The first thing we are going to do is update the display
1241 characteristics of the subwindow. This also clears the dirty
1242 flags as a side effect. */
1243 redisplay_subwindow (image_instance);
1245 /* This makes the glyph area fit into the display area. */
1246 if (!redisplay_normalize_glyph_area (db, dga))
1249 XSETWINDOW (window, w);
1251 /* Clear the area the subwindow is going into. */
1252 redisplay_clear_clipped_region (window, findex,
1253 db, dga, 0, image_instance);
1255 /* This shrinks the display box to exactly enclose the glyph
1257 redisplay_normalize_display_box (db, dga);
1259 /* if we can't view the whole window we can't view any of it. We
1260 have to be careful here since we may be being asked to display
1261 part of a subwindow, the rest of which is on-screen as well. We
1262 need to allow this case and map the entire subwindow. We also
1263 need to be careful since the subwindow could be outside the
1264 window in the gutter or modeline - we also need to allow these
1266 sdga.xoffset = -dga->xoffset;
1267 sdga.yoffset = -dga->yoffset;
1268 sdga.height = IMAGE_INSTANCE_HEIGHT (p);
1269 sdga.width = IMAGE_INSTANCE_WIDTH (p);
1271 if (redisplay_display_boxes_in_window_p (w, db, &sdga) == 0
1273 /* We only want to do full subwindow display for windows that
1274 are completely in the gutter, otherwise we must clip to be
1276 display_boxes_in_gutter_p (XFRAME (w->frame), db, &sdga) <= 0)
1278 map_subwindow (image_instance, db->xpos, db->ypos, dga);
1282 sdga.xoffset = sdga.yoffset = 0;
1283 map_subwindow (image_instance, db->xpos - dga->xoffset,
1284 db->ypos - dga->yoffset, &sdga);
1288 /****************************************************************************
1289 redisplay_output_layout
1291 Output a widget hierarchy. This can safely call itself recursively.
1293 The complexity of outputting layouts is deciding whether to do it or
1294 not. Consider a layout enclosing some text, the text changes and is
1295 marked as dirty, but the enclosing layout has not been marked as
1296 dirty so no updates occur and the text will potentially be truncated.
1297 Alternatively we hold a back pointer in the image instance to the
1298 parent and mark the parent as dirty. But the layout code assumes that
1299 if the layout is dirty then the whole layout should be redisplayed,
1300 so we then get lots of flashing even though only the text has changed
1301 size. Of course if the text shrinks in size then we do actually need
1302 to redisplay the layout to repaint the exposed area. So what happens
1303 if we make a non-structural change like changing color? Either we
1304 redisplay everything, or we redisplay nothing. These are exactly the
1305 issues lwlib has to grapple with. We really need to know what has
1306 actually changed and make a layout decision based on that. We also
1307 really need to know what has changed so that we can only make the
1308 necessary changes in update_subwindow. This has all now been
1309 implemented, Viva la revolution!
1310 ****************************************************************************/
1312 redisplay_output_layout (Lisp_Object domain,
1313 Lisp_Object image_instance,
1314 struct display_box* db, struct display_glyph_area* dga,
1315 face_index findex, int cursor_start, int cursor_width,
1318 Lisp_Image_Instance *p = XIMAGE_INSTANCE (image_instance);
1319 Lisp_Object rest, window = DOMAIN_WINDOW (domain);
1320 Emchar_dynarr *buf = Dynarr_new (Emchar);
1321 struct window *w = XWINDOW (window);
1322 struct device *d = DOMAIN_XDEVICE (domain);
1323 int layout_height, layout_width;
1325 layout_height = glyph_height (image_instance, domain);
1326 layout_width = glyph_width (image_instance, domain);
1328 dga->height = layout_height;
1329 dga->width = layout_width;
1330 #ifdef DEBUG_WIDGET_OUTPUT
1331 printf ("outputing layout glyph %p\n", p);
1333 /* This makes the glyph area fit into the display area. */
1334 if (!redisplay_normalize_glyph_area (db, dga))
1337 /* Highly dodgy optimization. We want to only output the whole
1338 layout if we really have to. */
1339 if (!IMAGE_INSTANCE_OPTIMIZE_OUTPUT (p)
1340 || IMAGE_INSTANCE_LAYOUT_CHANGED (p)
1341 || IMAGE_INSTANCE_WIDGET_FACE_CHANGED (p)
1342 || IMAGE_INSTANCE_SIZE_CHANGED (p)
1343 || IMAGE_INSTANCE_WIDGET_ITEMS_CHANGED (p))
1345 /* First clear the area we are drawing into. This is the easiest
1346 thing to do since we have many gaps that we have to make sure are
1348 redisplay_clear_clipped_region (window, findex, db, dga, 1, Qnil);
1350 /* Output a border if required */
1351 if (!NILP (IMAGE_INSTANCE_LAYOUT_BORDER (p)))
1354 enum edge_style style;
1355 int ypos = db->ypos;
1356 int xpos = db->xpos;
1357 int height = dga->height;
1358 int width = dga->width;
1360 /* The bevel_area routines always draw in from the specified
1361 area so there is no need to adjust the displayed area to
1362 make sure that the lines are visible. */
1363 if (dga->xoffset >= 0)
1365 if (dga->width - dga->xoffset == layout_width)
1366 edges |= EDGE_RIGHT;
1367 if (dga->yoffset >= 0)
1369 if (dga->height - dga->yoffset == layout_height)
1370 edges |= EDGE_BOTTOM;
1372 if (EQ (IMAGE_INSTANCE_LAYOUT_BORDER (p), Qetched_in))
1373 style = EDGE_ETCHED_IN;
1374 else if (EQ (IMAGE_INSTANCE_LAYOUT_BORDER (p), Qetched_out))
1375 style = EDGE_ETCHED_OUT;
1376 else if (EQ (IMAGE_INSTANCE_LAYOUT_BORDER (p), Qbevel_in))
1377 style = EDGE_BEVEL_IN;
1378 else if (INTP (IMAGE_INSTANCE_LAYOUT_BORDER (p)))
1380 style = EDGE_ETCHED_IN;
1381 if (edges & EDGE_TOP)
1383 ypos += XINT (IMAGE_INSTANCE_LAYOUT_BORDER (p));
1384 height -= XINT (IMAGE_INSTANCE_LAYOUT_BORDER (p));
1388 style = EDGE_BEVEL_OUT;
1390 MAYBE_DEVMETH (d, bevel_area,
1391 (w, findex, xpos, ypos, width, height,
1392 DEFAULT_WIDGET_SHADOW_WIDTH, edges, style));
1396 /* This shrinks the display box to exactly enclose the glyph
1398 redisplay_normalize_display_box (db, dga);
1400 /* Flip through the widgets in the layout displaying as necessary */
1401 LIST_LOOP (rest, IMAGE_INSTANCE_LAYOUT_CHILDREN (p))
1403 Lisp_Object child = glyph_image_instance (XCAR (rest), image_instance,
1406 struct display_box cdb;
1407 /* For losing HP-UX */
1408 cdb.xpos = db->xpos;
1409 cdb.ypos = db->ypos;
1410 cdb.width = db->width;
1411 cdb.height = db->height;
1413 /* First determine if the image is visible at all */
1414 if (IMAGE_INSTANCEP (child))
1416 Lisp_Image_Instance* childii = XIMAGE_INSTANCE (child);
1418 /* The enclosing layout offsets are +ve at this point */
1419 struct display_glyph_area cdga;
1420 cdga.xoffset = IMAGE_INSTANCE_XOFFSET (childii) - dga->xoffset;
1421 cdga.yoffset = IMAGE_INSTANCE_YOFFSET (childii) - dga->yoffset;
1422 cdga.width = glyph_width (child, image_instance);
1423 cdga.height = glyph_height (child, image_instance);
1425 IMAGE_INSTANCE_OPTIMIZE_OUTPUT (childii) =
1426 IMAGE_INSTANCE_OPTIMIZE_OUTPUT (p);
1428 /* Although normalization is done by the output routines
1429 we have to do it here so that they don't try and
1430 clear all of db. This is true below also. */
1431 if (redisplay_normalize_glyph_area (&cdb, &cdga))
1433 redisplay_normalize_display_box (&cdb, &cdga);
1434 /* Since the display boxes will now be totally in the
1435 window if they are visible at all we can now check this easily. */
1436 if (cdb.xpos < db->xpos || cdb.ypos < db->ypos
1437 || cdb.xpos + cdb.width > db->xpos + db->width
1438 || cdb.ypos + cdb.height > db->ypos + db->height)
1440 /* We have to invert the offset here as normalization
1441 will have made them positive which the output
1442 routines will treat as a truly +ve offset. */
1443 cdga.xoffset = -cdga.xoffset;
1444 cdga.yoffset = -cdga.yoffset;
1446 switch (IMAGE_INSTANCE_TYPE (childii))
1450 /* #### This is well hacked and could use some
1452 if (redisplay_normalize_glyph_area (&cdb, &cdga)
1454 (!IMAGE_INSTANCE_OPTIMIZE_OUTPUT (childii) ||
1455 IMAGE_INSTANCE_DIRTYP (childii)))
1457 struct display_line dl; /* this is fake */
1458 Lisp_Object string =
1459 IMAGE_INSTANCE_TEXT_STRING (childii);
1460 unsigned char charsets[NUM_LEADING_BYTES];
1461 struct face_cachel *cachel = WINDOW_FACE_CACHEL (w, findex);
1463 find_charsets_in_bufbyte_string (charsets,
1464 XSTRING_DATA (string),
1465 XSTRING_LENGTH (string));
1466 ensure_face_cachel_complete (cachel, window, charsets);
1468 convert_bufbyte_string_into_emchar_dynarr
1469 (XSTRING_DATA (string), XSTRING_LENGTH (string), buf);
1471 redisplay_normalize_display_box (&cdb, &cdga);
1472 /* Offsets are now +ve again so be careful
1473 when fixing up the display line. */
1475 /* Munge boxes into display lines. */
1476 dl.ypos = (cdb.ypos - cdga.yoffset)
1477 + glyph_ascent (child, image_instance);
1478 dl.ascent = glyph_ascent (child, image_instance);
1479 dl.descent = glyph_descent (child, image_instance);
1480 dl.top_clip = cdga.yoffset;
1481 dl.clip = (dl.ypos + dl.descent) - (cdb.ypos + cdb.height);
1482 /* output_string doesn't understand offsets in
1483 the same way as other routines - we have to
1484 add the offset to the width so that we
1485 output the full string. */
1486 MAYBE_DEVMETH (d, output_string, (w, &dl, buf, cdb.xpos,
1487 cdga.xoffset, cdb.xpos,
1488 cdga.width + cdga.xoffset,
1489 findex, 0, 0, 0, 0));
1495 case IMAGE_MONO_PIXMAP:
1496 case IMAGE_COLOR_PIXMAP:
1497 if (!IMAGE_INSTANCE_OPTIMIZE_OUTPUT (childii)
1498 || IMAGE_INSTANCE_DIRTYP (childii))
1499 redisplay_output_pixmap (w, child, &cdb, &cdga, findex,
1504 if (EQ (IMAGE_INSTANCE_WIDGET_TYPE (childii), Qlayout))
1506 redisplay_output_layout (image_instance, child, &cdb, &cdga, findex,
1510 case IMAGE_SUBWINDOW:
1511 if (!IMAGE_INSTANCE_OPTIMIZE_OUTPUT (childii) ||
1512 IMAGE_INSTANCE_DIRTYP (childii))
1513 redisplay_output_subwindow (w, child, &cdb, &cdga, findex,
1518 /* nothing is as nothing does */
1526 IMAGE_INSTANCE_OPTIMIZE_OUTPUT (childii) = 0;
1530 /* Update any display properties. I'm not sure whether this actually
1531 does anything for layouts except clear the changed flags. */
1532 redisplay_subwindow (image_instance);
1537 /****************************************************************************
1538 redisplay_output_pixmap
1542 ****************************************************************************/
1544 redisplay_output_pixmap (struct window *w,
1545 Lisp_Object image_instance,
1546 struct display_box* db, struct display_glyph_area* dga,
1547 face_index findex, int cursor_start, int cursor_width,
1548 int cursor_height, int offset_bitmap)
1550 struct frame *f = XFRAME (w->frame);
1551 struct device *d = XDEVICE (f->device);
1552 Lisp_Image_Instance *p = XIMAGE_INSTANCE (image_instance);
1554 XSETWINDOW (window, w);
1556 dga->height = IMAGE_INSTANCE_PIXMAP_HEIGHT (p);
1557 dga->width = IMAGE_INSTANCE_PIXMAP_WIDTH (p);
1559 #ifdef DEBUG_REDISPLAY
1560 printf ("redisplay_output_pixmap(request) \
1561 [%dx%d@%d+%d] in [%dx%d@%d+%d]\n",
1562 db->width, db->height, db->xpos, db->ypos,
1563 dga->width, dga->height, dga->xoffset, dga->yoffset);
1566 /* This makes the glyph area fit into the display area. */
1567 if (!redisplay_normalize_glyph_area (db, dga))
1570 #ifdef DEBUG_REDISPLAY
1571 printf ("redisplay_output_pixmap(normalized) \
1572 [%dx%d@%d+%d] in [%dx%d@%d+%d]\n",
1573 db->width, db->height, db->xpos, db->ypos,
1574 dga->width, dga->height, dga->xoffset, dga->yoffset);
1577 /* Clear the area the pixmap is going into. The pixmap itself will
1578 always take care of the full width. We don't want to clear where
1579 it is going to go in order to avoid flicker. So, all we have to
1580 take care of is any area above or below the pixmap. If the pixmap
1581 has a mask in which case we have to clear the whole damn thing
1582 since we can't yet clear just the area not included in the
1586 redisplay_clear_clipped_region (window, findex,
1588 (IMAGE_INSTANCE_PIXMAP_MASK (p) != 0),
1591 /* This shrinks the display box to exactly enclose the glyph
1593 redisplay_normalize_display_box (db, dga);
1595 assert (db->xpos >= 0 && db->ypos >= 0);
1597 MAYBE_DEVMETH (d, output_pixmap, (w, image_instance,
1599 findex, cursor_start,
1600 cursor_width, cursor_height,
1604 /****************************************************************************
1605 redisplay_clear_region
1607 Clear the area in the box defined by the given parameters using the
1608 given face. This has been generalised so that subwindows can be
1609 coped with effectively.
1610 ****************************************************************************/
1612 redisplay_clear_region (Lisp_Object locale, face_index findex, int x, int y,
1613 int width, int height)
1615 struct window *w = NULL;
1616 struct frame *f = NULL;
1618 Lisp_Object background_pixmap = Qunbound;
1619 Lisp_Object fcolor = Qnil, bcolor = Qnil;
1621 if (!width || !height)
1624 if (WINDOWP (locale))
1626 w = XWINDOW (locale);
1627 f = XFRAME (w->frame);
1629 else if (FRAMEP (locale))
1632 f = XFRAME (locale);
1637 d = XDEVICE (f->device);
1639 /* if we have subwindows in the region we have to unmap them */
1640 redisplay_unmap_subwindows_maybe (f, x, y, width, height);
1642 /* #### This isn't quite right for when this function is called
1643 from the toolbar code. */
1645 /* Don't use a backing pixmap in the border area */
1646 if (x >= FRAME_LEFT_BORDER_END (f)
1647 && x < FRAME_RIGHT_BORDER_START (f)
1648 && y >= FRAME_TOP_BORDER_END (f)
1649 && y < FRAME_BOTTOM_BORDER_START (f))
1655 temp = WINDOW_FACE_CACHEL_BACKGROUND_PIXMAP (w, findex);
1657 if (IMAGE_INSTANCEP (temp)
1658 && IMAGE_INSTANCE_PIXMAP_TYPE_P (XIMAGE_INSTANCE (temp)))
1660 /* #### maybe we could implement such that a string
1661 can be a background pixmap? */
1662 background_pixmap = temp;
1667 temp = FACE_BACKGROUND_PIXMAP (Vdefault_face, locale);
1669 if (IMAGE_INSTANCEP (temp)
1670 && IMAGE_INSTANCE_PIXMAP_TYPE_P (XIMAGE_INSTANCE (temp)))
1672 background_pixmap = temp;
1677 if (!UNBOUNDP (background_pixmap) &&
1678 XIMAGE_INSTANCE_PIXMAP_DEPTH (background_pixmap) == 0)
1682 fcolor = WINDOW_FACE_CACHEL_FOREGROUND (w, findex);
1683 bcolor = WINDOW_FACE_CACHEL_BACKGROUND (w, findex);
1687 fcolor = FACE_FOREGROUND (Vdefault_face, locale);
1688 bcolor = FACE_BACKGROUND (Vdefault_face, locale);
1694 WINDOW_FACE_CACHEL_BACKGROUND (w, findex) :
1695 FACE_BACKGROUND (Vdefault_face, locale));
1699 if (UNBOUNDP (background_pixmap))
1700 background_pixmap = Qnil;
1702 DEVMETH (d, clear_region,
1703 (locale, d, f, findex, x, y, width, height, fcolor, bcolor, background_pixmap));
1706 /****************************************************************************
1707 redisplay_clear_clipped_region
1709 Clear the area in the dest display_box not covered by the src
1710 display_glyph_area using the given face. This is a common occurrence
1711 for images shorter than the display line. Clipping can be played
1712 around with by altering these. glyphsrc should be normalized.
1713 ****************************************************************************/
1715 redisplay_clear_clipped_region (Lisp_Object window, face_index findex,
1716 struct display_box* dest, struct display_glyph_area* glyphsrc,
1717 int fullheight_p, Lisp_Object ignored_subwindow)
1719 /* assume dest->xpos >= 0 */
1721 struct frame* f = XFRAME (XWINDOW (window)->frame);
1723 if (glyphsrc->xoffset > 0)
1725 clear_x = dest->xpos + glyphsrc->xoffset;
1729 clear_x = dest->xpos;
1732 /* If we need the whole height cleared then just do it. */
1735 redisplay_clear_region (window, findex, clear_x, dest->ypos,
1736 glyphsrc->width, dest->height);
1740 int yoffset = (glyphsrc->yoffset > 0 ? glyphsrc->yoffset : 0);
1742 /* We need to make sure that subwindows are unmapped from the
1744 redisplay_unmap_subwindows_except_us (f, clear_x, dest->ypos,
1745 glyphsrc->width, dest->height,
1747 /* first the top box */
1750 redisplay_clear_region (window, findex, clear_x, dest->ypos,
1751 glyphsrc->width, yoffset);
1754 /* Then the bottom box */
1755 if (yoffset + glyphsrc->height < dest->height)
1757 redisplay_clear_region (window, findex, clear_x,
1758 dest->ypos + yoffset + glyphsrc->height,
1760 dest->height - (yoffset + glyphsrc->height));
1766 /*****************************************************************************
1767 redisplay_normalize_glyph_area
1768 redisplay_normalize_display_box
1770 Calculate the visible box for displaying glyphsrc in dest.
1772 display_box and display_glyph_area are used to represent an area to
1773 displayed and where to display it. Using these two structures all
1774 combinations of clipping and position can be accommodated.
1778 xpos - absolute horizontal position of area.
1780 ypos - absolute vertical position of area.
1782 glyphsrc - display_glyph_area
1784 xoffset - horizontal offset of the glyph, +ve means display
1785 the glyph with the x position offset by xoffset, -ve means
1786 display starting xoffset into the glyph.
1788 yoffset - vertical offset of the glyph, +ve means display the
1789 glyph with y position offset by yoffset, -ve means display
1790 starting xoffset into the glyph.
1792 ****************************************************************************/
1794 redisplay_normalize_glyph_area (struct display_box* dest,
1795 struct display_glyph_area* glyphsrc)
1797 if (dest->xpos + glyphsrc->xoffset > dest->xpos + dest->width
1799 dest->ypos + glyphsrc->yoffset > dest->ypos + dest->height
1801 -glyphsrc->xoffset >= glyphsrc->width
1803 -glyphsrc->yoffset >= glyphsrc->height
1805 /* #### Not sure why this wasn't coped with before but normalizing
1806 to zero width or height is definitely wrong. */
1807 (dest->xpos + glyphsrc->xoffset + glyphsrc->width > dest->xpos + dest->width
1809 dest->width - glyphsrc->xoffset <= 0)
1811 (dest->ypos + glyphsrc->yoffset + glyphsrc->height > dest->ypos + dest->height
1813 dest->height - glyphsrc->yoffset <= 0))
1815 /* It's all clipped out */
1819 /* Horizontal offsets. This works because xoffset can be -ve as well
1820 as +ve. When we enter this function the glyphsrc width and
1821 height are set to the actual glyph width and height irrespective
1822 of how much can be displayed. We are trying to clip both the
1823 offset into the image and the rightmost bounding box. Its
1824 possible for the glyph width to be much larger than the area we
1825 are displaying into (e.g. a large glyph in a small frame). */
1826 if (dest->xpos + glyphsrc->xoffset + glyphsrc->width > dest->xpos + dest->width)
1828 /* glyphsrc offset is +ve we are trying to display offset from the
1829 origin (the bounding box contains some space and then the
1830 glyph). At most the width we want to display is dest->width -
1831 glyphsrc->xoffset. */
1832 if (glyphsrc->xoffset > 0)
1833 glyphsrc->width = dest->width - glyphsrc->xoffset;
1834 /* glyphsrc offset is -ve we are trying to display hard up
1835 against the dest corner inset into the glyphsrc by
1837 else if (glyphsrc->xoffset < 0)
1839 glyphsrc->width += glyphsrc->xoffset;
1840 glyphsrc->width = min (glyphsrc->width, dest->width);
1843 glyphsrc->width = dest->width;
1846 else if (glyphsrc->xoffset < 0)
1847 glyphsrc->width += glyphsrc->xoffset;
1849 /* Vertical offsets. This works because yoffset can be -ve as well as +ve */
1850 if (dest->ypos + glyphsrc->yoffset + glyphsrc->height > dest->ypos + dest->height)
1852 if ((glyphsrc->yoffset > 0) && (dest->height > glyphsrc->yoffset))
1853 glyphsrc->height = dest->height - glyphsrc->yoffset;
1854 else if (glyphsrc->yoffset < 0)
1856 glyphsrc->height += glyphsrc->yoffset;
1857 glyphsrc->height = min (glyphsrc->height, dest->height);
1860 glyphsrc->height = dest->height;
1863 else if (glyphsrc->yoffset < 0)
1864 glyphsrc->height += glyphsrc->yoffset;
1870 redisplay_normalize_display_box (struct display_box* dest,
1871 struct display_glyph_area* glyphsrc)
1873 /* Adjust the destination area. At the end of this the destination
1874 area will exactly enclose the glyph area. The only remaining
1875 adjustment will be offsets into the glyph area. */
1877 /* Horizontal adjustment. */
1878 if (glyphsrc->xoffset > 0)
1880 dest->xpos += glyphsrc->xoffset;
1881 dest->width -= glyphsrc->xoffset;
1882 glyphsrc->xoffset = 0;
1885 glyphsrc->xoffset = -glyphsrc->xoffset;
1887 if (glyphsrc->width < dest->width)
1888 dest->width = glyphsrc->width;
1890 /* Vertical adjustment. */
1891 if (glyphsrc->yoffset > 0)
1893 dest->ypos += glyphsrc->yoffset;
1894 dest->height -= glyphsrc->yoffset;
1895 glyphsrc->yoffset = 0;
1898 glyphsrc->yoffset = -glyphsrc->yoffset;
1900 if (glyphsrc->height < dest->height)
1901 dest->height = glyphsrc->height;
1904 /*****************************************************************************
1905 redisplay_display_boxes_in_window_p
1907 Determine whether the required display_glyph_area is completely inside
1908 the window. -1 means the display_box is not in the window. 1 means the
1909 display_box and the display_glyph_area are in the window. 0 means
1910 the display_box is in the window but the display_glyph_area is not.
1911 ****************************************************************************/
1913 redisplay_display_boxes_in_window_p (struct window* w,
1914 struct display_box* db,
1915 struct display_glyph_area* dga)
1917 int left = WINDOW_TEXT_LEFT (w);
1918 int right = WINDOW_TEXT_RIGHT (w);
1919 int top = WINDOW_TEXT_TOP (w);
1920 int bottom = WINDOW_TEXT_BOTTOM (w);
1922 if (db->xpos < left || db->ypos < top
1923 || db->xpos + db->width > right
1924 || db->ypos + db->height > bottom)
1925 /* We are not displaying in a window at all */
1928 if (db->xpos + dga->xoffset >= left
1930 db->ypos + dga->yoffset >= top
1932 db->xpos + dga->xoffset + dga->width <= right
1934 db->ypos + dga->yoffset + dga->height <= bottom)
1940 /*****************************************************************************
1941 redisplay_calculate_display_boxes
1943 Convert from rune/display_line co-ordinates to display_box
1945 ****************************************************************************/
1947 redisplay_calculate_display_boxes (struct display_line *dl, int xpos,
1948 int xoffset, int yoffset, int start_pixpos,
1949 int width, struct display_box* dest,
1950 struct display_glyph_area* src)
1953 dest->ypos = DISPLAY_LINE_YPOS (dl);
1954 dest->width = width;
1955 dest->height = DISPLAY_LINE_HEIGHT (dl);
1957 src->xoffset = -xoffset;
1961 src->yoffset = -dl->top_clip + yoffset;
1963 if (start_pixpos >=0 && start_pixpos > xpos)
1965 /* Oops, we're asking for a start outside of the displayable
1967 if (start_pixpos > xpos + width)
1969 dest->xpos = start_pixpos;
1970 dest->width -= (start_pixpos - xpos);
1971 /* Offsets are -ve when we want to clip pixels off the displayed
1973 src->xoffset -= (start_pixpos - xpos);
1979 /*****************************************************************************
1980 redisplay_clear_top_of_window
1982 If window is topmost, clear the internal border above it.
1983 ****************************************************************************/
1985 redisplay_clear_top_of_window (struct window *w)
1988 XSETWINDOW (window, w);
1990 if (!NILP (Fwindow_highest_p (window)))
1992 struct frame *f = XFRAME (w->frame);
1993 int x, y, width, height;
1996 width = w->pixel_width;
1998 if (window_is_leftmost (w))
2000 x -= FRAME_BORDER_WIDTH (f);
2001 width += FRAME_BORDER_WIDTH (f);
2003 if (window_is_rightmost (w))
2004 width += FRAME_BORDER_WIDTH (f);
2006 y = FRAME_TOP_BORDER_START (f) - 1;
2007 height = FRAME_BORDER_HEIGHT (f) + 1;
2009 redisplay_clear_region (window, DEFAULT_INDEX, x, y, width, height);
2013 /*****************************************************************************
2014 redisplay_clear_to_window_end
2016 Clear the area between ypos1 and ypos2. Each margin area and the
2017 text area is handled separately since they may each have their own
2019 ****************************************************************************/
2021 redisplay_clear_to_window_end (struct window *w, int ypos1, int ypos2)
2023 struct frame *f = XFRAME (w->frame);
2024 struct device *d = XDEVICE (f->device);
2026 if (HAS_DEVMETH_P (d, clear_to_window_end))
2027 DEVMETH (d, clear_to_window_end, (w, ypos1, ypos2));
2030 int height = ypos2 - ypos1;
2035 int bflag = 0 ; /* (window_needs_vertical_divider (w) ? 0 : 1);*/
2036 layout_bounds bounds;
2038 bounds = calculate_display_line_boundaries (w, bflag);
2039 XSETWINDOW (window, w);
2041 if (window_is_leftmost (w))
2042 redisplay_clear_region (window, DEFAULT_INDEX, FRAME_LEFT_BORDER_START (f),
2043 ypos1, FRAME_BORDER_WIDTH (f), height);
2045 if (bounds.left_in - bounds.left_out > 0)
2046 redisplay_clear_region (window,
2047 get_builtin_face_cache_index (w, Vleft_margin_face),
2048 bounds.left_out, ypos1,
2049 bounds.left_in - bounds.left_out, height);
2051 if (bounds.right_in - bounds.left_in > 0)
2052 redisplay_clear_region (window,
2054 bounds.left_in, ypos1,
2055 bounds.right_in - bounds.left_in, height);
2057 if (bounds.right_out - bounds.right_in > 0)
2058 redisplay_clear_region (window,
2059 get_builtin_face_cache_index (w, Vright_margin_face),
2060 bounds.right_in, ypos1,
2061 bounds.right_out - bounds.right_in, height);
2063 if (window_is_rightmost (w))
2064 redisplay_clear_region (window, DEFAULT_INDEX, FRAME_RIGHT_BORDER_START (f),
2065 ypos1, FRAME_BORDER_WIDTH (f), height);
2070 /*****************************************************************************
2071 redisplay_clear_bottom_of_window
2073 Clear window from right below the last display line to right above
2074 the modeline. The calling function can limit the area actually
2075 erased by setting min_start and/or max_end to positive values.
2076 ****************************************************************************/
2078 redisplay_clear_bottom_of_window (struct window *w, display_line_dynarr *ddla,
2079 int min_start, int max_end)
2081 struct frame *f = XFRAME (w->frame);
2083 int ddla_len = Dynarr_length (ddla);
2085 ypos2 = WINDOW_TEXT_BOTTOM (w);
2086 #ifdef HAVE_SCROLLBARS
2087 /* This adjustment is to catch the intersection of any scrollbars. */
2088 if (f->windows_structure_changed && NILP (w->scrollbar_on_top_p))
2089 ypos2 += window_scrollbar_height (w);
2094 if (ddla_len == 1 && Dynarr_atp (ddla, 0)->modeline)
2096 ypos1 = WINDOW_TEXT_TOP (w);
2097 #ifdef HAVE_SCROLLBARS
2098 /* This adjustment is to catch the intersection of any scrollbars. */
2099 if (f->windows_structure_changed && !NILP (w->scrollbar_on_top_p))
2100 ypos1 -= window_scrollbar_height (w);
2105 struct display_line *dl = Dynarr_atp (ddla, ddla_len - 1);
2106 ypos1 = dl->ypos + dl->descent - dl->clip;
2110 ypos1 = WINDOW_TEXT_TOP (w);
2112 /* #### See if this can be made conditional on the frame
2114 if (MINI_WINDOW_P (w))
2115 ypos2 += FRAME_BORDER_HEIGHT (f);
2117 if (min_start >= 0 && ypos1 < min_start)
2119 if (max_end >= 0 && ypos2 > max_end)
2125 redisplay_clear_to_window_end (w, ypos1, ypos2);
2128 /*****************************************************************************
2129 redisplay_update_line
2131 This is used during incremental updates to update a single line and
2132 correct the offsets on all lines below it. At the moment
2133 update_values is false if we are only updating the modeline.
2134 ****************************************************************************/
2136 redisplay_update_line (struct window *w, int first_line, int last_line,
2139 struct frame *f = XFRAME (w->frame);
2140 struct device *d = XDEVICE (f->device);
2142 display_line_dynarr *cdla = window_display_lines (w, CURRENT_DISP);
2143 display_line_dynarr *ddla = window_display_lines (w, DESIRED_DISP);
2145 MAYBE_DEVMETH (d, window_output_begin, (w));
2147 while (first_line <= last_line)
2149 Charcount old_len = (Dynarr_atp (cdla, first_line)->end_bufpos -
2150 Dynarr_atp (cdla, first_line)->bufpos);
2151 Charcount new_len = (Dynarr_atp (ddla, first_line)->end_bufpos -
2152 Dynarr_atp (ddla, first_line)->bufpos);
2154 assert (Dynarr_length (cdla) == Dynarr_length (ddla));
2156 /* Output the changes. */
2157 output_display_line (w, cdla, ddla, first_line, -1, -1);
2159 /* Update the offsets. */
2162 int cur_line = first_line + 1;
2163 while (cur_line < Dynarr_length (cdla))
2165 Dynarr_atp (cdla, cur_line)->offset += (new_len - old_len);
2166 Dynarr_atp (ddla, cur_line)->offset += (new_len - old_len);
2171 /* Update the window_end_pos and other settings. */
2174 w->window_end_pos[CURRENT_DISP] -= (new_len - old_len);
2176 if (Dynarr_atp (ddla, first_line)->cursor_elt != -1)
2178 w->last_point_x[CURRENT_DISP] = w->last_point_x[DESIRED_DISP];
2179 w->last_point_y[CURRENT_DISP] = w->last_point_y[DESIRED_DISP];
2186 /* Update the window max line length. We have to scan the entire
2187 set of display lines otherwise we might not detect if the max is
2188 supposed to shrink. */
2193 w->max_line_len = 0;
2194 while (line < Dynarr_length (ddla))
2196 struct display_line *dl = Dynarr_atp (ddla, line);
2199 w->max_line_len = max (dl->num_chars, w->max_line_len);
2205 w->last_modified[CURRENT_DISP] = w->last_modified[DESIRED_DISP];
2206 w->last_facechange[CURRENT_DISP] = w->last_facechange[DESIRED_DISP];
2207 Fset_marker (w->last_point[CURRENT_DISP],
2208 Fmarker_position (w->last_point[DESIRED_DISP]), w->buffer);
2209 Fset_marker (w->last_start[CURRENT_DISP],
2210 Fmarker_position (w->last_start[DESIRED_DISP]), w->buffer);
2212 /* We don't bother updating the vertical scrollbars here. This
2213 gives us a performance increase while having minimal loss of
2214 quality to the scrollbar slider size and position since when this
2215 function is called we know that the changes to the buffer were
2216 very localized. We have to update the horizontal scrollbars,
2217 though, because this routine could cause a change which has a
2218 larger impact on their sizing. */
2219 /* #### See if we can get away with only calling this if
2220 max_line_len is greater than the window_char_width. */
2221 /* #### BILL!!! Should we do this for GTK as well? */
2222 #if defined(HAVE_SCROLLBARS) && defined(HAVE_X_WINDOWS)
2224 extern int stupid_vertical_scrollbar_drag_hack;
2226 update_window_scrollbars (w, NULL, 1, stupid_vertical_scrollbar_drag_hack);
2227 stupid_vertical_scrollbar_drag_hack = 1;
2231 redisplay_redraw_cursor (f, 0);
2232 MAYBE_DEVMETH (d, window_output_end, (w));
2235 /*****************************************************************************
2236 redisplay_output_window
2238 For the given window W, ensure that the current display lines are
2239 equal to the desired display lines, outputing changes as necessary.
2241 #### Fuck me. This just isn't going to cut it for tty's. The output
2242 decisions for them must be based on the contents of the entire frame
2243 because that is how the available output capabilities think. The
2244 solution is relatively simple. Create redisplay_output_frame. This
2245 will basically merge all of the separate window display structs into
2246 a single one for the frame. This combination structure will be able
2247 to be passed to the same output_display_line which works for windows
2248 on X frames and the right things will happen. It just takes time to
2250 ****************************************************************************/
2252 redisplay_output_window (struct window *w)
2254 struct frame *f = XFRAME (w->frame);
2255 struct device *d = XDEVICE (f->device);
2257 display_line_dynarr *cdla = window_display_lines (w, CURRENT_DISP);
2258 display_line_dynarr *ddla = window_display_lines (w, DESIRED_DISP);
2260 int cdla_len = Dynarr_length (cdla);
2261 int ddla_len = Dynarr_length (ddla);
2264 int need_to_clear_bottom = 0;
2265 int need_to_clear_start = -1;
2266 int need_to_clear_end = -1;
2268 /* Backgrounds may have changed or windows may have gone away
2269 leaving dividers lying around. */
2270 if (f->faces_changed
2271 || f->windows_structure_changed
2272 || w->shadow_thickness_changed)
2273 need_to_clear_bottom = 1;
2275 /* The first thing we do is determine if we are going to need to
2276 clear the bottom of the window. We only need to do this if the
2277 bottom of the current display lines is below the bottom of the
2278 desired display lines. Note that the number of lines is
2279 irrelevant. Only the position matters. We also clear to the
2280 bottom of the window if the modeline has shifted position. */
2281 /* #### We can't blindly not clear the bottom if f->clear is true
2282 since there might be a window-local background. However, for
2283 those cases where there isn't, clearing the end of the window in
2285 if (!need_to_clear_bottom)
2287 struct display_line *cdl, *ddl;
2289 /* If the modeline has changed position or size, clear the bottom
2291 if (!need_to_clear_bottom)
2296 cdl = Dynarr_atp (cdla, 0);
2298 ddl = Dynarr_atp (ddla, 0);
2301 need_to_clear_bottom = 1;
2302 else if ((!cdl->modeline && ddl->modeline)
2303 || (cdl->modeline && !ddl->modeline))
2304 need_to_clear_bottom = 1;
2305 else if (cdl->ypos != ddl->ypos ||
2306 cdl->ascent != ddl->ascent ||
2307 cdl->descent != ddl->descent ||
2308 cdl->clip != ddl->clip)
2309 need_to_clear_bottom = 1;
2311 /* #### This kludge is to make sure the modeline shadows get
2312 redrawn if the modeline position shifts. */
2313 if (need_to_clear_bottom)
2314 w->shadow_thickness_changed = 1;
2317 if (!need_to_clear_bottom)
2322 cdl = Dynarr_atp (cdla, cdla_len - 1);
2324 ddl = Dynarr_atp (ddla, ddla_len - 1);
2327 need_to_clear_bottom = 1;
2330 int cdl_bottom, ddl_bottom;
2332 cdl_bottom = cdl->ypos + cdl->descent;
2333 ddl_bottom = ddl->ypos + ddl->descent;
2335 if (cdl_bottom > ddl_bottom)
2337 need_to_clear_bottom = 1;
2338 need_to_clear_start = ddl_bottom;
2339 need_to_clear_end = cdl_bottom;
2345 /* Perform any output initialization. */
2346 MAYBE_DEVMETH (d, window_output_begin, (w));
2348 /* If the window's structure has changed clear the internal border
2349 above it if it is topmost (the function will check). */
2350 if (f->windows_structure_changed || f->faces_changed)
2351 redisplay_clear_top_of_window (w);
2353 /* Output each line. */
2354 for (line = 0; line < Dynarr_length (ddla); line++)
2356 output_display_line (w, cdla, ddla, line, -1, -1);
2359 /* If the number of display lines has shrunk, adjust. */
2360 if (cdla_len > ddla_len)
2362 Dynarr_length (cdla) = ddla_len;
2365 /* Output a vertical divider between windows, if necessary. */
2366 if (window_needs_vertical_divider (w)
2367 && (f->windows_structure_changed || f->clear))
2369 MAYBE_DEVMETH (d, output_vertical_divider, (w, f->windows_structure_changed));
2372 /* Clear the rest of the window, if necessary. */
2373 if (need_to_clear_bottom)
2375 redisplay_clear_bottom_of_window (w, ddla, need_to_clear_start,
2379 w->window_end_pos[CURRENT_DISP] = w->window_end_pos[DESIRED_DISP];
2380 Fset_marker (w->start[CURRENT_DISP],
2381 make_int (marker_position (w->start[DESIRED_DISP])),
2383 Fset_marker (w->pointm[CURRENT_DISP],
2384 make_int (marker_position (w->pointm[DESIRED_DISP])),
2386 w->last_modified[CURRENT_DISP] = w->last_modified[DESIRED_DISP];
2387 w->last_facechange[CURRENT_DISP] = w->last_facechange[DESIRED_DISP];
2388 Fset_marker (w->last_start[CURRENT_DISP],
2389 Fmarker_position (w->last_start[DESIRED_DISP]), w->buffer);
2390 Fset_marker (w->last_point[CURRENT_DISP],
2391 Fmarker_position (w->last_point[DESIRED_DISP]), w->buffer);
2392 w->last_point_x[CURRENT_DISP] = w->last_point_x[DESIRED_DISP];
2393 w->last_point_y[CURRENT_DISP] = w->last_point_y[DESIRED_DISP];
2394 w->shadow_thickness_changed = 0;
2396 set_window_display_buffer (w, XBUFFER (w->buffer));
2397 find_window_mirror (w)->truncate_win = window_truncation_on (w);
2399 /* Overkill on invalidating the cache. It is very bad for it to not
2400 get invalidated when it should be. */
2401 INVALIDATE_DEVICE_PIXEL_TO_GLYPH_CACHE (d);
2403 redisplay_redraw_cursor (f, 0);
2404 MAYBE_DEVMETH (d, window_output_end, (w));
2406 #ifdef HAVE_SCROLLBARS
2407 update_window_scrollbars (w, NULL, !MINI_WINDOW_P (w), 0);
2411 /*****************************************************************************
2414 Draw a 3d border around the modeline on window W.
2415 ****************************************************************************/
2417 bevel_modeline (struct window *w, struct display_line *dl)
2419 struct frame *f = XFRAME (w->frame);
2420 struct device *d = XDEVICE (f->device);
2421 int x, y, width, height;
2422 int shadow_thickness = MODELINE_SHADOW_THICKNESS (w);
2423 enum edge_style style;
2425 x = WINDOW_MODELINE_LEFT (w);
2426 width = WINDOW_MODELINE_RIGHT (w) - x;
2427 y = dl->ypos - dl->ascent - shadow_thickness;
2428 height = dl->ascent + dl->descent + 2 * shadow_thickness;
2430 if (XINT (w->modeline_shadow_thickness) < 0)
2432 style = EDGE_BEVEL_IN;
2436 style = EDGE_BEVEL_OUT;
2439 MAYBE_DEVMETH (d, bevel_area,
2440 (w, MODELINE_INDEX, x, y, width, height, shadow_thickness,