xemacs-beta: src/redisplay.c comparison

comparison src/redisplay.c @ 442:abe6d1db359e r21-2-36

Import from CVS: tag r21-2-36

author	cvs
date	Mon, 13 Aug 2007 11:35:02 +0200
parents	8de8e3f6228a
children	576fb035e263

comparison

equal deleted inserted replaced

-:72a7cfa4a488
+:abe6d1db359e
 Third:		It Is Better To Be Fast Than Not To Be
 ****************************************************************************/
 #include <config.h>
 #include "lisp.h"
-#include <limits.h>
 #include "buffer.h"
 #include "commands.h"
 #include "debug.h"
 #include "device.h"
 #include "line-number.h"
 #ifdef FILE_CODING
 #include "file-coding.h"
 #endif
+#include "sysfile.h"
 #ifdef HAVE_TTY
 #include "console-tty.h"
-#ifdef HAVE_UNISTD_H
-#include <unistd.h> /* for isatty() */
-#endif
 #endif /* HAVE_TTY */
 /* Note: We have to be careful throughout this code to properly handle
 and differentiate between Bufbytes and Emchars.
 #define BEGIN_GLYPHS	0
 #define END_GLYPHS	1
 #define LEFT_GLYPHS	2
 #define RIGHT_GLYPHS	3
-/* Set the vertical clip to 0 if we are currently updating the line
-start cache.  Otherwise for buffers of line height 1 it may fail to
-be able to work properly because regenerate_window will not layout
-a single line.  */
 #define VERTICAL_CLIP(w, display)					\
-(updating_line_start_cache						\
+((WINDOW_TTY_P (w) | (!display && scroll_on_clipped_lines))	        \
-? 0									\
-: ((WINDOW_TTY_P (w) | (!display && scroll_on_clipped_lines))	\
 ? INT_MAX								\
-: vertical_clip))
+: vertical_clip)
 /* The following structures are completely private to redisplay.c so
 we put them here instead of in a header file, for modularity. */
 /* NOTE: Bytinds not Bufpos's in this structure. */
 int vertical_clip;
 /* Minimum visible pixel width of clipped glyphs at right margin. */
 int horizontal_clip;
-/* Set if currently inside update_line_start_cache. */
-static int updating_line_start_cache;
 /* Nonzero means reading single-character input with prompt
 so put cursor on minibuffer after the prompt.  */
 int cursor_in_echo_area;
 Lisp_Object Qcursor_in_echo_area;
 hscroll, control-arrow, etc) is in need of updating
 somewhere. */
 int glyphs_changed;
 int glyphs_changed_set;
-/* non-zero if any displayed subwindow is in need of updating
+/* non-zero if any subwindow has been deleted. */
-somewhere. */
 int subwindows_changed;
 int subwindows_changed_set;
 /* non-zero if any displayed subwindow is in need of updating
 somewhere. */
 /* If non-nil, use vertical bar cursor. */
 Lisp_Object Vbar_cursor;
 Lisp_Object Qbar_cursor;
-int visible_bell;	/* If true and the terminal will support it
+Lisp_Object Vvisible_bell;	/* If true and the terminal will support it
-			   then the frame will flash instead of
+				   then the frame will flash instead of
-			   beeping when an error occurs */
+				   beeping when an error occurs */
 /* Nonzero means no need to redraw the entire frame on resuming
 a suspended Emacs.  This is useful on terminals with multiple pages,
 where one page is used for Emacs and another for all else. */
 int no_redraw_on_reenter;
 Lisp_Object Voverlay_arrow_string;
 Lisp_Object Vwindow_size_change_functions;
 Lisp_Object Vwindow_scroll_functions;
 Lisp_Object Qredisplay_end_trigger_functions, Vredisplay_end_trigger_functions;
+Lisp_Object Qbuffer_list_changed_hook, Vbuffer_list_changed_hook;
 #define INHIBIT_REDISPLAY_HOOKS  /* #### Until we've thought about
 				    this more. */
 #ifndef INHIBIT_REDISPLAY_HOOKS
 /* #### Chuck says: I think this needs more thought.
 Lisp_Object Vminimum_line_ascent, Vminimum_line_descent;
 Lisp_Object Vuse_left_overflow, Vuse_right_overflow;
 Lisp_Object Vtext_cursor_visible_p;
 int column_number_start_at_one;
+Lisp_Object Qtop_bottom;
 #define WINDOW_SCROLLED(w) \
 (w->hscroll > 0 || w->left_xoffset)
 gb.extent = Qnil;
 gb.glyph = Vhscroll_glyph;
 {
 int oldpixpos = data->pixpos;
-retval = add_glyph_rune (data, &gb, BEGIN_GLYPHS, 1,
+retval = add_glyph_rune (data, &gb, BEGIN_GLYPHS, 0,
 			     GLYPH_CACHEL (XWINDOW (data->window),
 					   HSCROLL_GLYPH_INDEX));
 data->hscroll_glyph_width_adjust =
 data->pixpos - oldpixpos - space_width (XWINDOW (data->window));
 }
 	  bytecount_to_charcount (XSTRING_DATA (data->string), data->bi_bufpos);
 }
 else if (data->is_modeline)
 crb->bufpos = data->modeline_charpos;
 else
-/* fuckme if this shouldn't be an abort. */
+/* Text but not in buffer */
-/* abort (); fuckme harder, this abort gets tripped quite often,
-		 in propagation and whatnot.  #### fixme */
 crb->bufpos = 0;
 crb->type = RUNE_CHAR;
 crb->object.chr.ch = data->font_is_bogus ? '~' : data->ch;
 crb->endpos = 0;
 		      dst += long_to_string_base ((char *)dst, data->ch, 16);
 		      break;*/
 		    case '%':
 		      dst += set_charptr_emchar (dst, '%');
 		      break;
+		      /* #### unimplemented */
 		    }
 		}
 	    }
 	  prop = add_bufbyte_string_runes (data, result, dst - result, 0);
 	}
 /* If window faces changed, and glyph instance is text, then
 glyph sizes might have changed too */
 invalidate_glyph_geometry_maybe (gb->glyph, w);
