1 files changed, 649 insertions, 330 deletions

diff --git a/src/dispnew.c b/src/dispnew.c
index 1a243079e46..1089ab4c4f8 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -71,7 +71,7 @@ struct dim
 
 /* Function prototypes.  */
 
-static void update_frame_line (struct frame *, int, bool);
+static void write_row (struct frame *f, int vpos, bool updating_menu_p);
 static int required_matrix_height (struct window *);
 static int required_matrix_width (struct window *);
 static void increment_row_positions (struct glyph_row *, ptrdiff_t, ptrdiff_t);
@@ -80,9 +80,9 @@ static void build_frame_matrix_from_window_tree (struct glyph_matrix *,
 static void build_frame_matrix_from_leaf_window (struct glyph_matrix *,
                                                  struct window *);
 static void adjust_decode_mode_spec_buffer (struct frame *);
-static void fill_up_glyph_row_with_spaces (struct glyph_row *);
+static void fill_up_glyph_row_with_spaces (struct frame *, struct glyph_row *);
 static void clear_window_matrices (struct window *, bool);
-static void fill_up_glyph_row_area_with_spaces (struct glyph_row *, int);
+static void fill_up_glyph_row_area_with_spaces (struct frame *, struct glyph_row *, int);
 static int scrolling_window (struct window *, int);
 static bool update_window_line (struct window *, int, bool *);
 static void mirror_make_current (struct window *, int);
@@ -93,7 +93,7 @@ static void check_matrix_pointers (struct glyph_matrix *,
 static void mirror_line_dance (struct window *, int, int, int *, char *);
 static bool update_window_tree (struct window *, bool);
 static bool update_window (struct window *, bool);
-static bool update_frame_1 (struct frame *, bool, bool, bool, bool);
+static bool write_matrix (struct frame *, bool, bool, bool, bool);
 static bool scrolling (struct frame *);
 static void set_window_cursor_after_update (struct window *);
 static void adjust_frame_glyphs_for_window_redisplay (struct frame *);
@@ -122,11 +122,6 @@ static int glyph_pool_count;
 
 #endif /* GLYPH_DEBUG and ENABLE_CHECKING */
 
-/* If non-null, the frame whose frame matrices are manipulated.  If
-   null, window matrices are worked on.  */
-
-static struct frame *frame_matrix_frame;
-
 /* Convert vpos and hpos from frame to window and vice versa.
    This may only be used for terminal frames.  */
 
@@ -1178,7 +1173,12 @@ line_hash_code (struct frame *f, struct glyph_row *row)
       while (glyph < end)
         {
           int c = glyph->u.ch;
+          /* FIXME/tty: struct frame can move with igc, and so on.
+             But we need something that takes different frames
+             into account. */
           int face_id = glyph->face_id;
+          if (glyph->frame != f)
+            face_id += (ptrdiff_t) glyph->frame;
           if (FRAME_MUST_WRITE_SPACES (f))
             c -= SPACEGLYPH;
           hash = (((hash << 4) + (hash >> 24)) & 0x0fffffff) + c;
@@ -1213,7 +1213,7 @@ line_draw_cost (struct frame *f, struct glyph_matrix *matrix, int vpos)
   if (!FRAME_MUST_WRITE_SPACES (f))
     {
       /* Skip from the end over trailing spaces.  */
-      while (end > beg && CHAR_GLYPH_SPACE_P (*(end - 1)))
+      while (end > beg && CHAR_GLYPH_SPACE_P (f, *(end - 1)))
         --end;
 
       /* All blank line.  */
@@ -1221,7 +1221,7 @@ line_draw_cost (struct frame *f, struct glyph_matrix *matrix, int vpos)
         return 0;
 
       /* Skip over leading spaces.  */
-      while (CHAR_GLYPH_SPACE_P (*beg))
+      while (CHAR_GLYPH_SPACE_P (f, *beg))
         ++beg;
     }
 
@@ -2558,6 +2558,7 @@ build_frame_matrix_from_leaf_window (struct glyph_matrix *frame_matrix, struct w
   int window_y, frame_y;
   /* If non-zero, a glyph to insert at the right border of W.  */
   GLYPH right_border_glyph;
+  struct frame *f = XFRAME (w->frame);
 
   SET_GLYPH_FROM_CHAR (right_border_glyph, 0);
 
@@ -2599,10 +2600,10 @@ build_frame_matrix_from_leaf_window (struct glyph_matrix *frame_matrix, struct w
 
       /* Fill up the frame row with spaces up to the left margin of the
          window row.  */
-      fill_up_frame_row_with_spaces (frame_row, window_matrix->matrix_x);
+      fill_up_frame_row_with_spaces (f, frame_row, window_matrix->matrix_x);
 
       /* Fill up areas in the window matrix row with spaces.  */
-      fill_up_glyph_row_with_spaces (window_row);
+      fill_up_glyph_row_with_spaces (f, window_row);
 
       /* If only part of W's desired matrix has been built, and
          window_row wasn't displayed, use the corresponding current
@@ -2638,7 +2639,7 @@ build_frame_matrix_from_leaf_window (struct glyph_matrix *frame_matrix, struct w
                  glyph with the vertical border glyph.  */
               eassert (border->type == CHAR_GLYPH);
               border->type = CHAR_GLYPH;
-              SET_CHAR_GLYPH_FROM_GLYPH (*border, right_border_glyph);
+              SET_CHAR_GLYPH_FROM_GLYPH (f, *border, right_border_glyph);
             }
 
 #ifdef GLYPH_DEBUG
@@ -2701,11 +2702,11 @@ spec_glyph_lookup_face (struct window *w, GLYPH *glyph)
    To be called for frame-based redisplay, only.  */
 
 static void
-fill_up_glyph_row_with_spaces (struct glyph_row *row)
+fill_up_glyph_row_with_spaces (struct frame *f, struct glyph_row *row)
 {
-  fill_up_glyph_row_area_with_spaces (row, LEFT_MARGIN_AREA);
-  fill_up_glyph_row_area_with_spaces (row, TEXT_AREA);
-  fill_up_glyph_row_area_with_spaces (row, RIGHT_MARGIN_AREA);
+  fill_up_glyph_row_area_with_spaces (f, row, LEFT_MARGIN_AREA);
+  fill_up_glyph_row_area_with_spaces (f, row, TEXT_AREA);
+  fill_up_glyph_row_area_with_spaces (f, row, RIGHT_MARGIN_AREA);
 }
 
 
@@ -2713,15 +2714,19 @@ fill_up_glyph_row_with_spaces (struct glyph_row *row)
    frame-based redisplay only.  */
 
 static void
-fill_up_glyph_row_area_with_spaces (struct glyph_row *row, int area)
+fill_up_glyph_row_area_with_spaces (struct frame *f, struct glyph_row *row,
+                                    int area)
 {
   if (row->glyphs[area] < row->glyphs[area + 1])
     {
       struct glyph *end = row->glyphs[area + 1];
       struct glyph *text = row->glyphs[area] + row->used[area];
 
-      while (text < end)
-        *text++ = space_glyph;
+      for (; text < end; ++text)
+        {
+          *text = space_glyph;
+          text->frame = f;
+        }
       row->used[area] = text - row->glyphs[area];
     }
 }
@@ -2731,13 +2736,16 @@ fill_up_glyph_row_area_with_spaces (struct glyph_row *row, int area)
    reached.  In frame matrices only one area, TEXT_AREA, is used.  */
 
 void
-fill_up_frame_row_with_spaces (struct glyph_row *row, int upto)
+fill_up_frame_row_with_spaces (struct frame *f, struct glyph_row *row, int upto)
 {
   int i = row->used[TEXT_AREA];
   struct glyph *glyph = row->glyphs[TEXT_AREA];
 
-  while (i < upto)
-    glyph[i++] = space_glyph;
+  for (; i < upto; ++i)
+    {
+      glyph[i] = space_glyph;
+      glyph[i].frame = f;
+    }
 
   row->used[TEXT_AREA] = i;
 }
@@ -2748,17 +2756,6 @@ fill_up_frame_row_with_spaces (struct glyph_row *row, int upto)
       Mirroring operations on frame matrices in window matrices
  **********************************************************************/
 
-/* Set frame being updated via frame-based redisplay to F.  This
-   function must be called before updates to make explicit that we are
-   working on frame matrices or not.  */
-
-static void
-set_frame_matrix_frame (struct frame *f)
-{
-  frame_matrix_frame = f;
-}
-
-
 /* Make sure glyph row ROW in CURRENT_MATRIX is up to date.
    DESIRED_MATRIX is the desired matrix corresponding to
    CURRENT_MATRIX.  The update is done by exchanging glyph pointers
@@ -2768,9 +2765,10 @@ set_frame_matrix_frame (struct frame *f)
    operations in window matrices of frame_matrix_frame.  */
 
 static void
-make_current (struct glyph_matrix *desired_matrix,
-              struct glyph_matrix *current_matrix, int row)
+make_current (struct frame *f, struct window *w, int row)
 {
+  struct glyph_matrix *desired_matrix = f ? f->desired_matrix : w->desired_matrix;
+  struct glyph_matrix *current_matrix = f ? f->current_matrix : w->current_matrix;
   struct glyph_row *current_row = MATRIX_ROW (current_matrix, row);
   struct glyph_row *desired_row = MATRIX_ROW (desired_matrix, row);
   bool mouse_face_p = current_row->mouse_face_p;
@@ -2797,8 +2795,8 @@ make_current (struct glyph_matrix *desired_matrix,
 
   /* If we are called on frame matrices, perform analogous operations
      for window matrices.  */
-  if (frame_matrix_frame)
-    mirror_make_current (XWINDOW (frame_matrix_frame->root_window), row);
+  if (f)
+    mirror_make_current (XWINDOW (f->root_window), row);
 }
 
 
@@ -2862,9 +2860,11 @@ mirror_make_current (struct window *w, int frame_row)
    This function is called from do_scrolling and do_direct_scrolling.  */
 
 void
-mirrored_line_dance (struct glyph_matrix *matrix, int unchanged_at_top, int nlines,
+mirrored_line_dance (struct frame *f, int unchanged_at_top, int nlines,
                      int *copy_from, char *retained_p)
 {
+  struct glyph_matrix *matrix = f->current_matrix;
+
   /* A copy of original rows.  */
   struct glyph_row *old_rows;
 
@@ -2894,9 +2894,8 @@ mirrored_line_dance (struct glyph_matrix *matrix, int unchanged_at_top, int nlin
     }
 
   /* Do the same for window matrices, if MATRIX is a frame matrix.  */
-  if (frame_matrix_frame)
-    mirror_line_dance (XWINDOW (frame_matrix_frame->root_window),
-                       unchanged_at_top, nlines, copy_from, retained_p);
+  mirror_line_dance (XWINDOW (f->root_window),
+                     unchanged_at_top, nlines, copy_from, retained_p);
 
   SAFE_FREE ();
 }
@@ -3194,7 +3193,10 @@ redraw_frame (struct frame *f)
        future.  */
     SET_FRAME_GARBAGED (f);
 
-  clear_frame (f);
+  /* FIXME/tty: clear_frame is actually a "clear_terminal", i.e.
+     is clears the entire screen. */
+  if (!FRAME_PARENT_FRAME (f))
+    clear_frame (f);
   clear_current_matrices (f);
   update_end (f);
   fset_redisplay (f);
@@ -3229,145 +3231,501 @@ DEFUN ("redraw-display", Fredraw_display, Sredraw_display, 0, 0, "",
   return Qnil;
 }
 
-
 
-/***********************************************************************
-                             Frame Update
- ***********************************************************************/
+/**********************************************************************
+                            TTY Child Frames
+ **********************************************************************/
 
-/* Update frame F based on the data in desired matrices.
+/* The new thing that child frames on ttys provide is that frames on a
+   tty no longer always occupy the whole terminal. They can overlap
+   instead.
 
-   If FORCE_P, don't let redisplay be stopped by detecting pending input.
-   If INHIBIT_HAIRY_ID_P, don't try scrolling.
+   Let a "root" frame be a frame that has no parent frame. Such root
+   frames we require to be the size of the terminal screen. The current
+   glyph matrix of a root frame of a termimnal represents what is on the
+   screen. The desired matrix of a root frame represents what should be
+   one the screen.
 
-   Value is true if redisplay was stopped due to pending input.  */
+   Building the desired matrix of root frame proceeds by
 
-bool
-update_frame (struct frame *f, bool force_p, bool inhibit_hairy_id_p)
+   - building the desired matrix of the root frame itself which is
+     the bottommost frame in z-order,
+   - building desired matrices of child frames in z-order, topmost last,
+   - copying the desired glyphs from child frames to the desired glyphs
+     of the root frame
+
+   Updating the screen is then done using root frame matrices as it was
+   before child frames were introduced. Child frame current matrices are
+   updated by copying glyph contents of the current matrix of the root
+   frames to the current matrices of child frames. This imnplicitly
+   also updates the glyph contents of their windows' current matrices.  */
+
+struct rect
 {
-  /* True means display has been paused because of pending input.  */
-  bool paused_p;
-  struct window *root_window = XWINDOW (f->root_window);
+  int x, y, w, h;
+};
 
-  if (redisplay_dont_pause)
-    force_p = true;
-  else if (!force_p && detect_input_pending_ignore_squeezables ())
+#ifdef GLYPH_DEBUG
+static bool
+is_glyph_in_matrix (struct glyph_matrix *m, struct glyph *g)
+{
+  for (int y = 0; y < m->matrix_h; ++y)
     {
-      paused_p = true;
-      goto do_pause;
+      struct glyph_row *r = MATRIX_ROW (m, y);
+      if (g >= r->glyphs[0] && g < r->glyphs[0] + m->matrix_w)
+        return true;
     }
+  return false;
+}
 
-  if (FRAME_WINDOW_P (f))
+/* Return true if GLYPH is part of the desired matrix of F. */
+
+bool
+is_tty_desired_glyph (struct frame *f, struct glyph *g)
+{
+  eassert (is_tty_frame (f));
+  return is_glyph_in_matrix (f->desired_matrix, g);
+}
+
+/* Return true if GLYPH is part of the desired matrix of F. */
+
+bool
+is_tty_current_glyph (struct frame *f, struct glyph *g)
+{
+  eassert (is_tty_frame (f));
+  return is_glyph_in_matrix (f->current_matrix, g);
+}
+#endif // GLYPH_DEBUG
+
+/* Compute the intersection of R1 and R2 in R. Value is true if R1 and
+   R2 intersect, false otherwise. */
+
+static bool
+rect_intersect (struct rect *r, struct rect r1, struct rect r2)
+{
+  int x1 = max (r1.x, r2.x);
+  int x2 = min (r1.x + r1.w, r2.x + r2.w);
+  if (x2 < x1)
+    return false;
+  int y1 = max (r1.y, r2.y);
+  int y2 = min (r1.y + r1.h, r2.y + r2.h);
+  if (y2 < y1)
+    return false;
+  *r = (struct rect) { .x = x1, .y = y1, .w = x2 - x1, .h = y2 - y1 };
+  return true;
+}
+
+/* Return the rectanlge frame F occupies. */
+
+static struct rect
+frame_rect (struct frame *f)
+{
+  return (struct rect) {
+    .x = f->left_pos, .y = f->top_pos, .w = f->total_cols, .h = f->total_lines
+  };
+}
+
+/* Return the root frame of frame F. Follow the parent_frame chain until
+   we reach a frame that has no parent. That is the root frame. Note
+   that the root of a root frame is itself. */
+
+struct frame *
+root_frame (struct frame *f)
+{
+  while (FRAME_PARENT_FRAME (f))
+    f = FRAME_PARENT_FRAME (f);
+  return f;
+}
+
+/* Return true if F1 is an ancestor of F2.  */
+
+static bool
+is_frame_ancestor (struct frame *f1, struct frame *f2)
+{
+  for (struct frame *f = FRAME_PARENT_FRAME (f2); f; f = FRAME_PARENT_FRAME (f))
+    if (f == f1)
+      return true;
+  return false;
+}
+
+/* Return a list of all frames having root frame ROOT. */
+
+Lisp_Object
+frames_with_root (struct frame *root, bool visible)
+{
+  Lisp_Object list = Qnil;
+  Lisp_Object tail, frame;
+  FOR_EACH_FRAME (tail, frame)
     {
-      /* We are working on window matrix basis.  All windows whose
-         flag must_be_updated_p is set have to be updated.  */
+      struct frame *f = XFRAME (frame);
+      if (FRAME_VISIBLE_P (f) && root_frame (f) == root)
+        list = Fcons (frame, list);
+    }
+  return list;
+}
 
-      /* Record that we are not working on frame matrices.  */
-      set_frame_matrix_frame (NULL);
+/* Compare frames F1 and F2 for z-order. Value is like strcmp. */
 
-      /* Update all windows in the window tree of F, maybe stopping
-         when pending input is detected.  */
-      update_begin (f);
+static bool
+frame_z_order_cmp (struct frame *f1, struct frame *f2)
+{
+  if (f1 == f2)
+    return 0;
+  if (is_frame_ancestor (f1, f2))
+    return -1;
+  return f1->z_order - f2->z_order;
+}
 
-#if defined HAVE_WINDOW_SYSTEM && !defined HAVE_EXT_MENU_BAR
-      /* Update the menu bar on X frames that don't have toolkit
-         support.  */
-      if (WINDOWP (f->menu_bar_window))
-        update_window (XWINDOW (f->menu_bar_window), true);
-#endif
+DEFUN ("frame--z-order-sort-predicate",
+       Fframe__z_order_sort_predicate,
+       Sframe__z_order_sort_predicate,
+       2, 2, 0,
+       doc: /* Internal frame sorting function A < B.  */)
+  (Lisp_Object a, Lisp_Object b)
+{
+  CHECK_FRAME (a); CHECK_FRAME (b);
+  return frame_z_order_cmp (XFRAME (a), XFRAME (b)) < 0 ? Qt : Qnil;
+}
 
-#if defined (HAVE_WINDOW_SYSTEM)
-      /* Update the tab-bar window, if present.  */
-      if (WINDOWP (f->tab_bar_window))
+/* Return a z-order list of frames on the same terminal as F.  The list
+   is ordered topmost frame last. Note that this list may contain
+   more than one root frame plus their children. */
+
+Lisp_Object
+frames_in_reverse_z_order (struct frame *f, bool visible)
+{
+  struct frame *root = root_frame (f);
+  Lisp_Object frames = frames_with_root (root, visible);
+  frames = CALLN (Fsort, frames, Qframe__z_order_sort_predicate);
+  eassert (FRAMEP (XCAR (frames)));
+  eassert (XFRAME (XCAR (frames)) == root);
+  return frames;
+}
+
+void
+tty_raise_lower_frame (struct frame *f, bool raise)
+{
+  struct frame *parent = FRAME_PARENT_FRAME (f);
+  if (parent)
+    {
+      Lisp_Object children = frames_in_reverse_z_order (root_frame (f), false);
+      Lisp_Object siblings = Qnil;
+      for (Lisp_Object tail = children; CONSP (tail); tail = XCDR (tail))
         {
-          struct window *w = XWINDOW (f->tab_bar_window);
+          struct frame *child = XFRAME (XCAR (tail));
+          if (FRAME_PARENT_FRAME (child) == parent)
+            siblings = Fcons (XCAR (tail), siblings);
+        }
 
-          /* Update tab-bar window.  */
-          if (w->must_be_updated_p)
+      int n = list_length (siblings);
+      if (n > 1)
+        {
+          int i;
+          if (raise)
+            f->z_order = 0, i = 1;
+          else
+            f->z_order = n - 1, i = 0;
+          for (Lisp_Object tail = siblings; CONSP (tail); tail = XCDR (tail))
             {
-              Lisp_Object tem;
+              struct frame *child = XFRAME (XCAR (tail));
+              if (f != child)
+                child->z_order = i++;
+            }
+        }
+    }
+}
 
-              update_window (w, true);
-              w->must_be_updated_p = false;
+/* Return true if frame F is a tty frame. */
 
-              /* Swap tab-bar strings.  We swap because we want to
-                 reuse strings.  */
-              tem = f->current_tab_bar_string;
-              fset_current_tab_bar_string (f, f->desired_tab_bar_string);
-              fset_desired_tab_bar_string (f, tem);
-            }
+bool
+is_tty_frame (struct frame *f)
+{
+  return FRAME_TERMCAP_P (f);
+}
+
+/* Return true if frame F is a tty child frame. */
+
+bool
+is_tty_child_frame (struct frame *f)
+{
+  return FRAME_PARENT_FRAME (f) && is_tty_frame (f);
+}
+
+/* Return true if frame F is a tty root frame. */
+
+bool
+is_tty_root_frame (struct frame *f)
+{
+  return !FRAME_PARENT_FRAME (f) && is_tty_frame (f);
+}
+
+/* Return the index of the first enabled row in MATRIX, or -1 if there
+   is none. */
+
+static int
+first_enabled_row (struct glyph_matrix *matrix)
+{
+  for (int i = 0; i < matrix->nrows; ++i)
+    if (MATRIX_ROW_ENABLED_P (matrix, i))
+      return i;
+  return -1;
+}
+
+/* On tty frame F, make desired matrix current, without writing
+   to the terminal. */
+
+static void
+make_matrix_current (struct frame *f)
+{
+  int first_row = first_enabled_row (f->desired_matrix);
+  if (first_row >= 0)
+    for (int i = first_row; i < f->desired_matrix->nrows; ++i)
+      if (MATRIX_ROW_ENABLED_P (f->desired_matrix, i))
+        make_current (f, NULL, i);
+}
+
+/* Copy to ROOT's desired matrix what we need from CHILD's current frame matrix. */
+
+static void
+copy_child_glyphs (struct frame *root, struct frame *child)
+{
+  eassert (!FRAME_PARENT_FRAME (root));
+  eassert (is_frame_ancestor (root, child));
+
+  /* Determine the intersection of the child frame rectangle with
+     the root frame. This is basically clipping the child frame to
+     the root frame rectangle. */
+  struct rect r;
+  if (!rect_intersect (&r, frame_rect (root), frame_rect (child)))
+    return;
+
+  /* Build CHILD's current matrix which we need to copy from it. */
+  make_matrix_current (child);
+
+  /* The first row of the child's matrix that is visible in the parent
+     depends on how many child rows are above the parent, which is
+     abs (child->top_pos) if top_pos is negative. */
+  int child_y = child->top_pos < 0 ? abs (child->top_pos) : 0;
+
+  /* The first column of the child's matrix that is visible in the
+     parent depends on how many child columns are to the left of the
+     parent, which is abs (child->left_pos) if left_pos is negative. */
+  int child_x = child->left_pos < 0 ? abs (child->left_pos) : 0;
+
+  /* For all rows in the intersection, copy glyphs from the child's
+     current matrix to the root's desired matrix, enabling those
+     rows. */
+  for (int y = r.y; y < r.y + r.h; ++y, ++child_y)
+    {
+      /* Start with the root's desired matrix row. If that hasn't
+         been redisplayed, copy from the root's current matrix. */
+      struct glyph_row *root_row = MATRIX_ROW (root->desired_matrix, y);
+      if (!root_row->enabled_p)
+        {
+          struct glyph_row *from = MATRIX_ROW (root->current_matrix, y);
+          memcpy (root_row->glyphs[0], from->glyphs[0],
+                  root->current_matrix->matrix_w * sizeof (struct glyph));
+          root_row->enabled_p = true;
         }
+
+      /* Copy the child's current row contents over it. */
+      struct glyph_row *child_row = MATRIX_ROW (child->current_matrix, child_y);
+      memcpy (root_row->glyphs[0] + r.x,
+              child_row->glyphs[0] + child_x,
+              r.w * sizeof (struct glyph));
+
+      /* Compute a new hash since we changed glyphs. */
+      root_row->hash = row_hash (root_row);
+    }
+}
+
+/***********************************************************************
+                             Frame Update
+ ***********************************************************************/
+
+/* Update the menu bar on X frames that don't have toolkit
+   support.  */
+
+static void
+update_menu_bar (struct frame *f)
+{
+#if defined HAVE_WINDOW_SYSTEM && !defined HAVE_EXT_MENU_BAR
+  if (WINDOWP (f->menu_bar_window))
+    update_window (XWINDOW (f->menu_bar_window), true);
 #endif
+}
 
-#if defined (HAVE_WINDOW_SYSTEM) && ! defined (HAVE_EXT_TOOL_BAR)
-      /* Update the tool-bar window, if present.  */
-      if (WINDOWP (f->tool_bar_window))
+#ifdef HAVE_WINDOW_SYSTEM
+static void
+update_bar_window (Lisp_Object window, Lisp_Object *current,
+                       Lisp_Object *desired)
+{
+  if (WINDOWP (window))
+    {
+      struct window *w = XWINDOW (window);
+      if (w->must_be_updated_p)
         {
-          struct window *w = XWINDOW (f->tool_bar_window);
+          update_window (w, true);
+          w->must_be_updated_p = false;
+          Lisp_Object tem = *current;
+          *current = *desired;
+          *desired = tem;
+        }
+    }
+}
+#endif
 
-          /* Update tool-bar window.  */
-          if (w->must_be_updated_p)
-            {
-              Lisp_Object tem;
+/* Update the tab-bar window of frame F, if present.
+   FIXME/tty: This is almost identical to the updating
+   of the tab bar. */
 
-              update_window (w, true);
-              w->must_be_updated_p = false;
+static void
+update_tab_bar (struct frame *f)
+{
+#if defined(HAVE_WINDOW_SYSTEM)
+  update_bar_window (f->tab_bar_window, &f->current_tab_bar_string,
+                     &f->desired_tab_bar_string);
+#endif
+}
 
-              /* Swap tool-bar strings.  We swap because we want to
-                 reuse strings.  */
-              tem = f->current_tool_bar_string;
-              fset_current_tool_bar_string (f, f->desired_tool_bar_string);
-              fset_desired_tool_bar_string (f, tem);
-            }
-        }
+static void
+update_tool_bar (struct frame *f)
+{
+#if defined(HAVE_WINDOW_SYSTEM) && !defined(HAVE_EXT_TOOL_BAR)
+  update_bar_window (f->tool_bar_window, &f->current_tool_bar_string,
+                     &f->desired_tool_bar_string);
 #endif
+}
 
-      /* Update windows.  */
-      paused_p = update_window_tree (root_window, force_p);
-      update_end (f);
-    }
-  else
+static bool
+update_window_frame (struct frame *f, bool force_p)
+{
+  eassert (FRAME_WINDOW_P (f));
+  update_begin (f);
+  update_menu_bar (f);
+  update_tab_bar (f);
+  update_tool_bar (f);
+  struct window *root_window = XWINDOW (f->root_window);
+  bool paused_p = update_window_tree (root_window, force_p);
+  update_end (f);
+  set_window_update_flags (root_window, false);
+  return paused_p;
+}
+
+static bool
+update_initial_frame (struct frame *f, bool force_p)
+{
+  build_frame_matrix (f);
+  struct window *root_window = XWINDOW (f->root_window);
+  set_window_update_flags (root_window, false);
+  return false;
+}
+
+static void
+flush_terminal (struct frame *f)
+{
+  if (FRAME_TTY (f)->termscript)
+    fflush (FRAME_TTY (f)->termscript);
+  fflush (FRAME_TTY (f)->output);
+}
+
+static bool
+update_tty_frame (struct frame *f, bool force_p)
+{
+  build_frame_matrix (f);
+  return false;
+}
+
+bool
+combine_updates_for_frame (struct frame *f, bool force_p, bool inhibit_scrolling)
+{
+  struct frame *root = root_frame (f);
+  eassert (FRAME_VISIBLE_P (root));
+
+  /* Process child frames in reverse z-order, topmost last.  For each
+     child, copy what we need to the root's desired matrix. */
+  Lisp_Object z_order = frames_in_reverse_z_order (root, true);
+  for (Lisp_Object tail = XCDR (z_order); CONSP (tail); tail = XCDR (tail))
     {
-      /* We are working on frame matrix basis.  Set the frame on whose
-         frame matrix we operate.  */
-      set_frame_matrix_frame (f);
+      struct frame *child = XFRAME (XCAR (tail));
+      copy_child_glyphs (root, child);
+    }
 
-      /* Build F's desired matrix from window matrices.  */
-      build_frame_matrix (f);
+  update_begin (root);
+  bool paused = write_matrix (root, force_p, inhibit_scrolling, 1, false);
+  if (!paused)
+    make_matrix_current (root);
+  update_end (root);
+  flush_terminal (root);
 
-      /* Update the display.  */
-      if (FRAME_INITIAL_P (f))
-        /* No actual display to update so the "update" is a nop and
-           obviously isn't interrupted by pending input.  */
-        paused_p = false;
-      else
-        {
-          update_begin (f);
-          paused_p = update_frame_1 (f, force_p, inhibit_hairy_id_p, 1, false);
-          update_end (f);
-        }
-
-      if (FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f))
-        {
-          if (FRAME_TTY (f)->termscript)
-            fflush (FRAME_TTY (f)->termscript);
-          if (FRAME_TERMCAP_P (f))
-            fflush (FRAME_TTY (f)->output);
-        }
-
-      /* Check window matrices for lost pointers.  */
+  for (Lisp_Object tail = z_order; CONSP (tail); tail = XCDR (tail))
+    {
+      struct frame *f = XFRAME (XCAR (tail));
+      struct window *root_window = XWINDOW (f->root_window);
+      set_window_update_flags (root_window, false);
+      clear_desired_matrices (f);
 #ifdef GLYPH_DEBUG
       check_window_matrix_pointers (root_window);
-      add_frame_display_history (f, paused_p);
+      add_frame_display_history (f, false);
 #endif
     }
 
- do_pause:
-  /* Reset flags indicating that a window should be updated.  */
-  set_window_update_flags (root_window, false);
+  return paused;
+}
 
-  display_completed = !paused_p;
-  return paused_p;
+/* Update on the screen all root frames ROOTS. Called from
+   redisplay_internal as the last step of redisplaying. */
+
+bool
+combine_updates (Lisp_Object roots, bool force_p, bool inhibit_scrolling)
+{
+  for (; CONSP (roots); roots = XCDR (roots))
+    {
+      struct frame *root = XFRAME (XCAR (roots));
+      if (combine_updates_for_frame (root, force_p, inhibit_scrolling))
+        {
+          display_completed = false;
+          return true;
+        }
+    }
+
+  display_completed = true;
+  return false;
+}
+
+/* Update frame F based on the data in desired matrices.
+
+   If FORCE_P, don't let redisplay be stopped by detecting pending input.
+   If INHIBIT_SCROLLING, don't try scrolling.
+
+   Value is true if redisplay was stopped due to pending input.  */
+
+bool
+update_frame (struct frame *f, bool force_p, bool inhibit_scrolling)
+{
+  struct window *root_window = XWINDOW (f->root_window);
+
+  if (redisplay_dont_pause)
+    force_p = true;
+  else if (!force_p && detect_input_pending_ignore_squeezables ())
+    {
+      /* Reset flags indicating that a window should be updated.  */
+      set_window_update_flags (root_window, false);
+      display_completed = false;
+      return true;
+    }
+
+  bool paused;
+  if (FRAME_WINDOW_P (f))
+    paused = update_window_frame (f, force_p);
+  else if (FRAME_INITIAL_P (f))
+    paused = update_initial_frame (f, force_p);
+  else
+    paused = update_tty_frame (f, force_p);
+
+  if (paused)
+    display_completed = false;
+  return paused;
 }
 
 /* Update a TTY frame F that has a menu dropped down over some of its
@@ -3384,29 +3742,25 @@ void
 update_frame_with_menu (struct frame *f, int row, int col)
 {
   struct window *root_window = XWINDOW (f->root_window);
-  bool paused_p, cursor_at_point_p;
+  bool cursor_at_point_p;
 
   eassert (FRAME_TERMCAP_P (f));
 
-  /* We are working on frame matrix basis.  Set the frame on whose
-     frame matrix we operate.  */
-  set_frame_matrix_frame (f);
-
   /* Update the display.  */
   update_begin (f);
   cursor_at_point_p = !(row >= 0 && col >= 0);
-  /* Force update_frame_1 not to stop due to pending input, and not
-     try scrolling.  */
-  paused_p = update_frame_1 (f, 1, 1, cursor_at_point_p, true);
+  /* Do not stop due to pending input, and do not try scrolling. This
+     means that write_glyphs will always return false. */
+  write_matrix (f, 1, 1, cursor_at_point_p, true);
+  make_matrix_current (f);
+  clear_desired_matrices (f);
   /* ROW and COL tell us where in the menu to position the cursor, so
      that screen readers know the active region on the screen.  */
   if (!cursor_at_point_p)
     cursor_to (f, row, col);
   update_end (f);
+  flush_terminal (f);
 
-  if (FRAME_TTY (f)->termscript)
-    fflush (FRAME_TTY (f)->termscript);
-  fflush (FRAME_TTY (f)->output);
   /* Check window matrices for lost pointers.  */
 #if GLYPH_DEBUG
 #if 0
@@ -3415,12 +3769,12 @@ update_frame_with_menu (struct frame *f, int row, int col)
          making any updates to the window matrices.  */
   check_window_matrix_pointers (root_window);
 #endif
-  add_frame_display_history (f, paused_p);
+  add_frame_display_history (f, false);
 #endif
 
   /* Reset flags indicating that a window should be updated.  */
   set_window_update_flags (root_window, false);
-  display_completed = !paused_p;
+  display_completed = true;
 }
 
 /* Update the mouse position for a frame F.  This handles both
@@ -3507,9 +3861,6 @@ update_single_window (struct window *w)
     {
       struct frame *f = XFRAME (WINDOW_FRAME (w));
 
-      /* Record that this is not a frame-based redisplay.  */
-      set_frame_matrix_frame (NULL);
-
       /* Update W.  */
       update_begin (f);
       update_window (w, true);
@@ -3688,6 +4039,8 @@ update_window (struct window *w, bool force_p)
 
 #ifdef HAVE_WINDOW_SYSTEM
       gui_update_window_begin (w);
+#else
+      (void) changed_p;
 #endif
       yb = window_text_bottom_y (w);
       row = MATRIX_ROW (desired_matrix, 0);
@@ -4321,7 +4674,7 @@ update_window_line (struct window *w, int vpos, bool *mouse_face_overwritten_p)
 
   /* Update current_row from desired_row.  */
   was_stipple = current_row->stipple_p;
-  make_current (w->desired_matrix, w->current_matrix, vpos);
+  make_current (NULL, w, vpos);
 
   /* If only a partial update was performed, any stipple already
      displayed in MATRIX_ROW (w->current_matrix, vpos) might still be
@@ -4931,7 +5284,92 @@ scrolling_window (struct window *w, int tab_line_p)
                          Frame-Based Updates
  ************************************************************************/
 
-/* Update the desired frame matrix of frame F.
+static void
+tty_set_cursor (void)
+{
+  struct frame *f = SELECTED_FRAME ();
+
+  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.  */
+       || (BASE_EQ (minibuf_window, selected_window)
+           && BASE_EQ (minibuf_window, echo_area_window)
+           && !NILP (echo_area_buffer[0])))
+      /* These cases apply only to the frame that contains
+         the active mini-buffer window.  */
+      && FRAME_HAS_MINIBUF_P (f)
+      && BASE_EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
+    {
+      int top = WINDOW_TOP_EDGE_LINE (XWINDOW (FRAME_MINIBUF_WINDOW (f)));
+      int col;
+
+      /* Put cursor at the end of the prompt.  If the mini-buffer
+         is several lines high, find the last line that has
+         any text on it.  */
+      int row = FRAME_TOTAL_LINES (f);
+      do
+        {
+          row--;
+          col = 0;
+
+          if (MATRIX_ROW_ENABLED_P (f->current_matrix, row))
+            {
+              /* Frame rows are filled up with spaces that
+                 must be ignored here.  */
+              struct glyph_row *r = MATRIX_ROW (f->current_matrix, row);
+              struct glyph *start = r->glyphs[TEXT_AREA];
+
+              col = r->used[TEXT_AREA];
+              while (0 < col && start[col - 1].charpos < 0)
+                col--;
+            }
+        }
+      while (row > top && col == 0);
+
+      /* We exit the loop with COL at the glyph _after_ the last one.  */
+      if (col > 0)
+        col--;
+
+      /* Make sure COL is not out of range.  */
+      if (col >= FRAME_CURSOR_X_LIMIT (f))
+        {
+          /* If we have another row, advance cursor into it.  */
+          if (row < FRAME_TOTAL_LINES (f) - 1)
+            {
+              col = FRAME_LEFT_SCROLL_BAR_COLS (f);
+              row++;
+            }
+          /* Otherwise move it back in range.  */
+          else
+            col = FRAME_CURSOR_X_LIMIT (f) - 1;
+        }
+
+      cursor_to (f, row, col);
+    }
+  else
+    {
+      /* We have only one cursor on terminal frames.  Use it to
+         display the cursor of the selected window.  */
+      struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
+      if (w->cursor.vpos >= 0
+          /* The cursor vpos may be temporarily out of bounds
+             in the following situation:  There is one window,
+             with the cursor in the lower half of it.  The window
+             is split, and a message causes a redisplay before
+             a new cursor position has been computed.  */
+          && w->cursor.vpos < WINDOW_TOTAL_LINES (w))
+        {
+          int x = WINDOW_TO_FRAME_HPOS (w, w->cursor.hpos);
+          int y = WINDOW_TO_FRAME_VPOS (w, w->cursor.vpos);
+
+          x += max (0, w->left_margin_cols);
+          cursor_to (f, y, x);
+        }
+    }
+}
+
+/* Write desired matix of tty frame F and make it current.
 
    FORCE_P means that the update should not be stopped by pending input.
    INHIBIT_ID_P means that scrolling by insert/delete should not be tried.
@@ -4940,167 +5378,58 @@ scrolling_window (struct window *w, int tab_line_p)
    Value is true if update was stopped due to pending input.  */
 
 static bool
