xemacs-beta: src/redisplay.c comparison

comparison src/redisplay.c @ 424:11054d720c21 r21-2-20

Import from CVS: tag r21-2-20

author	cvs
date	Mon, 13 Aug 2007 11:26:11 +0200
parents	95016f13131a
children

comparison

equal deleted inserted replaced

-:28d9c139be4c
+:11054d720c21
 			   need to be skipped.  This is used for horizontal
 			   scrolling, where a certain number of columns
 			   (those off the left side of the screen) need
 			   to be skipped before anything is displayed. */
 Bytind bi_start_col_enabled;
+int start_col_xoffset;	/* Number of pixels that still need to
+			   be skipped.  This is used for
+			   horizontal scrolling of glyphs, where we want
+			   to be able to scroll over part of the glyph. */
 int hscroll_glyph_width_adjust;  /* how much the width of the hscroll
 				      glyph differs from space_width (w).
 				      0 if no hscroll glyph was used,
 				      i.e. the window is not scrolled
 static prop_block_dynarr *add_glyph_rune (pos_data *data,
 					  struct glyph_block *gb,
 					  int pos_type, int allow_cursor,
 					  struct glyph_cachel *cachel);
 static Bytind create_text_block (struct window *w, struct display_line *dl,
-				 Bytind bi_start_pos, int start_col,
+				 Bytind bi_start_pos, prop_block_dynarr **prop,
-				 prop_block_dynarr **prop,
 				 int type);
 static int create_overlay_glyph_block (struct window *w,
 				       struct display_line *dl);
 static void create_left_glyph_block (struct window *w,
 				     struct display_line *dl,
 static void decode_mode_spec (struct window *w, Emchar spec, int type);
 static void free_display_line (struct display_line *dl);
 static void update_line_start_cache (struct window *w, Bufpos from, Bufpos to,
 				     Bufpos point, int no_regen);
 static int point_visible (struct window *w, Bufpos point, int type);
-extern Bytind bi_find_next_emchar_in_string (struct Lisp_String* str, Emchar target,
-					     Bytind st, EMACS_INT count);
-extern int string_column_at_point (struct Lisp_String* s, Bufpos init_pos, int tab_width);
 /* This used to be 10 but 30 seems to give much better performance. */
 #define INIT_MAX_PREEMPTS	30
 static int max_preempts;
 isn't any reason we need more than a single set. */
 display_line_dynarr *cmotion_display_lines;
 /* Used by generate_formatted_string.  Global because they get used so
 much that the dynamic allocation time adds up. */
-Emchar_dynarr *formatted_string_emchar_dynarr;
+static Emchar_dynarr *formatted_string_emchar_dynarr;
-struct display_line formatted_string_display_line;
+static struct display_line formatted_string_display_line;
 /* We store the extents that we need to generate in a Dynarr and then
 frob them all on at the end of generating the string.  We do it
 this way rather than adding them as we generate the string because
 we don't store the text into the resulting string until we're done
 (to avoid having to resize the string multiple times), and we don't
 want to go around adding extents to a string when the extents might
 stretch off the end of the string. */
-EXTENT_dynarr *formatted_string_extent_dynarr;
+static EXTENT_dynarr *formatted_string_extent_dynarr;
-Bytecount_dynarr *formatted_string_extent_start_dynarr;
+static Bytecount_dynarr *formatted_string_extent_start_dynarr;
-Bytecount_dynarr *formatted_string_extent_end_dynarr;
+static Bytecount_dynarr *formatted_string_extent_end_dynarr;
 /* #### probably temporary */
 int cache_adjustment;
 /* Minimum visible pixel width of clipped glyphs at right margin. */
 int horizontal_clip;
 /* Set if currently inside update_line_start_cache. */
-int updating_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;
 /* non-zero if any displayed subwindow is in need of updating
 somewhere. */
 int subwindows_changed;
 int subwindows_changed_set;
+/* non-zero if any displayed subwindow is in need of updating
+somewhere. */
+int subwindows_state_changed;
+int subwindows_state_changed_set;
 /* This variable is 1 if the icon has to be updated.
 It is set to 1 when `frame-icon-glyph' changes. */
 int icon_changed;
 int icon_changed_set;
 Lisp_Object Voverlay_arrow_position;
 /* String to display for the arrow.  */
 Lisp_Object Voverlay_arrow_string;
 Lisp_Object Vwindow_size_change_functions;