+/* This makes sure the glyph is in the cachels.
+#### We do this to make sure the glyph is in the glyph cachels,
+so that the dirty flag can be reset after redisplay has
+finished. We should do this some other way, maybe by iterating
+over the window cache of subwindows. */
+get_glyph_cachel_index (w, gb->glyph);
 /* A nil extent indicates a special glyph (ex. truncator). */
 if (NILP (gb->extent)
 || (pos_type == BEGIN_GLYPHS &&
 	  extent_begin_glyph_layout (XEXTENT (gb->extent)) == GL_TEXT)
 || (pos_type == END_GLYPHS &&
-	  extent_end_glyph_layout (XEXTENT (gb->extent)) == GL_TEXT))
+	  extent_end_glyph_layout (XEXTENT (gb->extent)) == GL_TEXT)
+|| pos_type == LEFT_GLYPHS || pos_type == RIGHT_GLYPHS)
 {
 struct rune rb;
 int width;
 int xoffset = 0;
 int ascent, descent;
 Lisp_Object baseline;
 Lisp_Object face;
+Lisp_Object instance;
+face_index findex;
 if (cachel)
 	width = cachel->width;
 else
 	width = glyph_width (gb->glyph, data->window);
 	    abort ();
 	}
 face = glyph_face (gb->glyph, data->window);
 if (NILP (face))
-	rb.findex = data->findex;
+	findex = data->findex;
 else
-	rb.findex = get_builtin_face_cache_index (w, face);
+	findex = get_builtin_face_cache_index (w, face);
+instance = glyph_image_instance (gb->glyph, data->window,
+				       ERROR_ME_NOT, 1);
+if (TEXT_IMAGE_INSTANCEP (instance))
+	{
+	  Lisp_Object string = XIMAGE_INSTANCE_TEXT_STRING (instance);
+	  face_index orig_findex = data->findex;
+	  Bytind orig_bufpos = data->bi_bufpos;
+	  Bytind orig_start_col_enabled = data->bi_start_col_enabled;
+	  data->findex = findex;
+	  data->bi_start_col_enabled = 0;
+	  if (!allow_cursor)
+	    data->bi_bufpos = 0;
+	  add_bufbyte_string_runes (data, XSTRING_DATA (string),
+				    XSTRING_LENGTH (string), 0);
+	  data->findex = orig_findex;
+	  data->bi_bufpos = orig_bufpos;
+	  data->bi_start_col_enabled = orig_start_col_enabled;
+	  return NULL;
+	}
+rb.findex = findex;
 rb.xpos = data->pixpos;
 rb.width = width;
 rb.bufpos = 0;			/* glyphs are never "at" anywhere */
 if (data->bi_endpos)
 	/* #### is this necessary at all? */
 	rb.endpos = bytind_to_bufpos (XBUFFER (WINDOW_BUFFER (w)),
 				      data->bi_endpos);
 else
 rb.endpos = 0;
 rb.type = RUNE_DGLYPH;
-/* #### Ben sez: this is way bogus if the glyph is a string.
-	 You should not make the output routines have to cope with
-	 this.  The string could contain Mule characters, or non-
-	 printable characters, or characters to be passed through
-	 the display table, or non-character objects (when this gets
-	 implemented), etc.  Instead, this routine here should parse
-	 the string into a series of runes. */
 rb.object.dglyph.glyph = gb->glyph;
 rb.object.dglyph.extent = gb->extent;
 rb.object.dglyph.xoffset = xoffset;
 if (allow_cursor)
 Lisp_Object synch_minibuffers_value =
 symbol_value_in_buffer (Qsynchronize_minibuffers, w->buffer);
 dl->used_prop_data = 0;
 dl->num_chars = 0;
+dl->line_continuation = 0;
 xzero (data);
 data.ef = extent_fragment_new (w->buffer, f);
 /* These values are used by all of the rune addition routines.  We add
 	      /* The cursor can never be on the continuation glyph. */
 	      data.cursor_type = NO_CURSOR;
 	      /* data.bi_bufpos is already at the start of the next line. */
+	      dl->line_continuation = 1;
 	      gb.glyph = Vcontinuation_glyph;
 	      cachel = GLYPH_CACHEL (w, CONT_GLYPH_INDEX);
 	    }