-update_frame_1 (struct frame *f, bool force_p, bool inhibit_id_p,
-                bool set_cursor_p, bool updating_menu_p)
+write_matrix (struct frame *f, bool force_p, bool inhibit_id_p,
+              bool set_cursor_p, bool updating_menu_p)
 {
-  /* Frame matrices to work on.  */
-  struct glyph_matrix *current_matrix = f->current_matrix;
-  struct glyph_matrix *desired_matrix = f->desired_matrix;
-  int i;
-  bool pause_p;
-  int preempt_count = clip_to_bounds (1, baud_rate / 2400 + 1, INT_MAX);
-
-  eassert (current_matrix && desired_matrix);
-
-  if (baud_rate != FRAME_COST_BAUD_RATE (f))
-    calculate_costs (f);
-
   if (!force_p && detect_input_pending_ignore_squeezables ())
-    {
-      pause_p = 1;
-      goto do_pause;
-    }
+    return true;
 
   /* If we cannot insert/delete lines, it's no use trying it.  */
   if (!FRAME_LINE_INS_DEL_OK (f))
-    inhibit_id_p = 1;
+    inhibit_id_p = true;
 
-  /* See if any of the desired lines are enabled; don't compute for
-     i/d line if just want cursor motion.  */
-  for (i = 0; i < desired_matrix->nrows; i++)
-    if (MATRIX_ROW_ENABLED_P (desired_matrix, i))
-      break;
+  if (baud_rate != FRAME_COST_BAUD_RATE (f))
+    calculate_costs (f);
 
-  /* Try doing i/d line, if not yet inhibited.  */
-  if (!inhibit_id_p && i < desired_matrix->nrows)
+ /* See if any of the desired lines are enabled; don't compute for
+     i/d line if just want cursor motion.  */
+  int first_row = first_enabled_row (f->desired_matrix);
+  if (!inhibit_id_p && first_row >= 0)
     force_p |= scrolling (f);
 
-  /* Update the individual lines as needed.  Do bottom line first.  */
-  if (MATRIX_ROW_ENABLED_P (desired_matrix, desired_matrix->nrows - 1))
-    update_frame_line (f, desired_matrix->nrows - 1, updating_menu_p);
+  /* Update the individual lines as needed.  Do bottom line first.  This
+     is done so that messages are made visible when pausing. */
+  int last_row = f->desired_matrix->nrows - 1;
+  if (MATRIX_ROW_ENABLED_P (f->desired_matrix, last_row))
+    write_row (f, last_row, updating_menu_p);
 
-  /* Now update the rest of the lines.  */
-  for (i = 0; i < desired_matrix->nrows - 1 && (force_p || !input_pending); i++)
+  bool pause_p = false;
+  if (first_row >= 0)
     {
-      if (MATRIX_ROW_ENABLED_P (desired_matrix, i))
-        {
-          /* Note that output_buffer_size being 0 means that we want the
-             old default behavior of flushing output every now and then.  */
-          if (FRAME_TERMCAP_P (f) && FRAME_TTY (f)->output_buffer_size == 0)
-            {
-              /* Flush out every so many lines.
-                 Also flush out if likely to have more than 1k buffered
-                 otherwise.   I'm told that some telnet connections get
-                 really screwed by more than 1k output at once.  */
-              FILE *display_output = FRAME_TTY (f)->output;
-              if (display_output)
-                {
-                  ptrdiff_t outq = __fpending (display_output);
-                  if (outq > 900
-                      || (outq > 20 && ((i - 1) % preempt_count == 0)))
-                    fflush (display_output);
-                }
-            }
+      const int preempt_count = clip_to_bounds (1, baud_rate / 2400 + 1, INT_MAX);
 
-          if (!force_p && (i - 1) % preempt_count == 0)
-            detect_input_pending_ignore_squeezables ();
+      for (int i = first_row, n = 0; i < last_row; ++i)
+        if (MATRIX_ROW_ENABLED_P (f->desired_matrix, i))
+          {
+            if (!force_p && n % preempt_count == 0
+                && detect_input_pending_ignore_squeezables ())
+              {
+                pause_p = true;
+                break;
+              }
 
-          update_frame_line (f, i, updating_menu_p);
-        }
+            write_row (f, i, updating_menu_p);
+            ++n;
+          }
     }
 
-  pause_p = 0 < i && i < FRAME_TOTAL_LINES (f) - 1;
-
   /* Now just clean up termcap drivers and set cursor, etc.  */
   if (!pause_p && set_cursor_p)
-    {
-      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.  */
-           || (BASE_EQ (minibuf_window, selected_window)
-               && BASE_EQ (minibuf_window, echo_area_window)
-               && !NILP (echo_area_buffer[0])))
-          /* These cases apply only to the frame that contains
-             the active mini-buffer window.  */
-          && FRAME_HAS_MINIBUF_P (f)
-          && BASE_EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
-        {
-          int top = WINDOW_TOP_EDGE_LINE (XWINDOW (FRAME_MINIBUF_WINDOW (f)));
-          int col;
-
-          /* Put cursor at the end of the prompt.  If the mini-buffer
-             is several lines high, find the last line that has
-             any text on it.  */
-          int row = FRAME_TOTAL_LINES (f);
-          do
-            {
-              row--;
-              col = 0;
-
-              if (MATRIX_ROW_ENABLED_P (current_matrix, row))
-                {
-                  /* Frame rows are filled up with spaces that
-                     must be ignored here.  */
-                  struct glyph_row *r = MATRIX_ROW (current_matrix, row);
-                  struct glyph *start = r->glyphs[TEXT_AREA];
-
-                  col = r->used[TEXT_AREA];
-                  while (0 < col && start[col - 1].charpos < 0)
-                    col--;
-                }
-            }
-          while (row > top && col == 0);
-
-          /* We exit the loop with COL at the glyph _after_ the last one.  */
-          if (col > 0)
-            col--;
-
-          /* Make sure COL is not out of range.  */
-          if (col >= FRAME_CURSOR_X_LIMIT (f))
-            {
-              /* If we have another row, advance cursor into it.  */
-              if (row < FRAME_TOTAL_LINES (f) - 1)
-                {
-                  col = FRAME_LEFT_SCROLL_BAR_COLS (f);
-                  row++;
-                }
-              /* Otherwise move it back in range.  */
-              else
-                col = FRAME_CURSOR_X_LIMIT (f) - 1;
-            }
+    tty_set_cursor ();
 
-          cursor_to (f, row, col);
-        }
-      else
-        {
-          /* We have only one cursor on terminal frames.  Use it to
-             display the cursor of the selected window.  */
-          struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
-          if (w->cursor.vpos >= 0
-              /* The cursor vpos may be temporarily out of bounds
-                 in the following situation:  There is one window,
-                 with the cursor in the lower half of it.  The window
-                 is split, and a message causes a redisplay before
-                 a new cursor position has been computed.  */
-              && w->cursor.vpos < WINDOW_TOTAL_LINES (w))
-            {
-              int x = WINDOW_TO_FRAME_HPOS (w, w->cursor.hpos);
-              int y = WINDOW_TO_FRAME_VPOS (w, w->cursor.vpos);
-
-              x += max (0, w->left_margin_cols);
-              cursor_to (f, y, x);
-            }
-        }
-    }
-
- do_pause:
-
-  clear_desired_matrices (f);
   return pause_p;
 }
 
