xemacs-beta: src/redisplay.c comparison

comparison src/redisplay.c @ 70:131b0175ea99 r20-0b30

Import from CVS: tag r20-0b30

author	cvs
date	Mon, 13 Aug 2007 09:02:59 +0200
parents	c0965ff3b039
children	b9518feda344

comparison

equal deleted inserted replaced

-:804d1389bcd6
+:131b0175ea99
 #include "process.h"
 #include "redisplay.h"
 #include "toolbar.h"
 #include "window.h"
+#ifdef MULE
+#include "mule-coding.h"
+#endif
 /* Note: We have to be careful throughout this code to properly handle
 and differentiate between Bufbytes and Emchars.
 Since strings are generally composed of Bufbytes, I've taken the tack
 			   add_emchar_rune(). */
 Lisp_Object last_charset; /* The charset of the previous character.
 			       Used to optimize some lookups -- we
 			       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;
 				     int overlay_width);
 static void create_right_glyph_block (struct window *w,
 				      struct display_line *dl);
 static void regenerate_window (struct window *w, Bufpos start_pos,
 			       Bufpos point, int type);
-static Bufpos regenerate_window_point_center (struct window *w, Bufpos point,
+static void regenerate_window_point_center (struct window *w, Bufpos point,
-					      int type);
+					    int type);
 int window_half_pixpos (struct window *w);
 int line_at_center (struct window *w, int type, Bufpos start, Bufpos point);
 Bufpos point_at_center (struct window *w, int type, Bufpos start,
 			Bufpos point);
 static void redisplay_window (Lisp_Object window, int skip_selected);
 #define INHIBIT_REDISPLAY_HOOKS  /* #### Until we've thought about
 				    this more. */
 #ifndef INHIBIT_REDISPLAY_HOOKS
 /* #### Chuck says: I think this needs more thought.
 Think about this for 19.14. */