-	  add_glyph_rune (&data, &gb, BEGIN_GLYPHS, 1, cachel);
+	  add_glyph_rune (&data, &gb, BEGIN_GLYPHS, 0, cachel);
 	  if (truncate_win && data.bi_bufpos == BI_BUF_ZV (b)
 	      && BI_BUF_FETCH_CHAR (b, prev_bytind (b, BI_BUF_ZV (b))) != '\n')
 	    /* #### Damn this losing shit. */
 	    data.bi_bufpos++;
 {
 glyph_block_dynarr *gbd = (side == LEFT_GLYPHS
 			     ? dl->left_glyphs
 			     : dl->right_glyphs);
 int elt, end;
-int xpos = start;
 int reverse;
+struct window *w = XWINDOW (window);
+struct frame *f = XFRAME (w->frame);
+struct device *d = XDEVICE (f->device);
+pos_data data;
+xzero (data);
+data.d = d;
+data.window = window;
+data.db = db;
+data.dl = dl;
+data.pixpos = start;
+data.cursor_type = NO_CURSOR;
+data.cursor_x = -1;
+data.last_charset = Qunbound;
+data.last_findex = DEFAULT_INDEX;
+data.result_str = Qnil;
+data.string = Qnil;
+data.new_ascent = dl->ascent;
+data.new_descent = dl->descent;
 if ((layout == GL_WHITESPACE && side == LEFT_GLYPHS)
 || (layout == GL_INSIDE_MARGIN && side == RIGHT_GLYPHS))
 {
 reverse = 1;
 	  ((side == LEFT_GLYPHS &&
 	    extent_begin_glyph_layout (XEXTENT (gb->extent)) == layout)
 	   || (side == RIGHT_GLYPHS &&
 	       extent_end_glyph_layout (XEXTENT (gb->extent)) == layout)))
 	{
-	  struct rune rb;
+	  data.findex = gb->findex;
+	  data.max_pixpos = data.pixpos + gb->width;
-	  rb.width = gb->width;
+	  add_glyph_rune (&data, gb, side, 0, NULL);
-	  rb.findex = gb->findex;
-	  rb.xpos = xpos;
-	  rb.bufpos = -1;
-	  rb.endpos = 0;
-	  rb.type = RUNE_DGLYPH;
-	  rb.object.dglyph.glyph = gb->glyph;
-	  rb.object.dglyph.extent = gb->extent;
-	  rb.object.dglyph.xoffset = 0;
-	  rb.cursor_type = CURSOR_OFF;
-	  Dynarr_add (db->runes, rb);
-	  xpos += rb.width;
 	  count--;
 	  gb->active = 0;
-	  if (glyph_contrib_p (gb->glyph, window))
-	    {
-	      unsigned short ascent, descent;
-	      Lisp_Object baseline = glyph_baseline (gb->glyph, window);
-	      ascent = glyph_ascent (gb->glyph, window);
-	      descent = glyph_descent (gb->glyph, window);
-	      /* A pixmap that has not had a baseline explicitly set.
-We use the existing ascent / descent ratio of the
-line. */
-	      if (NILP (baseline))
-		{
-		  int gheight = ascent + descent;
-		  int line_height = dl->ascent + dl->descent;
-		  int pix_ascent, pix_descent;
-		  pix_descent = (int) (gheight * dl->descent) / line_height;
-		  pix_ascent = gheight - pix_descent;
-		  dl->ascent = max ((int) dl->ascent, pix_ascent);
-		  dl->descent = max ((int) dl->descent, pix_descent);
-		}
-	      /* A string so determine contribution normally. */
-	      else if (EQ (baseline, Qt))
-		{
-		  dl->ascent = max (dl->ascent, ascent);
-		  dl->descent = max (dl->descent, descent);
-		}
-	      /* A pixmap with an explicitly set baseline.  We determine the
-		 contribution here. */
-	      else if (INTP (baseline))
-		{
-		  int height = ascent + descent;
-		  int pix_ascent, pix_descent;
-		  pix_ascent = height * XINT (baseline) / 100;
-		  pix_descent = height - pix_ascent;
-		  dl->ascent = max ((int) dl->ascent, pix_ascent);
-		  dl->descent = max ((int) dl->descent, pix_descent);
-		}
-	      /* Otherwise something is screwed up. */
-	      else
-		abort ();
-	    }
 	}
 (reverse ? elt-- : elt++);
 }
-return xpos;
+if (data.max_pixmap_height)
+{
+int height = data.new_ascent + data.new_descent;
+int pix_ascent, pix_descent;
+pix_descent = data.max_pixmap_height * data.new_descent / height;
+pix_ascent = data.max_pixmap_height - pix_descent;
+data.new_ascent = max (data.new_ascent, pix_ascent);
+data.new_descent = max (data.new_descent, pix_descent);
+}
+dl->ascent = data.new_ascent;
+dl->descent = data.new_descent;
+return data.pixpos;
 }
 /* Add a blank to a margin display block. */
 static void
 Dynarr_reset (formatted_string_extent_start_dynarr);
 Dynarr_reset (formatted_string_extent_end_dynarr);
 /* result_str is nil when we're building a frame or icon title. Otherwise,
 we're building a modeline, so the offset starts at the modeline
-horizontal scrolling ammount */
+horizontal scrolling amount */
 if (! NILP (result_str))
 offset = w->modeline_hscroll;
 generate_fstring_runes (w, &data, 0, 0, -1, format_str, 0,
 max_pixpos - min_pixpos, findex, type, &offset,
 			  Qnil);
 {
 int elt;
 Bytecount len;
 Bufbyte *strdata;
 struct buffer *buf = XBUFFER (WINDOW_BUFFER (w));
+in_modeline_generation = 1;
 detach_all_extents (result_str);
 resize_string (XSTRING (result_str), -1,
 data.bytepos - XSTRING_LENGTH (result_str));
 (XEXTENT (child),
 Dynarr_at (formatted_string_extent_start_dynarr, elt),
 Dynarr_at (formatted_string_extent_end_dynarr, elt),
 result_str);
 }
+in_modeline_generation = 0;
 }
 }
 /* Ensure that the given display line DL accurately represents the
 modeline for the given window. */
 dl->ascent = DEVMETH (d, divider_height, ());
 dl->descent = 0;
 /* The modeline is at the bottom of the gutters. */
 dl->ypos = WINDOW_BOTTOM (w);
-/* adjust for the bottom gutter */
-if (window_is_lowest (w))
-	dl->ypos -= FRAME_BOTTOM_GUTTER_BOUNDS (f);
 rb.findex = MODELINE_INDEX;
 rb.xpos = dl->bounds.left_out;
 rb.width = dl->bounds.right_out - dl->bounds.left_out;
 rb.bufpos = 0;
 /* The modeline is at the bottom of the gutters.  We have to wait to
 set this until we've generated the modeline in order to account
 for any embedded faces. */
 dl->ypos = WINDOW_BOTTOM (w) - dl->descent - ypos_adj;
-/* adjust for the bottom gutter */
-if (window_is_lowest (w))
-dl->ypos -= FRAME_BOTTOM_GUTTER_BOUNDS (f);
 }
 static Charcount