-
 /* Do line insertions/deletions on frame F for frame-based redisplay.  */
 
 static bool
@@ -5209,12 +5538,12 @@ scrolling (struct frame *frame)
    which is LEN glyphs long.  */
 
 static int
-count_blanks (struct glyph *r, int len)
+count_blanks (struct frame *f, struct glyph *r, int len)
 {
   int i;
 
   for (i = 0; i < len; ++i)
-    if (!CHAR_GLYPH_SPACE_P (r[i]))
+    if (!CHAR_GLYPH_SPACE_P (f, r[i]))
       break;
 
   return i;
@@ -5250,7 +5579,7 @@ count_match (struct glyph *str1, struct glyph *end1, struct glyph *str2, struct
 /* Perform a frame-based update on line VPOS in frame FRAME.  */
 
 static void
-update_frame_line (struct frame *f, int vpos, bool updating_menu_p)
+write_row (struct frame *f, int vpos, bool updating_menu_p)
 {
   struct glyph *obody, *nbody, *op1, *op2, *np1, *nend;
   int tem;
@@ -5264,11 +5593,6 @@ update_frame_line (struct frame *f, int vpos, bool updating_menu_p)
   bool colored_spaces_p = (FACE_FROM_ID (f, DEFAULT_FACE_ID)->background
                            != FACE_TTY_DEFAULT_BG_COLOR);
 
-  /* This should never happen, but evidently sometimes does if one
-     resizes the frame quickly enough.  Prevent aborts in cmcheckmagic.  */
-  if (vpos >= FRAME_TOTAL_LINES (f))
-    return;
-
   if (colored_spaces_p)
     write_spaces_p = 1;
 
@@ -5287,7 +5611,7 @@ update_frame_line (struct frame *f, int vpos, bool updating_menu_p)
 
       /* Ignore trailing spaces, if we can.  */
       if (!write_spaces_p)
-        while (olen > 0 && CHAR_GLYPH_SPACE_P (obody[olen-1]))
+        while (olen > 0 && CHAR_GLYPH_SPACE_P (f, obody[olen-1]))
           olen--;
     }
 
@@ -5316,7 +5640,7 @@ update_frame_line (struct frame *f, int vpos, bool updating_menu_p)
     {
       /* Ignore spaces at the end, if we can.  */
       if (!write_spaces_p)
-        while (nlen > 0 && CHAR_GLYPH_SPACE_P (nbody[nlen - 1]))
+        while (nlen > 0 && CHAR_GLYPH_SPACE_P (f, nbody[nlen - 1]))
           --nlen;
 
       /* Write the contents of the desired line.  */
@@ -5338,15 +5662,13 @@ update_frame_line (struct frame *f, int vpos, bool updating_menu_p)
         /* Make sure we are in the right row, otherwise cursor movement
            with cmgoto might use `ch' in the wrong row.  */
         cursor_to (f, vpos, 0);
-
-      make_current (desired_matrix, current_matrix, vpos);
       return;
     }
 
   /* Pretend trailing spaces are not there at all,
      unless for one reason or another we must write all spaces.  */
   if (!write_spaces_p)
-    while (nlen > 0 && CHAR_GLYPH_SPACE_P (nbody[nlen - 1]))
+    while (nlen > 0 && CHAR_GLYPH_SPACE_P (f, nbody[nlen - 1]))
       nlen--;
 
   /* If there's no i/d char, quickly do the best we can without it.  */
@@ -5383,9 +5705,6 @@ update_frame_line (struct frame *f, int vpos, bool updating_menu_p)
           cursor_to (f, vpos, nlen);
           clear_end_of_line (f, olen);
         }
-
-      /* Make current row = desired row.  */
-      make_current (desired_matrix, current_matrix, vpos);
       return;
     }
 
