Merge branch 'master' of git.sv.gnu.org:/srv/git/emacs into feature/pgtk

17 files changed, 348 insertions, 196 deletions

diff --git a/src/character.c b/src/character.c
index e874cf5e53c..38a81d36b09 100644
--- a/src/character.c
+++ b/src/character.c
@@ -328,12 +328,14 @@ strwidth (const char *str, ptrdiff_t len)
    compositions.  If PRECISION > 0, return the width of longest
    substring that doesn't exceed PRECISION, and set number of
    characters and bytes of the substring in *NCHARS and *NBYTES
-   respectively.  FROM and TO are zero-based character indices
-   that define the substring of STRING to consider.  */
+   respectively.  FROM and TO are zero-based character indices that
+   define the substring of STRING to consider.  If AUTO_COMP is
+   non-zero, account for automatic compositions in STRING.  */
 
 ptrdiff_t
 lisp_string_width (Lisp_Object string, ptrdiff_t from, ptrdiff_t to,
-                   ptrdiff_t precision, ptrdiff_t *nchars, ptrdiff_t *nbytes)
+                   ptrdiff_t precision, ptrdiff_t *nchars, ptrdiff_t *nbytes,
+                   bool auto_comp)
 {
   /* This set multibyte to 0 even if STRING is multibyte when it
      contains only ascii and eight-bit-graphic, but that's
@@ -370,9 +372,11 @@ lisp_string_width (Lisp_Object string, ptrdiff_t from, ptrdiff_t to,
           bytes = string_char_to_byte (string, end) - i_byte;
         }
 #ifdef HAVE_WINDOW_SYSTEM
-      else if (f && FRAME_WINDOW_P (f)
+      else if (auto_comp
+               && f && FRAME_WINDOW_P (f)
                && multibyte
-               && find_automatic_composition (i, -1, &ignore, &end, &val, string)
+               && find_automatic_composition (i, -1, i, &ignore,
+                                              &end, &val, string)
                && end > i)
         {
           int j;
@@ -471,7 +475,7 @@ usage: (string-width STRING &optional FROM TO)  */)
 
   CHECK_STRING (str);
   validate_subarray (str, from, to, SCHARS (str), &ifrom, &ito);
-  XSETFASTINT (val, lisp_string_width (str, ifrom, ito, -1, NULL, NULL));
+  XSETFASTINT (val, lisp_string_width (str, ifrom, ito, -1, NULL, NULL, true));
   return val;
 }
 
diff --git a/src/character.h b/src/character.h
index 75351cd1edf..1a745484daa 100644
--- a/src/character.h
+++ b/src/character.h
@@ -573,7 +573,7 @@ extern ptrdiff_t strwidth (const char *, ptrdiff_t);
 extern ptrdiff_t c_string_width (const unsigned char *, ptrdiff_t, int,
                                  ptrdiff_t *, ptrdiff_t *);
 extern ptrdiff_t lisp_string_width (Lisp_Object, ptrdiff_t, ptrdiff_t,
-                                    ptrdiff_t, ptrdiff_t *, ptrdiff_t *);
+                                    ptrdiff_t, ptrdiff_t *, ptrdiff_t *, bool);
 
 extern Lisp_Object Vchar_unify_table;
 extern Lisp_Object string_escape_byte8 (Lisp_Object);
diff --git a/src/composite.c b/src/composite.c
index 17d5914e634..129e9d6bb25 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -1473,14 +1473,60 @@ struct position_record
     (POSITION).pos--;                           \
   } while (0)
 
-/* This is like find_composition, but find an automatic composition
-   instead.  It is assured that POS is not within a static
-   composition.  If found, set *GSTRING to the glyph-string
-   representing the composition, and return true.  Otherwise, *GSTRING to
-   Qnil, and return false.  */
+/* Similar to find_composition, but find an automatic composition instead.
+
+   This function looks for automatic composition at or near position
+   POS of OBJECT (a buffer or a string).  OBJECT defaults to the
+   current buffer.  It must be assured that POS is not within a static
+   composition.  Also, the current buffer must be displayed in some
+   window, otherwise the function will return FALSE.
+
+   If LIMIT is negative, and there's no composition that includes POS
+   (i.e. starts at or before POS and ends at or after POS), return
+   FALSE.  In this case, the function is allowed to look from POS as
+   far back as BACKLIM, and as far forward as POS+1 plus
+   MAX_AUTO_COMPOSITION_LOOKBACK, the maximum number of look-back for
+   automatic compositions (3) -- this is a limitation imposed by
+   composition rules in composition-function-table, which see.  If
+   BACKLIM is negative, it stands for the beginning of OBJECT: BEGV
+   for a buffer or position zero for a string.
+
+   If LIMIT is positive, search for a composition forward (LIMIT >
+   POS) or backward (LIMIT < POS).  In this case, LIMIT bounds the
+   search for the first character of a composed sequence.
+   (LIMIT == POS is the same as LIMIT < 0.)  If LIMIT > POS, the
+   function can find a composition that starts after POS.
+
+   BACKLIM limits how far back is the function allowed to look in
+   OBJECT while trying to find a position where it is safe to start
+   searching forward for compositions.  Such a safe place is generally
+   the position after a character that can never be composed.
+
+   If BACKLIM is negative, that means the first character position of
+   OBJECT; this is useful when calling the function for the first time
+   for a given buffer or string, since it is possible that a
+   composition begins before POS.  However, if POS is very far from
+   the beginning of OBJECT, a negative value of BACKLIM could make the
+   function slow.  Also, in this case the function may return START
+   and END that do not include POS, something that is not necessarily
+   wanted, and needs to be explicitly checked by the caller.
+
+   When calling the function in a loop for the same buffer/string, the
+   caller should generally set BACKLIM equal to POS, to avoid costly
+   repeated searches backward.  This is because if the previous
+   positions were already checked for compositions, there should be no
+   reason to re-check them.
+
+   If BACKLIM is positive, it must be less or equal to LIMIT.
+
+   If an automatic composition satisfying the above conditions is
+   found, set *GSTRING to the Lispy glyph-string representing the
+   composition, set *START and *END to the start and end of the
+   composed sequence, and return TRUE.  Otherwise, set *GSTRING to
+   nil, and return FALSE.  */
 
 bool