-Lisp_Object Qwindow_scroll_functions, Vwindow_scroll_functions;
+Lisp_Object Vwindow_scroll_functions;
 Lisp_Object Qredisplay_end_trigger_functions, Vredisplay_end_trigger_functions;
 #define INHIBIT_REDISPLAY_HOOKS  /* #### Until we've thought about
 				    this more. */
 #ifndef INHIBIT_REDISPLAY_HOOKS
 Think about this for 19.14. */
 Lisp_Object Vpre_redisplay_hook, Vpost_redisplay_hook;
 Lisp_Object Qpre_redisplay_hook, Qpost_redisplay_hook;
 #endif /* INHIBIT_REDISPLAY_HOOKS */
-int last_display_warning_tick, display_warning_tick;
+static int last_display_warning_tick, display_warning_tick;
 Lisp_Object Qdisplay_warning_buffer;
 int inhibit_warning_display;
 Lisp_Object Vleft_margin_width, Vright_margin_width;
 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;
+#define WINDOW_SCROLLED(w) \
+(w->hscroll > 0 || w->left_xoffset)
 /***************************************************************************/
 /*									   */
 /*              low-level interfaces onto device routines                  */
 /*									   */
 {
 int n_pos = left_pixpos;
 int pix_tab_width = tab_pix_width (w);
 /* Adjust n_pos for any hscrolling which has happened. */
-if (w->hscroll > 1)
+if (WINDOW_SCROLLED (w))
-n_pos -= space_width (w) * (w->hscroll - 1);
+n_pos -= space_width (w) * (w->hscroll - 1) + w->left_xoffset;
 while (n_pos <= start_pixpos)
 n_pos += pix_tab_width;
 return n_pos;
 when the contents of the line reach the right boundary of the given
 window. */
 static Bufpos
 generate_display_line (struct window *w, struct display_line *dl, int bounds,
-		       Bufpos start_pos, int start_col,
+		       Bufpos start_pos, prop_block_dynarr **prop,
-		       prop_block_dynarr **prop,
 		       int type)
 {
 Bufpos ret_bufpos;
 int overlay_width;
 struct buffer *b = XBUFFER (WINDOW_BUFFER (w));
 /* Create a display block for the text region of the line. */
 {
 /* #### urk urk urk!!! Chuck fix this shit! */
 Bytind hacked_up_bytind =
 create_text_block (w, dl, bufpos_to_bytind (b, start_pos),
-			 start_col, prop, type);
+			 prop, type);
 if (hacked_up_bytind > BI_BUF_ZV (b))
 ret_bufpos = BUF_ZV (b) + 1;
 else
 ret_bufpos = bytind_to_bufpos (b, hacked_up_bytind);
 }
 	width = glyph_width (gb->glyph, Qnil, data->findex, data->window);
 if (!width)
 	return NULL;
-if (data->start_col)
+if (data->start_col || data->start_col_xoffset)
 	{
 	  prop_block_dynarr *retval;
 	  int glyph_char_width = width / space_width (w);
 	  /* If we still have not fully scrolled horizontally after
 NOTE NOTE NOTE NOTE: This function works with and returns Bytinds.
 You must do appropriate conversion. */
 static Bytind
 create_text_block (struct window *w, struct display_line *dl,
-		   Bytind bi_start_pos, int start_col,
+		   Bytind bi_start_pos, prop_block_dynarr **prop,
-		   prop_block_dynarr **prop,
 		   int type)
 {
 struct frame *f = XFRAME (w->frame);
 struct buffer *b = XBUFFER (w->buffer);
 struct device *d = XDEVICE (f->device);
 else
 data.cursor_type = NO_CURSOR;
 data.cursor_x = -1;
 data.start_col = w->hscroll;
+data.start_col_xoffset = w->left_xoffset;
 data.bi_start_col_enabled = (w->hscroll ? bi_start_pos : 0);
 data.hscroll_glyph_width_adjust = 0;
 /* We regenerate the line from the very beginning. */
 Dynarr_reset (db->runes);
 that the cursor shows up properly. */
 		  data.ch = '\n';
 		  data.blank_width = DEVMETH (d, eol_cursor_width, ());
 		  data.findex = DEFAULT_INDEX;
 		  data.start_col = 0;
+		  data.start_col_xoffset = 0;
 		  data.bi_start_col_enabled = 0;
 		  add_emchar_rune (&data);
 		}
 	      int next_tab_start;
 	      int char_tab_width;
 	      int prop_width = 0;
 	      if (data.start_col > 1)
-		tab_start_pixpos -= (space_width (w) * (data.start_col - 1));
+		tab_start_pixpos -= (space_width (w) * (data.start_col - 1))
+		  + data.start_col_xoffset;
 	      next_tab_start =
 		next_tab_position (w, tab_start_pixpos,
 				   dl->bounds.left_in +
 				   data.hscroll_glyph_width_adjust);
 data.ch = '\n';
 data.blank_width = DEVMETH (d, eol_cursor_width, ());
 data.findex = DEFAULT_INDEX;
 data.start_col = 0;
+data.start_col_xoffset = 0;
 data.bi_start_col_enabled = 0;
 data.max_pixpos += data.blank_width;
 add_emchar_rune (&data);
 data.max_pixpos -= data.blank_width;
 			  face_index default_face)
 {
 struct frame *f = XFRAME (w->frame);
 /* Note that a lot of the buffer controlled stuff has been left in
 because you might well want to make use of it (selective display
-etc), its just the buffer text that we do not use. */
+etc), its just the buffer text that we do not use. However, it
-struct buffer *b = XBUFFER (w->buffer);
+seems to be possible for buffer to be nil sometimes so protect
+against this case. */
+struct buffer *b = BUFFERP (w->buffer) ? XBUFFER (w->buffer) : 0;
 struct device *d = XDEVICE (f->device);
 struct Lisp_String* s = XSTRING (disp_string);
 /* we're working with these a lot so precalculate them */
 Bytecount slen = XSTRING_LENGTH (disp_string);
 Bytecount bi_string_zv = slen;
 Bytind bi_start_pos = charcount_to_bytecount (string_data (s), start_pos);
 pos_data data;
-int truncate_win = window_truncation_on (w);
+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
 FSF thing and invisble extents are the way to go
 here. Implementing it also relies on a number of buffer-specific
 #s(range-table data ((256 524288) (format "%x")))
 Since more than one display table is possible, you have
 great flexibility in mapping ranges of characters.  */
-Emchar printable_min = (CHAR_OR_CHAR_INTP (b->ctl_arrow)
+Emchar printable_min = b ? (CHAR_OR_CHAR_INTP (b->ctl_arrow)
 			  ? XCHAR_OR_CHAR_INT (b->ctl_arrow)
 			  : ((EQ (b->ctl_arrow, Qt) || EQ (b->ctl_arrow, Qnil))
-			     ? 255 : 160));
+			     ? 255 : 160)) : 255;
 Lisp_Object face_dt, window_dt;
 /* The text display block for this display line. */
 struct display_block *db = get_display_block_from_line (dl, TEXT);
 	    }
 	}
 }
 else if (data.bi_bufpos == bi_string_zv)
 {
-/* We need to add a marker to the end of the line since there is no
+/* create_text_block () adds a bogus \n marker here which screws
-newline character in order for the cursor to get drawn.  We label
+	 up subwindow display. Since we never have a cursor in the
-it as a newline so that it gets handled correctly by the
+	 gutter we can safely ignore it. */
-whitespace routines below. */
+}
-data.ch = '\n';
-data.blank_width = DEVMETH (d, eol_cursor_width, ());
-data.findex = default_face;
-data.start_col = 0;
-data.bi_start_col_enabled = 0;
-data.max_pixpos += data.blank_width;
-add_emchar_rune (&data);
-data.max_pixpos -= data.blank_width;
-/* #### urk!  Chuck, this shit is bad news.  Going around
-	 manipulating invalid positions is guaranteed to result in
-	 trouble sooner or later. */
-data.bi_bufpos = bi_string_zv + 1;
-}
 /* Calculate left whitespace boundary. */
 {
 int elt = 0;
 /* Whitespace past a newline is considered right whitespace. */
 dl->end_bufpos = buffer_or_string_bytind_to_bufpos (disp_string, bi_string_zv);
 else
 dl->end_bufpos = buffer_or_string_bytind_to_bufpos (disp_string, data.bi_bufpos) - 1;
 if (truncate_win)
 data.dl->num_chars =
-string_column_at_point (s, dl->end_bufpos, XINT (b->tab_width));
+string_column_at_point (s, dl->end_bufpos, b ? XINT (b->tab_width) : 8);
 else
 /* This doesn't correctly take into account tabs and control
 characters but if the window isn't being truncated then this
 value isn't going to end up being used anyhow. */
 data.dl->num_chars = dl->end_bufpos - dl->bufpos;
 			      face_index default_face)
 {
 Bufpos ret_bufpos;
 /* you must set bounds before calling this. */
 /* Reset what this line is using. */
 if (dl->display_blocks)
 Dynarr_reset (dl->display_blocks);
 if (dl->left_glyphs)
 {
 /* if there's nothing to do then do nothing. code after this assumes
 there is something to do. */
 if (NILP (disp_string))
 return;
-s_zv = XSTRING_CHAR_LENGTH (disp_string) - 1;
+s_zv = XSTRING_CHAR_LENGTH (disp_string);
 bounds.left_out = xpos;
 bounds.right_out = xpos + width;
 /* The inner boundaries mark where the glyph margins are located. */
 bounds.left_in = bounds.left_out + window_left_margin_width (w);
 {
 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);
 prop_block_dynarr *prop;
 layout_bounds bounds;
 display_line_dynarr *dla;
 int need_modeline;
 	  local = 1;
 	}
 dlp->bounds = bounds;
 dlp->offset = 0;
-start_pos = generate_display_line (w, dlp, 1, start_pos,
+start_pos = generate_display_line (w, dlp, 1, start_pos, &prop, type);
-					 w->hscroll, &prop, type);
-dlp->ypos = ypos + dlp->ascent;
+if (yclip > dlp->ascent)
+	{
+	  /* this should never happen, but if it does just display the
+	     whole line */
+	  yclip = 0;
+	}
+dlp->ypos = (ypos + dlp->ascent) - yclip;
 ypos = dlp->ypos + dlp->descent;
+/* See if we've been asked to start midway through a line, for
+partial display line scrolling. */
+if (yclip)
+	{
+	  dlp->top_clip = yclip;
+	  yclip = 0;
+	}
+else
+	dlp->top_clip = 0;
 if (ypos > yend)
 	{
 	  int visible_height = dlp->ascent + dlp->descent;
 	  dlp->clip = (ypos - yend);
-	  visible_height -= dlp->clip;
+	  /* 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 (local)
 		free_display_line (dlp);
 we'll have the necessary propagation data. */
 if (line == first_line && ddl->used_prop_data)
 	return 0;
 new_start = generate_display_line (w, ddl, 0, ddl->bufpos + ddl->offset,
-					 w->hscroll, &prop, DESIRED_DISP);
+					 &prop, DESIRED_DISP);
 ddl->offset = 0;
 /* #### If there is propagated stuff the fail.  We could
 probably actually deal with this if the line had propagated
 information when originally created by a full
 cursor has disappeared or disappeared, fail.  */
 db = get_display_block_from_line (ddl, TEXT);
 if (cdl->ypos != ddl->ypos
 	  || cdl->ascent != ddl->ascent
 	  || cdl->descent != ddl->descent
+	  || cdl->top_clip != ddl->top_clip
 	  || (cdl->cursor_elt != -1 && ddl->cursor_elt == -1)
 	  || (cdl->cursor_elt == -1 && ddl->cursor_elt != -1)
 	  || old_start != ddl->bufpos
 	  || old_end != ddl->end_bufpos
 	  || initial_size != Dynarr_length (db->runes))
 /* If the line was generated using propagation data, fail. */
 if (ddl->used_prop_data)
 	return 0;
 new_start = generate_display_line (w, ddl, 0, ddl->bufpos + ddl->offset,
-					 w->hscroll, &prop, DESIRED_DISP);
+					 &prop, DESIRED_DISP);
 ddl->offset = 0;
 /* If there is propagated stuff then it is pretty much a
 guarantee that more than just the one line is affected. */
 if (prop)
 /* If any line position parameters have changed or a
 cursor has disappeared or disappeared, fail. */
 if (cdl->ypos != ddl->ypos
 	  || cdl->ascent != ddl->ascent
 	  || cdl->descent != ddl->descent
+	  || cdl->top_clip != ddl->top_clip
 	  || (cdl->cursor_elt != -1 && ddl->cursor_elt == -1)
 	  || (cdl->cursor_elt == -1 && ddl->cursor_elt != -1))
 	{
 	  return 0;
 	}
 || f->faces_changed)
 reset_face_cachels (w);
 else
 mark_face_cachels_as_not_updated (w);