-add_string_to_fstring_db_runes (pos_data *data, CONST Bufbyte *str,
+add_string_to_fstring_db_runes (pos_data *data, const Bufbyte *str,
 Charcount pos, Charcount min_pos, Charcount max_pos)
 {
 /* This function has been Mule-ized. */
 Charcount end;
-CONST Bufbyte *cur_pos = str;
+const Bufbyte *cur_pos = str;
 struct display_block *db = data->db;
 data->blank_width = space_width (XWINDOW (data->window));
 while (Dynarr_length (db->runes) < pos)
 add_blank_rune (data, NULL, 0);
 end = (Dynarr_length (db->runes) +
-bytecount_to_charcount (str, strlen ((CONST char *) str)));
+bytecount_to_charcount (str, strlen ((const char *) str)));
 if (max_pos != -1)
 end = min (max_pos, end);
 while (pos < end && *cur_pos)
 {
-CONST Bufbyte *old_cur_pos = cur_pos;
+const Bufbyte *old_cur_pos = cur_pos;
 int succeeded;
 data->ch = charptr_emchar (cur_pos);
 succeeded = (add_emchar_rune (data) != ADD_FAILED);
 INC_CHARPTR (cur_pos);
 		*offset -= size;
 	      else
 		{
 		  Charcount tmp_max = (max_pos == -1 ? pos + size - *offset :
 				       min (pos + size - *offset, max_pos));
-		  CONST Bufbyte *tmp_last = charptr_n_addr (last, *offset);
+		  const Bufbyte *tmp_last = charptr_n_addr (last, *offset);
 		  pos = add_string_to_fstring_db_runes (data, tmp_last,
 							pos, pos, tmp_max);
 		  *offset = 0;
 		}
 num_to_add++;
 }
 while (num_to_add--)
 pos = add_string_to_fstring_db_runes
-(data, (CONST Bufbyte *) "-", pos, pos, max_pos);
+(data, (const Bufbyte *) "-", pos, pos, max_pos);
 }
 else if (*this != 0)
 {
 Emchar ch = charptr_emchar (this);
 Bufbyte *str;
 		  if (size <= *offset)
 		    *offset -= size;
 		  else
 		    {
-		      CONST Bufbyte *tmp_str = charptr_n_addr (str, *offset);
+		      const Bufbyte *tmp_str = charptr_n_addr (str, *offset);
 		      /* #### NOTE: I don't understand why a tmp_max is not
 			 computed and used here as in the plain string case
 			 above. -- dv */
 		      pos = add_string_to_fstring_db_runes (data, tmp_str,
 	      if (size <= *offset)
 		*offset -= size;
 	      else
 		{
-		  CONST Bufbyte *tmp_str = charptr_n_addr (str, *offset);
+		  const Bufbyte *tmp_str = charptr_n_addr (str, *offset);
 		  /* #### NOTE: I don't understand why a tmp_max is not
 		     computed and used here as in the plain string case
 		     above. -- dv */
 		  pos = add_string_to_fstring_db_runes (data, tmp_str, pos,
 *   at most that many characters.  If positive, pad (with spaces)
 *   to at least that many characters.
 * - If first element is another symbol, process the cadr or caddr
 *   recursively according to whether the symbol's value is non-nil or
 *   nil.
-* - If first element is a face, process the cdr recursively
+* - If first element is an extent, process the cdr recursively
-*   without altering the depth.
+*   and handle the extent's face.
 */
 Lisp_Object car, tem;
 car = XCAR (elt);
 	if (size <= *offset)
 	  *offset -= size;
 	else
 	  {
-	    CONST Bufbyte *tmp_str =
+	    const Bufbyte *tmp_str =
-	      charptr_n_addr ((CONST Bufbyte *) str, *offset);
+	      charptr_n_addr ((const Bufbyte *) str, *offset);
 	    /* #### NOTE: I don't understand why a tmp_max is not computed and
 	       used here as in the plain string case above. -- dv */
 	    pos = add_string_to_fstring_db_runes (data, tmp_str, pos,
 						  min_pos, max_pos);
 }
 }
 if (min_pos > pos)
 {
-add_string_to_fstring_db_runes (data, (CONST Bufbyte *) "", pos,
+add_string_to_fstring_db_runes (data, (const Bufbyte *) "", pos,
 				      min_pos, -1);
 }
 return pos;
 }
 pos_data data;
 int truncate_win = b ? window_truncation_on (w) : 0;
 int end_glyph_width = 0;
-/* we're going to ditch selective display for static text, its an
+/* We're going to ditch selective display for static text, it's an
-FSF thing and invisble extents are the way to go
+FSF thing and invisible extents are the way to go here.
-here. Implementing it also relies on a number of buffer-specific
+Implementing it also relies on a number of buffer-specific
 functions that we don't have the luxury of being able to use
 here. */
 /* The variable ctl-arrow allows the user to specify what characters
 can actually be displayed and which octal should be used for.
 displayed. */
 int no_more_frags = 0;
 dl->used_prop_data = 0;
 dl->num_chars = 0;
+dl->line_continuation = 0;
 /* set up faces to use for clearing areas, used by
 output_display_line */
 dl->default_findex = default_face;
 if (default_face)
 	      /* The cursor can never be on the continuation glyph. */
 	      data.cursor_type = NO_CURSOR;
 	      /* data.bi_bufpos is already at the start of the next line. */
+	      dl->line_continuation = 1;
 	      gb.glyph = Vcontinuation_glyph;
 	      cachel = GLYPH_CACHEL (w, CONT_GLYPH_INDEX);
 	    }
 	  if (end_glyph_width)
 	    add_glyph_rune (&data, &gb, BEGIN_GLYPHS, 0, cachel);
 	  if (truncate_win && data.bi_bufpos == bi_string_zv)
 	    {
-	      CONST Bufbyte* endb = charptr_n_addr (string_data (s), bi_string_zv);
+	      const Bufbyte* endb = charptr_n_addr (string_data (s), bi_string_zv);
 	      DEC_CHARPTR (endb);
 	      if (charptr_emchar (endb) != '\n')
 		{
 		  /* #### Damn this losing shit. */
 		  data.bi_bufpos++;
 struct frame *f = XFRAME (w->frame);
 struct buffer *b = XBUFFER (w->buffer);
 int ypos = WINDOW_TEXT_TOP (w);
 int yend;	/* set farther down */
 int yclip = WINDOW_TEXT_TOP_CLIP (w);
+int force;
 prop_block_dynarr *prop;
 layout_bounds bounds;
 display_line_dynarr *dla;
 int need_modeline;
 Dynarr_add (prop, pb);
 }
 else
 prop = 0;
-while (ypos < yend)
+/* When we are computing things for scrolling purposes, make
+sure at least one line is always generated */
+force = (type == CMOTION_DISP);
+/* Make sure this is set always */
+/* Note the conversion at end */
+w->window_end_pos[type] = start_pos;
+while (ypos < yend || force)
 {
 struct display_line dl;
 struct display_line *dlp;
 int local;
 	  /* Although this seems strange we could have a single very
 	     tall line visible for which we need to account for both
 	     the top clip and the bottom clip. */
 	  visible_height -= (dlp->clip + dlp->top_clip);
-	  if (visible_height < VERTICAL_CLIP (w, 1))
+	  if (visible_height < VERTICAL_CLIP (w, 1) && !force)
 	    {
 	      if (local)
 		free_display_line (dlp);
 	      break;
 	    }
 /* #### This type of check needs to be done down in the
 	 generate_display_line call. */
 if (start_pos > BUF_ZV (b))
 	break;
+force = 0;
 }
 if (prop)
 Dynarr_free (prop);
 /* #### More not quite right, but close enough. */
-/* #### Ben sez: apparently window_end_pos[] is measured
+/* Ben sez: apparently window_end_pos[] is measured
 as the number of characters between the window end and the
 end of the buffer?  This seems rather weirdo.  What's
-the justification for this? */
+the justification for this?
+JV sez: Because BUF_Z (b) would be a good initial value, however
+that can change. This representation allows initalizing with 0.
+*/
 w->window_end_pos[type] = BUF_Z (b) - w->window_end_pos[type];
 if (need_modeline)
 {
 /* We know that this is the right thing to use because we put it
 assert (cdl->bufpos == ddl->bufpos);
 assert (cdl->end_bufpos == ddl->end_bufpos);
 assert (cdl->offset == ddl->offset);
-/* If the last rune is already a continuation glyph, fail.
+/* If the line continues to next display line, fail. */
-#### We should be able to handle this better. */
+if (ddl->line_continuation)
-{
+	return 0;
-	struct display_block *db = get_display_block_from_line (ddl, TEXT);
-	if (Dynarr_length (db->runes))
-	  {
-	    struct rune *rb =
-	      Dynarr_atp (db->runes, Dynarr_length (db->runes) - 1);
-	    if (rb->type == RUNE_DGLYPH
-		&& EQ (rb->object.dglyph.glyph, Vcontinuation_glyph))
-	      return 0;
-	  }
-}
 /* If the line was generated using propagation data, fail. */
 if (ddl->used_prop_data)
 	return 0;
 	{
 	  Dynarr_free (prop);
 	  return 0;
 	}
-/* If the last rune is now a continuation glyph, fail. */
+/* If the line continues to next display line, fail. */
-{
+if (ddl->line_continuation)
-	struct display_block *db = get_display_block_from_line (ddl, TEXT);
+	return 0;
-	if (Dynarr_length (db->runes))
-	  {
-	    struct rune *rb =
-	      Dynarr_atp (db->runes, Dynarr_length (db->runes) - 1);
-	    if (rb->type == RUNE_DGLYPH
-		&& EQ (rb->object.dglyph.glyph, Vcontinuation_glyph))
-	      return 0;
-	  }
-}
 /* If any line position parameters have changed or a
 cursor has disappeared or disappeared, fail. */
 if (cdl->ypos != ddl->ypos
 	  || cdl->ascent != ddl->ascent
 /* This check is to make sure we restore the minibuffer after a
 temporary change to the echo area. */
 && !(MINI_WINDOW_P (w) && f->buffers_changed)
 && !f->frame_changed
 && !truncation_changed
-/* check whether start is really at the begining of a line  GE */
+/* check whether start is really at the beginning of a line  GE */
 && (!w->start_at_line_beg || beginning_of_line_p (b, startp))
 )
 {
 /* Check if the cursor has actually moved. */
 if (EQ (Fmarker_buffer (w->last_point[CURRENT_DISP]), w->buffer)
 	  && !f->clip_changed
 	  && !f->extents_changed
 	  && !f->faces_changed
 	  && !f->glyphs_changed
 	  && !f->subwindows_changed
-	  && !f->subwindows_state_changed
+	  /*	  && !f->subwindows_state_changed*/
 	  && !f->point_changed
 	  && !f->windows_structure_changed)
 	{
 	  /* If not, we're done. */
 	  if (f->modeline_changed)
 	      && !f->clip_changed
 	      && !f->extents_changed
 	      && !f->faces_changed
 	      && !f->glyphs_changed
 	      && !f->subwindows_changed
-	      && !f->subwindows_state_changed
+	      /*	      && !f->subwindows_state_changed*/
 	      && !f->windows_structure_changed)
 	    {
 	      if (point_visible (w, pointm, CURRENT_DISP)
 		  && w->last_point_x[CURRENT_DISP] != -1
 		  && w->last_point_y[CURRENT_DISP] != -1)
 else if (!w->windows_changed
 	   && !f->clip_changed
 	   && !f->faces_changed
 	   && !f->glyphs_changed
 	   && !f->subwindows_changed
-	   && !f->subwindows_state_changed
+	   /*	   && !f->subwindows_state_changed*/
 	   && !f->windows_structure_changed
 	   && !f->frame_changed
 	   && !truncation_changed
 	   && pointm >= startp
 	   && regenerate_window_incrementally (w, startp, pointm))
 return 0;
 }
 /* Ensure that all windows on the given frame are correctly displayed. */
-static int
+int
 redisplay_frame (struct frame *f, int preemption_check)
 {
 struct device *d = XDEVICE (f->device);
 if (preemption_check)
 int preempted;
 REDISPLAY_PREEMPTION_CHECK;
 if (preempted)
 	return 1;
+}
+if (!internal_equal (f->old_buffer_alist, f->buffer_alist, 0))
+{
+Lisp_Object frame;
+f->old_buffer_alist = Freplace_list (f->old_buffer_alist,
+					   f->buffer_alist);
+XSETFRAME (frame, f);
+va_run_hook_with_args (Qbuffer_list_changed_hook, 1, frame);
 }
 /* Before we put a hold on frame size changes, attempt to process
 any which are already pending. */
 if (f->size_change_pending)
 the menubar's visibility.  This way we avoid having flashing
 caused by an Expose event generated by the visibility change
 being handled. */
 update_frame_menubars (f);
 #endif /* HAVE_MENUBARS */
-/* widgets are similar to menus in that they can call lisp to
-determine activation etc. Therefore update them before we get
-into redisplay. This is primarily for connected widgets such as
-radio buttons. */
-update_frame_subwindows (f);
 #ifdef HAVE_TOOLBARS
 /* Update the toolbars. */
 update_frame_toolbars (f);
 #endif /* HAVE_TOOLBARS */
+/* Gutter update proper has to be done inside display when no frame
+size changes can occur, thus we separately update the gutter
+geometry here if it needs it. */
+update_frame_gutter_geometry (f);
 /* If we clear the frame we have to force its contents to be redrawn. */
 if (f->clear)
 f->frame_changed = 1;
-/* invalidate the subwindow cache. We use subwindows_changed here to
+/* Invalidate the subwindow caches. We use subwindows_changed here
-cause subwindows to get instantiated. This is because
+to cause subwindows to get instantiated. This is because
 subwindows_state_changed is less strict - dealing with things
 like the clicked state of button. We have to do this before
 redisplaying the gutters as subwindows get unmapped in the
 process.*/
-if (!Dynarr_length (f->subwindow_cachels)
+if (f->frame_changed)
-|| f->subwindows_changed
+reset_frame_subwindow_instance_cache (f);
-|| f->faces_changed
-|| f->frame_changed)
+if (f->frame_changed || f->subwindows_changed)
 {
-reset_subwindow_cachels (f);
 /* we have to do this so the gutter gets regenerated. */
 reset_gutter_display_lines (f);
 }
-else
-mark_subwindow_cachels_as_not_updated (f);
-/* We can now update the gutters, safe in the knowledge that our
-efforts won't get undone. */
-update_frame_gutters (f);
 hold_frame_size_changes ();
 /* ----------------- BEGIN CRITICAL REDISPLAY SECTION ---------------- */
 /* Within this section, we are defenseless and assume that the
 we simply return. #### We should abort instead.
 #### If a frame-size change does occur we should probably
 actually be preempting redisplay. */
+MAYBE_DEVMETH (d, frame_output_begin, (f));
+/* We can now update the gutters, safe in the knowledge that our
+efforts won't get undone. */
+/* This can call lisp, but redisplay is protected by binding
+inhibit_quit.  More importantly the code involving display lines
+*assumes* that GC will not happen and so does not GCPRO
+anything. Since we use this code the whole time with the gutters
+we cannot allow GC to happen when manipulating the gutters. */
+update_frame_gutters (f);
 /* Erase the frame before outputting its contents. */
 if (f->clear)
 {
-DEVMETH (d, clear_frame, (f));
+MAYBE_DEVMETH (d, clear_frame, (f));
 }
 /* Do the selected window first. */
 redisplay_window (FRAME_SELECTED_WINDOW (f), 0);
 /* Then do the rest. */
 redisplay_windows (f->root_window, 1);
-/* We now call the output_end routine for tty frames.  We delay
+MAYBE_DEVMETH (d, frame_output_end, (f));
-doing so in order to avoid cursor flicker.  So much for 100%
-encapsulation. */
-if (FRAME_TTY_P (f))
-DEVMETH (d, output_end, (d));
 update_frame_title (f);
 CLASS_RESET_CHANGED_FLAGS (f);
 f->window_face_cache_reset = 0;
 static void
 decode_mode_spec (struct window *w, Emchar spec, int type)
 {
 Lisp_Object obj = Qnil;
-CONST char *str = NULL;
+const char *str = NULL;
 struct buffer *b = XBUFFER (w->buffer);
 Dynarr_reset (mode_spec_bufbyte_string);
 switch (spec)
 	char buf[32];
 	long_to_string (buf, col);
 	Dynarr_add_many (mode_spec_bufbyte_string,
-			 (CONST Bufbyte *) buf, strlen (buf));
+			 (const Bufbyte *) buf, strlen (buf));
 	goto decode_mode_spec_done;
 }
 /* print the file coding system */
 case 'C':
 	    mark_object (gb->extent);
 	}
 }
 }
-static void
+/* See the comment in image_instantiate_cache_result as to why marking
+the glyph will also mark the image_instance. */
+void
 mark_redisplay_structs (display_line_dynarr *dla)
 {
 display_line *dl = Dynarr_atp (dla, 0);
 display_line *dl_last = Dynarr_atp (dla, Dynarr_length (dla));
 FRAME_LOOP_NO_BREAK (frmcons, devcons, concons)
 {
 struct frame *f = XFRAME (XCAR (frmcons));
 update_frame_window_mirror (f);
 mark_window_mirror (f->root_mirror);
+mark_gutters (f);
 }
 }
 /*****************************************************************************
 Line Start Cache Description and Rationale
 /* For the given window W, if display starts at STARTP, what will be
 the buffer position at the beginning or end of the last line
 displayed.  The end of the last line is also know as the window end
 position.
+WARNING: It is possible that redisplay failed to layout any lines for the
+windows. Under normal circumstances this is rare. However it seems that it
+does occur in the following situation: A mouse event has come in and we
+need to compute its location in a window. That code (in
+pixel_to_glyph_translation) already can handle 0 as an error return value.
 #### With a little work this could probably be reworked as just a
 call to start_with_line_at_pixpos. */
 static Bufpos
-start_end_of_last_line (struct window *w, Bufpos startp, int end)
+start_end_of_last_line (struct window *w, Bufpos startp, int end,
+int may_error)
 {
 struct buffer *b = XBUFFER (w->buffer);
 line_start_cache_dynarr *cache = w->line_start_cache;
 int pixpos = 0;
 int bottom = WINDOW_TEXT_HEIGHT (w);
 startp = BUF_ZV (b);
 cur_start = startp;
 start_elt = point_in_line_start_cache (w, cur_start, 0);
 if (start_elt == -1)
-abort ();	/* this had better never happen */
+return may_error ? 0 : startp;
 while (1)
 {
 int height = Dynarr_atp (cache, start_elt)->height;
 the buffer position at the beginning of the last line displayed. */
 Bufpos
 start_of_last_line (struct window *w, Bufpos startp)
 {
-return start_end_of_last_line (w, startp, 0);
+return start_end_of_last_line (w, startp, 0 , 0);
 }
 /* For the given window W, if display starts at STARTP, what will be
 the buffer position at the end of the last line displayed.  This is
 also know as the window end position. */
 Bufpos
 end_of_last_line (struct window *w, Bufpos startp)
 {
-return start_end_of_last_line (w, startp, 1);
+return start_end_of_last_line (w, startp, 1, 0);
 }
+static Bufpos
+end_of_last_line_may_error (struct window *w, Bufpos startp)
+{
+return start_end_of_last_line (w, startp, 1, 1);
+}
 /* For window W, what does the starting position have to be so that
 the line containing POINT will cover pixel position PIXPOS. */
 Bufpos
 line_start_cache_dynarr *cache = w->line_start_cache;
 Bufpos low_bound, high_bound;
 validate_line_start_cache (w);
 w->line_cache_validation_override++;
-updating_line_start_cache = 1;
 if (from < BUF_BEGV (b))
 from = BUF_BEGV (b);
 if (to > BUF_ZV (b))
 to = BUF_ZV (b);
 if (from > to)
 {
-updating_line_start_cache = 0;
 w->line_cache_validation_override--;
 return;
 }
 if (Dynarr_length (cache))
 high_bound = line_start_cache_end (w);
 /* Check to see if the desired range is already in the cache. */
 if (from >= low_bound && to <= high_bound)
 	{
-	  updating_line_start_cache = 0;
 	  w->line_cache_validation_override--;
 	  return;
 	}
 /* Check to make sure that the desired range is adjacent to the
 Bufpos start, end;
 update_internal_cache_list (w, DESIRED_DISP);
 if (!Dynarr_length (internal_cache))
 	{
-	  updating_line_start_cache = 0;
 	  w->line_cache_validation_override--;
 	  return;
 	}
 start = Dynarr_atp (internal_cache, 0)->start;
 if (!Dynarr_length (cache))
 	{
 	  Dynarr_add_many (cache, Dynarr_atp (internal_cache, 0),
 			   Dynarr_length (internal_cache));
-	  updating_line_start_cache = 0;
 	  w->line_cache_validation_override--;
 	  return;
 	}
 /* An extra check just in case the calling function didn't pass in
 the bounds of the DESIRED structs in the first place. */
 if (start >= low_bound && end <= high_bound)
 	{
-	  updating_line_start_cache = 0;
 	  w->line_cache_validation_override--;
 	  return;
 	}
 /* At this point we know that the internal cache partially overlaps
 	  if (!(ic_elt >= 0))
 	    {
 	      Dynarr_reset (cache);
 	      Dynarr_add_many (cache, Dynarr_atp (internal_cache, 0),
 			       Dynarr_length (internal_cache));
-	      updating_line_start_cache = 0;
 	      w->line_cache_validation_override--;
 	      return;
 	    }
 	  Dynarr_insert_many_at_start (cache, Dynarr_atp (internal_cache, 0),
 	  if (!(ic_elt < Dynarr_length (internal_cache)))
 	    {
 	      Dynarr_reset (cache);
 	      Dynarr_add_many (cache, Dynarr_atp (internal_cache, 0),
 			       Dynarr_length (internal_cache));
-	      updating_line_start_cache = 0;
 	      w->line_cache_validation_override--;
 	      return;
 	    }
 	  Dynarr_add_many (cache, Dynarr_atp (internal_cache, ic_elt),
 			   Dynarr_length (internal_cache) - ic_elt);
 	}
-updating_line_start_cache = 0;
 w->line_cache_validation_override--;
 return;
 }
 if (!Dynarr_length (cache) || from < low_bound)
 	  regenerate_window (w, startp, point, CMOTION_DISP);
 	  update_internal_cache_list (w, CMOTION_DISP);
 	  /* If this assert is triggered then regenerate_window failed
-to layout a single line.  That is not supposed to be
+to layout a single line. This is not possible since we
-possible because we impose a minimum height on the buffer
+	     force at least a single line to be layout for CMOTION_DISP */
-and override vertical clip when we are in here. */
+	  assert (Dynarr_length (internal_cache));
-	  /* #### Ah, but it is because the window may temporarily
-exist but not have any lines at all if the minibuffer is
-real big.  Look into that situation better. */
-	  if (!Dynarr_length (internal_cache))
-	    {
-	      if (old_lb == -1 && low_bound == -1)
-		{
-		  updating_line_start_cache = 0;
-		  w->line_cache_validation_override--;
-		  return;
-		}
-	      assert (Dynarr_length (internal_cache));
-	    }
 	  assert (startp == Dynarr_atp (internal_cache, 0)->start);
 	  ic_elt = Dynarr_length (internal_cache) - 1;
 	  if (low_bound != -1)
 	    {
 	  if (startp < low_bound || low_bound == -1)
 	    low_bound = startp;
 	  startp = new_startp;
 	  if (startp > BUF_ZV (b))
 	    {
-	      updating_line_start_cache = 0;
 	      w->line_cache_validation_override--;
 	      return;
 	    }
 	}
 }
 	  startp = high_bound + 1;
 	}
 while (to > high_bound);
 }
-updating_line_start_cache = 0;
 w->line_cache_validation_override--;
 assert (to <= high_bound);
 }
 /* #### This should be checked out some more to determine what
 should really be going on. */
 if (!MARKERP ((*w)->start[CURRENT_DISP]))
 *closest = 0;
 else
