comparison src/xdisp.c @ 2729:76afd3322533

Arrange to tell redisplay about changes in overlays. * xdisp.c (redisplay_region): New function. * buffer.c (Fmove_overlay): Call redisplay_region on the areas the overlay has enclosed or left. (Fdelete_overlay): Call redisplay_region on the area the overlay used to occupy. (Foverlay_put): Call redisplay_region on the area the overlay now occupies; we may have put a face property on it. * xdisp.c (redisplay): If we're doing a thorough redisplay (all windows on all frames involved), go ahead and flush the GC cache - call clear_face_vector. * xdisp.c (display_text_line): Apply faces to characters according to overlays and text properties; use compute_char_face and compute_glyph_face to figure out what face to use, and where a new face starts. * xterm.c (dumpglyphs): Use the upper bits of the glyphs to decide which frame face to use. Call GLYPH_FOLLOW_ALIASES to make sure we're implementing the glyph table properly. If we're not using the default or mode line face, call intern_face to find a display face for the frame face selected by the glyph code. Implement underlining. Remove the `font' argument; we have to derive this from the frame and face anyway. Change all callers. * disptab.h (GLYPH_FOLLOW_ALIASES): New macro.

2728:93c9529b2b69

  if (all_windows)
    {
      Lisp_Object tail, frame;

      /* Recompute # windows showing selected buffer.
	 This will be incremented each time such a window is displayed.  */
      buffer_shared = 0;

      FOR_EACH_FRAME (tail, frame)

	abort ();
    }

  return 1;
}

/* Copy glyphs from the vector FROM to the rope T.
   But don't actually copy the parts that would come in before S.
   Value is T, advanced past the copied data.  */

  GLYPH truncator = (dp == 0 || XTYPE (DISP_TRUNC_GLYPH (dp)) != Lisp_Int
		    ? '$' : XINT (DISP_TRUNC_GLYPH (dp)));
  GLYPH continuer = (dp == 0 || XTYPE (DISP_CONTINUE_GLYPH (dp)) != Lisp_Int
		    ? '\\' : XINT (DISP_CONTINUE_GLYPH (dp)));

  hpos += XFASTINT (w->left);
  get_display_line (f, vpos, XFASTINT (w->left));
  if (tab_width <= 0 || tab_width > 1000) tab_width = 8;

  if (MINI_WINDOW_P (w) && start == 1

  startp = desired_glyphs->glyphs[vpos] + XFASTINT (w->left);
  endp = startp + width;

  /* Loop generating characters.
     Stop at end of buffer, before newline,
     or if reach or pass continuation column.  */

  pause = pos;
  while (p1 < endp)
    {
      p1prev = p1;
      if (pos == pause)
	{
	  if (pos == end)
	    break;
	  if (pos == point && cursor_vpos < 0)
	    {
	      cursor_vpos = vpos;
	      cursor_hpos = p1 - startp;
	    }

	  pause = end;
	  if (pos < point && point < pause)
	    pause = point;
	  if (pos < GPT && GPT < pause)
	    pause = GPT;

      c = *p++;
      if (c >= 040 && c < 0177
	  && (dp == 0 || XTYPE (DISP_CHAR_VECTOR (dp, c)) != Lisp_Vector))
	{
	  if (p1 >= startp)
	    *p1 = c;
	  p1++;
	}
      else if (c == '\n')
	{
	  invis = 0;

		p1 = endp;
	      copy_part_of_rope (p1prev, p1prev,
				 XVECTOR (DISP_INVIS_VECTOR (dp))->contents,
				 (p1 - p1prev));
	    }
	  break;
	}
      else if (c == '\t')
	{
	  do
	    {

		p1 = endp;
	      copy_part_of_rope (p1prev, p1prev,
				 XVECTOR(DISP_INVIS_VECTOR (dp))->contents,
				 (p1 - p1prev));
	    }
	  break;
	}
      else if (dp != 0 && XTYPE (DISP_CHAR_VECTOR (dp, c)) == Lisp_Vector)
	{
	  p1 = copy_rope (p1, startp, DISP_CHAR_VECTOR (dp, c));
	}
      else if (c < 0200 && ctl_arrow)
	{
	  if (p1 >= startp)
	    *p1 = (dp && XTYPE (DISP_CTRL_GLYPH (dp)) == Lisp_Int
		   ? XINT (DISP_CTRL_GLYPH (dp)) : '^');
	  p1++;
	  if (p1 >= startp && p1 < endp)
	    *p1 = c ^ 0100;
	  p1++;
	}
      else
	{
	  if (p1 >= startp)
	    *p1 = (dp && XTYPE (DISP_ESCAPE_GLYPH (dp)) == Lisp_Int
		   ? XINT (DISP_ESCAPE_GLYPH (dp)) : '\\');
	  p1++;
	  if (p1 >= startp && p1 < endp)
	    *p1 = (c >> 6) + '0';
	  p1++;
	  if (p1 >= startp && p1 < endp)
	    *p1 = (7 & (c >> 3)) + '0';
	  p1++;
	  if (p1 >= startp && p1 < endp)
	    *p1 = (7 & c) + '0';
	  p1++;
	}
      pos++;
    }

  val.hpos = - XINT (w->hscroll);
  if (val.hpos)

2729:76afd3322533

  if (all_windows)
    {
      Lisp_Object tail, frame;

#ifdef HAVE_X_WINDOWS
      /* Since we're doing a thorough redisplay, we might as well
	 recompute all our display faces.  */
      clear_face_vector ();
#endif

      /* Recompute # windows showing selected buffer.
	 This will be incremented each time such a window is displayed.  */
      buffer_shared = 0;

      FOR_EACH_FRAME (tail, frame)

	abort ();
    }

  return 1;
}