-/* Ditto the glyph cache elements. */
+/* Ditto the glyph cache elements, although we do *not* invalidate
+the cache purely because glyphs have changed - this is now
+handled by the dirty flag.*/
 if ((!echo_active && b != window_display_buffer (w))
-|| !Dynarr_length (w->glyph_cachels)
+|| !Dynarr_length (w->glyph_cachels))
-|| f->glyphs_changed)
 reset_glyph_cachels (w);
 else
 mark_glyph_cachels_as_not_updated (w);
 /* If the marker's buffer is not the window's buffer, then we need
 	  && !f->clip_changed
 	  && !f->extents_changed
 	  && !f->faces_changed
 	  && !f->glyphs_changed
 	  && !f->subwindows_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->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->windows_structure_changed
 	   && !f->frame_changed
 	   && !truncation_changed
 	   && pointm >= startp
 	   && regenerate_window_incrementally (w, startp, pointm))
 /* #### This should be dependent on face changes and will need to be
 somewhere else once tty updates occur on a per-frame basis. */
 mark_face_cachels_as_clean (w);
+/* The glyph cachels only get dirty if someone changed something. */
+if (glyphs_changed)
+mark_glyph_cachels_as_clean (w);
 w->windows_changed = 0;
 }
 /* Call buffer_reset_changes for all buffers present in any window
 currently visible in all frames on all devices.  #### There has to
 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 */