-find_automatic_composition (ptrdiff_t pos, ptrdiff_t limit,
+find_automatic_composition (ptrdiff_t pos, ptrdiff_t limit, ptrdiff_t backlim,
                             ptrdiff_t *start, ptrdiff_t *end,
                             Lisp_Object *gstring, Lisp_Object string)
 {
@@ -1502,13 +1548,13 @@ find_automatic_composition (ptrdiff_t pos, ptrdiff_t limit,
   cur.pos = pos;
   if (NILP (string))
     {
-      head = BEGV, tail = ZV, stop = GPT;
+      head = backlim < 0 ? BEGV : backlim, tail = ZV, stop = GPT;
       cur.pos_byte = CHAR_TO_BYTE (cur.pos);
       cur.p = BYTE_POS_ADDR (cur.pos_byte);
     }
   else
     {
-      head = 0, tail = SCHARS (string), stop = -1;
+      head = backlim < 0 ? 0 : backlim, tail = SCHARS (string), stop = -1;
       cur.pos_byte = string_char_to_byte (string, cur.pos);
       cur.p = SDATA (string) + cur.pos_byte;
     }
@@ -1516,6 +1562,9 @@ find_automatic_composition (ptrdiff_t pos, ptrdiff_t limit,
     /* Finding a composition covering the character after POS is the
        same as setting LIMIT to POS.  */
     limit = pos;
+
+  eassert (backlim < 0 || backlim <= limit);
+
   if (limit <= pos)
     fore_check_limit = min (tail, pos + 1 + MAX_AUTO_COMPOSITION_LOOKBACK);
   else
@@ -1696,8 +1745,8 @@ composition_adjust_point (ptrdiff_t last_pt, ptrdiff_t new_pt)
     return new_pt;
 
   /* Next check the automatic composition.  */
-  if (! find_automatic_composition (new_pt, (ptrdiff_t) -1, &beg, &end, &val,
-                                    Qnil)
+  if (! find_automatic_composition (new_pt, (ptrdiff_t) -1, (ptrdiff_t) -1,
+                                    &beg, &end, &val, Qnil)
       || beg == new_pt)
     return new_pt;
   for (i = 0; i < LGSTRING_GLYPH_LEN (val); i++)
@@ -1893,8 +1942,8 @@ See `find-composition' for more details.  */)
     {
       if (!NILP (BVAR (current_buffer, enable_multibyte_characters))
           && ! NILP (Vauto_composition_mode)
-          && find_automatic_composition (from, to, &start, &end, &gstring,
-                                         string))
+          && find_automatic_composition (from, to, (ptrdiff_t) -1,
+                                         &start, &end, &gstring, string))
         return list3 (make_fixnum (start), make_fixnum (end), gstring);
       return Qnil;
     }
@@ -1902,7 +1951,8 @@ See `find-composition' for more details.  */)
     {
       ptrdiff_t s, e;
 
-      if (find_automatic_composition (from, to, &s, &e, &gstring, string)
+      if (find_automatic_composition (from, to, (ptrdiff_t) -1,
+                                      &s, &e, &gstring, string)
           && (e <= fixed_pos ? e > end : s < start))
         return list3 (make_fixnum (s), make_fixnum (e), gstring);
     }
diff --git a/src/composite.h b/src/composite.h
index 75e5f9b9ecb..67e87201bf2 100644
--- a/src/composite.h
+++ b/src/composite.h
@@ -246,6 +246,11 @@ composition_valid_p (ptrdiff_t start, ptrdiff_t end, Lisp_Object prop)
 /* Macros for lispy glyph-string.  This is completely different from
    struct glyph_string.  */
 
+/* LGSTRING is a string of font glyphs, LGLYPHs.  It is represented as
+   a Lisp vector, with components shown below.  Once LGSTRING was
+   processed by a shaping engine, it holds font glyphs for one or more
+   grapheme clusters.  */
+
 #define LGSTRING_HEADER(lgs) AREF (lgs, 0)
 #define LGSTRING_SET_HEADER(lgs, header) ASET (lgs, 0, header)
 
@@ -259,6 +264,10 @@ composition_valid_p (ptrdiff_t start, ptrdiff_t end, Lisp_Object prop)
 #define LGSTRING_ID(lgs) AREF (lgs, 1)
 #define LGSTRING_SET_ID(lgs, id) ASET (lgs, 1, id)
 
+/* LGSTRING_GLYPH_LEN is the maximum number of LGLYPHs that the
+   LGSTRING can hold.  This is NOT the actual number of valid LGLYPHs;
+   to find the latter, walk the glyphs returned by LGSTRING_GLYPH
+   until the first one that is nil.  */
 #define LGSTRING_GLYPH_LEN(lgs) (ASIZE ((lgs)) - 2)
 #define LGSTRING_GLYPH(lgs, idx) AREF ((lgs), (idx) + 2)
 #define LGSTRING_SET_GLYPH(lgs, idx, val) ASET ((lgs), (idx) + 2, (val))
@@ -278,6 +287,14 @@ enum lglyph_indices
     LGLYPH_SIZE
   };
 
+/* Each LGLYPH is a single font glyph, whose font code is in
+   LGLYPH_CODE.
+   LGLYPH_FROM and LGLYPH_TO are indices into LGSTRING; all the
+   LGLYPHs that share the same values of LGLYPH_FROM and LGLYPH_TO
+   belong to the same grapheme cluster.
+   LGLYPH_CHAR is one of the characters, usually the first one, that
+   contributed to the glyph (since there isn't a 1:1 correspondence
+   between composed characters and the font glyphs).  */
 #define LGLYPH_NEW() make_nil_vector (LGLYPH_SIZE)
 #define LGLYPH_FROM(g) XFIXNUM (AREF ((g), LGLYPH_IX_FROM))
 #define LGLYPH_TO(g) XFIXNUM (AREF ((g), LGLYPH_IX_TO))
@@ -320,9 +337,9 @@ extern bool composition_gstring_p (Lisp_Object);
 extern int composition_gstring_width (Lisp_Object, ptrdiff_t, ptrdiff_t,
                                       struct font_metrics *);
 
-extern bool find_automatic_composition (ptrdiff_t, ptrdiff_t, ptrdiff_t *,
-                                        ptrdiff_t *, Lisp_Object *,
-                                        Lisp_Object);
+extern bool find_automatic_composition (ptrdiff_t, ptrdiff_t, ptrdiff_t,
+                                        ptrdiff_t *, ptrdiff_t *,
+                                        Lisp_Object *, Lisp_Object);
 
 extern void composition_compute_stop_pos (struct composition_it *,
                                           ptrdiff_t, ptrdiff_t, ptrdiff_t,
diff --git a/src/data.c b/src/data.c
index d547f5da5e0..059f31e514b 100644
--- a/src/data.c
+++ b/src/data.c
@@ -2200,7 +2200,9 @@ From now on the default value will apply in this buffer.  Return VARIABLE.  */)
 DEFUN ("local-variable-p", Flocal_variable_p, Slocal_variable_p,
        1, 2, 0,
        doc: /* Non-nil if VARIABLE has a local binding in buffer BUFFER.
-BUFFER defaults to the current buffer.  */)
+BUFFER defaults to the current buffer.
+
+Also see `buffer-local-boundp'.*/)
   (Lisp_Object variable, Lisp_Object buffer)
 {
   struct buffer *buf = decode_buffer (buffer);
diff --git a/src/editfns.c b/src/editfns.c
index 182d3ba6f2b..aa0f46fea04 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -3390,7 +3390,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
                   ptrdiff_t nch, nby;
                   nchars_string = SCHARS (arg);
                   width = lisp_string_width (arg, 0, nchars_string, prec,
-                                             &nch, &nby);
+                                             &nch, &nby, false);
                   if (prec < 0)
                     nbytes = SBYTES (arg);
                   else
diff --git a/src/frame.c b/src/frame.c
index f8479f63f1d..3c7c4078cb0 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -985,6 +985,7 @@ make_frame (bool mini_p)
   f->ns_transparent_titlebar = false;
 #endif
 #endif
+  f->select_mini_window_flag = false;
   /* This one should never be zero.  */
   f->change_stamp = 1;
   root_window = make_window ();
@@ -1545,7 +1546,17 @@ do_switch_frame (Lisp_Object frame, int track, int for_deletion, Lisp_Object nor
       tty->top_frame = frame;
     }
 
+  sf->select_mini_window_flag = MINI_WINDOW_P (XWINDOW (sf->selected_window));
+
   selected_frame = frame;
+
+  move_minibuffers_onto_frame (sf, for_deletion);
+
+  if (f->select_mini_window_flag
+      && !NILP (Fminibufferp (XWINDOW (f->minibuffer_window)->contents, Qt)))
+    f->selected_window = f->minibuffer_window;
+  f->select_mini_window_flag = false;
+
   if (! FRAME_MINIBUF_ONLY_P (XFRAME (selected_frame)))
     last_nonminibuf_frame = XFRAME (selected_frame);
 
@@ -1562,7 +1573,6 @@ do_switch_frame (Lisp_Object frame, int track, int for_deletion, Lisp_Object nor
 #endif
     internal_last_event_frame = Qnil;
 
-  move_minibuffers_onto_frame (sf, for_deletion);
   return frame;
 }
 
diff --git a/src/frame.h b/src/frame.h
index b1ad525779c..d3ae548ed3b 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -462,6 +462,11 @@ struct frame
      in X builds only.  */
   bool_bf was_invisible : 1;
 
+  /* True when the frame isn't selected, and selecting it in the
+     future should select the mini-window rather than the currently
+     selected window in the frame, assuming there is still an active
+     minibuffer in that mini-window.  */
+  bool_bf select_mini_window_flag : 1;
   /* Bitfield area ends here.  */
 
   /* This frame's change stamp, set the last time window change
diff --git a/src/image.c b/src/image.c
index 9b8b7d97bda..916edd502da 100644
--- a/src/image.c
+++ b/src/image.c
@@ -3276,19 +3276,16 @@ image_find_image_fd (Lisp_Object file, int *pfd)
   /* Try to find FILE in data-directory/images, then x-bitmap-file-path.  */
   fd = openp (search_path, file, Qnil, &file_found,
               pfd ? Qt : make_fixnum (R_OK), false, false);
-  if (fd >= 0 || fd == -2)
+  if (fd == -2)
     {
-      file_found = ENCODE_FILE (file_found);
-      if (fd == -2)
-        {
-          /* The file exists locally, but has a file name handler.
-             (This happens, e.g., under Auto Image File Mode.)
-             'openp' didn't open the file, so we should, because the
-             caller expects that.  */
-          fd = emacs_open (SSDATA (file_found), O_RDONLY, 0);
-        }
+      /* The file exists locally, but has a file name handler.
+         (This happens, e.g., under Auto Image File Mode.)
+         'openp' didn't open the file, so we should, because the
+         caller expects that.  */
+      Lisp_Object encoded_name = ENCODE_FILE (file_found);
+      fd = emacs_open (SSDATA (encoded_name), O_RDONLY, 0);
     }
-  else  /* fd < 0, but not -2 */
+  else if (fd < 0)
     return Qnil;
   if (pfd)
     *pfd = fd;
@@ -3296,8 +3293,8 @@ image_find_image_fd (Lisp_Object file, int *pfd)
 }
 
 /* Find image file FILE.  Look in data-directory/images, then
-   x-bitmap-file-path.  Value is the encoded full name of the file
-   found, or nil if not found.  */
+   x-bitmap-file-path.  Value is the full name of the file found, or
+   nil if not found.  */
 
 Lisp_Object
 image_find_image_file (Lisp_Object file)
diff --git a/src/keyboard.c b/src/keyboard.c
index b2aabdda325..87a9512a45b 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -2254,8 +2254,17 @@ read_decoded_event_from_main_queue (struct timespec *end_time,
                 {
                   int i;
                   if (meta_key != 2)
-                    for (i = 0; i < n; i++)
-                      events[i] = make_fixnum (XFIXNUM (events[i]) & ~0x80);
+                    {
+                      for (i = 0; i < n; i++)
+                        {
+                          int c = XFIXNUM (events[i]);
+                          int modifier =
+                            (meta_key == 3 && c < 0x100 && (c & 0x80))
+                            ? meta_modifier
+                            : 0;
+                          events[i] = make_fixnum ((c & ~0x80) | modifier);
+                        }
+                    }
                 }
               else
                 {
@@ -2264,7 +2273,7 @@ read_decoded_event_from_main_queue (struct timespec *end_time,
                   int i;
                   for (i = 0; i < n; i++)
                     src[i] = XFIXNUM (events[i]);
-                  if (meta_key != 2)
+                  if (meta_key < 2) /* input-meta-mode is t or nil */
                     for (i = 0; i < n; i++)
                       src[i] &= ~0x80;
                   coding->destination = dest;
@@ -2282,7 +2291,18 @@ read_decoded_event_from_main_queue (struct timespec *end_time,
                       eassert (coding->carryover_bytes == 0);
                       n = 0;
                       while (n < coding->produced_char)
-                        events[n++] = make_fixnum (string_char_advance (&p));
+                        {
+                          int c = string_char_advance (&p);
+                          if (meta_key == 3)
+                            {
+                              int modifier
+                                = (c < 0x100 && (c & 0x80)
+                                   ? meta_modifier
+                                   : 0);
+                              c = (c & ~0x80) | modifier;
+                            }
+                          events[n++] = make_fixnum (c);
+                        }
                     }
                 }
             }
@@ -5021,6 +5041,10 @@ static short const internal_border_parts[] = {
 
 static Lisp_Object button_down_location;
 
+/* A cons recording the original frame-relative x and y coordinates of
+   the down mouse event.  */
+static Lisp_Object frame_relative_event_pos;
+
 /* Information about the most recent up-going button event:  Which
    button, what location, and what time.  */
 
@@ -5672,6 +5696,7 @@ make_lispy_event (struct input_event *event)
               double_click_count = 1;
             button_down_time = event->timestamp;
             *start_pos_ptr = Fcopy_alist (position);
+            frame_relative_event_pos = Fcons (event->x, event->y);
             ignore_mouse_drag_p = false;
           }
 
@@ -5694,20 +5719,12 @@ make_lispy_event (struct input_event *event)
               ignore_mouse_drag_p = false;
             else
               {
-                Lisp_Object new_down, down;
                 intmax_t xdiff = double_click_fuzz, ydiff = double_click_fuzz;
 
-                /* The third element of every position
-                   should be the (x,y) pair.  */
-                down = Fcar (Fcdr (Fcdr (start_pos)));
-                new_down = Fcar (Fcdr (Fcdr (position)));
-
-                if (CONSP (down)
-                    && FIXNUMP (XCAR (down)) && FIXNUMP (XCDR (down)))
-                  {
-                    xdiff = XFIXNUM (XCAR (new_down)) - XFIXNUM (XCAR (down));
-                    ydiff = XFIXNUM (XCDR (new_down)) - XFIXNUM (XCDR (down));
-                  }
+                xdiff = XFIXNUM (event->x)
+                  - XFIXNUM (XCAR (frame_relative_event_pos));
+                ydiff = XFIXNUM (event->y)
+                  - XFIXNUM (XCDR (frame_relative_event_pos));
 
                 if (! (0 < double_click_fuzz
                        && - double_click_fuzz < xdiff
@@ -5724,12 +5741,51 @@ make_lispy_event (struct input_event *event)
                           a click.  But mouse-drag-region completely ignores
                           this case and it hasn't caused any real problem, so
                           it's probably OK to ignore it as well.  */
-                       && EQ (Fcar (Fcdr (start_pos)), Fcar (Fcdr (position)))))
+                       && (EQ (Fcar (Fcdr (start_pos)),
+                               Fcar (Fcdr (position))) /* Same buffer pos */
+                           || !EQ (Fcar (start_pos),
+                                   Fcar (position))))) /* Different window */
                   {
                     /* Mouse has moved enough.  */
                     button_down_time = 0;
                     click_or_drag_modifier = drag_modifier;
                   }
+                else if (((!EQ (Fcar (start_pos), Fcar (position)))
+                          || (!EQ (Fcar (Fcdr (start_pos)),
+                                   Fcar (Fcdr (position)))))
+                         /* Was the down event in a window body? */
+                         && FIXNUMP (Fcar (Fcdr (start_pos)))
+                         && WINDOW_LIVE_P (Fcar (start_pos))
+                         && !NILP (Ffboundp (Qwindow_edges)))
+                  /* If the window (etc.) at the mouse position has
+                     changed between the down event and the up event,
+                     we assume there's been a redisplay between the
+                     two events, and we pretend the mouse is still in
+                     the old window to prevent a spurious drag event
+                     being generated.  */
+                  {
+                    Lisp_Object edges
+                      = call4 (Qwindow_edges, Fcar (start_pos), Qt, Qnil, Qt);
+                    int new_x = XFIXNUM (Fcar (frame_relative_event_pos));
+                    int new_y = XFIXNUM (Fcdr (frame_relative_event_pos));
+
+                    /* If the up-event is outside the down-event's
+                       window, use coordinates that are within it.  */
+                    if (new_x < XFIXNUM (Fcar (edges)))
+                      new_x = XFIXNUM (Fcar (edges));
+                    else if (new_x >= XFIXNUM (Fcar (Fcdr (Fcdr (edges)))))
+                      new_x = XFIXNUM (Fcar (Fcdr (Fcdr (edges)))) - 1;
+                    if (new_y < XFIXNUM (Fcar (Fcdr (edges))))
+                      new_y = XFIXNUM (Fcar (Fcdr (edges)));
+                    else if (new_y
+                             >= XFIXNUM (Fcar (Fcdr (Fcdr (Fcdr (edges))))))
+                      new_y = XFIXNUM (Fcar (Fcdr (Fcdr (Fcdr (edges))))) - 1;
+
+                    position = make_lispy_position
+                      (XFRAME (event->frame_or_window),
+                       make_fixnum (new_x), make_fixnum (new_y),
+                       event->timestamp);
+                  }
               }
 
             /* Don't check is_double; treat this as multiple if the
@@ -7040,7 +7096,7 @@ tty_read_avail_input (struct terminal *terminal,
       buf.modifiers = 0;
       if (tty->meta_key == 1 && (cbuf[i] & 0x80))
         buf.modifiers = meta_modifier;
-      if (tty->meta_key != 2)
+      if (tty->meta_key < 2)
         cbuf[i] &= ~0x80;
 
       buf.code = cbuf[i];
@@ -11047,7 +11103,10 @@ See also `current-input-mode'.  */)
 DEFUN ("set-input-meta-mode", Fset_input_meta_mode, Sset_input_meta_mode, 1, 2, 0,
        doc: /* Enable or disable 8-bit input on TERMINAL.
 If META is t, Emacs will accept 8-bit input, and interpret the 8th
-bit as the Meta modifier.
+bit as the Meta modifier before it decodes the characters.
+
+If META is `encoded', Emacs will interpret the 8th bit of single-byte
+characters after decoding the characters.
 
 If META is nil, Emacs will ignore the top bit, on the assumption it is
 parity.
@@ -11076,6 +11135,8 @@ See also `current-input-mode'.  */)
     new_meta = 0;
   else if (EQ (meta, Qt))
     new_meta = 1;
+  else if (EQ (meta, Qencoded))
+    new_meta = 3;
   else
     new_meta = 2;
 
@@ -11138,6 +11199,8 @@ Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal
  (no effect except in CBREAK mode).
 Third arg META t means accept 8-bit input (for a Meta key).
  META nil means ignore the top bit, on the assumption it is parity.
+ META `encoded' means accept 8-bit input and interpret Meta after
+   decoding the input characters.
  Otherwise, accept 8-bit input and don't use the top bit for Meta.
 Optional fourth arg QUIT if non-nil specifies character to use for quitting.
 See also `current-input-mode'.  */)
@@ -11158,9 +11221,12 @@ The value is a list of the form (INTERRUPT FLOW META QUIT), where
     nil, Emacs is using CBREAK mode.
   FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the
     terminal; this does not apply if Emacs uses interrupt-driven input.
-  META is t if accepting 8-bit input with 8th bit as Meta flag.
-    META nil means ignoring the top bit, on the assumption it is parity.
-    META is neither t nor nil if accepting 8-bit input and using
+  META is t if accepting 8-bit unencoded input with 8th bit as Meta flag.
+  META is `encoded' if accepting 8-bit encoded input with 8th bit as
+    Meta flag which has to be interpreted after decoding the input.
+  META is nil if ignoring the top bit of input, on the assumption that
+    it is a parity bit.
+  META is neither t nor nil if accepting 8-bit input and using
     all 8 bits as the character code.
   QUIT is the character Emacs currently uses to quit.
 The elements of this list correspond to the arguments of
@@ -11176,7 +11242,9 @@ The elements of this list correspond to the arguments of
       flow = FRAME_TTY (sf)->flow_control ? Qt : Qnil;
       meta = (FRAME_TTY (sf)->meta_key == 2
               ? make_fixnum (0)
-              : (CURTTY ()->meta_key == 1 ? Qt : Qnil));
+              : (CURTTY ()->meta_key == 1
+                 ? Qt
+                 : (CURTTY ()->meta_key == 3 ? Qencoded : Qnil)));
     }
   else
     {
@@ -11653,6 +11721,7 @@ syms_of_keyboard (void)
   DEFSYM (Qmake_frame_visible, "make-frame-visible");
   DEFSYM (Qselect_window, "select-window");
   DEFSYM (Qselection_request, "selection-request");
+  DEFSYM (Qwindow_edges, "window-edges");
   {
     int i;
 
@@ -11666,9 +11735,11 @@ syms_of_keyboard (void)
       }
   }
   DEFSYM (Qno_record, "no-record");
+  DEFSYM (Qencoded, "encoded");
 
   button_down_location = make_nil_vector (5);
   staticpro (&button_down_location);
+  staticpro (&frame_relative_event_pos);
   mouse_syms = make_nil_vector (5);
   staticpro (&mouse_syms);
   wheel_syms = make_nil_vector (ARRAYELTS (lispy_wheel_names));
@@ -12273,7 +12344,10 @@ Called with three arguments:
 - the error data, a list of the form (SIGNALED-CONDITION . SIGNAL-DATA)
   such as what `condition-case' would bind its variable to,
 - the context (a string which normally goes at the start of the message),
-- the Lisp function within which the error was signaled.  */);
+- the Lisp function within which the error was signaled.
+
+Also see `set-message-function' (which controls how non-error messages
+are displayed).  */);
   Vcommand_error_function = intern ("command-error-default-function");
 
   DEFVAR_LISP ("enable-disabled-menus-and-buttons",
diff --git a/src/minibuf.c b/src/minibuf.c
index cffb7fe787c..00069eabbe5 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -2385,7 +2385,7 @@ default top level value is used.  */);
   Vminibuffer_setup_hook = Qnil;
 
   DEFVAR_LISP ("minibuffer-exit-hook", Vminibuffer_exit_hook,
-               doc: /* Normal hook run just after exit from minibuffer.  */);
+               doc: /* Normal hook run whenever a minibuffer is exited.  */);
   Vminibuffer_exit_hook = Qnil;
 
   DEFVAR_LISP ("history-length", Vhistory_length,
diff --git a/src/nsfns.m b/src/nsfns.m
index d14f7b51eaf..454a6fdab62 100644
--- a/src/nsfns.m
+++ b/src/nsfns.m
@@ -1953,8 +1953,11 @@ DEFUN ("ns-hide-emacs", Fns_hide_emacs, Sns_hide_emacs,
        doc: /* If ON is non-nil, the entire Emacs application is hidden.
 Otherwise if Emacs is hidden, it is unhidden.
 If ON is equal to `activate', Emacs is unhidden and becomes
-the active application.  */)
-     (Lisp_Object on)
+the active application.
+If ON is equal to `activate-front', Emacs is unhidden and
+becomes the active application, but only the selected frame
+is layered in front of the windows of other applications.  */)
+  (Lisp_Object on)
 {
   check_window_system (NULL);
   if (EQ (on, intern ("activate")))
@@ -1962,6 +1965,12 @@ the active application.  */)
       [NSApp unhide: NSApp];
       [NSApp activateIgnoringOtherApps: YES];
     }
+  else if (EQ (on, intern ("activate-front")))
+    {
+      [NSApp unhide: NSApp];
+      [[NSRunningApplication currentApplication]
+        activateWithOptions: NSApplicationActivateIgnoringOtherApps];
+    }
   else if (NILP (on))
     [NSApp unhide: NSApp];
   else
@@ -3024,7 +3033,8 @@ all_nonzero_ascii (unsigned char *str, ptrdiff_t n)
 }
 
 @implementation NSString (EmacsString)
-/* Make an NSString from a Lisp string.  */
+/* Make an NSString from a Lisp string.  STRING must not be in an
+   encoded form (e.g. UTF-8).  */
 + (NSString *)stringWithLispString:(Lisp_Object)string
 {
   /* Shortcut for the common case.  */
diff --git a/src/nsimage.m b/src/nsimage.m
index fa81a41a519..3c16cd371e6 100644
--- a/src/nsimage.m
+++ b/src/nsimage.m
@@ -254,15 +254,15 @@ ns_image_size_in_bytes (void *img)
   NSImageRep *imgRep;
   Lisp_Object found;
   EmacsImage *image;
+  NSString *filename;
 
   /* Search bitmap-file-path for the file, if appropriate.  */
   found = image_find_image_file (file);
   if (!STRINGP (found))
     return nil;
-  found = ENCODE_FILE (found);
+  filename = [NSString stringWithLispString:found];
 
-  image = [[EmacsImage alloc] initByReferencingFile:
-                     [NSString stringWithLispString: found]];
+  image = [[EmacsImage alloc] initByReferencingFile:filename];
 
   image->bmRep = nil;
 #ifdef NS_IMPL_COCOA
@@ -277,8 +277,7 @@ ns_image_size_in_bytes (void *img)
     }
 
   [image setSize: NSMakeSize([imgRep pixelsWide], [imgRep pixelsHigh])];
-
-  [image setName: [NSString stringWithLispString: file]];
+  [image setName:filename];
 
   return image;
 }
diff --git a/src/nsterm.h b/src/nsterm.h
index 017c2394ef1..e7ea907569e 100644
--- a/src/nsterm.h
+++ b/src/nsterm.h
@@ -443,7 +443,6 @@ typedef id instancetype;
    int maximized_width, maximized_height;
    NSWindow *nonfs_window;
    BOOL fs_is_native;
-   BOOL in_fullscreen_transition;
 #ifdef NS_DRAW_TO_BUFFER
    EmacsSurface *surface;
 #endif
@@ -475,8 +474,6 @@ typedef id instancetype;
 - (void) toggleFullScreen: (id) sender;
 - (BOOL) fsIsNative;
 - (BOOL) isFullscreen;
-- (BOOL) inFullScreenTransition;
-- (void) waitFullScreenTransition;
 #if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
 - (void) updateCollectionBehavior;
 #endif
@@ -724,8 +721,9 @@ typedef id instancetype;
   IOSurfaceRef currentSurface;
   IOSurfaceRef lastSurface;
   CGContextRef context;
+  CGFloat scale;
 }
-- (id) initWithSize: (NSSize)s ColorSpace: (CGColorSpaceRef)cs;
+- (id) initWithSize: (NSSize)s ColorSpace: (CGColorSpaceRef)cs Scale: (CGFloat)scale;
 - (void) dealloc;
 - (NSSize) getSize;
 - (CGContextRef) getContext;
diff --git a/src/nsterm.m b/src/nsterm.m
index bb20886ab1d..838c14d5abb 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -1640,8 +1640,6 @@ ns_make_frame_visible (struct frame *f)
          fullscreen also.  So skip handleFS as this will print an error.  */
       if ([view fsIsNative] && [view isFullscreen])
         {
-          // maybe it is not necessary to wait
-          [view waitFullScreenTransition];
           return;
         }
 
@@ -2057,11 +2055,7 @@ ns_set_parent_frame (struct frame *f, Lisp_Object new_value, Lisp_Object old_val
 #if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
           // child frame must not be in fullscreen
           if ([view fsIsNative] && [view isFullscreen])
-            {
-              // in case child is going fullscreen
-              [view waitFullScreenTransition];
-              [view toggleFullScreen:child];
-            }
+            [view toggleFullScreen:child];
           NSTRACE ("child setCollectionBehavior:NSWindowCollectionBehaviorFullScreenAuxiliary");
           [child setCollectionBehavior:NSWindowCollectionBehaviorFullScreenAuxiliary];
 #endif
@@ -7489,7 +7483,6 @@ not_in_argv (NSString *arg)
 #endif
     fs_is_native = ns_use_native_fullscreen;
 #endif
-  in_fullscreen_transition = NO;
 
   maximized_width = maximized_height = -1;
   nonfs_window = nil;
@@ -7862,7 +7855,6 @@ not_in_argv (NSString *arg)
 - (void)windowWillEnterFullScreen:(NSNotification *)notification
 {
   NSTRACE ("[EmacsView windowWillEnterFullScreen:]");
-  in_fullscreen_transition = YES;
   [self windowWillEnterFullScreen];
 }
 - (void)windowWillEnterFullScreen /* provided for direct calls */
@@ -7875,7 +7867,6 @@ not_in_argv (NSString *arg)
 {
   NSTRACE ("[EmacsView windowDidEnterFullScreen:]");
   [self windowDidEnterFullScreen];
-  in_fullscreen_transition = NO;
 }
 
 - (void)windowDidEnterFullScreen /* provided for direct calls */
@@ -7914,7 +7905,6 @@ not_in_argv (NSString *arg)
 - (void)windowWillExitFullScreen:(NSNotification *)notification
 {
   NSTRACE ("[EmacsView windowWillExitFullScreen:]");
-  in_fullscreen_transition = YES;
   [self windowWillExitFullScreen];
 }
 
@@ -7934,7 +7924,6 @@ not_in_argv (NSString *arg)
 {
   NSTRACE ("[EmacsView windowDidExitFullScreen:]");
   [self windowDidExitFullScreen];
-  in_fullscreen_transition = NO;
 }
 
 - (void)windowDidExitFullScreen /* provided for direct calls */
@@ -7963,22 +7952,6 @@ not_in_argv (NSString *arg)
     [[self window] performZoom:self];
 }
 
-- (BOOL)inFullScreenTransition
-{
-  return in_fullscreen_transition;
-}
-
-- (void)waitFullScreenTransition
-{
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
-  while ([self inFullScreenTransition])
-    {
-      NSTRACE ("wait for fullscreen");
-      wait_reading_process_output (0, 300000000, 0, 1, Qnil, NULL, 0);
-    }
-#endif
-}
-
 - (BOOL)fsIsNative
 {
   return fs_is_native;
@@ -8058,14 +8031,8 @@ not_in_argv (NSString *arg)
 #if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
 #if MAC_OS_X_VERSION_MIN_REQUIRED < 1070
       if ([[self window] respondsToSelector: @selector(toggleFullScreen:)])
-        {
-#endif
-          [[self window] toggleFullScreen:sender];
-          // wait for fullscreen animation complete (bug#28496)
-          [self waitFullScreenTransition];
-#if MAC_OS_X_VERSION_MIN_REQUIRED < 1070
-        }
 #endif
+        [[self window] toggleFullScreen:sender];
 #endif
       return;
     }
@@ -8353,19 +8320,17 @@ not_in_argv (NSString *arg)
 
       surface = [[EmacsSurface alloc] initWithSize:s
                                         ColorSpace:[[[self window] colorSpace]
-                                                     CGColorSpace]];
+                                                     CGColorSpace]
+                                             Scale:scale];
 
       /* Since we're using NSViewLayerContentsRedrawOnSetNeedsDisplay
          the layer's scale factor is not set automatically, so do it
          now.  */
-      [[self layer] setContentsScale:[[self window] backingScaleFactor]];
+      [[self layer] setContentsScale:scale];
     }
 
   CGContextRef context = [surface getContext];
 
-  CGContextTranslateCTM(context, 0, [surface getSize].height);
-  CGContextScaleCTM(context, scale, -scale);
-
   [NSGraphicsContext
     setCurrentContext:[NSGraphicsContext
                         graphicsContextWithCGContext:context
@@ -8378,7 +8343,6 @@ not_in_argv (NSString *arg)
   NSTRACE ("[EmacsView unfocusDrawingBuffer]");
 
   [NSGraphicsContext setCurrentContext:nil];
-  [surface releaseContext];
   [self setNeedsDisplay:YES];
 }
 
@@ -8516,7 +8480,11 @@ not_in_argv (NSString *arg)
      There's a private method, -[CALayer setContentsChanged], that we
      could use to force it, but we shouldn't often get the same
      surface twice in a row.  */
+  [surface releaseContext];
   [[self layer] setContents:(id)[surface getSurface]];
+  [surface performSelectorOnMainThread:@selector (getContext)
+                            withObject:nil
+                         waitUntilDone:NO];
 }
 #endif
 
@@ -9717,17 +9685,20 @@ nswindow_orderedIndex_sort (id w1, id w2, void *c)
    probably be some sort of pruning job that removes excess
    surfaces.  */
 
+#define CACHE_MAX_SIZE 2
 
 - (id) initWithSize: (NSSize)s
          ColorSpace: (CGColorSpaceRef)cs
+              Scale: (CGFloat)scl
 {
   NSTRACE ("[EmacsSurface initWithSize:ColorSpace:]");
 
   [super init];
 
-  cache = [[NSMutableArray arrayWithCapacity:3] retain];
+  cache = [[NSMutableArray arrayWithCapacity:CACHE_MAX_SIZE] retain];
   size = s;
   colorSpace = cs;
+  scale = scl;
 
   return self;
 }
@@ -9740,8 +9711,6 @@ nswindow_orderedIndex_sort (id w1, id w2, void *c)
 
   if (currentSurface)
     CFRelease (currentSurface);
-  if (lastSurface)
-    CFRelease (lastSurface);
 
   for (id object in cache)
     CFRelease ((IOSurfaceRef)object);
@@ -9764,50 +9733,66 @@ nswindow_orderedIndex_sort (id w1, id w2, void *c)
    calls cannot be nested.  */
 - (CGContextRef) getContext
 {
-  IOSurfaceRef surface = NULL;
-
-  NSTRACE ("[EmacsSurface getContextWithSize:]");
-  NSTRACE_MSG ("IOSurface count: %lu", [cache count] + (lastSurface ? 1 : 0));
+  NSTRACE ("[EmacsSurface getContext]");
 
-  for (id object in cache)
+  if (!context)
     {
-      if (!IOSurfaceIsInUse ((IOSurfaceRef)object))
-      {
-        surface = (IOSurfaceRef)object;
-        [cache removeObject:object];
-        break;
-      }
-    }
+      IOSurfaceRef surface = NULL;
 
-  if (!surface)
-    {
-      int bytesPerRow = IOSurfaceAlignProperty (kIOSurfaceBytesPerRow,
-                                                size.width * 4);
+      NSTRACE_MSG ("IOSurface count: %lu", [cache count] + (lastSurface ? 1 : 0));
 
-      surface = IOSurfaceCreate
-        ((CFDictionaryRef)@{(id)kIOSurfaceWidth:[NSNumber numberWithInt:size.width],
-            (id)kIOSurfaceHeight:[NSNumber numberWithInt:size.height],
-            (id)kIOSurfaceBytesPerRow:[NSNumber numberWithInt:bytesPerRow],
-            (id)kIOSurfaceBytesPerElement:[NSNumber numberWithInt:4],
-            (id)kIOSurfacePixelFormat:[NSNumber numberWithUnsignedInt:'BGRA']});
-    }
+      for (id object in cache)
+        {
+          if (!IOSurfaceIsInUse ((IOSurfaceRef)object))
+            {
+              surface = (IOSurfaceRef)object;
+              [cache removeObject:object];
+              break;
+            }
+        }
 
-  IOReturn lockStatus = IOSurfaceLock (surface, 0, nil);
-  if (lockStatus != kIOReturnSuccess)
-    NSLog (@"Failed to lock surface: %x", lockStatus);
+      if (!surface && [cache count] >= CACHE_MAX_SIZE)
+        {
+          /* Just grab the first one off the cache.  This may result
+             in tearing effects.  The alternative is to wait for one
+             of the surfaces to become free.  */
+          surface = (IOSurfaceRef)[cache firstObject];
+          [cache removeObject:(id)surface];
+        }
+      else if (!surface)
+        {
+          int bytesPerRow = IOSurfaceAlignProperty (kIOSurfaceBytesPerRow,
+                                                    size.width * 4);
+
+          surface = IOSurfaceCreate
+            ((CFDictionaryRef)@{(id)kIOSurfaceWidth:[NSNumber numberWithInt:size.width],
+                (id)kIOSurfaceHeight:[NSNumber numberWithInt:size.height],
+                (id)kIOSurfaceBytesPerRow:[NSNumber numberWithInt:bytesPerRow],
+                (id)kIOSurfaceBytesPerElement:[NSNumber numberWithInt:4],
+                (id)kIOSurfacePixelFormat:[NSNumber numberWithUnsignedInt:'BGRA']});
+        }
+
+      IOReturn lockStatus = IOSurfaceLock (surface, 0, nil);
+      if (lockStatus != kIOReturnSuccess)
+        NSLog (@"Failed to lock surface: %x", lockStatus);
 
-  [self copyContentsTo:surface];
+      [self copyContentsTo:surface];
 
-  currentSurface = surface;
+      currentSurface = surface;
+
+      context = CGBitmapContextCreate (IOSurfaceGetBaseAddress (currentSurface),
+                                       IOSurfaceGetWidth (currentSurface),
+                                       IOSurfaceGetHeight (currentSurface),
+                                       8,
+                                       IOSurfaceGetBytesPerRow (currentSurface),
+                                       colorSpace,
+                                       (kCGImageAlphaPremultipliedFirst
+                                        | kCGBitmapByteOrder32Host));
+
+      CGContextTranslateCTM(context, 0, size.height);
+      CGContextScaleCTM(context, scale, -scale);
+    }
 
-  context = CGBitmapContextCreate (IOSurfaceGetBaseAddress (currentSurface),
-                                   IOSurfaceGetWidth (currentSurface),
-                                   IOSurfaceGetHeight (currentSurface),
-                                   8,
-                                   IOSurfaceGetBytesPerRow (currentSurface),
-                                   colorSpace,
-                                   (kCGImageAlphaPremultipliedFirst
-                                    | kCGBitmapByteOrder32Host));
   return context;
 }
 
@@ -9818,6 +9803,9 @@ nswindow_orderedIndex_sort (id w1, id w2, void *c)
 {
   NSTRACE ("[EmacsSurface releaseContextAndGetSurface]");
 
+  if (!context)
+    return;
+
   CGContextRelease (context);
   context = NULL;
 
@@ -9825,11 +9813,8 @@ nswindow_orderedIndex_sort (id w1, id w2, void *c)
   if (lockStatus != kIOReturnSuccess)
     NSLog (@"Failed to unlock surface: %x", lockStatus);
 
-  /* Put lastSurface back on the end of the cache.  It may not have
-     been displayed on the screen yet, but we probably want the new
-     data and not some stale data anyway.  */
-  if (lastSurface)
-    [cache addObject:(id)lastSurface];
+  /* Put currentSurface back on the end of the cache.  */
+  [cache addObject:(id)currentSurface];
   lastSurface = currentSurface;
   currentSurface = NULL;
 }
@@ -9854,7 +9839,7 @@ nswindow_orderedIndex_sort (id w1, id w2, void *c)
 
   NSTRACE ("[EmacsSurface copyContentsTo:]");
 
-  if (! lastSurface)
+  if (!lastSurface || lastSurface == destination)
     return;
 
   lockStatus = IOSurfaceLock (lastSurface, kIOSurfaceLockReadOnly, nil);
@@ -9874,6 +9859,7 @@ nswindow_orderedIndex_sort (id w1, id w2, void *c)
     NSLog (@"Failed to unlock source surface: %x", lockStatus);
 }
 
+#undef CACHE_MAX_SIZE
 
 @end /* EmacsSurface */
 
diff --git a/src/window.c b/src/window.c
index 9961c54161d..db324effcce 100644
--- a/src/window.c
+++ b/src/window.c
@@ -468,6 +468,7 @@ Return WINDOW.  */)
   else
     {
       fset_selected_window (XFRAME (frame), window);
+      /* Don't clear FRAME's select_mini_window_flag here.  */
       return window;
     }
 }
@@ -517,6 +518,9 @@ select_window (Lisp_Object window, Lisp_Object norecord,
     /* Do not select a tooltip window (Bug#47207).  */
     error ("Cannot select a tooltip window");
 
+  /* We deinitely want to select WINDOW, not the mini-window.  */
+  f->select_mini_window_flag = false;
+
   /* Make the selected window's buffer current.  */
   Fset_buffer (w->contents);
 
@@ -3242,6 +3246,9 @@ window-start value is reasonable when this function is called.  */)
           if (EQ (selected_frame, w->frame))
             Fselect_window (window, Qnil);
           else
+            /* Do not clear f->select_mini_window_flag here.  If the
+               last selected window on F was an active minibuffer, we
+               want to return to it on a later Fselect_frame.  */
             fset_selected_window (f, window);
         }
     }
@@ -5141,37 +5148,23 @@ Signal an error when WINDOW is the only window on its frame.  */)
       adjust_frame_glyphs (f);
 
       if (!WINDOW_LIVE_P (FRAME_SELECTED_WINDOW (f)))
-        /* We deleted the frame's selected window.  */
+        /* We apparently deleted the frame's selected window; use the
+           frame's first window as substitute but don't record it yet.
+           `delete-window' may have something better up its sleeves.  */
         {
           /* Use the frame's first window as fallback ...  */
           Lisp_Object new_selected_window = Fframe_first_window (frame);
-          /* ... but preferably use its most recently used window.  */
-          Lisp_Object mru_window;
 
-          /* `get-mru-window' might fail for some reason so play it safe
-          - promote the first window _without recording it_ first.  */
           if (EQ (FRAME_SELECTED_WINDOW (f), selected_window))
             Fselect_window (new_selected_window, Qt);
           else
-            fset_selected_window (f, new_selected_window);
-
-          unblock_input ();
-
-          /* Now look whether `get-mru-window' gets us something.  */
-          mru_window = call1 (Qget_mru_window, frame);
-          if (WINDOW_LIVE_P (mru_window)
-              && EQ (XWINDOW (mru_window)->frame, frame))
-            new_selected_window = mru_window;
-
-          /* If all ended up well, we now promote the mru window.  */
-          if (EQ (FRAME_SELECTED_WINDOW (f), selected_window))
-            Fselect_window (new_selected_window, Qnil);
-          else
+            /* Do not clear f->select_mini_window_flag here.  If the
+               last selected window on F was an active minibuffer, we
+               want to return to it on a later Fselect_frame.  */
             fset_selected_window (f, new_selected_window);
         }
-      else
-        unblock_input ();
 
+      unblock_input ();
       FRAME_WINDOW_CHANGE (f) = true;
     }
   else
diff --git a/src/xdisp.c b/src/xdisp.c
index 74fa0a57e44..e95e64a24cd 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -10795,6 +10795,9 @@ include the height of both, if present, in the return value.  */)
           it.max_descent = max (it.max_descent, it.descent);
         }
     }
