xemacs-beta: src/redisplay.c comparison

comparison src/redisplay.c @ 183:e121b013d1f0 r20-3b18

Import from CVS: tag r20-3b18

author	cvs
date	Mon, 13 Aug 2007 09:54:23 +0200
parents	9ad43877534d
children	3d6bfa290dbd

comparison

equal deleted inserted replaced

-:f07455f06202
+:e121b013d1f0
 			       only have to do some things when
 			       the charset changes. */
 face_index last_findex;   /* The face index of the previous character.
 			       Needed to ensure the validity of the
 			       last_charset optimization. */
 int last_char_width;	/* The width of the previous character. */
 int font_is_bogus;	/* If true, it means we couldn't instantiate
 			   the font for this charset, so we substitute
 			   ~'s from the ASCII charset. */
 Bytind bi_bufpos;
 */
 struct prop_block
 {
 enum prop_type type;
 union data
 {
 struct
 	{
 	  Bufbyte *str;
 	  Bytecount len; /* length of the string. */
 	} p_string;
 struct
 	{
 	  Emchar ch;
 	  Bytind bi_cursor_bufpos; /* NOTE: is in Bytinds */
 	  unsigned int cursor_type :3;
 	} p_char;
 struct
 	{
 	  int width;
 	  face_index findex;
 	} p_blank;
 int faces_changed;
 /* Nonzero means some frames have been marked as garbaged */
 int frame_changed;
 /* 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;
 /* This variable is 1 if the menubar widget has to be updated.
 It is set to 1 by set-menubar-dirty-flag and cleared when the widget
 has been indapted. */
 /* indapted???? */
 int menubar_changed;
 int menubar_changed_set;
 #ifndef INHIBIT_REDISPLAY_HOOKS
 /* #### Chuck says: I think this needs more thought.
 Think about this for 19.14. */
 Lisp_Object Vpre_redisplay_hook, Vpost_redisplay_hook;
 Lisp_Object Qpre_redisplay_hook, Qpost_redisplay_hook;
-#endif
+#endif /* INHIBIT_REDISPLAY_HOOKS */
 int last_display_warning_tick, display_warning_tick;
 Lisp_Object Qdisplay_warning_buffer;
 int inhibit_warning_display;
 			     Bytecount offset, Bytecount len)
 {
 if (!rtw_emchar_dynarr)
 rtw_emchar_dynarr = Dynarr_new (Emchar);
 Dynarr_reset (rtw_emchar_dynarr);
 fixup_internal_substring (nonreloc, reloc, offset, &len);
 if (STRINGP (reloc))
 nonreloc = XSTRING_DATA (reloc);
 convert_bufbyte_string_into_emchar_dynarr (nonreloc, len, rtw_emchar_dynarr);
 return redisplay_text_width_emchar_string
 if (!EQ (charset, data->last_charset) ||
 	  data->findex != data->last_findex)
 	{
 	  /* OK, we need to do things the hard way. */
 	  struct window *w = XWINDOW (data->window);
 	  struct face_cachel *cachel = WINDOW_FACE_CACHEL (w, data->findex);
 	  Lisp_Object font_instance =
 	    ensure_face_cachel_contains_charset (cachel, data->window,
 						 charset);
 	  struct Lisp_Font_Instance *fi;
 /* #### This function is too simplistic.  It needs to do the same
 sort of character interpretation (display-table lookup,
 ctl-arrow checking), etc. that create_text_block() does.
 The functionality to do this in that routine needs to be
 modularized. */
 for (pos = c_string; pos < end;)
 {
 data->ch = charptr_emchar (pos);
 prop = add_emchar_rune (data);
 	  if (spcwid >= data->blank_width)
 	    data->blank_width = 0;
 	  else
 	    data->blank_width -= spcwid;
 	}
 data->start_col = 0;
 retval = add_hscroll_rune (data);
 /* Could be caused by the handling of the hscroll rune. */
 if (retval != NULL || !data->blank_width)
 	  abort ();
 	}
 }
 oops_no_more_space:
 data->bi_cursor_bufpos = bi_old_cursor_bufpos;
 data->cursor_type = old_cursor_type;
 if (elt < Dynarr_length (*prop))
 {
 Dynarr_delete_many (*prop, 0, elt);
 displayed. */
 int no_more_frags = 0;
 Lisp_Object synch_minibuffers_value =
 symbol_value_in_buffer (Qsynchronize_minibuffers, w->buffer);
 dl->used_prop_data = 0;
 dl->num_chars = 0;
 memset (&data, 0, sizeof (data));
 data.ef = extent_fragment_new (w->buffer, f);
 	  else if (data.bi_bufpos == BI_BUF_ZV (b))
 	    goto done;
 	  else if (data.bi_bufpos < BI_BUF_BEGV (b))
 	    /* #### urk urk urk! Aborts are not very fun! Fix this please! */
 	    data.bi_bufpos = BI_BUF_BEGV (b);
 	  else
 	    INC_BYTIND (b, data.bi_bufpos);
 	}
 /* If there are end glyphs, add them to the line.  These are
 	 the end glyphs for the previous run of text.  We add them
 make it appear on the truncation glyph.  If we've hit
 the end of the buffer then we also make the cursor
 appear unless eob is immediately preceded by a
 newline.  In that case the cursor should actually
 appear on the next line. */
 	      if (data.cursor_type == CURSOR_ON
 		  && data.bi_cursor_bufpos >= data.bi_bufpos
 		  && (data.bi_cursor_bufpos < bi_pos ||
 		      (bi_pos == BI_BUF_ZV (b)
 		       && (bi_pos == BI_BUF_BEGV (b)
 			   || (BI_BUF_FETCH_CHAR (b, prev_bytind (b, bi_pos))
 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_BUF_ZV (b) + 1;
 }
 create_overlay_glyph_block (struct window *w, struct display_line *dl)
 {
 struct frame *f = XFRAME (w->frame);
 struct device *d = XDEVICE (f->device);
 pos_data data;
 /* If Voverlay_arrow_string isn't valid then just fail silently. */
 if (!STRINGP (Voverlay_arrow_string) && !GLYPHP (Voverlay_arrow_string))
 return 0;
 memset (&data, 0, sizeof (data));
 	}
 elt++;
 }
-/* Now that we now where everything goes, we add the glyphs as runes
+/* Now that we know where everything goes, we add the glyphs as
-to the appropriate display blocks. */
+runes to the appropriate display blocks. */
 if (out_cnt || in_out_cnt || white_out_cnt)
 {
 odb = get_display_block_from_line (dl, LEFT_OUTSIDE_MARGIN);
 odb->start_pos = dl->bounds.left_out;
 /* #### We should stop adding a blank to account for the space
 -- C zero-terminated-string lossage.
 -- Non-printable characters should be converted into something
 appropriate (e.g. ^F) instead of blindly being printed anyway.
 */
 tail_recurse:
 if (depth > 10)
 goto invalid;
 depth++;
 		(data, XSTRING_DATA (tem), pos, min_pos, max_pos);
 }
 /* Give up right away for nil or t.  */
 else if (!EQ (tem, elt))
 	    {
 	      elt = tem;
 	      goto tail_recurse;
 	    }
 }
 }
 else if (CONSP (elt))
 {
 Use its car if CAR has a non-nil value.  */
 if (!UNBOUNDP (tem))
 {
 if (!NILP (tem))
 {
 elt = XCAR (elt);
 goto tail_recurse;
 		}
 }
 /* Symbol's value is nil (or symbol is unbound)
 * Get the cddr of the original list
 		  new_findex = get_builtin_face_cache_index (w, face);
 		  /* !!#### not right; needs to compute the max height of
 		     all the charsets */
 		  font_inst = WINDOW_FACE_CACHEL_FONT (w, new_findex,
 						       Vcharset_ascii);
 		  data->dl->ascent = max (data->dl->ascent,
 					  XFONT_INSTANCE (font_inst)->ascent);
 		  data->dl->descent = max (data->dl->descent,
 					   XFONT_INSTANCE (font_inst)->
 					   descent);
 		}
 	      else
 		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);
 	      data->findex = old_findex;
 /* Update the menubar.  It is done first since it could change
 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
+#endif /* HAVE_MENUBARS */
 #ifdef HAVE_TOOLBARS
 /* Update the toolbars. */
 update_frame_toolbars (f);
-#endif
+#endif /* HAVE_TOOLBARS */
 hold_frame_size_changes ();
 /* ----------------- BEGIN CRITICAL REDISPLAY SECTION ---------------- */
 /* Within this section, we are defenseless and assume that the
 if (preempted)
 return 1;
 /* Always do the selected frame first. */
 frame = DEVICE_SELECTED_FRAME (d);
 f = XFRAME (frame);
 if (f->icon_changed || f->windows_changed)
 update_frame_icon (f);
 restore_profiling_redisplay_flag (Lisp_Object val)
 {
 profiling_redisplay_flag = XINT (val);
 return Qnil;
 }
-#endif
+#endif /* WINDOWSNT */
 /* Ensure that all windows on all frames on all devices are displaying
 the current contents of their respective buffers. */
 static void
 {
 record_unwind_protect (restore_profiling_redisplay_flag,
 			     make_int (profiling_redisplay_flag));
 profiling_redisplay_flag = 1;
 }
-#endif
+#endif /* WINDOWSNT */
 if (asynch_device_change_pending)
 handle_asynch_device_change ();
 if (!buffers_changed && !clip_changed && !extents_changed && !faces_changed
 C code that call redisplay() are prepared to handle GCing,
 so we should be OK. */
 #ifndef INHIBIT_REDISPLAY_HOOKS
 run_hook_trapping_errors ("Error in pre-redisplay-hook",
 			    Qpre_redisplay_hook);
-#endif
+#endif /* INHIBIT_REDISPLAY_HOOKS */
 redisplay_without_hooks ();
 #ifndef INHIBIT_REDISPLAY_HOOKS
 run_hook_trapping_errors ("Error in post-redisplay-hook",
 			    Qpost_redisplay_hook);
-#endif
+#endif /* INHIBIT_REDISPLAY_HOOKS */
 }
 /* Inefficiently determine the line number of the line point is on and
 return it as a string.  Always do this regardless of whether
 line_number_mode is true. */
 	    if (CODING_SYSTEMP (codesys))
 obj = Fcoding_system_property (codesys, Qmnemonic);
 }
 }
 break;