-*closest = end_of_last_line (*w,
+*closest = end_of_last_line_may_error (*w,
 				 marker_position ((*w)->start[CURRENT_DISP]));
 *col = 0;
 UPDATE_CACHE_RETURN;
 }
 #undef UPDATE_CACHE_RETURN
 	  struct frame *f = XFRAME (XCAR (frmcons));
 	  if (FRAME_REPAINT_P (f) && FRAME_HAS_MINIBUF_P (f))
 	    {
 	      Lisp_Object window = FRAME_MINIBUF_WINDOW (f);
+	      MAYBE_DEVMETH (d, frame_output_begin, (f));
 	      /*
 	       * If the frame size has changed, there may be random
 	       * chud on the screen left from previous messages
 	       * because redisplay_frame hasn't been called yet.
 	       * Clear the screen to get rid of the potential mess.
 	       */
 	      if (f->echo_area_garbaged)
 		{
-		  DEVMETH (d, clear_frame, (f));
+		  MAYBE_DEVMETH (d, clear_frame, (f));
 		  f->echo_area_garbaged = 0;
 		}
 	      redisplay_window (window, 0);
+	      MAYBE_DEVMETH (d, frame_output_end, (f));
 	      call_redisplay_end_triggers (XWINDOW (window), 0);
 	    }
 	}
