xemacs-beta: src/redisplay.c comparison

comparison src/redisplay.c @ 793:e38acbeb1cae

[xemacs-hg @ 2002-03-29 04:46:17 by ben] lots o' fixes etc/ChangeLog: New file. Separated out all entries for etc/ into their own ChangeLog. Includes entries for the following files: etc/BABYL, etc/BETA, etc/CHARSETS, etc/DISTRIB, etc/Emacs.ad, etc/FTP, etc/GNUS-NEWS, etc/GOATS, etc/HELLO, etc/INSTALL, etc/MACHINES, etc/MAILINGLISTS, etc/MSDOS, etc/MYTHOLOGY, etc/NEWS, etc/OXYMORONS, etc/PACKAGES, etc/README, etc/TUTORIAL, etc/TUTORIAL.de, etc/TUTORIAL.ja, etc/TUTORIAL.ko, etc/TUTORIAL.se, etc/aliases.ksh, etc/altrasoft-logo.xpm, etc/check_cygwin_setup.sh, etc/custom/example-themes/europe-theme.el, etc/custom/example-themes/ex-custom-file, etc/custom/example-themes/example-theme.el, etc/e/eterm.ti, etc/edt-user.doc, etc/enriched.doc, etc/etags.1, etc/gnuserv.1, etc/gnuserv.README, etc/package-index.LATEST.gpg, etc/package-index.LATEST.pgp, etc/photos/jan.png, etc/recycle.xpm, etc/refcard.tex, etc/sample.Xdefaults, etc/sample.emacs, etc/sgml/CATALOG, etc/sgml/HTML32.dtd, etc/skk/SKK.tut.E, etc/smilies/Face_ase.xbm, etc/smilies/Face_ase2.xbm, etc/smilies/Face_ase3.xbm, etc/smilies/Face_smile.xbm, etc/smilies/Face_weep.xbm, etc/sounds, etc/toolbar, etc/toolbar/workshop-cap-up.xpm, etc/xemacs-ja.1, etc/xemacs.1, etc/yow.lines, etc\BETA, etc\NEWS, etc\README, etc\TUTORIAL, etc\TUTORIAL.de, etc\check_cygwin_setup.sh, etc\sample.init.el, etc\unicode\README, etc\unicode\mule-ucs\*, etc\unicode\other\* unicode/unicode-consortium/8859-16.TXT: New file. mule/english.el: Define this charset now, since a bug was fixed that formerly prevented it. mule/ethio-util.el: Fix compile errors involving Unicode `characters', which should be integers. Makefile.in.in: Always include gui.c, to fix compile error when TTY-only. EmacsFrame.c, abbrev.c, alloc.c, buffer.c, buffer.h, bytecode.c, bytecode.h, callint.c, callproc.c, casetab.c, casetab.h, charset.h, chartab.c, chartab.h, cmds.c, console-msw.c, console-msw.h, console-tty.c, console-x.c, console-x.h, console.c, console.h, data.c, database.c, device-gtk.c, device-msw.c, device-x.c, device.c, device.h, dialog-msw.c, doc.c, doprnt.c, dumper.c, dynarr.c, editfns.c, eldap.c, eldap.h, elhash.c, elhash.h, emacs.c, eval.c, event-Xt.c, event-gtk.c, event-msw.c, event-stream.c, event-tty.c, event-unixoid.c, events.c, events.h, extents.c, extents.h, faces.c, faces.h, file-coding.c, file-coding.h, fileio.c, filelock.c, fns.c, frame-gtk.c, frame-msw.c, frame-tty.c, frame-x.c, frame.c, frame.h, free-hook.c, general-slots.h, glyphs-eimage.c, glyphs-gtk.c, glyphs-msw.c, glyphs-widget.c, glyphs-x.c, glyphs.c, glyphs.h, gpmevent.c, gtk-xemacs.c, gui-msw.c, gui-x.c, gui-x.h, gui.c, gui.h, gutter.c, gutter.h, indent.c, input-method-xlib.c, insdel.c, keymap.c, keymap.h, lisp-disunion.h, lisp-union.h, lisp.h, lread.c, lrecord.h, lstream.c, lstream.h, marker.c, menubar-gtk.c, menubar-msw.c, menubar-x.c, menubar.c, minibuf.c, mule-canna.c, mule-ccl.c, mule-charset.c, mule-wnnfns.c, native-gtk-toolbar.c, objects-msw.c, objects-tty.c, objects-x.c, objects.c, objects.h, opaque.c, opaque.h, postgresql.c, postgresql.h, print.c, process-unix.c, process.c, process.h, rangetab.c, rangetab.h, redisplay-gtk.c, redisplay-msw.c, redisplay-output.c, redisplay-tty.c, redisplay-x.c, redisplay.c, scrollbar-gtk.c, scrollbar-msw.c, scrollbar-x.c, scrollbar.c, scrollbar.h, search.c, select-gtk.c, select-x.c, sound.c, specifier.c, specifier.h, strftime.c, symbols.c, symeval.h, syntax.h, text.c, text.h, toolbar-common.c, toolbar-msw.c, toolbar.c, toolbar.h, tooltalk.c, tooltalk.h, ui-gtk.c, ui-gtk.h, undo.c, vm-limit.c, window.c, window.h: Eliminate XSETFOO. Replace all usages with wrap_foo(). Make symbol->name a Lisp_Object, not Lisp_String *. Eliminate nearly all uses of Lisp_String * in favor of Lisp_Object, and correct macros so most of them favor Lisp_Object. Create new error-behavior ERROR_ME_DEBUG_WARN -- output warnings, but at level `debug' (usually ignored). Use it when instantiating specifiers, so problems can be debugged. Move log-warning-minimum-level into C so that we can optimize ERROR_ME_DEBUG_WARN. Fix warning levels consistent with new definitions. Add default_ and parent fields to char table; not yet implemented. New fun Dynarr_verify(); use for further error checking on Dynarrs. Rearrange code at top of lisp.h in conjunction with dynarr changes. Fix eifree(). Use Eistrings in various places (format_event_object(), where_is_to_char(), and callers thereof) to avoid fixed-size strings buffers. New fun write_eistring(). Reindent and fix GPM code to follow standards. Set default MS Windows font to Lucida Console (same size as Courier New but less interline spacing, so more lines fit). Increase default frame size on Windows to 50 lines. (If that's too big for the workspace, the frame will be shrunk as necessary.) Fix problem with text files with no newlines (). (Change `convert-eol' coding system to use `nil' for autodetect, consistent with make-coding-system.) Correct compile warnings in vm-limit.c. Fix handling of reverse-direction charsets to avoid errors when opening (e.g.) mule-ucs/lisp/reldata/uiso8859-6.el. Recode some object printing methods to use write_fmt_string() instead of a fixed buffer and sprintf. Turn on display of png comments as warnings (level `info'), now that they're unobtrusive. Revamped the sound documentation. Fixed bug in redisplay w.r.t. hscroll/truncation/continuation glyphs causing jumping up and down of the lines, since they're bigger than the line size. (It was seen most obviously when there's a horizontal scroll bar, e.g. do C-h a glyph or something like that.) The problem was that the glyph-contrib-p setting on glyphs was ignored even if it was set properly, which it wasn't until now.

author	ben
date	Fri, 29 Mar 2002 04:49:13 +0000
parents	943eaba38521
children	a5954632b187

comparison

equal deleted inserted replaced

-:4e83fdb13eb9
+:e38acbeb1cae
 : vertical_clip)
 /* The following structures are completely private to redisplay.c so
 we put them here instead of in a header file, for modularity. */
-/* NOTE: Bytebposs not Charbpos's in this structure. */
+/* NOTE: Bytebpos's not Charbpos's in this structure. */
 typedef struct position_redisplay_data_type
 {
 /* This information is normally filled in by the create_*_block
 routines and is used by the add_*_rune routines. */
 {
 unsigned char charsets[NUM_LEADING_BYTES];
 Lisp_Object window;
 find_charsets_in_emchar_string (charsets, str, len);
-XSETWINDOW (window, w);
+window = wrap_window (w);
 ensure_face_cachel_complete (WINDOW_FACE_CACHEL (w, findex), window,
 			       charsets);
 return DEVMETH (XDEVICE (FRAME_DEVICE (XFRAME (WINDOW_FRAME (w)))),
 		  text_width, (XFRAME (WINDOW_FRAME (w)),
 			       WINDOW_FACE_CACHEL (w, findex), str, len));
 nonreloc = XSTRING_DATA (reloc);
 convert_intbyte_string_into_emchar_dynarr (nonreloc, len, rtw_emchar_dynarr);
 find_charsets_in_intbyte_string (charsets, nonreloc, len);
 reset_face_cachel (&cachel);
 cachel.face = face;
-XSETFRAME (frame, f);
+frame = wrap_frame (f);
 ensure_face_cachel_complete (&cachel, frame, charsets);
 return DEVMETH (XDEVICE (FRAME_DEVICE (f)),
 		  text_width, (f, &cachel, Dynarr_atp (rtw_emchar_dynarr, 0),
 			       Dynarr_length (rtw_emchar_dynarr)));
 }
 data->bi_start_col_enabled = 0;
 return retval;
 }
-/* Adds a character rune to a display block.  If there is not enough
+/* Adds a character rune to a display block.  If there is not enough room
-room to fit the rune on the display block (as determined by the
+to fit the rune on the display block (as determined by the MAX_PIXPOS)
-MAX_PIXPOS) then it adds nothing and returns ADD_FAILED. */
+then it adds nothing and returns ADD_FAILED.  If
+NO_CONTRIBUTE_TO_LINE_HEIGHT is non-zero, don't allow the char's height
+to affect the total line height. (See add_intbyte_string_runes()). */
 static prop_block_dynarr *
-add_emchar_rune (pos_data *data)
+add_emchar_rune_1 (pos_data *data, int no_contribute_to_line_height)
 {
 struct rune rb, *crb;
 int width, local;
 if (data->start_col)
 		redisplay_text_width_emchar_string (XWINDOW (data->window),
 						    data->findex, &ch, 1);
 	    }
 	  else
 	    data->last_char_width = -1;
-	  data->new_ascent  = max (data->new_ascent,  (int) fi->ascent);
+	  if (!no_contribute_to_line_height)
-	  data->new_descent = max (data->new_descent, (int) fi->descent);
+	    {
+	      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;
 crb->width = width;
 if (data->bi_charbpos)
 {
 if (NILP (data->string))
 	crb->charbpos =
-	  bytebpos_to_charbpos (XBUFFER (WINDOW_BUFFER (XWINDOW (data->window))),
+	  bytebpos_to_charbpos (XBUFFER (WINDOW_BUFFER
-			    data->bi_charbpos);
+					 (XWINDOW (data->window))),
+				data->bi_charbpos);
 else
 	crb->charbpos =
-	  XSTRING_INDEX_BYTE_TO_CHAR (data->string, data->bi_charbpos);
+	  string_index_byte_to_char (data->string, data->bi_charbpos);
 }
 else if (data->is_modeline)
 crb->charbpos = data->modeline_charpos;
 else
 /* Text but not in buffer */
 data->pixpos += width;
 return NULL;
 }
-/* Given a string C_STRING of length C_LENGTH, call add_emchar_rune
+static prop_block_dynarr *
-for each character in the string.  Propagate any left-over data
+add_emchar_rune (pos_data *data)
-unless NO_PROP is non-zero. */
+{
+return add_emchar_rune_1 (data, 0);
+}
+/* Given a string C_STRING of length C_LENGTH, call add_emchar_rune for
+each character in the string.  Propagate any left-over data unless
+NO_PROP is non-zero.  If NO_CONTRIBUTE_TO_LINE_HEIGHT is non-zero, don't
+allow this character to increase the total height of the line. (This is
+used when the character is part of a text glyph.  In that case, the
+glyph code itself adjusts the line height as necessary, depending on
+whether glyph-contrib-p is true.) */
 static prop_block_dynarr *
 add_intbyte_string_runes (pos_data *data, Intbyte *c_string,
-			  Bytecount c_length, int no_prop)
+			  Bytecount c_length, int no_prop,
+			  int no_contribute_to_line_height)
 {
 Intbyte *pos, *end = c_string + c_length;
 prop_block_dynarr *prop;
 /* #### This function is too simplistic.  It needs to do the same
 {
 Intbyte *old_pos = pos;
 data->ch = charptr_emchar (pos);
-prop = add_emchar_rune (data);
+prop = add_emchar_rune_1 (data, no_contribute_to_line_height);
 if (prop)
 	{
 	  if (no_prop)
 	    return ADD_FAILED;
 if (STRINGP (entry))
 {
 prop = add_intbyte_string_runes (data,
 				       XSTRING_DATA   (entry),
 				       XSTRING_LENGTH (entry),
-				       0);
+				       0, 0);
 }
 else if (GLYPHP (entry))
 {
 if (data->start_col)
 	data->start_col--;
 		      break;
 		      /* #### unimplemented */
 		    }
 		}
 	    }
-	  prop = add_intbyte_string_runes (data, result, dst - result, 0);
+	  prop = add_intbyte_string_runes (data, result, dst - result, 0, 0);
 	}
 }
 /* Else blow it off because someone added a bad entry and we don't
 have any safe way of signaling an error. */
 	findex = data->findex;
 else
 	findex = get_builtin_face_cache_index (w, face);
 instance = glyph_image_instance (gb->glyph, data->window,
-				       ERROR_ME_NOT, 1);
+				       ERROR_ME_DEBUG_WARN, 1);
 if (TEXT_IMAGE_INSTANCEP (instance))
 	{
 	  Lisp_Object string = XIMAGE_INSTANCE_TEXT_STRING (instance);
 	  face_index orig_findex = data->findex;
 	  Bytebpos orig_charbpos = data->bi_charbpos;
 	  data->findex = findex;
 	  data->bi_start_col_enabled = 0;
 	  if (!allow_cursor)
 	    data->bi_charbpos = 0;
 	  add_intbyte_string_runes (data, XSTRING_DATA (string),
-				    XSTRING_LENGTH (string), 0);
+				    XSTRING_LENGTH (string), 0, 1);
 	  data->findex = orig_findex;
 	  data->bi_charbpos = orig_charbpos;
 	  data->bi_start_col_enabled = orig_start_col_enabled;
 	  return NULL;
 	}
 data.ef = extent_fragment_new (w->buffer, f);
 /* These values are used by all of the rune addition routines.  We add
 them to this structure for ease of passing. */
 data.d = d;
-XSETWINDOW (data.window, w);
+data.window = wrap_window (w);
 data.string = Qnil;
 data.db = db;
 data.dl = dl;
 data.bi_charbpos = bi_start_pos;
 return 0;
 xzero (data);
 data.ef = NULL;
 data.d = d;
-XSETWINDOW (data.window, w);
+data.window = wrap_window (w);
 data.db = get_display_block_from_line (dl, OVERWRITE);
 data.dl = dl;
 data.pixpos = dl->bounds.left_in;
 data.max_pixpos = dl->bounds.right_in;
 data.cursor_type = NO_CURSOR;
 {
 add_intbyte_string_runes
 	(&data,
 	 XSTRING_DATA   (Voverlay_arrow_string),
 	 XSTRING_LENGTH (Voverlay_arrow_string),
-	 1);
+	 1, 0);
 }
 else if (GLYPHP (Voverlay_arrow_string))
 {
 struct glyph_block gb;
 int left_in_start = dl->bounds.left_in;
 int left_in_end = dl->bounds.left_in + overlay_width;
 struct display_block *odb, *idb;
-XSETWINDOW (window, w);
+window = wrap_window (w);
 /* We have to add the glyphs to the line in the order outside,
 inside, whitespace.  However the precedence dictates that we
 determine how many will fit in the reverse order. */
 int out_start, in_out_end, in_in_start, white_out_end, white_in_end;
 int out_cnt, in_out_cnt, in_in_cnt, white_out_cnt, white_in_cnt;
 struct display_block *odb, *idb;
-XSETWINDOW (window, w);
+window = wrap_window (w);
 /* We have to add the glyphs to the line in the order outside,
 inside, whitespace.  However the precedence dictates that we
 determine how many will fit in the reverse order. */
 data.last_charset = Qunbound;
 data.last_findex = DEFAULT_INDEX;
 data.result_str = result_str;
 data.is_modeline = 1;
 data.string = Qnil;
-XSETWINDOW (data.window, w);
+data.window = wrap_window (w);
 Dynarr_reset (formatted_string_extent_dynarr);
 Dynarr_reset (formatted_string_extent_start_dynarr);
 Dynarr_reset (formatted_string_extent_end_dynarr);
 in_modeline_generation = 1;
 sledgehammer_check_ascii_begin (result_str);
 detach_all_extents (result_str);
-resize_string (XSTRING (result_str), -1,
+resize_string (result_str, -1,
 data.bytepos - XSTRING_LENGTH (result_str));
 strdata = XSTRING_DATA (result_str);
 for (elt = 0, len = 0; elt < Dynarr_length (db->runes); elt++)
 elt++)
 {
 Lisp_Object extent = Qnil;
 Lisp_Object child;
-XSETEXTENT (extent, Dynarr_at (formatted_string_extent_dynarr, elt));
+extent = wrap_extent (Dynarr_at (formatted_string_extent_dynarr, elt));
 child = Fgethash (extent, buf->modeline_extent_table, Qnil);
 if (NILP (child))
 {
 child = Fmake_extent (Qnil, Qnil, result_str);
 Fputhash (extent, child, buf->modeline_extent_table);
 }
 }
 else if (GENERIC_SPECIFIERP (elt))
 {
 Lisp_Object window, tem;
-XSETWINDOW (window, w);
+window = wrap_window (w);
 tem = specifier_instance_no_quit (elt, Qunbound, window,
-					ERROR_ME_NOT, 0, Qzero);
+					ERROR_ME_DEBUG_WARN, 0, Qzero);
 if (!UNBOUNDP (tem))
 	{
 	  elt = tem;
 	  goto tail_recurse;
 	}
 	  if (SYMBOLP (car))
 	    tem = symbol_value_in_buffer (car, w->buffer);
 	  else
 	    tem = specifier_instance_no_quit (car, Qunbound, wrap_window (w),
-					      ERROR_ME_NOT, 0, Qzero);
+					      ERROR_ME_DEBUG_WARN, 0, Qzero);
 	  /* elt is now the cdr, and we know it is a cons cell.
 	     Use its car if CAR has a non-nil value.  */
 	  if (!UNBOUNDP (tem) && !NILP (tem))
 	    {
 	      elt = XCAR (elt);
 etc), its just the buffer text that we do not use. However, it
 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);
-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;
-Bytebpos bi_start_pos = string_index_char_to_byte (s, start_pos);
+Bytebpos bi_start_pos = string_index_char_to_byte (disp_string, start_pos);
 pos_data data;
 int truncate_win = b ? window_truncation_on (w) : 0;
 int end_glyph_width = 0;
 data.ef = extent_fragment_new (disp_string, f);
 /* These values are used by all of the rune addition routines.  We add
 them to this structure for ease of passing. */
 data.d = d;
-XSETWINDOW (data.window, w);
+data.window = wrap_window (w);
 data.db = db;
 data.dl = dl;
 data.bi_charbpos = bi_start_pos;
 data.pixpos = dl->bounds.left_in;
 /* Check for face changes. */
 if (initial || (!no_more_frags && data.bi_charbpos == data.ef->end))
 	{
 	  /* Now compute the face and begin/end-glyph information. */
 	  data.findex =
-	    /* Remember that the extent-fragment routines deal in Bytebpos's. */
+	    /* Remember that the extent-fragment routines deal in
+Bytebpos's. */
 	    extent_fragment_update (w, data.ef, data.bi_charbpos);
 	  /* This is somewhat cheesy but the alternative is to
 propagate default_face into extent_fragment_update. */
 	  if (data.findex == DEFAULT_INDEX)
 	    data.findex = default_face;
 	    data.start_col--;
 	  if (data.bi_charbpos == bi_string_zv)
 	    goto done;
 	  else
-	    INC_CHARBYTEBPOS (string_data (s), data.bi_charbpos);
+	    INC_CHARBYTEBPOS (XSTRING_DATA (disp_string), data.bi_charbpos);
 	}
 /* If there is propagation data, then it represents the current
 buffer position being displayed.  Add them and advance the
 position counter.  This might also add the minibuffer
 	    goto done;
 	  else if (data.bi_charbpos < 0)
 	    /* #### urk urk urk! Aborts are not very fun! Fix this please! */
 	    data.bi_charbpos = 0;
 	  else
-	    INC_CHARBYTEBPOS (string_data (s), data.bi_charbpos);
+	    INC_CHARBYTEBPOS (XSTRING_DATA (disp_string), data.bi_charbpos);
 	}
 /* If there are end glyphs, add them to the line.  These are
 	 the end glyphs for the previous run of text.  We add them
 	 here rather than doing them at the end of handling the
 else
 	{
 	  Lisp_Object entry = Qnil;
 	  /* Get the character at the current buffer position. */
-	  data.ch = string_char (s, data.bi_charbpos);
+	  data.ch = XSTRING_CHAR (disp_string, data.bi_charbpos);
 	  if (!NILP (face_dt) || !NILP (window_dt))
 	    entry = display_table_entry (data.ch, face_dt, window_dt);
 	  /* If there is a display table entry for it, hand it off to
 add_disp_table_entry_runes and let it worry about it. */
 	      *prop = add_emchar_rune (&data);
 	      if (*prop)
 		goto done;
 	    }
-	  INC_CHARBYTEBPOS (string_data (s), data.bi_charbpos);
+	  INC_CHARBYTEBPOS (XSTRING_DATA (disp_string), data.bi_charbpos);
 	}
 }
 done:
 /* The common case is that the line ended because we hit a newline.
 In that case, the next character is just the next buffer
 position. */
 if (data.ch == '\n')
 	{
-	  INC_CHARBYTEBPOS (string_data (s), data.bi_charbpos);
+	  INC_CHARBYTEBPOS (XSTRING_DATA (disp_string), data.bi_charbpos);
 	}
 /* Otherwise we have a buffer line which cannot fit on one display
 line. */
 else
 	  if (truncate_win)
 	    {
 	      Bytebpos bi_pos;
 	      /* Now find the start of the next line. */
-	      bi_pos = bi_find_next_emchar_in_string (s, '\n', data.bi_charbpos, 1);
+	      bi_pos = bi_find_next_emchar_in_string (disp_string, '\n',
+						      data.bi_charbpos, 1);
 	      data.cursor_type = NO_CURSOR;
 	      data.bi_charbpos = bi_pos;
 	      gb.glyph = Vtruncation_glyph;
 	      cachel = GLYPH_CACHEL (w, TRUN_GLYPH_INDEX);
 	  if (end_glyph_width)
 	    add_glyph_rune (&data, &gb, BEGIN_GLYPHS, 0, cachel);
 	  if (truncate_win && data.bi_charbpos == bi_string_zv)
 	    {
-	      const Intbyte* endb = charptr_n_addr (string_data (s), bi_string_zv);
+	      const Intbyte *endb = charptr_n_addr (XSTRING_DATA (disp_string),
+						    bi_string_zv);
 	      DEC_CHARPTR (endb);
 	      if (charptr_emchar (endb) != '\n')
 		{
 		  /* #### Damn this losing shit. */
 		  data.bi_charbpos++;
 }
 dl->cursor_elt = data.cursor_x;
 /* #### lossage lossage lossage! Fix this shit! */
 if (data.bi_charbpos > bi_string_zv)
-dl->end_charbpos = buffer_or_string_bytebpos_to_charbpos (disp_string, bi_string_zv);
+dl->end_charbpos = buffer_or_string_bytebpos_to_charbpos (disp_string,
+							      bi_string_zv);
 else
-dl->end_charbpos = buffer_or_string_bytebpos_to_charbpos (disp_string, data.bi_charbpos) - 1;
+dl->end_charbpos =
+buffer_or_string_bytebpos_to_charbpos (disp_string,
+					     data.bi_charbpos) - 1;
 if (truncate_win)
 data.dl->num_chars =
-string_column_at_point (s, dl->end_charbpos, b ? XINT (b->tab_width) : 8);
+string_column_at_point (disp_string, dl->end_charbpos,
+			      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_charbpos - dl->charbpos;
 it so that regenerate_window will exit properly.  This is bogus.
 The main loop should get fixed so that it isn't necessary to call
 this function if we are already at EOB. */
 if (data.bi_charbpos == bi_string_zv && bi_start_pos == bi_string_zv)
-return string_index_byte_to_char (s, data.bi_charbpos) + 1; /* Yuck! */
+return string_index_byte_to_char (disp_string,
+				      data.bi_charbpos) + 1; /* Yuck! */
 else
-return string_index_byte_to_char (s, data.bi_charbpos);
+return string_index_byte_to_char (disp_string, data.bi_charbpos);
 }
 /* Given a display line and a starting position, ensure that the
 contents of the display line accurately represent the visual
 representation of the buffer contents starting from the given
 	  return 0;
 	}
 if (lrpos >= pos)
 	{
-	  Lisp_Object window;
+	  Lisp_Object window = wrap_window (w);
-	  XSETWINDOW (window, w);
 	  va_run_hook_with_args_in_buffer (XBUFFER (w->buffer),
 					   Qredisplay_end_trigger_functions,
 					   2, window,
 					   w->redisplay_end_trigger);
 	  w->redisplay_end_trigger = Qnil;
 {
 Lisp_Object frame;
 f->old_buffer_alist = Freplace_list (f->old_buffer_alist,
 					   f->buffer_alist);
-XSETFRAME (frame, f);
+frame = wrap_frame (f);
 va_run_hook_with_args (Qbuffer_list_changed_hook, 1, frame);
 }
 /* Before we put a hold on frame size changes, attempt to process
 any which are already pending. */
 	  int adjustment =
 	    (cur_elt + new_line) - Dynarr_length (w->line_start_cache) + 1;
 	  Lisp_Object window;
 	  int defheight;
-	  XSETWINDOW (window, w);
+	  window = wrap_window (w);
 	  default_face_height_and_width (window, &defheight, 0);
 	  cur_elt = Dynarr_length (w->line_start_cache) - 1;
 	  pixpos -= (adjustment * defheight);
 display_line_dynarr *dla = window_display_lines (w, CURRENT_DISP);
 int num_disp_lines, modeline;
 Lisp_Object window;
 int defheight, defwidth;
-XSETWINDOW (window, w);
+window = wrap_window (w);
 default_face_height_and_width (window, &defheight, &defwidth);
 /* If we get a bogus value indicating somewhere above or to the left of
 the window, use the first window line or character position
 instead. */
 	  struct display_line *dl = Dynarr_atp (dla, bot_elt);
 	  int adj_area = y_coord - (dl->ypos + dl->descent);
 	  Lisp_Object lwin;
 	  int defheight;
-	  XSETWINDOW (lwin, *w);
+	  lwin = wrap_window (*w);
 	  default_face_height_and_width (lwin, 0, &defheight);
 	  *row += (adj_area / defheight);
 	}
 }

Mercurial > hg > xemacs-beta

comparison src/redisplay.c @ 793:e38acbeb1cae