xemacs-beta: src/redisplay.c comparison

comparison src/redisplay.c @ 438:84b14dcb0985 r21-2-27

Import from CVS: tag r21-2-27

author	cvs
date	Mon, 13 Aug 2007 11:32:25 +0200
parents	9d177e8d4150
children	8de8e3f6228a

comparison

equal deleted inserted replaced

-:e2a4e8b94b82
+:84b14dcb0985
 {
 Dynarr_declare (prop_block);
 } prop_block_dynarr;
-static void generate_formatted_string_db (Lisp_Object format_str,
-					  Lisp_Object result_str,
-					  struct window *w,
-					  struct display_line *dl,
-					  struct display_block *db,
-					  face_index findex, int min_pixpos,
-					  int max_pixpos, int type);
 static Charcount generate_fstring_runes (struct window *w, pos_data *data,
 					 Charcount pos, Charcount min_pos,
 					 Charcount max_pos, Lisp_Object elt,
 					 int depth, int max_pixsize,
-					 face_index findex, int type);
+					 face_index findex, int type,
+					 Charcount *offset,
+					 Lisp_Object cur_ext);
 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,
 routines.  We used to just give each window a third set.  However,
 we always fully regenerate the structures when needed so there
 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. */
-static Emchar_dynarr *formatted_string_emchar_dynarr;
-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
 int windows_structure_changed;
 /* 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
 			   then the frame will flash instead of
 			   beeping when an error occurs */
 Lisp_Object face;
 if (cachel)
 	width = cachel->width;
 else