-/* We now call the output_end routine for tty frames.  We delay
-	 doing so in order to avoid cursor flicker.  So much for 100%
-	 encapsulation. */
-if (DEVICE_TTY_P (d))
-	DEVMETH (d, output_end, (d));
 }
 return Qnil;
 }
 disable_preemption++;
 }
 f->clear = 1;
 redisplay_frame (f, 1);
+/* See the comment in Fredisplay_frame. */
+RESET_CHANGED_SET_FLAGS;
 return unbind_to (count, Qnil);
 }
 DEFUN ("redisplay-frame", Fredisplay_frame, 0, 2, 0, /*
 disable_preemption++;
 }
 redisplay_frame (f, 1);
+/* If we don't reset the global redisplay flags here, subsequent
+changes to the display will not get registered by redisplay
+because it thinks it already has registered changes. If you
+really knew what you were doing you could confuse redisplay by
+calling Fredisplay_frame while updating another frame. We assume
+that if you know what you are doing you will not be that
+stupid. */
+RESET_CHANGED_SET_FLAGS;
 return unbind_to (count, Qnil);
 }
 DEFUN ("redraw-device", Fredraw_device, 0, 2, 0, /*
 Clear device DEVICE and output again what is supposed to appear on it.
 DEVICE_FRAME_LOOP (frmcons, d)
 {
 XFRAME (XCAR (frmcons))->clear = 1;
 }
 redisplay_device (d, 0);
+/* See the comment in Fredisplay_frame. */
+RESET_CHANGED_SET_FLAGS;
 return unbind_to (count, Qnil);
 }
 DEFUN ("redisplay-device", Fredisplay_device, 0, 2, 0, /*
 			     make_int (disable_preemption));
 disable_preemption++;
 }
 redisplay_device (d, 0);
+/* See the comment in Fredisplay_frame. */
+RESET_CHANGED_SET_FLAGS;
 return unbind_to (count, Qnil);
 }
 /* Big lie.  Big lie.  This will force all modelines to be updated
 #endif /* INHIBIT_REDISPLAY_HOOKS */
 defsymbol (&Qdisplay_warning_buffer, "display-warning-buffer");
 defsymbol (&Qbar_cursor, "bar-cursor");
 defsymbol (&Qredisplay_end_trigger_functions,
 	     "redisplay-end-trigger-functions");