/* Mark a section of BUF as modified, but only for the sake of redisplay.
   This is useful for recording changes to overlays.

   We increment the buffer's modification timestamp and set the
   redisplay caches (windows_or_buffers_changed, beg_unchanged, etc)
   as if the region of text between START and END had been modified;
   the redisplay code will check this against the windows' timestamps,
   and redraw the appropriate area of the buffer.

   However, if the buffer is unmodified, we bump the last-save
   timestamp as well, so that incrementing the timestamp doesn't fool
   Emacs into thinking that the buffer's text has been modified. 

   Tweaking the timestamps shouldn't hurt the first-modification
   timestamps recorded in the undo records; those values aren't
   written until just before a real text modification is made, so they
   will never catch the timestamp value just before this function gets
   called.  */

void
redisplay_region (buf, start, end)
     struct buffer *buf;
     int start, end;
{
  if (start == end)
    return;

  if (start > end)
    {
      int temp = start;
      start = end; end = temp;
    }

  if (buf != current_buffer)
    windows_or_buffers_changed = 1;
  else
    {
      if (unchanged_modified == MODIFF)
	{
	  beg_unchanged = start - BEG;
	  end_unchanged = Z - end;
	}
      else
	{
	  if (Z - end < end_unchanged)
	    end_unchanged = Z - end;
	  if (start - BEG < beg_unchanged)
	    beg_unchanged = start - BEG;
	}
    }

  /* Increment the buffer's time stamp, but also increment the save
     and autosave timestamps, so as not to screw up that timekeeping. */
  if (BUF_MODIFF (buf) == buf->save_modified)
    buf->save_modified++;
  if (BUF_MODIFF (buf) == buf->auto_save_modified)
    buf->auto_save_modified++;

  BUF_MODIFF (buf) ++;
}