+  else
+    bidi_unshelve_cache (it2data, true);
+
   if (!NILP (x_limit))
     {
       /* Don't return more than X-LIMIT.  */
@@ -22386,15 +22389,23 @@ extend_face_to_end_of_line (struct it *it)
       it->face_id = (it->glyph_row->ends_at_zv_p ?
                      default_face->id : face->id);
 
-      /* Display fill-column indicator if needed.  */
-      const int indicator_column = fill_column_indicator_column (it, 1);
-
       /* Make sure our idea of current_x is in sync with the glyphs
          actually in the glyph row.  They might differ because
          append_space_for_newline can insert one glyph without
          updating current_x.  */
       it->current_x = it->glyph_row->used[TEXT_AREA];
 
+      /* The above assignment causes the code below to use a
+         non-standard semantics of it->current_x: it is measured
+         relative to the beginning of the text-area, thus disregarding
+         the window's hscroll.  That is why we need to correct the
+         indicator column for the hscroll, otherwise the indicator
+         will not move together with the text as result of horizontal
+         scrolling.  */
+      const int indicator_column =
+        fill_column_indicator_column (it, 1) - it->first_visible_x;
+
+      /* Display fill-column indicator if needed.  */
       while (it->current_x <= it->last_visible_x)
         {
           if (it->current_x != indicator_column)
@@ -30305,7 +30316,7 @@ produce_glyphless_glyph (struct it *it, bool for_no_font, Lisp_Object acronym)
 
       /* +4 is for vertical bars of a box plus 1-pixel spaces at both side.  */
       width = max (metrics_upper.width, metrics_lower.width) + 4;
-      upper_xoff = upper_yoff = 2; /* the typical case */
+      upper_xoff = lower_xoff = 2; /* the typical case */
       if (base_width >= width)
         {
           /* Align the upper to the left, the lower to the right.  */
@@ -30319,13 +30330,7 @@ produce_glyphless_glyph (struct it *it, bool for_no_font, Lisp_Object acronym)
           if (metrics_upper.width >= metrics_lower.width)
             lower_xoff = (width - metrics_lower.width) / 2;
           else
-            {
-              /* FIXME: This code doesn't look right.  It formerly was
-                 missing the "lower_xoff = 0;", which couldn't have
-                 been right since it left lower_xoff uninitialized.  */
-              lower_xoff = 0;
-              upper_xoff = (width - metrics_upper.width) / 2;
-            }
+            upper_xoff = (width - metrics_upper.width) / 2;
         }
 
       /* +5 is for horizontal bars of a box plus 1-pixel spaces at
@@ -35660,8 +35665,10 @@ as usual.  If the function returns a string, the returned string is
 displayed in the echo area.  If this function returns any other non-nil
 value, this means that the message was already handled, and the original
 message text will not be displayed in the echo area.
-See also `clear-message-function' that can be used to clear the
-message displayed by this function.  */);
+
+Also see `clear-message-function' (which can be used to clear the
+message displayed by this function), and `command-error-function'
+(which controls how error messages are displayed).  */);
   Vset_message_function = Qnil;
 
   DEFVAR_LISP ("clear-message-function", Vclear_message_function,