+defsymbol (&Qtop_bottom, "top-bottom");
+defsymbol (&Qbuffer_list_changed_hook, "buffer-list-changed-hook");
 DEFSUBR (Fredisplay_echo_area);
 DEFSUBR (Fredraw_frame);
 DEFSUBR (Fredisplay_frame);
 DEFSUBR (Fredraw_device);
 DEFSUBR (Fredraw_modeline);
 DEFSUBR (Fforce_cursor_redisplay);
 }
 void
-reinit_vars_of_redisplay (void)
-{
-updating_line_start_cache = 0;
-}
-void
 vars_of_redisplay (void)
 {
-reinit_vars_of_redisplay ();
 #if 0
 staticpro (&last_arrow_position);
 staticpro (&last_arrow_string);
 last_arrow_position = Qnil;
 */ ,
 		     redisplay_variable_changed);
 Voverlay_arrow_position = Qnil;
 DEFVAR_LISP_MAGIC ("overlay-arrow-string", &Voverlay_arrow_string /*
-String to display as an arrow.  See also `overlay-arrow-position'.
+String or glyph to display as an arrow.  See also `overlay-arrow-position'.
+(Note that despite the name of this variable, it can be set to a glyph as
+well as a string.)
 */ ,
 		     redisplay_variable_changed);
 Voverlay_arrow_string = Qnil;
 DEFVAR_INT ("scroll-step", &scroll_step /*
 *Non-nil means truncate lines in all windows less than full frame wide.
 */ ,
 		     redisplay_variable_changed);
 truncate_partial_width_windows = 1;