-#endif
+#endif /* MULE */
 /* print the current line number */
 case 'l':
 str = window_line_number (w, type);
 break;
 	  {
 	    str = alloca (10);
 	    sprintf (str, "-%d", f->order_count);
 	  }
 }
-#endif
+#endif /* HAVE_TTY */
 break;
 /* print Narrow if appropriate */
 case 'n':
 if (BUF_BEGV (b) > BUF_BEG (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)
 	botpos = toppos;
 if (botpos >= BUF_ZV (b))
 	{
 	  if (toppos <= BUF_BEGV (b))
 	    str = "All";
 	  else
 	{
 	  w->line_cache_validation_override--;
 	  if (-pixheight > point_line_height)
 	    /* We can't make the target line cover pixpos, so put it
 	       above pixpos.  That way it will at least be visible. */
 	    return prev_pos;
 	  else
 	    return cur_pos;
 	}
 cur_elt--;
 int pixpos = WINDOW_TEXT_BOTTOM (w);
 Bufpos retval, search_point;
 /* If scroll_on_clipped_lines is false, the last "visible" line of
 	 the window covers the pixel at WINDOW_TEXT_BOTTOM (w) - 1.
 	 If s_o_c_l is true, then we don't want to count a clipped
 	 line, so back up from the bottom by the height of the line
 	 containing point. */
 if (scroll_on_clipped_lines)
 	pixpos -= Dynarr_atp (w->line_start_cache, cur_elt)->height;
 else
 	pixpos -= 1;
 *obj1 = toolbar_button_at_pixpos (f, x_coord, y_coord);
 *obj2 = Qnil;
 *w = 0;
 UPDATE_CACHE_RETURN;
 }
-#endif
+#endif /* HAVE_TOOLBARS */
 /* We still have to return the window the pointer is next to and its
 relative y position even if it is outside the x boundary. */
 if (x_coord < frm_left)
 x_coord = frm_left;
 			  Dynarr_atp (db->runes,
 				      Dynarr_length (db->runes) - 1)->bufpos;
 		      else
 			*closest =
 			  Dynarr_atp (db->runes,
-				      Dynarr_length (db->runes) - 2)->bufpos;
+				      Dynarr_length (db->runes) - 1)->bufpos;
 		    }
 		  if (dl->modeline)
 		    *modeline_closest += dl->offset;
 		  else
 			  if (dl->modeline)
 			    *modeline_closest = dl->end_bufpos + dl->offset;
 			  else
 			    *closest = dl->end_bufpos + dl->offset;
 			  really_over_nothing = 1;
 			}
 		    }
 		  else
 		    {
 		      if (dl->modeline)
 			*modeline_closest = rb->bufpos + dl->offset;
 /***************************************************************************/
 static int
 compute_rune_dynarr_usage (rune_dynarr *dyn, struct overhead_stats *ovstats)
 {
-int total = 0;
+return dyn ? Dynarr_memory_usage (dyn, ovstats) : 0;
-if (dyn)
-total += Dynarr_memory_usage (dyn, ovstats);
-return total;
 }
 static int
 compute_display_block_dynarr_usage (display_block_dynarr *dyn,
 				    struct overhead_stats *ovstats)
 {
-int total = 0;
+int total, i;
-if (dyn)
+if (!dyn)
-{
+return 0;
-int i;
+total = Dynarr_memory_usage (dyn, ovstats);
-total += Dynarr_memory_usage (dyn, ovstats);
+for (i = 0; i < Dynarr_largest (dyn); i++)
-for (i = 0; i < Dynarr_largest (dyn); i++)
+total += compute_rune_dynarr_usage (Dynarr_at (dyn, i).runes, ovstats);
-	total += compute_rune_dynarr_usage (Dynarr_at (dyn, i).runes, ovstats);
-}
 return total;
 }
 static int
 compute_glyph_block_dynarr_usage (glyph_block_dynarr *dyn,
 				  struct overhead_stats *ovstats)
 {
-int total = 0;
+return dyn ? Dynarr_memory_usage (dyn, ovstats) : 0;
-if (dyn)
-total += Dynarr_memory_usage (dyn, ovstats);
-return total;
 }
 int
 compute_display_line_dynarr_usage (display_line_dynarr *dyn,
 				   struct overhead_stats *ovstats)
 {
-int total = 0;
+int total, i;
-if (dyn)
+if (!dyn)
-{
+return 0;
-int i;
+total = Dynarr_memory_usage (dyn, ovstats);
-total += Dynarr_memory_usage (dyn, ovstats);
+for (i = 0; i < Dynarr_largest (dyn); i++)
-for (i = 0; i < Dynarr_largest (dyn); i++)
+{
-	{
+struct display_line *dl = &Dynarr_at (dyn, i);
-	  total +=
+total += compute_display_block_dynarr_usage(dl->display_blocks, ovstats);
-	    compute_display_block_dynarr_usage (Dynarr_at (dyn, i).
+total += compute_glyph_block_dynarr_usage  (dl->left_glyphs,    ovstats);
-						display_blocks, ovstats);
+total += compute_glyph_block_dynarr_usage  (dl->right_glyphs,   ovstats);
-	  total +=
-	    compute_glyph_block_dynarr_usage (Dynarr_at (dyn, i).
-					      left_glyphs, ovstats);
-	  total +=
-	    compute_glyph_block_dynarr_usage (Dynarr_at (dyn, i).
-					      right_glyphs, ovstats);
-	}
 }
 return total;
 }
 int
 compute_line_start_cache_dynarr_usage (line_start_cache_dynarr *dyn,
 				       struct overhead_stats *ovstats)
 {
-int total = 0;
+return dyn ? Dynarr_memory_usage (dyn, ovstats) : 0;
-if (dyn)
-total += Dynarr_memory_usage (dyn, ovstats);
-return total;
 }
 #endif /* MEMORY_USAGE_STATS */
 /* Some stuff checks this way early. */
 Vwindow_system = Qx;
 Vinitial_window_system = Qx;
 return;
 }
-#endif
+#endif /* HAVE_X_WINDOWS */
 /* If no window system has been specified, try to use the terminal.  */
 if (!isatty (0))
 {
 stderr_out ("XEmacs: standard input is not a tty\n");
 {
 defsymbol (&Qcursor_in_echo_area, "cursor-in-echo-area");
 #ifndef INHIBIT_REDISPLAY_HOOKS
 defsymbol (&Qpre_redisplay_hook, "pre-redisplay-hook");
 defsymbol (&Qpost_redisplay_hook, "post-redisplay-hook");
-#endif
+#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");
 #if 0
 staticpro (&last_arrow_position);
 staticpro (&last_arrow_string);
 last_arrow_position = Qnil;
 last_arrow_string = Qnil;
-#endif
+#endif /* 0 */
 updating_line_start_cache = 0;
 /* #### Probably temporary */
 DEFVAR_INT ("redisplay-cache-adjustment", &cache_adjustment /*
 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
+#endif /* INHIBIT_REDISPLAY_HOOKS */
 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.
 DEFVAR_SPECIFIER ("left-margin-width", &Vleft_margin_width /*
 *Width of left margin.
 This is a specifier; use `set-specifier' to change it.
 */ );
 Vleft_margin_width = Fmake_specifier (Qnatnum);
-set_specifier_fallback
+set_specifier_fallback (Vleft_margin_width, list1 (Fcons (Qnil, Qzero)));
-(Vleft_margin_width,
-list1 (Fcons (Qnil, Qzero)));
 set_specifier_caching (Vleft_margin_width,
 			 slot_offset (struct window, left_margin_width),
 			 some_window_value_changed,
 			 slot_offset (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
+set_specifier_fallback (Vright_margin_width, list1 (Fcons (Qnil, Qzero)));
-(Vright_margin_width,
-list1 (Fcons (Qnil, Qzero)));
 set_specifier_caching (Vright_margin_width,
 			 slot_offset (struct window, right_margin_width),
 			 some_window_value_changed,
 			 slot_offset (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,
+set_specifier_fallback (Vminimum_line_ascent, list1 (Fcons (Qnil, Qzero)));
-			  list1 (Fcons (Qnil, Qzero)));
 set_specifier_caching (Vminimum_line_ascent,
-			 slot_offset (struct window,
+			 slot_offset (struct window, minimum_line_ascent),
-				      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,
+set_specifier_fallback (Vminimum_line_descent, list1 (Fcons (Qnil, Qzero)));
-			  list1 (Fcons (Qnil, Qzero)));
 set_specifier_caching (Vminimum_line_descent,
-			 slot_offset (struct window,
+			 slot_offset (struct window, minimum_line_descent),
-				      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
 displaying 'whitespace or 'inside-margin glyphs.
 This is a specifier; use `set-specifier' to change it.
 */ );
 Vuse_left_overflow = Fmake_specifier (Qboolean);
-set_specifier_fallback (Vuse_left_overflow,
+set_specifier_fallback (Vuse_left_overflow, list1 (Fcons (Qnil, Qnil)));
-			  list1 (Fcons (Qnil, Qnil)));
 set_specifier_caching (Vuse_left_overflow,
-			 slot_offset (struct window,
+			 slot_offset (struct window, use_left_overflow),
-				      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
 displaying 'whitespace or 'inside-margin glyphs.
 This is a specifier; use `set-specifier' to change it.
 */ );
 Vuse_right_overflow = Fmake_specifier (Qboolean);
-set_specifier_fallback (Vuse_right_overflow,
+set_specifier_fallback (Vuse_right_overflow, list1 (Fcons (Qnil, Qnil)));
-			  list1 (Fcons (Qnil, Qnil)));
 set_specifier_caching (Vuse_right_overflow,
-			 slot_offset (struct window,
+			 slot_offset (struct window, use_right_overflow),
-				      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,
+set_specifier_fallback (Vtext_cursor_visible_p, list1 (Fcons (Qnil, Qt)));
-			  list1 (Fcons (Qnil, Qt)));
 set_specifier_caching (Vtext_cursor_visible_p,
-			 slot_offset (struct window,
+			 slot_offset (struct window, text_cursor_visible_p),
-				      text_cursor_visible_p),
 			 text_cursor_visible_p_changed,
 			 0, 0);
 }

Mercurial > hg > xemacs-beta

comparison src/redisplay.c @ 183:e121b013d1f0 r20-3b18