-	width = glyph_width (gb->glyph, Qnil, data->findex, data->window);
+	width = glyph_width (gb->glyph, data->window);
 if (!width)
 	return NULL;
 if (data->start_col || data->start_col_xoffset)
 	  ascent = cachel->ascent;
 	  descent = cachel->descent;
 	}
 else
 	{
-	  ascent = glyph_ascent (gb->glyph, Qnil, data->findex, data->window);
+	  ascent = glyph_ascent (gb->glyph, data->window);
-	  descent = glyph_descent (gb->glyph, Qnil, data->findex,
+	  descent = glyph_descent (gb->glyph, data->window);
-				   data->window);
 	}
 baseline = glyph_baseline (gb->glyph, data->window);
 if (glyph_contrib_p (gb->glyph, data->window))
 	  if (glyph_contrib_p (gb->glyph, window))
 	    {
 	      unsigned short ascent, descent;
 	      Lisp_Object baseline = glyph_baseline (gb->glyph, window);
-	      ascent = glyph_ascent (gb->glyph, Qnil, gb->findex, window);
+	      ascent = glyph_ascent (gb->glyph, window);
-	      descent = glyph_descent (gb->glyph, Qnil, gb->findex, 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))
 if (extent_begin_glyph_layout (XEXTENT (gb->extent)) == GL_WHITESPACE)
 	{
 	  int width;
-	  width = glyph_width (gb->glyph, Qnil, gb->findex, window);
+	  width = glyph_width (gb->glyph, window);
 	  if (white_in_start - width >= left_in_end)
 	    {
 	      white_in_cnt++;
 	      white_in_start -= width;
 	  abort ();	/* these should have been handled in add_glyph_rune */
 	if (extent_begin_glyph_layout (XEXTENT (gb->extent)) ==
 	    GL_INSIDE_MARGIN)
 	  {
-	    gb->width = glyph_width (gb->glyph, Qnil, gb->findex, window);
+	    gb->width = glyph_width (gb->glyph, window);
 	    used_in += gb->width;
 	    Dynarr_add (ib, *gb);
 	  }
 	elt++;
 	  abort ();	/* these should have been handled in add_glyph_rune */
 	if (extent_begin_glyph_layout (XEXTENT (gb->extent)) ==
 	    GL_INSIDE_MARGIN)
 	  {
-	    int width = glyph_width (gb->glyph, Qnil, gb->findex, window);
+	    int width = glyph_width (gb->glyph, window);
 	    if (used_out)
 	      {
 		in_out_cnt++;
 		in_out_start -= width;
 	abort ();	/* these should have been handled in add_glyph_rune */
 if (extent_begin_glyph_layout (XEXTENT (gb->extent)) ==
 	  GL_OUTSIDE_MARGIN)
 	{
-	  int width = glyph_width (gb->glyph, Qnil, gb->findex, window);
+	  int width = glyph_width (gb->glyph, window);
 	  if (out_end + width <= in_out_start)
 	    {
 	      out_cnt++;
 	      out_end += width;
 if (NILP (gb->extent))
 	abort ();	/* these should have been handled in add_glyph_rune */
 if (extent_end_glyph_layout (XEXTENT (gb->extent)) == GL_WHITESPACE)
 	{
-	  int width = glyph_width (gb->glyph, Qnil, gb->findex, window);
+	  int width = glyph_width (gb->glyph, window);
 	  if (white_in_end + width <= dl->bounds.right_in)
 	    {
 	      white_in_cnt++;
 	      white_in_end += width;
 	if (NILP (gb->extent))
 	  abort ();	/* these should have been handled in add_glyph_rune */
 	if (extent_end_glyph_layout (XEXTENT (gb->extent)) == GL_INSIDE_MARGIN)
 	  {
-	    gb->width = glyph_width (gb->glyph, Qnil, gb->findex, window);
+	    gb->width = glyph_width (gb->glyph, window);
 	    used_in += gb->width;
 	    Dynarr_add (ib, *gb);
 	  }
 	elt++;
 	if (NILP (gb->extent))
 	  abort ();	/* these should have been handled in add_glyph_rune */
 	if (extent_end_glyph_layout (XEXTENT (gb->extent)) == GL_INSIDE_MARGIN)
 	  {
-	    int width = glyph_width (gb->glyph, Qnil, gb->findex, window);
+	    int width = glyph_width (gb->glyph, window);
 	    if (used_out)
 	      {
 		in_out_cnt++;
 		in_out_end += width;
 if (NILP (gb->extent))
 	abort ();	/* these should have been handled in add_glyph_rune */
 if (extent_end_glyph_layout (XEXTENT (gb->extent)) == GL_OUTSIDE_MARGIN)
 	{
-	  int width = glyph_width (gb->glyph, Qnil, gb->findex, window);
+	  int width = glyph_width (gb->glyph, window);
 	  if (out_start - width >= in_out_end)
 	    {
 	      out_cnt++;
 	      out_start -= width;
 /*									   */
 /*                            modeline routines                            */
 /*									   */
 /***************************************************************************/
-/* Ensure that the given display line DL accurately represents the
+/* This function is also used in frame.c by `generate_title_string' */
-modeline for the given window. */
+void
-static void
-generate_modeline (struct window *w, struct display_line *dl, int type)
-{
-struct buffer *b = XBUFFER (w->buffer);
-struct frame *f = XFRAME (w->frame);
-struct device *d = XDEVICE (f->device);
-/* Unlike display line and rune pointers, this one can't change underneath
-our feet. */
-struct display_block *db = get_display_block_from_line (dl, TEXT);
-int max_pixpos, min_pixpos, ypos_adj;
-Lisp_Object font_inst;
-/* This will actually determine incorrect inside boundaries for the
-modeline since it ignores the margins.  However being aware of this fact
-we never use those values anywhere so it doesn't matter. */
-dl->bounds = calculate_display_line_boundaries (w, 1);
-/* We are generating a modeline. */
-dl->modeline = 1;
-dl->cursor_elt = -1;
-/* Reset the runes on the modeline. */
-Dynarr_reset (db->runes);
-if (!WINDOW_HAS_MODELINE_P (w))
-{
-struct rune rb;
-/* If there is a horizontal scrollbar, don't add anything. */
-if (window_scrollbar_height (w))
-	return;
-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;
-rb.endpos = 0;
-rb.type = RUNE_HLINE;
-rb.object.hline.thickness = 1;
-rb.object.hline.yoffset = 0;
-rb.cursor_type = NO_CURSOR;
-if (!EQ (Qzero, w->modeline_shadow_thickness)
-	  && FRAME_WIN_P (f))
-	{
-	  int shadow_thickness = MODELINE_SHADOW_THICKNESS (w);
-	  dl->ypos -= shadow_thickness;
-	  rb.xpos += shadow_thickness;
-	  rb.width -= 2 * shadow_thickness;
-	}
-Dynarr_add (db->runes, rb);
-return;
-}
-/* !!#### not right; needs to compute the max height of
-all the charsets */
-font_inst = WINDOW_FACE_CACHEL_FONT (w, MODELINE_INDEX, Vcharset_ascii);
-dl->ascent = XFONT_INSTANCE (font_inst)->ascent;
-dl->descent = XFONT_INSTANCE (font_inst)->descent;
-min_pixpos = dl->bounds.left_out;
-max_pixpos = dl->bounds.right_out;
-if (!EQ (Qzero, w->modeline_shadow_thickness) && FRAME_WIN_P (f))
-{
-int shadow_thickness = MODELINE_SHADOW_THICKNESS (w);
-ypos_adj = shadow_thickness;
-min_pixpos += shadow_thickness;
-max_pixpos -= shadow_thickness;
-}
-else
-ypos_adj = 0;
-generate_formatted_string_db (b->modeline_format,
-				b->generated_modeline_string, w, dl, db,
-				MODELINE_INDEX, min_pixpos, max_pixpos, type);
-/* 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 void
 generate_formatted_string_db (Lisp_Object format_str, Lisp_Object result_str,
 struct window *w, struct display_line *dl,
 struct display_block *db, face_index findex,
 int min_pixpos, int max_pixpos, int type)
 {
 struct frame *f = XFRAME (w->frame);
 struct device *d = XDEVICE (f->device);
 pos_data data;
 int c_pixpos;
+Charcount offset = 0;
 xzero (data);
 data.d = d;
 data.db = db;
 data.dl = dl;
 Dynarr_reset (formatted_string_extent_dynarr);
 Dynarr_reset (formatted_string_extent_start_dynarr);
 Dynarr_reset (formatted_string_extent_end_dynarr);
-/* This recursively builds up the modeline. */
+/* 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 */
+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);
+max_pixpos - min_pixpos, findex, type, &offset,
+			  Qnil);
 if (Dynarr_length (db->runes))
 {
 struct rune *rb =
 Dynarr_atp (db->runes, Dynarr_length (db->runes) - 1);
 result_str);
 }
 }
 }
+/* Ensure that the given display line DL accurately represents the
+modeline for the given window. */
+static void
+generate_modeline (struct window *w, struct display_line *dl, int type)
+{
+struct buffer *b = XBUFFER (w->buffer);
+struct frame *f = XFRAME (w->frame);
+struct device *d = XDEVICE (f->device);
+/* Unlike display line and rune pointers, this one can't change underneath
+our feet. */
+struct display_block *db = get_display_block_from_line (dl, TEXT);
+int max_pixpos, min_pixpos, ypos_adj;
+Lisp_Object font_inst;
+/* This will actually determine incorrect inside boundaries for the
+modeline since it ignores the margins.  However being aware of this fact
+we never use those values anywhere so it doesn't matter. */
+dl->bounds = calculate_display_line_boundaries (w, 1);
+/* We are generating a modeline. */
+dl->modeline = 1;
+dl->cursor_elt = -1;
+/* Reset the runes on the modeline. */
+Dynarr_reset (db->runes);
+if (!WINDOW_HAS_MODELINE_P (w))
+{
+struct rune rb;
+/* If there is a horizontal scrollbar, don't add anything. */
+if (window_scrollbar_height (w))
+	return;
+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;
+rb.endpos = 0;
+rb.type = RUNE_HLINE;
+rb.object.hline.thickness = 1;
+rb.object.hline.yoffset = 0;
+rb.cursor_type = NO_CURSOR;
+if (!EQ (Qzero, w->modeline_shadow_thickness)
+	  && FRAME_WIN_P (f))
+	{
+	  int shadow_thickness = MODELINE_SHADOW_THICKNESS (w);
+	  dl->ypos -= shadow_thickness;
+	  rb.xpos += shadow_thickness;
+	  rb.width -= 2 * shadow_thickness;
+	}
+Dynarr_add (db->runes, rb);
+return;
+}
+/* !!#### not right; needs to compute the max height of
+all the charsets */
+font_inst = WINDOW_FACE_CACHEL_FONT (w, MODELINE_INDEX, Vcharset_ascii);
+dl->ascent = XFONT_INSTANCE (font_inst)->ascent;
+dl->descent = XFONT_INSTANCE (font_inst)->descent;
+min_pixpos = dl->bounds.left_out;
+max_pixpos = dl->bounds.right_out;
+if (!EQ (Qzero, w->modeline_shadow_thickness) && FRAME_WIN_P (f))
+{
+int shadow_thickness = MODELINE_SHADOW_THICKNESS (w);
+ypos_adj = shadow_thickness;
+min_pixpos += shadow_thickness;
+max_pixpos -= shadow_thickness;
+}
+else
+ypos_adj = 0;
+generate_formatted_string_db (b->modeline_format,
+				b->generated_modeline_string, w, dl, db,
+				MODELINE_INDEX, min_pixpos, max_pixpos, type);
+/* 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,
 Charcount pos, Charcount min_pos, Charcount max_pos)
 {
 /* This function has been Mule-ized. */
 /* #### Urk!  Should also handle begin-glyphs and end-glyphs in
 modeline extents. */
 static Charcount
 add_glyph_to_fstring_db_runes (pos_data *data, Lisp_Object glyph,
-Charcount pos, Charcount min_pos, Charcount max_pos)
+Charcount pos, Charcount min_pos,
+			       Charcount max_pos, Lisp_Object extent)
 {
 /* This function has been Mule-ized. */
 Charcount end;
 struct display_block *db = data->db;
 struct glyph_block gb;
 end = Dynarr_length (db->runes) + 1;
 if (max_pos != -1)
 end = min (max_pos, end);
 gb.glyph = glyph;
-gb.extent = Qnil;
+gb.extent = extent;
 add_glyph_rune (data, &gb, BEGIN_GLYPHS, 0, 0);
 pos++;
 while (Dynarr_length (db->runes) < pos &&
 (data->pixpos + data->blank_width <= data->max_pixpos))
 modeline. */
 static Charcount
 generate_fstring_runes (struct window *w, pos_data *data, Charcount pos,
 Charcount min_pos, Charcount max_pos,
 Lisp_Object elt, int depth, int max_pixsize,
-face_index findex, int type)
+face_index findex, int type, Charcount *offset,
+			Lisp_Object cur_ext)
 {
 /* This function has been Mule-ized. */
 /* #### The other losing things in this function are:
 -- C zero-terminated-string lossage.
 while (*this && *this != '%')
 this++;
 if (this != last)
 {
-/* The string is just a string. */
+/* No %-construct */
 Charcount size =
-bytecount_to_charcount (last, this - last) + pos;
+		bytecount_to_charcount (last, this - last);
-Charcount tmp_max = (max_pos == -1 ? size : min (size, max_pos));
+	      if (size <= *offset)
-pos = add_string_to_fstring_db_runes (data, last, pos, pos,
+		*offset -= size;
-tmp_max);
+	      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);
+		  pos = add_string_to_fstring_db_runes (data, tmp_last,
+							pos, pos, tmp_max);
+		  *offset = 0;
+		}
 }
 else /* *this == '%' */
 {
 Charcount spec_width = 0;
 if (*this == 'M')
 {
 pos = generate_fstring_runes (w, data, pos, spec_width,
 max_pos, Vglobal_mode_string,
 depth, max_pixsize, findex,
-type);
+type, offset, cur_ext);
 }
 else if (*this == '-')
 {
 Charcount num_to_add;
 pos = add_string_to_fstring_db_runes
 (data, (CONST Bufbyte *) "-", pos, pos, max_pos);
 }
 else if (*this != 0)
 {
+Emchar ch = charptr_emchar (this);
 Bufbyte *str;
-Emchar ch = charptr_emchar (this);
+		  Charcount size;
 decode_mode_spec (w, ch, type);
 str = Dynarr_atp (mode_spec_bufbyte_string, 0);
-pos = add_string_to_fstring_db_runes (data,str, pos, pos,
+		  size = bytecount_to_charcount
-max_pos);
+		    /* Skip the null character added by `decode_mode_spec' */
+		    (str, Dynarr_length (mode_spec_bufbyte_string)) - 1;
+		  if (size <= *offset)
+		    *offset -= size;
+		  else
+		    {
+		      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, pos,
+							    max_pos);
+		      *offset = 0;
+		    }
 }
 /* NOT this++.  There could be any sort of character at
 the current position. */
 INC_CHARPTR (this);
 as if it appeared here directly. */
 Lisp_Object tem = symbol_value_in_buffer (elt, w->buffer);
 if (!UNBOUNDP (tem))
 {
-/* If value is a string, output that string literally:
+	  /* If value is a string, output that string literally:
 don't check for % within it.  */
 if (STRINGP (tem))
 {
-pos =
+	      Bufbyte *str = XSTRING_DATA (tem);
-add_string_to_fstring_db_runes
+	      Charcount size = XSTRING_CHAR_LENGTH (tem);
-(data, XSTRING_DATA (tem), pos, min_pos, max_pos);
+	      if (size <= *offset)
+		*offset -= size;
+	      else
+		{
+		  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,
+							min_pos, max_pos);
+		  *offset = 0;
+		}
 }
 /* Give up right away for nil or t.  */
 else if (!EQ (tem, elt))
 {
 elt = tem;
 	}
 }
 else if (CONSP (elt))
 {
 /* A cons cell: four distinct cases.
-* If first element is a string or a cons, process all the elements
+* - If first element is a string or a cons, process all the elements
-* and effectively concatenate them.
+*   and effectively concatenate them.
-* If first element is a negative number, truncate displaying cdr to
+* - If first element is a negative number, truncate displaying cdr to
-* at most that many characters.  If positive, pad (with spaces)
+*   at most that many characters.  If positive, pad (with spaces)
-* to at least that many characters.
+*   to at least that many characters.
-* If first element is a symbol, process the cadr or caddr recursively
+* - If first element is another symbol, process the cadr or caddr
-* according to whether the symbol's value is non-nil or nil.
+*   recursively according to whether the symbol's value is non-nil or
-* If first element is a face, process the cdr recursively
+*   nil.
-* without altering the depth.
+* - If first element is a face, process the cdr recursively
+*   without altering the depth.
 */
 Lisp_Object car, tem;
 car = XCAR (elt);
 if (SYMBOLP (car))
-{
+	{
-elt = XCDR (elt);
+	  elt = XCDR (elt);
-if (!CONSP (elt))
+	  if (!CONSP (elt))
-goto invalid;
+	    goto invalid;
-tem = symbol_value_in_buffer (car, w->buffer);
-/* elt is now the cdr, and we know it is a cons cell.
+	  tem = symbol_value_in_buffer (car, w->buffer);
-Use its car if CAR has a non-nil value.  */
+	  /* elt is now the cdr, and we know it is a cons cell.
-if (!UNBOUNDP (tem))
+	     Use its car if CAR has a non-nil value.  */
-{
+	  if (!UNBOUNDP (tem))
-if (!NILP (tem))
+	    {
-{
+	      if (!NILP (tem))
-elt = XCAR (elt);
+		{
-goto tail_recurse;
+		  elt = XCAR (elt);
-}
+		  goto tail_recurse;
-}
+		}
-/* Symbol's value is nil (or symbol is unbound)
+	    }
-* Get the cddr of the original list
+	  /* Symbol's value is nil (or symbol is unbound)
-* and if possible find the caddr and use that.
+	   * Get the cddr of the original list
-*/
+	   * and if possible find the caddr and use that.
-elt = XCDR (elt);
+	   */
-if (NILP (elt))
+	  elt = XCDR (elt);
-;
+	  if (NILP (elt))
-else if (!CONSP (elt))
+	    ;
-goto invalid;
+	  else if (!CONSP (elt))
-else
+	    goto invalid;
-{
+	  else
-elt = XCAR (elt);
+	    {
-goto tail_recurse;
+	      elt = XCAR (elt);
-}
+	      goto tail_recurse;
-}
+	    }
+	}
 else if (INTP (car))
 {
 Charcount lim = XINT (car);
 elt = XCDR (elt);
 goto tail_recurse;
 }
 else if (STRINGP (car) || CONSP (car))
 {
 int limit = 50;
 /* LIMIT is to protect against circular lists.  */
 while (CONSP (elt) && --limit > 0
 && (pos < max_pos || max_pos == -1))
 {
 pos = generate_fstring_runes (w, data, pos, pos, max_pos,
-XCAR (elt), depth,
+XCAR (elt), depth, max_pixsize,
-max_pixsize, findex, type);
+					    findex, type, offset, cur_ext);
 elt = XCDR (elt);
 }
 }
 else if (EXTENTP (car))
 {
 new_findex = old_findex;
 data->findex = new_findex;
 pos = generate_fstring_runes (w, data, pos, pos, max_pos,
 XCDR (elt), depth - 1,
-max_pixsize, new_findex, type);
+					    max_pixsize, new_findex, type,
+					    offset, car);
 data->findex = old_findex;
 Dynarr_add (formatted_string_extent_dynarr, ext);
 Dynarr_add (formatted_string_extent_start_dynarr, start);
 Dynarr_add (formatted_string_extent_end_dynarr, data->bytepos);
 }
 }
 }
 else if (GLYPHP (elt))
 {
-pos = add_glyph_to_fstring_db_runes (data, elt, pos, pos, max_pos);
+/* Glyphs are considered as one character with respect to the modeline
+	 horizontal scrolling facility. -- dv */
+if (*offset > 0)
+	*offset -= 1;
+else
+	pos = add_glyph_to_fstring_db_runes (data, elt, pos, pos, max_pos,
+					     cur_ext);
 }
 else
 {
 invalid:
-pos =
+{
-add_string_to_fstring_db_runes
+	char *str = GETTEXT ("*invalid*");
-(data, (CONST Bufbyte *) GETTEXT ("*invalid*"), pos, min_pos,
+	Charcount size = (Charcount) strlen (str); /* is this ok ?? -- dv */
-max_pos);
+	if (size <= *offset)
+	  *offset -= size;
+	else
+	  {
+	    CONST Bufbyte *tmp_str =
+	      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);
+	    *offset = 0;
+	  }
+}
 }
 if (min_pos > pos)
 {
-add_string_to_fstring_db_runes (data, (CONST Bufbyte *) "", pos, min_pos,
+add_string_to_fstring_db_runes (data, (CONST Bufbyte *) "", pos,
--1);
+				      min_pos, -1);
 }
 return pos;
-}
-/* The caller is responsible for freeing the returned string. */
-Bufbyte *
-generate_formatted_string (struct window *w, Lisp_Object format_str,
-			   Lisp_Object result_str, face_index findex, int type)
-{
-struct display_line *dl;
-struct display_block *db;
-int elt = 0;
-dl = &formatted_string_display_line;
-db = get_display_block_from_line (dl, TEXT);
-Dynarr_reset (db->runes);
-generate_formatted_string_db (format_str, result_str, w, dl, db, findex, 0,
--1, type);
-Dynarr_reset (formatted_string_emchar_dynarr);
-while (elt < Dynarr_length (db->runes))
-{
-if (Dynarr_atp (db->runes, elt)->type == RUNE_CHAR)
-	Dynarr_add (formatted_string_emchar_dynarr,
-		    Dynarr_atp (db->runes, elt)->object.chr.ch);
-elt++;
-}
-return
-convert_emchar_string_into_malloced_string
-( Dynarr_atp (formatted_string_emchar_dynarr, 0),
-Dynarr_length (formatted_string_emchar_dynarr), 0);
 }
 /* Update just the modeline.  Assumes the desired display structs.  If
 they do not have a modeline block, it does nothing. */
 static void
 /* #### 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. */