-update_frame_gutters (f);
 /* 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 */
+/* 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
+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)
+|| f->subwindows_changed
+|| f->frame_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
 following cannot happen:
 we simply return. #### We should abort instead.
 #### If a frame-size change does occur we should probably
 actually be preempting redisplay. */
-/* If we clear the frame we have to force its contents to be redrawn. */
-if (f->clear)
-f->frame_changed = 1;
 /* Erase the frame before outputting its contents. */
 if (f->clear)
 {
 DEVMETH (d, clear_frame, (f));
 }
-/* invalidate the subwindow cache. we are going to reuse the glyphs
-flag here to cause subwindows to get instantiated. This is
-because subwindows changed is less strict - dealing with things
-like the clicked state of button. */
-if (!Dynarr_length (f->subwindow_cachels)
-|| f->glyphs_changed
-|| f->frame_changed)
-reset_subwindow_cachels (f);
-else
-mark_subwindow_cachels_as_not_updated (f);
 /* Do the selected window first. */
 redisplay_window (FRAME_SELECTED_WINDOW (f), 0);
 /* Then do the rest. */
 if (FRAME_TTY_P (f))
 DEVMETH (d, output_end, (d));
 update_frame_title (f);
-f->buffers_changed  = 0;
+CLASS_RESET_CHANGED_FLAGS (f);
-f->clip_changed     = 0;
-f->extents_changed  = 0;
-f->faces_changed    = 0;
-f->frame_changed    = 0;
-f->glyphs_changed   = 0;
-f->subwindows_changed   = 0;
-f->icon_changed     = 0;
-f->menubar_changed  = 0;
-f->modeline_changed = 0;
-f->point_changed    = 0;
-f->toolbar_changed  = 0;
-f->gutter_changed  = 0;
-f->windows_changed  = 0;
-f->windows_structure_changed = 0;
 f->window_face_cache_reset = 0;
 f->echo_area_garbaged = 0;
 f->clear = 0;
 if (!f->size_change_pending)
 f->size_changed = 0;
 if (f->icon_changed || f->windows_changed)
 update_frame_icon (f);
 if (FRAME_REPAINT_P (f))
 {
-if (f->buffers_changed  || f->clip_changed  || f->extents_changed ||
+if (CLASS_REDISPLAY_FLAGS_CHANGEDP(f))
-	  f->faces_changed    || f->frame_changed || f->menubar_changed ||
-	  f->modeline_changed || f->point_changed || f->size_changed    ||
-	  f->toolbar_changed  || f->windows_changed || f->size_slipped  ||
-	  f->windows_structure_changed || f->glyphs_changed ||
-	  f->subwindows_changed || f->gutter_changed)
 	{
 	  preempted = redisplay_frame (f, 0);
 	}
 if (preempted)
 if (f->icon_changed || f->windows_changed)
 	update_frame_icon (f);
 if (FRAME_REPAINT_P (f))
 	{
-	  if (f->buffers_changed  || f->clip_changed  || f->extents_changed ||
+	  if (CLASS_REDISPLAY_FLAGS_CHANGEDP(f)
-	      f->faces_changed    || f->frame_changed || f->menubar_changed ||
+	      || f->size_changed)
-	      f->modeline_changed || f->point_changed || f->size_changed    ||
-	      f->toolbar_changed  || f->windows_changed ||
-	      f->windows_structure_changed || f->gutter_changed ||
-	      f->glyphs_changed || f->subwindows_changed)
 	    {
 	      preempted = redisplay_frame (f, 0);
 	    }
 	  if (preempted)
 	}
 }
 /* If we get here then we redisplayed all of our frames without
 getting preempted so mark ourselves as clean. */