-/* 19.16:  We're still thinking, I guess.  -slb */
 Lisp_Object Vpre_redisplay_hook, Vpost_redisplay_hook;
 Lisp_Object Qpre_redisplay_hook, Qpost_redisplay_hook;
 #endif
 int last_display_warning_tick, display_warning_tick;
 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;
 /***************************************************************************/
 /*									   */
 /*              low-level interfaces onto device routines                  */
 /*									   */
 width = data->blank_width;
 }
 else
 {
 Lisp_Object charset = CHAR_CHARSET (data->ch);
-if (!EQ (charset, data->last_charset) ||
+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 =
 	    data->last_char_width = fi->width;
 	  else
 	    data->last_char_width = -1;
 	  data->new_ascent  = max (data->new_ascent,  (int) fi->ascent);
 	  data->new_descent = max (data->new_descent, (int) fi->descent);
-	  data->last_charset = charset;
-	  data->last_findex = data->findex;
 	}
 width = data->last_char_width;
 if (width < 0)
 	{
 data.dl = dl;
 data.bi_bufpos = bi_start_pos;
 data.pixpos = dl->bounds.left_in;
 data.last_charset = Qunbound;
-data.last_findex = DEFAULT_INDEX;
 data.result_str = Qnil;
 /* Set the right boundary adjusting it to take into account any end
 glyph.  Save the width of the end glyph for later use. */
 data.max_pixpos = dl->bounds.right_in;
 else
 	data.cursor_type = NO_CURSOR;
 }
 else if (MINI_WINDOW_P (w) && !active_minibuffer)
 data.cursor_type = NO_CURSOR;
-else if (w == XWINDOW (FRAME_SELECTED_WINDOW (f)) &&
+else if (w == XWINDOW (FRAME_SELECTED_WINDOW (device_selected_frame (d))))
-	   EQ(DEVICE_CONSOLE(d), Vselected_console) &&
-	   d == XDEVICE(CONSOLE_SELECTED_DEVICE(XCONSOLE(DEVICE_CONSOLE(d))))&&
-	   f == XFRAME(DEVICE_SELECTED_FRAME(d)))
 {
 data.bi_cursor_bufpos = BI_BUF_PT (b);
 data.cursor_type = CURSOR_ON;
 }
 else if (w == XWINDOW (FRAME_SELECTED_WINDOW (f)))
 	      bi_pos = bi_find_next_newline_no_quit (b, data.bi_bufpos, 1);
 	      /* If the cursor is past the truncation line then we
 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
+appear unless eob is immediately preceeded 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 ||
 data.max_pixpos = dl->bounds.right_in;
 data.cursor_type = NO_CURSOR;
 data.cursor_x = -1;
 data.findex = DEFAULT_INDEX;
 data.last_charset = Qunbound;
-data.last_findex = DEFAULT_INDEX;
 data.result_str = Qnil;
 Dynarr_reset (data.db->runes);
 if (STRINGP (Voverlay_arrow_string))
 data.findex = findex;
 data.pixpos = min_pixpos;
 data.max_pixpos = max_pixpos;
 data.cursor_type = NO_CURSOR;
 data.last_charset = Qunbound;
-data.last_findex = DEFAULT_INDEX;
 data.result_str = result_str;
 data.is_modeline = 1;
 XSETWINDOW (data.window, w);
 Dynarr_reset (formatted_string_extent_dynarr);
 /* Oh, well. */
 return 0;
 }
 /* Given a window and a point, update the given display lines such
-that point is displayed in the middle of the window.
+that point is displayed in the middle of the window. */
-Return the window's new start position. */
+static void
-static Bufpos
 regenerate_window_point_center (struct window *w, Bufpos point, int type)
 {
 Bufpos startp;
 /* We need to make sure that the modeline is generated so that the
 startp = start_with_line_at_pixpos (w, point, window_half_pixpos (w));
 regenerate_window (w, startp, point, type);
 Fset_marker (w->start[type], make_int (startp), w->buffer);
-return startp;
+return;
 }
 /* Given a window and a set of display lines, return a boolean
 indicating whether the given point is contained within. */
 Lisp_Object old_buffer = w->buffer;
 struct buffer *b;
 int echo_active = 0;
 int startp = 1;
 int pointm;
-int selected_in_its_frame;
+int selected;
-int selected_globally;
 int skip_output = 0;
 int truncation_changed;
 int inactive_minibuffer =
 (MINI_WINDOW_P (w) &&
 (f != device_selected_frame (d)) &&
 redisplay_windows (w->hchild, skip_selected);
 return;
 }
 /* Is this window the selected window on its frame? */
-selected_in_its_frame = (w == XWINDOW (FRAME_SELECTED_WINDOW (f)));
+selected =
-selected_globally =
+(w == XWINDOW (FRAME_SELECTED_WINDOW (device_selected_frame (d))));
-selected_in_its_frame &&
+if (skip_selected && selected)
-EQ(DEVICE_CONSOLE(d), Vselected_console) &&
-XDEVICE(CONSOLE_SELECTED_DEVICE(XCONSOLE(DEVICE_CONSOLE(d)))) == d &&
-XFRAME(DEVICE_SELECTED_FRAME(d)) == f;
-if (skip_selected && selected_in_its_frame)
 return;
 /* It is possible that the window is not fully initialized yet. */
 if (NILP (w->buffer))
 return;
 if (echo_active)
 pointm = 1;
 else
 {
-if (selected_globally)
+if (selected)
 	{
 	  pointm = BUF_PT (b);
 	}
 else
 	{
 /* If the marker's buffer is not the window's buffer, then we need
 to find a new starting position. */
 if (!MINI_WINDOW_P (w)
 && !EQ (Fmarker_buffer (w->start[CURRENT_DISP]), w->buffer))
 {
-startp = regenerate_window_point_center (w, pointm, DESIRED_DISP);
+regenerate_window_point_center (w, pointm, DESIRED_DISP);
 goto regeneration_done;
 }
 if (echo_active)
 if (!point_visible (w, pointm, DESIRED_DISP) && !inactive_minibuffer)
 	{
 	  pointm = point_at_center (w, DESIRED_DISP, 0, 0);
-	  if (selected_globally)
+	  if (selected)
 	    BUF_SET_PT (b, pointm);
 	  Fset_marker (w->pointm[DESIRED_DISP], make_int (pointm),
 		       old_buffer);
 && !truncation_changed)
 {
 /* Check if the cursor has actually moved. */
 if (EQ (Fmarker_buffer (w->last_point[CURRENT_DISP]), w->buffer)
 	  && pointm == marker_position (w->last_point[CURRENT_DISP])
-	  && selected_globally
+	  && selected
 	  && !w->windows_changed
 	  && !f->clip_changed
 	  && !f->extents_changed
 	  && !f->faces_changed
 	  && !f->point_changed
 		      skip_output = 1;
 		      goto regeneration_done;
 		    }
 		}
-	      else if (!selected_in_its_frame && !f->point_changed)
+	      else if (!selected && !f->point_changed)
 		{
 		  if (f->modeline_changed)
 		    regenerate_modeline (w);
 		  skip_output = 1;
 	   || (pointm == startp &&
 	       EQ (Fmarker_buffer (w->last_start[CURRENT_DISP]), w->buffer) &&
 	       startp < marker_position (w->last_start[CURRENT_DISP]))
 	   || (startp == BUF_ZV (b)))
 {
-startp = regenerate_window_point_center (w, pointm, DESIRED_DISP);
+regenerate_window_point_center (w, pointm, DESIRED_DISP);
 goto regeneration_done;
 }
 /* See if we can update the data structures locally based on
 knowledge of what changed in the buffer. */
 /* We still haven't gotten the window regenerated with point
 visible.  Next we try scrolling a little and see if point comes
 back onto the screen. */
 if (scroll_step)
 {
-startp = vmotion (w, startp,
+Bufpos bufpos;
+bufpos = vmotion (w, startp,
 			(pointm < startp) ? -scroll_step : scroll_step, 0);
-regenerate_window (w, startp, pointm, DESIRED_DISP);
+regenerate_window (w, bufpos, pointm, DESIRED_DISP);
 if (point_visible (w, pointm, DESIRED_DISP))
 	goto regeneration_done;
 }
 /* We still haven't managed to get the screen drawn with point on
 the screen, so just center it and be done with it. */
-startp = regenerate_window_point_center (w, pointm, DESIRED_DISP);
+regenerate_window_point_center (w, pointm, DESIRED_DISP);
 regeneration_done:
 /* If the window's frame is changed then reset the current display
 FRAME_LOOP_NO_BREAK (frmcons, devcons, concons)
 {
 struct frame *f = XFRAME (XCAR (frmcons));
-if (FRAME_REPAINT_P (f))
+if (FRAME_VISIBLE_P (f))
 	map_windows (f, reset_buffer_changes_mapfun, 0);
 }
 }
 /* Ensure that all windows underneath the given window in the window
 f = XFRAME (frame);
 if (f->icon_changed || f->windows_changed)
 update_frame_icon (f);
-if (FRAME_REPAINT_P (f))
+if (FRAME_VISIBLE_P (f))
 {
 if (f->buffers_changed || f->clip_changed || f->extents_changed
 	  || f->faces_changed || f->frame_changed || f->menubar_changed
 	  || f->modeline_changed || f->point_changed || f->size_changed
 	  || f->toolbar_changed || f->windows_changed
 	continue;
 if (f->icon_changed || f->windows_changed)
 	update_frame_icon (f);
-if (FRAME_REPAINT_P (f))
+if (FRAME_VISIBLE_P (f))
 	{
 	  if (f->buffers_changed || f->clip_changed || f->extents_changed
 	      || f->faces_changed || f->frame_changed || f->menubar_changed
 	      || f->modeline_changed || f->point_changed || f->size_changed
 	      || f->toolbar_changed || f->windows_changed
 window_line_number (struct window *w, int type)
 {
 struct device *d = XDEVICE (XFRAME (w->frame)->device);
 struct buffer *b = XBUFFER (w->buffer);
 Bufpos end =
-(((w == XWINDOW (FRAME_SELECTED_WINDOW (device_selected_frame (d)))) &&
+((w == XWINDOW (FRAME_SELECTED_WINDOW (device_selected_frame (d))))
-EQ(DEVICE_CONSOLE(d), Vselected_console) &&
-XDEVICE(CONSOLE_SELECTED_DEVICE(XCONSOLE(DEVICE_CONSOLE(d)))) == d &&
-EQ(DEVICE_SELECTED_FRAME(d), w->frame))
 ? BUF_PT (b)
 : marker_position (w->pointm[type]));
 int lots = 999999999;
 int shortage, line;
 break;
 /* print the current column */
 case 'c':
 {
-	int col = current_column (b) + (column_number_start_at_one != 0);
+	int col = current_column (b);
 	int temp = col;
 	int size = 2;
 	char *buf;
 	while (temp >= 10)
 			 (CONST Bufbyte *) buf, strlen (buf));
 	goto decode_mode_spec_done;
 }
+#ifdef MULE
+/* print the file coding system */
+case 'C':
+{
+Lisp_Object codesys = b->file_coding_system;
+/* Be very careful here not to get an error. */
+	if (NILP (codesys) || SYMBOLP (codesys) || CODING_SYSTEMP (codesys))
+{
+codesys = Ffind_coding_system (codesys);
+	    if (CODING_SYSTEMP (codesys))
+obj = Fcoding_system_property (codesys, Qmnemonic);
+}
+}
+break;
+#endif
 /* print the current line number */
 case 'l':
 str = window_line_number (w, type);
 break;
 Bufpos
 start_with_line_at_pixpos (struct window *w, Bufpos point, int pixpos)
 {
 struct buffer *b = XBUFFER (w->buffer);
 int cur_elt;
-Bufpos cur_pos, prev_pos = point;
+Bufpos cur_pos;
-int point_line_height;
 int pixheight = pixpos - WINDOW_TEXT_TOP (w);
 validate_line_start_cache (w);
 w->line_cache_validation_override++;
 cur_elt = point_in_line_start_cache (w, point, 0);
 /* #### See comment in update_line_start_cache about big minibuffers. */
 if (cur_elt < 0)
 return point;
-point_line_height = Dynarr_atp (w->line_start_cache, cur_elt)->height;
 while (1)
 {
 cur_pos = Dynarr_atp (w->line_start_cache, cur_elt)->start;
 pixheight -= Dynarr_atp (w->line_start_cache, cur_elt)->height;
 /* Do not take into account the value of vertical_clip here.
 That is the responsibility of the calling functions. */
 if (pixheight < 0)
 	{
 	  w->line_cache_validation_override--;
-	  if (-pixheight > point_line_height)
+	  return cur_pos;
-	    /* 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--;
 if (cur_elt < 0)
 	{
 	  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);
 	}
-prev_pos = cur_pos;
 }
 }
 /* For window W, what does the starting position have to be so that
 the line containing point is on display line LINE.  If LINE is
 			  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
 DEVICE_FRAME_LOOP (frmcons, d)
 	{
 	  struct frame *f = XFRAME (XCAR (frmcons));
-	  if (FRAME_REPAINT_P (f) && FRAME_HAS_MINIBUF_P (f))
+	  if (FRAME_VISIBLE_P (f) && FRAME_HAS_MINIBUF_P (f))
 	    {
 	      Lisp_Object window = FRAME_MINIBUF_WINDOW (f);
 	      redisplay_window (window, 0);
 	      call_redisplay_end_triggers (XWINDOW (window), 0);
 	    }
 DEVICE defaults to the selected device if omitted.
 Normally, redisplay is preempted as normal if input arrives.  However,
 if optional second arg NO-PREEMPT is non-nil, redisplay will not stop for
 input and is guaranteed to proceed to completion.
 */
 (device, no_preempt))
 {
 struct device *d = decode_device (device);
 Lisp_Object frmcons;
 int count = specpdl_depth ();
 DEFUN ("force-cursor-redisplay", Fforce_cursor_redisplay, 0, 1, 0, /*
 Force an immediate update of the cursor on FRAME.
 FRAME defaults to the selected frame if omitted.
 */
 (frame))
 {
 redisplay_redraw_cursor (decode_frame (frame), 1);
 return Qnil;
 }
 Emacs's frame display when you reenter Emacs.
 It is up to you to set this variable if your terminal can do that.
 */ );
 no_redraw_on_reenter = 0;
+/* #### This should be removed in 19.14 */
 DEFVAR_LISP ("window-system", &Vwindow_system /*
 A symbol naming the window-system under which Emacs is running,
 such as `x', or nil if emacs is running on an ordinary terminal.
+This variable is OBSOLETE and will be removed in a future version.
 */ );
 Vwindow_system = Qnil;
 /* #### Temporary shit until window-system is eliminated. */
 DEFVAR_LISP ("initial-window-system", &Vinitial_window_system /*
 DEFVAR_LISP ("redisplay-end-trigger-functions",
 &Vredisplay_end_trigger_functions /*
 See `set-window-redisplay-end-trigger'.
 */ );
 Vredisplay_end_trigger_functions = Qnil;
-DEFVAR_BOOL ("column-number-start-at-one", &column_number_start_at_one /*
-Non-nil means column display number starts at 1.
-*/ );
-column_number_start_at_one = 1;
 }
 void
 specifier_vars_of_redisplay (void)
 {
 set_specifier_caching (Vtext_cursor_visible_p,
 			 slot_offset (struct window,
 				      text_cursor_visible_p),
 			 text_cursor_visible_p_changed,
 			 0, 0);
+}
-}

Mercurial > hg > xemacs-beta

comparison src/redisplay.c @ 70:131b0175ea99 r20-0b30