@@ -5399,7 +5718,7 @@ update_frame_line (struct frame *f, int vpos, bool updating_menu_p)
       if (write_spaces_p)
         nsp = 0;
       else
-        nsp = count_blanks (nbody, nlen);
+        nsp = count_blanks (f, nbody, nlen);
 
       if (nlen > nsp)
         {
@@ -5407,14 +5726,12 @@ update_frame_line (struct frame *f, int vpos, bool updating_menu_p)
           write_glyphs (f, nbody + nsp, nlen - nsp);
         }
 
-      /* Exchange contents between current_frame and new_frame.  */
-      make_current (desired_matrix, current_matrix, vpos);
       return;
     }
 
   /* Compute number of leading blanks in old and new contents.  */
-  osp = count_blanks (obody, olen);
-  nsp = (colored_spaces_p ? 0 : count_blanks (nbody, nlen));
+  osp = count_blanks (f, obody, olen);
+  nsp = (colored_spaces_p ? 0 : count_blanks (f, nbody, nlen));
 
   /* Compute number of matching chars starting with first non-blank.  */
   begmatch = count_match (obody + osp, obody + olen,
@@ -5425,7 +5742,7 @@ update_frame_line (struct frame *f, int vpos, bool updating_menu_p)
   if (!write_spaces_p && osp + begmatch == olen)
     {
       np1 = nbody + nsp;
-      while (np1 + begmatch < nend && CHAR_GLYPH_SPACE_P (np1[begmatch]))
+      while (np1 + begmatch < nend && CHAR_GLYPH_SPACE_P (f, np1[begmatch]))
         ++begmatch;
     }
 
@@ -5566,9 +5883,6 @@ update_frame_line (struct frame *f, int vpos, bool updating_menu_p)
       cursor_to (f, vpos, nlen);
       clear_end_of_line (f, olen);
     }