/* Copy glyphs from the vector FROM to the rope T.
   But don't actually copy the parts that would come in before S.
   Value is T, advanced past the copied data.  */

  GLYPH truncator = (dp == 0 || XTYPE (DISP_TRUNC_GLYPH (dp)) != Lisp_Int
		    ? '$' : XINT (DISP_TRUNC_GLYPH (dp)));
  GLYPH continuer = (dp == 0 || XTYPE (DISP_CONTINUE_GLYPH (dp)) != Lisp_Int
		    ? '\\' : XINT (DISP_CONTINUE_GLYPH (dp)));

  /* The next buffer location at which the face should change, due
     to overlays or text property changes.  */
  int next_face_change;

  /* The face we're currently using.  */
  int current_face;

  hpos += XFASTINT (w->left);
  get_display_line (f, vpos, XFASTINT (w->left));
  if (tab_width <= 0 || tab_width > 1000) tab_width = 8;

  if (MINI_WINDOW_P (w) && start == 1

  startp = desired_glyphs->glyphs[vpos] + XFASTINT (w->left);
  endp = startp + width;

  /* Loop generating characters.
     Stop at end of buffer, before newline,
     if reach or pass continuation column,
     or at face change.  */
  pause = pos;
  next_face_change = pos;
  while (p1 < endp)
    {
      p1prev = p1;
      if (pos >= pause)
	{
	  /* Did we hit the end of the visible region of the buffer?
	     Stop here.  */
	  if (pos >= end)
	    break;

	  /* Did we reach point?  Record the cursor location.  */
	  if (pos == point && cursor_vpos < 0)
	    {
	      cursor_vpos = vpos;
	      cursor_hpos = p1 - startp;
	    }

	  pause = end;

	  /* Did we hit a face change?  Figure out what face we should
	     use now.  We also hit this the first time through the
	     loop, to see what face we should start with.  */
	  if (pos == next_face_change)
	    {
	      current_face = compute_char_face (f, w, pos, &next_face_change);
	      if (pos < next_face_change && next_face_change < pause)
		pause = next_face_change;
	    }

	  /* Wouldn't you hate to read the next line to someone over
             the phone?  */
	  if (pos < point && point < pause)
	    pause = point;
	  if (pos < GPT && GPT < pause)
	    pause = GPT;

      c = *p++;
      if (c >= 040 && c < 0177
	  && (dp == 0 || XTYPE (DISP_CHAR_VECTOR (dp, c)) != Lisp_Vector))
	{
	  if (p1 >= startp)
	    *p1 = MAKE_GLYPH (c, 0);
	  p1++;
	}
      else if (c == '\n')
	{
	  invis = 0;

		p1 = endp;
	      copy_part_of_rope (p1prev, p1prev,
				 XVECTOR (DISP_INVIS_VECTOR (dp))->contents,
				 (p1 - p1prev));
	    }

	  /* This assures we'll exit the loop, but still gives us a chance to
	     apply current_face to the glyphs we've laid down.  */
	  end = pos;
	  pause = end;
	}
      else if (c == '\t')
	{
	  do
	    {

		p1 = endp;
	      copy_part_of_rope (p1prev, p1prev,
				 XVECTOR(DISP_INVIS_VECTOR (dp))->contents,
				 (p1 - p1prev));
	    }
	  end = pos;
	  pause = end;
	}
      else if (dp != 0 && XTYPE (DISP_CHAR_VECTOR (dp, c)) == Lisp_Vector)
	{
	  p1 = copy_rope (p1, startp, DISP_CHAR_VECTOR (dp, c));
	}
      else if (c < 0200 && ctl_arrow)
	{
	  if (p1 >= startp)
	    *p1 = MAKE_GLYPH ((dp && XTYPE (DISP_CTRL_GLYPH (dp)) == Lisp_Int
			       ? XINT (DISP_CTRL_GLYPH (dp)) : '^'),
			      0);
	  p1++;
	  if (p1 >= startp && p1 < endp)
	    *p1 = MAKE_GLYPH (c ^ 0100, 0);
	  p1++;
	}
      else
	{
	  if (p1 >= startp)
	    *p1 = MAKE_GLYPH ((dp && XTYPE (DISP_ESCAPE_GLYPH (dp)) == Lisp_Int
			       ? XINT (DISP_ESCAPE_GLYPH (dp)) : '\\'),
			      0);
	  p1++;
	  if (p1 >= startp && p1 < endp)
	    *p1 = MAKE_GLYPH ((c >> 6) + '0', 0);
	  p1++;
	  if (p1 >= startp && p1 < endp)
	    *p1 = MAKE_GLYPH ((7 & (c >> 3)) + '0', 0);
	  p1++;
	  if (p1 >= startp && p1 < endp)
	    *p1 = MAKE_GLYPH ((7 & c) + '0', 0);
	  p1++;
	}

      /* Now we've laid down some characters between p1prev and p1.
	 Let's apply current_face to those who have a face of zero
	 (the default), and apply Vglyph_table to the result.  */
      if (current_face)
	{
	  GLYPH *gstart, *gp, *gend;

	  gstart = (p1prev > startp) ? p1prev : startp;
	  gend   = (p1     < endp)   ? p1     : endp;

	  for (gp = gstart; gp < gend; gp++)
	    *gp = MAKE_GLYPH (GLYPH_CHAR (*gp),
			      (GLYPH_FACE (*gp) == 0
			       ? current_face
			       : compute_glyph_face (f, FRAME_DEFAULT_FACE (f),
						     GLYPH_FACE (*gp))));
	}

      pos++;
    }

  val.hpos = - XINT (w->hscroll);
  if (val.hpos)