+/* The glyph cachels only get dirty if someone changed something.
+Since redisplay has now effectively ended we can reset the dirty
+flag since everything must be up-to-date. */
 if (glyphs_changed)
 mark_glyph_cachels_as_clean (w);
 w->windows_changed = 0;
 }
 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);
 formatted_string_extent_start_dynarr = Dynarr_new (Bytecount);
 formatted_string_extent_end_dynarr = Dynarr_new (Bytecount);
 internal_cache = Dynarr_new (line_start_cache);
-xzero (formatted_string_display_line);
 }
 /* window system is nil when in -batch mode */
 if (!initialized || noninteractive)
 return;
 This is a specifier; use `set-specifier' to change it.
 */ );
 Vleft_margin_width = Fmake_specifier (Qnatnum);
 set_specifier_fallback (Vleft_margin_width, list1 (Fcons (Qnil, Qzero)));
 set_specifier_caching (Vleft_margin_width,
-			 slot_offset (struct window, left_margin_width),
+			 offsetof (struct window, left_margin_width),
 			 some_window_value_changed,
-			 slot_offset (struct frame, left_margin_width),
+			 offsetof (struct frame, left_margin_width),
 			 margin_width_changed_in_frame);
 DEFVAR_SPECIFIER ("right-margin-width", &Vright_margin_width /*
 *Width of right margin.
 This is a specifier; use `set-specifier' to change it.
 */ );
 Vright_margin_width = Fmake_specifier (Qnatnum);
 set_specifier_fallback (Vright_margin_width, list1 (Fcons (Qnil, Qzero)));
 set_specifier_caching (Vright_margin_width,
-			 slot_offset (struct window, right_margin_width),
+			 offsetof (struct window, right_margin_width),
 			 some_window_value_changed,
-			 slot_offset (struct frame, right_margin_width),
+			 offsetof (struct frame, right_margin_width),
 			 margin_width_changed_in_frame);
 DEFVAR_SPECIFIER ("minimum-line-ascent", &Vminimum_line_ascent /*
 *Minimum ascent height of lines.
 This is a specifier; use `set-specifier' to change it.
 */ );
 Vminimum_line_ascent = Fmake_specifier (Qnatnum);
 set_specifier_fallback (Vminimum_line_ascent, list1 (Fcons (Qnil, Qzero)));
 set_specifier_caching (Vminimum_line_ascent,
-			 slot_offset (struct window, minimum_line_ascent),
+			 offsetof (struct window, minimum_line_ascent),
 			 some_window_value_changed,
 			 0, 0);
 DEFVAR_SPECIFIER ("minimum-line-descent", &Vminimum_line_descent /*
 *Minimum descent height of lines.
 This is a specifier; use `set-specifier' to change it.
 */ );
 Vminimum_line_descent = Fmake_specifier (Qnatnum);
 set_specifier_fallback (Vminimum_line_descent, list1 (Fcons (Qnil, Qzero)));
 set_specifier_caching (Vminimum_line_descent,
-			 slot_offset (struct window, minimum_line_descent),
+			 offsetof (struct window, minimum_line_descent),
 			 some_window_value_changed,
 			 0, 0);
 DEFVAR_SPECIFIER ("use-left-overflow", &Vuse_left_overflow /*
 *Non-nil means use the left outside margin as extra whitespace when
 This is a specifier; use `set-specifier' to change it.
 */ );
 Vuse_left_overflow = Fmake_specifier (Qboolean);
 set_specifier_fallback (Vuse_left_overflow, list1 (Fcons (Qnil, Qnil)));
 set_specifier_caching (Vuse_left_overflow,
-			 slot_offset (struct window, use_left_overflow),
+			 offsetof (struct window, use_left_overflow),
 			 some_window_value_changed,
 			 0, 0);
 DEFVAR_SPECIFIER ("use-right-overflow", &Vuse_right_overflow /*
 *Non-nil means use the right outside margin as extra whitespace when
 This is a specifier; use `set-specifier' to change it.
 */ );
 Vuse_right_overflow = Fmake_specifier (Qboolean);
 set_specifier_fallback (Vuse_right_overflow, list1 (Fcons (Qnil, Qnil)));
 set_specifier_caching (Vuse_right_overflow,
-			 slot_offset (struct window, use_right_overflow),
+			 offsetof (struct window, use_right_overflow),
 			 some_window_value_changed,
 			 0, 0);
 DEFVAR_SPECIFIER ("text-cursor-visible-p", &Vtext_cursor_visible_p /*
 *Non-nil means the text cursor is visible (this is usually the case).
 This is a specifier; use `set-specifier' to change it.
 */ );
 Vtext_cursor_visible_p = Fmake_specifier (Qboolean);
 set_specifier_fallback (Vtext_cursor_visible_p, list1 (Fcons (Qnil, Qt)));
 set_specifier_caching (Vtext_cursor_visible_p,
-			 slot_offset (struct window, text_cursor_visible_p),
+			 offsetof (struct window, text_cursor_visible_p),
 			 text_cursor_visible_p_changed,
 			 0, 0);
 }

Mercurial > hg > xemacs-beta

comparison src/redisplay.c @ 438:84b14dcb0985 r21-2-27