-
-  /* Exchange contents between current_frame and new_frame.  */
-  make_current (desired_matrix, current_matrix, vpos);
 }
 
 
@@ -5967,7 +6281,8 @@ handle_window_change_signal (int sig)
             {
               struct frame *f = XFRAME (frame);
 
-              if (FRAME_TERMCAP_P (f) && FRAME_TTY (f) == tty)
+              if (FRAME_TERMCAP_P (f) && FRAME_TTY (f) == tty
+                  && !FRAME_PARENT_FRAME (f))
                 /* Record the new sizes, but don't reallocate the data
                    structures now.  Let that be done later outside of the
                    signal handler.  */
@@ -6534,7 +6849,7 @@ init_display_interactive (void)
 
   /* Construct the space glyph.  */
   space_glyph.type = CHAR_GLYPH;
-  SET_CHAR_GLYPH (space_glyph, ' ', DEFAULT_FACE_ID, 0);
+  SET_CHAR_GLYPH (NULL, space_glyph, ' ', DEFAULT_FACE_ID, 0);
   space_glyph.charpos = -1;
 
   inverse_video = 0;
@@ -6808,6 +7123,7 @@ syms_of_display (void)
   defsubr (&Ssend_string_to_terminal);
   defsubr (&Sinternal_show_cursor);
   defsubr (&Sinternal_show_cursor_p);
+  defsubr (&Sframe__z_order_sort_predicate);
 
 #ifdef GLYPH_DEBUG
   defsubr (&Sdump_redisplay_history);
@@ -6818,6 +7134,7 @@ syms_of_display (void)
 
   /* This is the "purpose" slot of a display table.  */
   DEFSYM (Qdisplay_table, "display-table");
+  DEFSYM (Qframe__z_order_sort_predicate, "frame--z-order-sort-predicate");
 
   DEFSYM (Qredisplay_dont_pause, "redisplay-dont-pause");
 
@@ -6921,6 +7238,8 @@ Possible values are t (below the tool bar), nil (above the tool bar).
 This option affects only builds where the tool bar is not external.  */);
 
   pdumper_do_now_and_after_load (syms_of_display_for_pdumper);
+
+  Fprovide (intern_c_string ("tty-child-frames"), Qnil);
 }
 
 static void