(do_pending_window_change): Add parameter `safe'.

(change_frame_size): Ditto.
(change_frame_size_1): Ditto.  Deley size changes if redisplaying
and not called from a safe place.
(window_change_signal): Call change_frame_size with new parameter.
(set_window_cursor_after_update): Do the
cursor_in_echo_area case only for a mini-window showing
a message.  Don't let cursor end up after the end of a row.
(adjust_frame_message_buffer): Removed references
to echo_area_glyphs and previous_echo_glyphs.
(direct_output_for_insert): Check for mini-window displaying
echo area message differently.
(update_frame): Likewise.
(set_window_cursor_after_update): Likewise.  In echo area,
don't try to set cursor on rows that aren't enabled.

diff --git a/src/dispnew.c b/src/dispnew.c
index 55c56a9361c491d69c280d97d00fba5cac5ffdee..487e2f1d8c6a673d333e442b4bff9ba6f2af1896 100644 (file)
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -126,7 +126,7 @@ struct glyph_matrix *new_glyph_matrix P_ ((struct glyph_pool *));
 static void free_glyph_matrix P_ ((struct glyph_matrix *));
 static void adjust_glyph_matrix P_ ((struct window *, struct glyph_matrix *,
                                     int, int, struct dim));
-static void change_frame_size_1 P_ ((struct frame *, int, int, int, int));
+static void change_frame_size_1 P_ ((struct frame *, int, int, int, int, int));
 static void swap_glyphs_in_rows P_ ((struct glyph_row *, struct glyph_row *));
 static void swap_glyph_pointers P_ ((struct glyph_row *, struct glyph_row *));
 static int glyph_row_slice_p P_ ((struct glyph_row *, struct glyph_row *));
@@ -155,8 +155,10 @@ static void make_current P_ ((struct glyph_matrix *, struct glyph_matrix *,
                              int));
 static void mirror_make_current P_ ((struct window *, int));
 void check_window_matrix_pointers P_ ((struct window *));
+#if GLYPH_DEBUG
 static void check_matrix_pointers P_ ((struct glyph_matrix *,
                                       struct glyph_matrix *));
+#endif
 static void mirror_line_dance P_ ((struct window *, int, int, int *, char *));
 static int update_window_tree P_ ((struct window *, int));
 static int update_window P_ ((struct window *, int));
@@ -2096,10 +2098,6 @@ adjust_frame_glyphs_for_window_redisplay (f)
 
 /* Adjust/ allocate message buffer of frame F. 
 
-   The global variables echo_area_glyphs and previous_echo_area_glyphs
-   may be pointing to the frames message buffer and must be relocated
-   if the buffer is reallocated.
-
    Note that the message buffer is never freed.  Since I could not
    find a free in 19.34, I assume that freeing it would be
    problematic in some way and don't do it either.
@@ -2117,12 +2115,6 @@ adjust_frame_message_buffer (f)
     {
       char *buffer = FRAME_MESSAGE_BUF (f);
       char *new_buffer = (char *) xrealloc (buffer, size);
- 
-      if (buffer == echo_area_glyphs)
-        echo_area_glyphs = new_buffer;
-      if (buffer == previous_echo_glyphs)
-        previous_echo_glyphs = new_buffer;
-
       FRAME_MESSAGE_BUF (f) = new_buffer;
     }
   else
@@ -3028,8 +3020,7 @@ direct_output_for_insert (g)
       /* Give up if buffer appears in two places.  */
       || buffer_shared > 1
       /* Give up if w is mini-buffer and a message is being displayed there */
-      || (MINI_WINDOW_P (w)
-         && (echo_area_glyphs || STRINGP (echo_area_message)))
+      || (MINI_WINDOW_P (w) && !NILP (echo_area_buffer[0]))
       /* Give up for hscrolled mini-buffer because display of the prompt
         is handled specially there (see display_line).  */
       || (MINI_WINDOW_P (w) && XFASTINT (w->hscroll))
@@ -3586,12 +3577,14 @@ update_window (w, force_p)
      struct window *w;
      int force_p;
 {
-  struct frame *f = XFRAME (WINDOW_FRAME (w));
   struct glyph_matrix *desired_matrix = w->desired_matrix;
   int paused_p;
   int preempt_count = baud_rate / 2400 + 1;
   extern int input_pending;
+#if GLYPH_DEBUG
+  struct frame *f = XFRAME (WINDOW_FRAME (w));
   extern struct frame *updating_frame;
+#endif
 
   /* Check that W's frame doesn't have glyph matrices.  */
   xassert (FRAME_WINDOW_P (f));
@@ -4019,13 +4012,12 @@ set_window_cursor_after_update (w)
   /* Not intended for frame matrix updates.  */
   xassert (FRAME_WINDOW_P (f));
   
-  if ((cursor_in_echo_area
-       /* If we are showing a message instead of the mini-buffer,
-         show the cursor for the message instead of for the
-         (now hidden) mini-buffer contents.  */
-       || (XWINDOW (minibuf_window) == w
-          && EQ (minibuf_window, echo_area_window)
-          && (echo_area_glyphs || STRINGP (echo_area_message))))
+  if (cursor_in_echo_area
+      && !NILP (echo_area_buffer[0])
+      /* If we are showing a message instead of the mini-buffer,
+        show the cursor for the message instead.  */
+      && XWINDOW (minibuf_window) == w
+      && EQ (minibuf_window, echo_area_window)
       /* These cases apply only to the frame that contains
         the active mini-buffer window.  */
       && FRAME_HAS_MINIBUF_P (f)
@@ -4044,7 +4036,9 @@ set_window_cursor_after_update (w)
          int yb = window_text_bottom_y (w);
 
          last_row = NULL;
-         for (row = MATRIX_ROW (w->current_matrix, 0);; ++row)
+         for (row = MATRIX_ROW (w->current_matrix, 0);
+              row->enabled_p;
+              ++row)
            {
              if (row->used[TEXT_AREA]
                  && row->glyphs[TEXT_AREA][0].charpos >= 0)
@@ -4057,9 +4051,9 @@ set_window_cursor_after_update (w)
          if (last_row)
            {
              struct glyph *start = row->glyphs[TEXT_AREA];
-             struct glyph *last = start + row->used[TEXT_AREA];
+             struct glyph *last = start + row->used[TEXT_AREA] - 1;
 
-             while (last > start && (last - 1)->charpos < 0)
+             while (last > start && last->charpos < 0)
                --last;
              
              for (glyph = start; glyph < last; ++glyph)
@@ -4529,7 +4523,7 @@ update_frame_1 (f, force_p, inhibit_id_p)
              (now hidden) mini-buffer contents.  */
           || (EQ (minibuf_window, selected_window)
               && EQ (minibuf_window, echo_area_window)
-              && (echo_area_glyphs || STRINGP (echo_area_message))))
+              && !NILP (echo_area_buffer[0])))
          /* These cases apply only to the frame that contains
             the active mini-buffer window.  */
          && FRAME_HAS_MINIBUF_P (f)
@@ -4561,7 +4555,6 @@ update_frame_1 (f, force_p, inhibit_id_p)
                    {
                      /* Frame rows are filled up with spaces that
                         must be ignored here.  */
-                     int i;
                      struct glyph_row *r = MATRIX_ROW (current_matrix,
                                                        row);
                      struct glyph *start = r->glyphs[TEXT_AREA];
@@ -5186,7 +5179,7 @@ window_change_signal (signalnum) /* If we don't have an argument, */
       {
        if (FRAME_TERMCAP_P (XFRAME (frame)))
          {
-           change_frame_size (XFRAME (frame), height, width, 0, 1);
+           change_frame_size (XFRAME (frame), height, width, 0, 1, 0);
            break;
          }
       }
@@ -5198,12 +5191,18 @@ window_change_signal (signalnum) /* If we don't have an argument, */
 #endif /* SIGWINCH */
 
 
-/* Do any change in frame size that was requested by a signal.  */
+/* Do any change in frame size that was requested by a signal.  SAFE
+   non-zero means this function is called from a place where it is
+   safe to change frame sizes  while a redisplay is in progress.  */
 
 void
-do_pending_window_change ()
+do_pending_window_change (safe)
+     int safe;
 {
   /* If window_change_signal should have run before, run it now.  */
+  if (redisplaying_p && !safe)
+    return;
+  
   while (delayed_size_change)
     {
       Lisp_Object tail, frame;
@@ -5218,7 +5217,7 @@ do_pending_window_change ()
          int width = FRAME_NEW_WIDTH (f);
 
          if (height != 0 || width != 0)
-           change_frame_size (f, height, width, 0, 0);
+           change_frame_size (f, height, width, 0, 0, safe);
        }
     }
 }
@@ -5230,12 +5229,15 @@ do_pending_window_change ()
    If DELAY is non-zero, then assume we're being called from a signal
    handler, and queue the change for later - perhaps the next
    redisplay.  Since this tries to resize windows, we can't call it
-   from a signal handler.  */
+   from a signal handler.
+
+   SAFE non-zero means this function is called from a place where it's
+   safe to change frame sizes while a redisplay is in progress.  */
 
 void
-change_frame_size (f, newheight, newwidth, pretend, delay)
+change_frame_size (f, newheight, newwidth, pretend, delay, safe)
      register struct frame *f;
-     int newheight, newwidth, pretend, delay;
+     int newheight, newwidth, pretend, delay, safe;
 {
   Lisp_Object tail, frame;
 
@@ -5246,23 +5248,22 @@ change_frame_size (f, newheight, newwidth, pretend, delay)
       FOR_EACH_FRAME (tail, frame)
        if (! FRAME_WINDOW_P (XFRAME (frame)))
          change_frame_size_1 (XFRAME (frame), newheight, newwidth,
-                              pretend, delay);
+                              pretend, delay, safe);
     }
   else
-    change_frame_size_1 (f, newheight, newwidth, pretend, delay);
+    change_frame_size_1 (f, newheight, newwidth, pretend, delay, safe);
 }
 
 static void
-change_frame_size_1 (f, newheight, newwidth, pretend, delay)
+change_frame_size_1 (f, newheight, newwidth, pretend, delay, safe)
      register struct frame *f;
-     int newheight, newwidth, pretend, delay;
+     int newheight, newwidth, pretend, delay, safe;
 {
   int new_frame_window_width;
-  unsigned int total_glyphs;
   int count = specpdl_ptr - specpdl;
 
   /* If we can't deal with the change now, queue it for later.  */
-  if (delay)
+  if (delay || (redisplaying_p && !safe))
     {
       FRAME_NEW_HEIGHT (f) = newheight;
       FRAME_NEW_WIDTH (f) = newwidth;