-d->buffers_changed  = 0;
+CLASS_RESET_CHANGED_FLAGS (d);
-d->clip_changed     = 0;
-d->extents_changed  = 0;
-d->faces_changed    = 0;
-d->frame_changed    = 0;
-d->glyphs_changed   = 0;
-d->subwindows_changed   = 0;
-d->icon_changed     = 0;
-d->menubar_changed  = 0;
-d->modeline_changed = 0;
-d->point_changed    = 0;
-d->toolbar_changed  = 0;
-d->gutter_changed  = 0;
-d->windows_changed  = 0;
-d->windows_structure_changed = 0;
 if (!size_change_failed)
 d->size_changed = 0;
 return 0;
 }
 if (asynch_device_change_pending)
 handle_asynch_device_change ();
-if (!buffers_changed && !clip_changed     && !extents_changed &&
+if (!GLOBAL_REDISPLAY_FLAGS_CHANGEDP &&
-!faces_changed   && !frame_changed    && !icon_changed    &&
+!size_changed && !disable_preemption && preemption_count < max_preempts)
-!menubar_changed && !modeline_changed && !point_changed   &&
-!size_changed    && !toolbar_changed  && !windows_changed &&
-!glyphs_changed  && !subwindows_changed &&
-!gutter_changed && !windows_structure_changed &&
-!disable_preemption && preemption_count < max_preempts)
 goto done;
 DEVICE_LOOP_NO_BREAK (devcons, concons)
 {
 struct device *d = XDEVICE (XCAR (devcons));
 int preempted;
-if (d->buffers_changed  || d->clip_changed     || d->extents_changed ||
+if (CLASS_REDISPLAY_FLAGS_CHANGEDP (d)
-	  d->faces_changed    || d->frame_changed    || d->icon_changed    ||
+	  || d->size_changed)
-	  d->menubar_changed  || d->modeline_changed || d->point_changed   ||
-	  d->size_changed     || d->toolbar_changed  || d->windows_changed ||
-	  d->windows_structure_changed || d->gutter_changed ||
-	  d->glyphs_changed || d->subwindows_changed)
 	{
 	  preempted = redisplay_device (d);
 	  if (preempted)
 	    {
 	}
 }
 preemption_count = 0;
 /* Mark redisplay as accurate */
-buffers_changed  = 0;
+GLOBAL_RESET_CHANGED_FLAGS;
-clip_changed     = 0;
-extents_changed  = 0;
-frame_changed    = 0;
-glyphs_changed   = 0;
-subwindows_changed   = 0;
-icon_changed     = 0;
-menubar_changed  = 0;
-modeline_changed = 0;
-point_changed    = 0;
-toolbar_changed  = 0;
-gutter_changed  = 0;
-windows_changed  = 0;
-windows_structure_changed = 0;
 RESET_CHANGED_SET_FLAGS;
 if (faces_changed)
 {
 mark_all_faces_as_clean ();
 /* print percent of buffer above top of window, or Top, Bot or All */
 case 'p':
 {
 Bufpos pos = marker_position (w->start[type]);
-Charcount total = BUF_ZV (b) - BUF_BEGV (b);
 /* This had better be while the desired lines are being done. */
 if (w->window_end_pos[type] <= BUF_Z (b) - BUF_ZV (b))
 	{
 	  if (pos <= BUF_BEGV (b))
 else
 	{
 	  /* This hard limit is ok since the string it will hold has a
 fixed maximum length of 3.  But just to be safe... */
 	  char buf[10];
+	  Charcount chars = pos - BUF_BEGV (b);
-	  total = ((pos - BUF_BEGV (b)) * 100 + total - 1) / total;
+	  Charcount total = BUF_ZV (b) - BUF_BEGV (b);
+	  /* Avoid overflow on big buffers */
+	  int percent = total > LONG_MAX/200 ?
+	    (chars + total/200) / (total / 100) :
+	    (chars * 100 + total/2) / total;
 	  /* We can't normally display a 3-digit number, so get us a
 2-digit number that is close. */
-	  if (total == 100)
+	  if (percent == 100)
-	    total = 99;
+	    percent = 99;
-	  sprintf (buf, "%2d%%", total);
+	  sprintf (buf, "%d%%", percent);
 	  Dynarr_add_many (mode_spec_bufbyte_string, (Bufbyte *) buf,
 			   strlen (buf));
 	  goto decode_mode_spec_done;
 	}
 Top, or print Bottom or All */
 case 'P':
 {
 Bufpos toppos = marker_position (w->start[type]);
 Bufpos botpos = BUF_Z (b) - w->window_end_pos[type];
-Charcount total = BUF_ZV (b) - BUF_BEGV (b);
 /* botpos is only accurate as of the last redisplay, so we can
 only treat it as a hint.  In particular, after erase-buffer,
 botpos may be negative. */
 if (botpos < toppos)
 else
 	{
 	  /* This hard limit is ok since the string it will hold has a
 fixed maximum length of around 6.  But just to be safe... */
 	  char buf[10];
+	  Charcount chars = botpos - BUF_BEGV (b);
-	  total = ((botpos - BUF_BEGV (b)) * 100 + total - 1) / total;
+	  Charcount total = BUF_ZV (b) - BUF_BEGV (b);
+	  /* Avoid overflow on big buffers */
+	  int percent = total > LONG_MAX/200 ?
+	    (chars + total/200) / (total / 100) :
+	    (chars * 100 + total/2) / max (total, 1);
 	  /* We can't normally display a 3-digit number, so get us a
 2-digit number that is close. */
-	  if (total == 100)
+	  if (percent == 100)
-	    total = 99;
+	    percent = 99;
 	  if (toppos <= BUF_BEGV (b))
-	    sprintf (buf, "Top%2d%%", total);
+	    sprintf (buf, "Top%d%%", percent);
 	  else
-	    sprintf (buf, "%2d%%", total);
+	    sprintf (buf, "%d%%", percent);
 	  Dynarr_add_many (mode_spec_bufbyte_string, (Bufbyte *) buf,
 			   strlen (buf));
 	  goto decode_mode_spec_done;
 /* Given an array of display lines, free them and all data structures
 contained within them. */
-static void
+void
 free_display_lines (display_line_dynarr *dla)
 {
 int line;
 for (line = 0; line < Dynarr_largest (dla); line++)
 }
 }
 static void
-mark_glyph_block_dynarr (glyph_block_dynarr *gba, void (*markobj) (Lisp_Object))
+mark_glyph_block_dynarr (glyph_block_dynarr *gba)
 {
 if (gba)
 {
 glyph_block *gb = Dynarr_atp (gba, 0);
 glyph_block *gb_last = Dynarr_atp (gba, Dynarr_length (gba));
 for (; gb < gb_last; gb++)
 	{
 	  if (!NILP (gb->glyph))
-	    markobj (gb->glyph);
+	    mark_object (gb->glyph);
 	  if (!NILP (gb->extent))
-	    markobj (gb->extent);
+	    mark_object (gb->extent);
 	}
 }
 }
 static void
-mark_redisplay_structs (display_line_dynarr *dla, void (*markobj) (Lisp_Object))
+mark_redisplay_structs (display_line_dynarr *dla)
 {
 display_line *dl = Dynarr_atp (dla, 0);
 display_line *dl_last = Dynarr_atp (dla, Dynarr_length (dla));
 for (; dl < dl_last; dl++)
 	  for (; r < r_last; r++)
 	    {
 	      if (r->type == RUNE_DGLYPH)
 		{
 		  if (!NILP (r->object.dglyph.glyph))
-		    markobj (r->object.dglyph.glyph);
+		    mark_object (r->object.dglyph.glyph);
 		  if (!NILP (r->object.dglyph.extent))
-		    markobj (r->object.dglyph.extent);
+		    mark_object (r->object.dglyph.extent);
 		}
 	    }
 	}
-mark_glyph_block_dynarr (dl->left_glyphs,  markobj);
+mark_glyph_block_dynarr (dl->left_glyphs);
-mark_glyph_block_dynarr (dl->right_glyphs, markobj);
+mark_glyph_block_dynarr (dl->right_glyphs);
 }
 }
 static void
-mark_window_mirror (struct window_mirror *mir, void (*markobj)(Lisp_Object))
+mark_window_mirror (struct window_mirror *mir)
 {
-mark_redisplay_structs (mir->current_display_lines, markobj);
+mark_redisplay_structs (mir->current_display_lines);
-mark_redisplay_structs (mir->desired_display_lines, markobj);
+mark_redisplay_structs (mir->desired_display_lines);
 if (mir->next)
-mark_window_mirror (mir->next, markobj);
+mark_window_mirror (mir->next);
 if (mir->hchild)
-mark_window_mirror (mir->hchild, markobj);
+mark_window_mirror (mir->hchild);
 else if (mir->vchild)
-mark_window_mirror (mir->vchild, markobj);
+mark_window_mirror (mir->vchild);
 }
 void
-mark_redisplay (void (*markobj)(Lisp_Object))
+mark_redisplay (void)
 {
 Lisp_Object frmcons, devcons, concons;
 FRAME_LOOP_NO_BREAK (frmcons, devcons, concons)
 {
 struct frame *f = XFRAME (XCAR (frmcons));
 update_frame_window_mirror (f);
-mark_window_mirror (f->root_mirror, markobj);
+mark_window_mirror (f->root_mirror);
 }
 }
 /*****************************************************************************
 Line Start Cache Description and Rationale
 applicable.
 ****************************************************************************/
 /* This will get used quite a bit so we don't want to be constantly
 allocating and freeing it. */
-line_start_cache_dynarr *internal_cache;
+static line_start_cache_dynarr *internal_cache;
 /* Makes internal_cache represent the TYPE display structs and only
 the TYPE display structs. */
 static void
 	  else
 	    return cur_pos;
 	}
 cur_elt--;
-if (cur_elt < 0)
+while (cur_elt < 0)
 	{
 	  Bufpos from, to;
 	  int win_char_height;
 	  if (cur_pos <= BUF_BEGV (b))
 	  from = find_next_newline_no_quit (b, cur_pos, -win_char_height);
 	  to = line_start_cache_end (w);
 	  update_line_start_cache (w, from, to, point, 0);
 	  cur_elt = point_in_line_start_cache (w, cur_pos, 2) - 1;
-	  assert (cur_elt >= 0);
+	  assert (cur_elt >= -1);
+	  /* This used to be cur_elt>=0 under the assumption that if
+	     point is in the top line and not at BUF_BEGV, then
+	     setting the window_start to a newline before the start of
+	     the first line will always cause scrolling.
+	     However in my (jv) opinion this is wrong.  That new line
+	     can be hidden in various ways: invisible extents, an
+	     explicit window-start not at a newline character etc.
+	     The existence of those are indeed known to create crashes
+	     on that assert.  So we have no option but to continue the
+	     search if we found point at the top of the line_start_cache
+	     again. */
+	  cur_pos = Dynarr_atp (w->line_start_cache,0)->start;
 	}
 prev_pos = cur_pos;
 }
 }
 global_redisplay_change. */
 MARK_CLIP_CHANGED;
 return 0;
 }