-DEFVAR_BOOL ("visible-bell", &visible_bell /*
+DEFVAR_LISP ("visible-bell", &Vvisible_bell /*
-*Non-nil means try to flash the frame to represent a bell.
+*Non-nil substitutes a visual signal for the audible bell.
+Default behavior is to flash the whole screen.  On some platforms,
+special effects are available using the following values:
+'display       Flash the whole screen (ie, the default behavior).
+'top-bottom    Flash only the top and bottom lines of the selected frame.
+When effects are unavailable on a platform, the visual bell is the
+default, whole screen.  (Currently only X supports any special effects.)
 */ );
-visible_bell = 0;
+Vvisible_bell = Qnil;
 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter /*
 *Non-nil means no need to redraw entire frame after suspending.
 A non-nil value is useful if the terminal can automatically preserve
 Emacs's frame display when you reenter Emacs.
 Vbar_cursor = Qnil;
 #ifndef INHIBIT_REDISPLAY_HOOKS
 xxDEFVAR_LISP ("pre-redisplay-hook", &Vpre_redisplay_hook /*
 Function or functions to run before every redisplay.
-Functions on this hook must be careful to avoid signalling errors!
 */ );
 Vpre_redisplay_hook = Qnil;
 xxDEFVAR_LISP ("post-redisplay-hook", &Vpost_redisplay_hook /*
 Function or functions to run after every redisplay.
-Functions on this hook must be careful to avoid signalling errors!
 */ );
 Vpost_redisplay_hook = Qnil;
 #endif /* INHIBIT_REDISPLAY_HOOKS */
+DEFVAR_LISP ("buffer-list-changed-hook", &Vbuffer_list_changed_hook /*
+Function or functions to call when a frame's buffer list has changed.
+This is called during redisplay, before redisplaying each frame.
+Functions on this hook are called with one argument, the frame.
+*/ );
+Vbuffer_list_changed_hook = Qnil;
 DEFVAR_INT ("display-warning-tick", &display_warning_tick /*
 Bump this to tell the C code to call `display-warning-buffer'
 at next redisplay.  You should not normally change this; the function
 `display-warning' automatically does this at appropriate times.

Mercurial > hg > xemacs-beta

comparison src/redisplay.c @ 442:abe6d1db359e r21-2-36