+/* This is called if the built-in glyphs have their properties
+changed. */
 void
 redisplay_glyph_changed (Lisp_Object glyph, Lisp_Object property,
 			 Lisp_Object locale)
 {
 if (WINDOWP (locale))
 {
 disable_preemption = 0;
 preemption_count = 0;
 max_preempts = INIT_MAX_PREEMPTS;
+#ifndef PDUMP
 if (!initialized)
+#endif
 {
 cmotion_display_lines = Dynarr_new (display_line);
 mode_spec_bufbyte_string = Dynarr_new (Bufbyte);
 formatted_string_emchar_dynarr = Dynarr_new (Emchar);
 formatted_string_extent_dynarr = Dynarr_new (EXTENT);
 defsymbol (&Qpre_redisplay_hook, "pre-redisplay-hook");
 defsymbol (&Qpost_redisplay_hook, "post-redisplay-hook");
 #endif /* INHIBIT_REDISPLAY_HOOKS */
 defsymbol (&Qdisplay_warning_buffer, "display-warning-buffer");
 defsymbol (&Qbar_cursor, "bar-cursor");
-defsymbol (&Qwindow_scroll_functions, "window-scroll-functions");
 defsymbol (&Qredisplay_end_trigger_functions,
 	     "redisplay-end-trigger-functions");
 DEFSUBR (Fredisplay_echo_area);
 DEFSUBR (Fredraw_frame);
 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;
 last_arrow_string = Qnil;
 #endif /* 0 */
-updating_line_start_cache = 0;
 /* #### Probably temporary */
 DEFVAR_INT ("redisplay-cache-adjustment", &cache_adjustment /*
 \(Temporary) Setting this will impact the performance of the internal
 line start cache.
 instead.
 */ );
 Vwindow_system = Qnil;
 /* #### Temporary shit until window-system is eliminated. */
-DEFVAR_LISP ("initial-window-system", &Vinitial_window_system /*
+DEFVAR_CONST_LISP ("initial-window-system", &Vinitial_window_system /*
 DON'T TOUCH
 */ );
 Vinitial_window_system = Qnil;
 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area /*

Mercurial > hg > xemacs-beta

comparison src/redisplay.c @ 424:11054d720c21 r21-2-20