Merge branch 'master' into scratch/correct-warning-pos

Merge branch:
commit d29291d665e808307126bf52c3e748fef78f0f9c (HEAD -> master,
origin/master, origin/HEAD)
Author: Stefan Monnier <monnier@iro.umontreal.ca>
Date:   Fri Jan 14 12:26:30 2022 -0500

    (macroexp--expand-all): Fix bug#53227 and bug#46636

14 files changed, 255 insertions, 64 deletions

diff --git a/src/buffer.c b/src/buffer.c
index 10ac91915c6..a3091015d9b 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -1247,7 +1247,7 @@ buffer_local_value (Lisp_Object variable, Lisp_Object buffer)
       { /* Look in local_var_alist.  */
         struct Lisp_Buffer_Local_Value *blv = SYMBOL_BLV (sym);
         XSETSYMBOL (variable, sym); /* Update In case of aliasing.  */
-        result = Fassoc (variable, BVAR (buf, local_var_alist), Qnil);
+        result = assq_no_quit (variable, BVAR (buf, local_var_alist));
         if (!NILP (result))
           {
             if (blv->fwd.fwdptr)
diff --git a/src/data.c b/src/data.c
index e999cee242e..7422348e392 100644
--- a/src/data.c
+++ b/src/data.c
@@ -2180,7 +2180,7 @@ Instead, use `add-hook' and specify t for the LOCAL argument.  */)
 
   /* Make sure this buffer has its own value of symbol.  */
   XSETSYMBOL (variable, sym);   /* Update in case of aliasing.  */
-  tem = Fassq (variable, BVAR (current_buffer, local_var_alist));
+  tem = assq_no_quit (variable, BVAR (current_buffer, local_var_alist));
   if (NILP (tem))
     {
       if (let_shadows_buffer_binding_p (sym))
@@ -2260,7 +2260,7 @@ From now on the default value will apply in this buffer.  Return VARIABLE.  */)
 
   /* Get rid of this buffer's alist element, if any.  */
   XSETSYMBOL (variable, sym);   /* Propagate variable indirection.  */
-  tem = Fassq (variable, BVAR (current_buffer, local_var_alist));
+  tem = assq_no_quit (variable, BVAR (current_buffer, local_var_alist));
   if (!NILP (tem))
     bset_local_var_alist
       (current_buffer,
@@ -2301,7 +2301,7 @@ Also see `buffer-local-boundp'.*/)
     case SYMBOL_PLAINVAL: return Qnil;
     case SYMBOL_LOCALIZED:
       {
-        Lisp_Object tail, elt, tmp;
+        Lisp_Object tmp;
         struct Lisp_Buffer_Local_Value *blv = SYMBOL_BLV (sym);
         XSETBUFFER (tmp, buf);
         XSETSYMBOL (variable, sym); /* Update in case of aliasing.  */
@@ -2309,13 +2309,9 @@ Also see `buffer-local-boundp'.*/)
         if (EQ (blv->where, tmp)) /* The binding is already loaded.  */
           return blv_found (blv) ? Qt : Qnil;
         else
-          for (tail = BVAR (buf, local_var_alist); CONSP (tail); tail = XCDR (tail))
-            {
-              elt = XCAR (tail);
-              if (EQ (variable, XCAR (elt)))
-                return Qt;
-            }
-        return Qnil;
+          return NILP (assq_no_quit (variable, BVAR (buf, local_var_alist)))
+            ? Qnil
+            : Qt;
       }
     case SYMBOL_FORWARDED:
       {
diff --git a/src/font.c b/src/font.c
index 266e5bc75c6..7e0219181c9 100644
--- a/src/font.c
+++ b/src/font.c
@@ -2183,7 +2183,9 @@ font_score (Lisp_Object entity, Lisp_Object *spec_prop)
 
   /* Score three style numeric fields.  Maximum difference is 127. */
   for (i = FONT_WEIGHT_INDEX; i <= FONT_WIDTH_INDEX; i++)
-    if (! NILP (spec_prop[i]) && ! EQ (AREF (entity, i), spec_prop[i]))
+    if (! NILP (spec_prop[i])
+        && ! EQ (AREF (entity, i), spec_prop[i])
+        && FIXNUMP (AREF (entity, i)))
       {
         EMACS_INT diff = ((XFIXNUM (AREF (entity, i)) >> 8)
                           - (XFIXNUM (spec_prop[i]) >> 8));
@@ -2764,26 +2766,31 @@ font_delete_unmatched (Lisp_Object vec, Lisp_Object spec, int size)
         {
           if (FIXNUMP (AREF (spec, prop)))
             {
-              int required = XFIXNUM (AREF (spec, prop)) >> 8;
-              int candidate = XFIXNUM (AREF (entity, prop)) >> 8;
+              if (!FIXNUMP (AREF (entity, prop)))
+                prop = FONT_SPEC_MAX;
+              else
+                {
+                  int required = XFIXNUM (AREF (spec, prop)) >> 8;
+                  int candidate = XFIXNUM (AREF (entity, prop)) >> 8;
 
-              if (candidate != required
+                  if (candidate != required
 #ifdef HAVE_NTGUI
-                  /* A kludge for w32 font search, where listing a
-                     family returns only 4 standard weights: regular,
-                     italic, bold, bold-italic.  For other values one
-                     must specify the font, not just the family in the
-                     :family attribute of the face.  But specifying
-                     :family in the face attributes looks for regular
-                     weight, so if we require exact match, the
-                     non-regular font will be rejected.  So we relax
-                     the accuracy of the match here, and let
-                     font_sort_entities find the best match.  */
-                  && (prop != FONT_WEIGHT_INDEX
-                      || eabs (candidate - required) > 100)
+                      /* A kludge for w32 font search, where listing a
+                         family returns only 4 standard weights: regular,
+                         italic, bold, bold-italic.  For other values one
+                         must specify the font, not just the family in the
+                         :family attribute of the face.  But specifying
+                         :family in the face attributes looks for regular
+                         weight, so if we require exact match, the
+                         non-regular font will be rejected.  So we relax
+                         the accuracy of the match here, and let
+                         font_sort_entities find the best match.  */
+                      && (prop != FONT_WEIGHT_INDEX
+                          || eabs (candidate - required) > 100)
 #endif
-                  )
-                prop = FONT_SPEC_MAX;
+                      )
+                    prop = FONT_SPEC_MAX;
+                }
             }
         }
       if (prop < FONT_SPEC_MAX
diff --git a/src/frame.c b/src/frame.c
index c0f4f3ecde3..e5d74edc168 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -2382,9 +2382,12 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
 }
 
 DEFUN ("delete-frame", Fdelete_frame, Sdelete_frame, 0, 2, "",
-       doc: /* Delete FRAME, permanently eliminating it from use.
+       doc: /* Delete FRAME, eliminating it from use.
 FRAME must be a live frame and defaults to the selected one.
 
+When `undelete-frame-mode' is enabled, the 16 most recently deleted
+frames can be undeleted with `undelete-frame', which see.
+
 A frame may not be deleted if its minibuffer serves as surrogate
 minibuffer for another frame.  Normally, you may not delete a frame if
 all other frames are invisible, but if the second optional argument
diff --git a/src/ftfont.c b/src/ftfont.c
index 2bdcce306bc..5797300d231 100644
--- a/src/ftfont.c
+++ b/src/ftfont.c
@@ -189,6 +189,24 @@ ftfont_pattern_entity (FcPattern *p, Lisp_Object extra)
     return Qnil;
   if (FcPatternGetInteger (p, FC_INDEX, 0, &idx) != FcResultMatch)
     return Qnil;
+#ifdef FC_VARIABLE
+  /* This is a virtual/meta FcPattern for a variable weight font, from
+     which it is possible to extract an FcRange value specifying the
+     minimum and maximum weights available in this file.  We don't
+     need to know that information explicitly, so skip it.  We will be
+     called with an FcPattern for each actually available, non-virtual
+     weight.
+
+     Fontconfig started generating virtual/meta patterns for variable
+     weight fonts in the same release that FC_VARIABLE was added, so
+     we conditionalize on that constant.  This also ensures that
+     FcPatternGetRange is available.  */
+  FcRange *range;
+  if (FcPatternGetRange (p, FC_WEIGHT, 0, &range) == FcResultMatch
+      && FcPatternGetBool (p, FC_VARIABLE, 0, &b) == FcResultMatch
+      && b == FcTrue)
+    return Qnil;
+#endif  /* FC_VARIABLE */
 
   file = (char *) str;
   key = Fcons (build_unibyte_string (file), make_fixnum (idx));
@@ -863,6 +881,9 @@ ftfont_list (struct frame *f, Lisp_Object spec)
 #if defined HAVE_XFT && defined FC_COLOR
                              FC_COLOR,
 #endif
+#ifdef FC_VARIABLE
+                             FC_VARIABLE,
+#endif  /* FC_VARIABLE */
                              NULL);
   if (! objset)
     goto err;
diff --git a/src/gtkutil.c b/src/gtkutil.c
index 1db166b1bad..36ed55bc039 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -6255,16 +6255,19 @@ xg_widget_key_press_event_cb (GtkWidget *widget, GdkEvent *event,
       kbd_buffer_store_buffered_event (&inev, &xg_pending_quit_event);
     }
 
-#ifdef USABLE_SIGIO
-  raise (SIGIO);
-#endif
+  XNoOp (FRAME_X_DISPLAY (f));
   return true;
 }
 
 bool
 xg_filter_key (struct frame *frame, XEvent *xkey)
 {
-  GdkEvent *xg_event = gdk_event_new (GDK_KEY_PRESS);
+  GdkEvent *xg_event = gdk_event_new ((xkey->type == ButtonPress
+#ifdef HAVE_XINPUT2
+                                       || (xkey->type == GenericEvent
+                                           && xkey->xgeneric.evtype == XI_KeyPress)
+#endif
+                                       ) ? GDK_KEY_PRESS : GDK_KEY_RELEASE);
   GdkDisplay *dpy = gtk_widget_get_display (FRAME_GTK_WIDGET (frame));
   GdkKeymap *keymap = gdk_keymap_get_for_display (dpy);
   GdkModifierType consumed;
diff --git a/src/haiku_draw_support.cc b/src/haiku_draw_support.cc
index 5d355ac2058..270a619b89b 100644
--- a/src/haiku_draw_support.cc
+++ b/src/haiku_draw_support.cc
@@ -313,7 +313,7 @@ BView_DrawBitmapWithEraseOp (void *view, void *bitmap, int x,
       BRect bounds = bc.Bounds ();
       for (int y = 0; y < BE_RECT_HEIGHT (bounds); ++y)
         {
-          for (int x = 0; x <= BE_RECT_WIDTH (bounds); ++x)
+          for (int x = 0; x < BE_RECT_WIDTH (bounds); ++x)
             {
               if (bits[y * (stride / 4) + x] == 0xFF000000)
                 bits[y * (stride / 4) + x] = RGB_COLOR_UINT32 (low_color);
diff --git a/src/haiku_support.cc b/src/haiku_support.cc
index 531dfb5c642..d49e319b98c 100644
--- a/src/haiku_support.cc
+++ b/src/haiku_support.cc
@@ -136,6 +136,15 @@ gui_abort (const char *msg)
   emacs_abort ();
 }
 
+/* Convert a raw character RAW produced by the keycode KEY into a key
+   symbol and place it in KEYSYM.
+
+   If RAW cannot be converted into a keysym, value is 0.  If RAW can
+   be converted into a keysym, but it should be ignored, value is -1.
+
+   Any other value means success, and that the keysym should be used
+   instead of mapping the keycode into a character.  */
+
 static int
 keysym_from_raw_char (int32 raw, int32 key, unsigned *code)
 {
@@ -186,6 +195,19 @@ keysym_from_raw_char (int32 raw, int32 key, unsigned *code)
 
     case B_FUNCTION_KEY:
       *code = XK_F1 + key - 2;
+
+      if (*code - XK_F1 == 12)
+        *code = XK_Print;
+      else if (*code - XK_F1 == 13)
+        /* Okay, Scroll Lock is a bit too much: keyboard.c doesn't
+           know about it yet, and it shouldn't, since that's a
+           modifier key.
+
+           *code = XK_Scroll_Lock; */
+        return -1;
+      else if (*code - XK_F1 == 14)
+        *code = XK_Pause;
+
       break;
 
     default:
@@ -693,6 +715,7 @@ public:
         rq.window = this;
 
         int32 raw, key;
+        int ret;
         msg->FindInt32 ("raw_char", &raw);
         msg->FindInt32 ("key", &key);
 
@@ -711,9 +734,14 @@ public:
         if (mods & B_OPTION_KEY)
           rq.modifiers |= HAIKU_MODIFIER_SUPER;
 
-        if (!keysym_from_raw_char (raw, key, &rq.keysym))
+        ret = keysym_from_raw_char (raw, key, &rq.keysym);
+
+        if (!ret)
           rq.keysym = 0;
 
+        if (ret < 0)
+          return;
+
         rq.multibyte_char = 0;
 
         if (!rq.keysym)
diff --git a/src/haikuterm.c b/src/haikuterm.c
index be28649aef2..3e99cc1c8d9 100644
--- a/src/haikuterm.c
+++ b/src/haikuterm.c
@@ -2222,6 +2222,7 @@ haiku_draw_fringe_bitmap (struct window *w, struct glyph_row *row,
   void *view = FRAME_HAIKU_VIEW (XFRAME (WINDOW_FRAME (w)));
   struct face *face = p->face;
 
+  block_input ();
   BView_draw_lock (view);
   BView_StartClip (view);
 
@@ -2256,6 +2257,7 @@ haiku_draw_fringe_bitmap (struct window *w, struct glyph_row *row,
     }
   BView_EndClip (view);
   BView_draw_unlock (view);
+  unblock_input ();
 }
 
 static void
@@ -3233,7 +3235,10 @@ haiku_read_socket (struct terminal *terminal, struct input_event *hold_quit)
             struct frame *f = haiku_window_to_frame (b->window);
 
             if (!f)
-              continue;
+              {
+                free (b->ref);
+                continue;
+              }
 
             inev.kind = DRAG_N_DROP_EVENT;
             inev.arg = build_string_from_utf8 (b->ref);
diff --git a/src/window.c b/src/window.c
index 7155f0e6bc3..2a5e4042a48 100644
--- a/src/window.c
+++ b/src/window.c
@@ -5861,7 +5861,8 @@ window_scroll_pixel_based (Lisp_Object window, int n, bool whole, bool noerror)
 
       /* We moved the window start towards ZV, so PT may be now
          in the scroll margin at the top.  */
-      move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
+      if (IT_CHARPOS (it) < PT)
+        move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
       if (IT_CHARPOS (it) == PT
           && it.current_y >= this_scroll_margin
           && it.current_y <= last_y - WINDOW_TAB_LINE_HEIGHT (w)
diff --git a/src/xdisp.c b/src/xdisp.c
index 2326df4300d..977d31703fb 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -18557,6 +18557,20 @@ try_cursor_movement (Lisp_Object window, struct text_pos startp,
                             || (NILP (g->object)
                                 && (g->charpos == PT
                                     || (g->charpos == 0 && endpos - 1 == PT)));
+                          /* Perhaps the point position is inside
+                             invisible text?  In that case, we trust
+                             'set_cursor_from_row' to do its job and
+                             find the best position for the cursor.  */
+                          if (!exact_match_p)
+                            {
+                              Lisp_Object val =
+                                get_char_property_and_overlay (make_fixnum (PT),
+                                                               Qinvisible,
+                                                               Qnil, NULL);
+
+                              if (TEXT_PROP_MEANS_INVISIBLE (val) != 0)
+                                exact_match_p = true;
+                            }
                         }
                       if (at_zv_p || exact_match_p)
                         {
diff --git a/src/xfns.c b/src/xfns.c
index 028ee29a4aa..ffad0bc3d1a 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -3347,6 +3347,8 @@ setup_xi_event_mask (struct frame *f)
   XISetMask (m, XI_Motion);
   XISetMask (m, XI_Enter);
   XISetMask (m, XI_Leave);
+  XISetMask (m, XI_FocusIn);
+  XISetMask (m, XI_FocusOut);
   XISetMask (m, XI_KeyPress);
   XISetMask (m, XI_KeyRelease);
   XISelectEvents (FRAME_X_DISPLAY (f),
@@ -3359,6 +3361,8 @@ setup_xi_event_mask (struct frame *f)
 #ifdef USE_X_TOOLKIT
   XISetMask (m, XI_KeyPress);
   XISetMask (m, XI_KeyRelease);
+  XISetMask (m, XI_FocusIn);
+  XISetMask (m, XI_FocusOut);
 
   XISelectEvents (FRAME_X_DISPLAY (f),
                   FRAME_OUTER_WINDOW (f),
diff --git a/src/xterm.c b/src/xterm.c
index 52715892703..ec415f5ffaf 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -20,6 +20,72 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 /* New display code by Gerd Moellmann <gerd@gnu.org>.  */
 /* Xt features made by Fred Pierresteguy.  */
 
+/* X window system support for GNU Emacs
+
+   This file is part of the X window system support for GNU Emacs.  It
+   contains subroutines comprising the redisplay interface, setting up
+   scroll bars and widgets, and handling input.
+
+   INPUT
+
+   Emacs handles input by running pselect in a loop, which returns
+   whenever there is input available on the connection to the X
+   server.  On some systems, Emacs also arranges for any new input on
+   that connection to send an asynchronous signal.  Whenever pselect
+   returns, or such a signal is received and input is not blocked,
+   XTread_socket is called and translates X11 events read by Xlib into
+   struct input_events, which are then stored in the keyboard buffer,
+   to be processed and acted upon at some later time.  The function
+   handle_one_xevent is responsible for handling core events after
+   they are filtered, and filtering X Input Extension events.  It also
+   performs actions on some special events, such as updating the
+   dimensions of a frame after a ConfigureNotify is sent by the X
+   server to inform us that it changed.
+
+   Before such events are translated, an Emacs build with
+   internationalization enabled (the default since X11R6) will filter
+   events through an X Input Method (XIM) or GTK, which might decide
+   to intercept the event and send a different one in its place, for
+   reasons such as enabling the user to insert international
+   characters that aren't on his keyboard by typing a sequence of
+   characters which are.  See the function x_filter_event and its
+   callers for more details.
+
+   Events that cause Emacs to quit are treated specially by the code
+   that stores them in the keyboard buffer and generally cause an
+   immediate interrupt.  Such an interrupt can lead to a longjmp from
+   the code that stored the keyboard event, which isn't safe inside
+   XTread_socket.  To avoid this problem, XTread_socket is provided a
+   special event buffer named hold_quit.  When a quit event is
+   encountered, it is stored inside this special buffer, which will
+   cause the keyboard code that called XTread_socket to store it at a
+   later time when it is safe to do so.
+
+   handle_one_xevent will generally have to determine which frame an
+   event should be attributed to.  This is not easy, because events
+   can come from multiple X windows, and a frame can also have
+   multiple windows.  handle_one_xevent usually calls the function
+   x_any_window_to_frame, which searches for a frame by toplevel
+   window and widget windows.  There are also some other functions for
+   searching by specific types of window, such as
+   x_top_window_to_frame (which only searches for frames by toplevel
+   window), and x_menubar_window_to_frame (which will only search
+   through frame menu bars).
+
+   INPUT FOCUS
+
+   Under X, the window where keyboard input is sent is not always
+   explictly defined.  When there is a focus window, it receives what
+   is referred to as "explicit focus", but when there is none, it
+   receives "implicit focus" whenever the pointer enters it, and loses
+   that focus when the pointer leaves.  When the toplevel window of a
+   frame receives an explicit focus event (FocusIn or FocusOut), we
+   treat that frame as having the current input focus, but when there
+   is no focus window, we treat each frame as having the input focus
+   whenever the pointer enters it, and undo that treatment when the
+   pointer leaves it.  See the callers of x_detect_focus_change for
+   more details.  */
+
 #include <config.h>
 #include <stdlib.h>
 #include <math.h>
@@ -4126,7 +4192,9 @@ x_draw_glyph_string (struct glyph_string *s)
       area_max_x = area_x + area_width - 1;
 
       decoration_width = s->width;
-      if (area_max_x < (s->x + decoration_width - 1))
+      if (!s->row->mode_line_p
+          && !s->row->tab_line_p
+          && area_max_x < (s->x + decoration_width - 1))
         decoration_width -= (s->x + decoration_width - 1) - area_max_x;
 
       /* Draw relief if not yet drawn.  */
@@ -5252,21 +5320,18 @@ x_detect_focus_change (struct x_display_info *dpyinfo, struct frame *frame,
         int focus_state
           = focus_frame ? focus_frame->output_data.x->focus_state : 0;
 
-#ifdef USE_GTK
         if (xi_event->evtype == XI_FocusIn
             || xi_event->evtype == XI_FocusOut)
           x_focus_changed ((xi_event->evtype == XI_FocusIn
                             ? FocusIn : FocusOut),
                            FOCUS_EXPLICIT,
                            dpyinfo, frame, bufp);
-        else
-#endif
-          if ((xi_event->evtype == XI_Enter
-               || xi_event->evtype == XI_Leave)
-              && (((XIEnterEvent *) xi_event)->detail
-                  != XINotifyInferior)
-              && ((XIEnterEvent *) xi_event)->focus
-              && !(focus_state & FOCUS_EXPLICIT))
+        else if ((xi_event->evtype == XI_Enter
+                  || xi_event->evtype == XI_Leave)
+                 && (((XIEnterEvent *) xi_event)->detail
+                     != XINotifyInferior)
+                 && ((XIEnterEvent *) xi_event)->focus
+                 && !(focus_state & FOCUS_EXPLICIT))
           x_focus_changed ((xi_event->evtype == XI_Enter
                             ? FocusIn : FocusOut),
                            FOCUS_IMPLICIT,
@@ -5386,8 +5451,6 @@ x_find_modifier_meanings (struct x_display_info *dpyinfo)
   dpyinfo->super_mod_mask = 0;
   dpyinfo->hyper_mod_mask = 0;
 
-  XDisplayKeycodes (dpyinfo->display, &min_code, &max_code);
-
 #ifdef HAVE_XKB
   if (dpyinfo->xkb_desc)
     {
@@ -5432,6 +5495,8 @@ x_find_modifier_meanings (struct x_display_info *dpyinfo)
     }
 #endif
 
+  XDisplayKeycodes (dpyinfo->display, &min_code, &max_code);
+
   syms = XGetKeyboardMapping (dpyinfo->display,
                               min_code, max_code - min_code + 1,
                               &syms_per_code);
@@ -5924,7 +5989,7 @@ XTmouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
         if (!f1 && insist > 0)
           f1 = SELECTED_FRAME ();
 
-        if (f1)
+        if (f1 && FRAME_X_P (f1))
           {
             /* Ok, we found a frame.  Store all the values.
                last_mouse_glyph is a rectangle used to reduce the
@@ -5934,7 +5999,6 @@ XTmouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
                on it, i.e. into the same rectangles that matrices on
                the frame are divided into.  */
 
-            /* FIXME: what if F1 is not an X frame?  */
             dpyinfo = FRAME_DISPLAY_INFO (f1);
             remember_mouse_glyph (f1, win_x, win_y, &dpyinfo->last_mouse_glyph);
             dpyinfo->last_mouse_glyph_frame = f1;
@@ -8285,8 +8349,10 @@ x_filter_event (struct x_display_info *dpyinfo, XEvent *event)
       && event->type == GenericEvent
       && (event->xgeneric.extension
           == dpyinfo->xi2_opcode)
-      && (event->xgeneric.evtype
-          == XI_KeyPress))
+      && ((event->xgeneric.evtype
+           == XI_KeyPress)
+          || (event->xgeneric.evtype
+              == XI_KeyRelease)))
     {
       f1 = x_any_window_to_frame (dpyinfo,
                                   ((XIDeviceEvent *)
@@ -9458,7 +9524,9 @@ handle_one_xevent (struct x_display_info *dpyinfo,
 
     case EnterNotify:
       x_display_set_last_user_time (dpyinfo, event->xcrossing.time);
-      x_detect_focus_change (dpyinfo, any, event, &inev.ie);
+
+      if (x_top_window_to_frame (dpyinfo, event->xcrossing.window))
+        x_detect_focus_change (dpyinfo, any, event, &inev.ie);
 
 #ifdef HAVE_XWIDGETS
       {
@@ -9540,7 +9608,9 @@ handle_one_xevent (struct x_display_info *dpyinfo,
       }
 #endif
       x_display_set_last_user_time (dpyinfo, event->xcrossing.time);
-      x_detect_focus_change (dpyinfo, any, event, &inev.ie);
+
+      if (x_top_window_to_frame (dpyinfo, event->xcrossing.window))
+        x_detect_focus_change (dpyinfo, any, event, &inev.ie);
 
       f = x_top_window_to_frame (dpyinfo, event->xcrossing.window);
 #if defined HAVE_X_TOOLKIT && defined HAVE_XINPUT2
@@ -10151,13 +10221,23 @@ handle_one_xevent (struct x_display_info *dpyinfo,
             x_detect_focus_change (dpyinfo, any, event, &inev.ie);
             goto XI_OTHER;
           case XI_Enter:
-            any = x_any_window_to_frame (dpyinfo, enter->event);
+
+            any = x_top_window_to_frame (dpyinfo, enter->event);
             ev.x = lrint (enter->event_x);
             ev.y = lrint (enter->event_y);
-            ev.window = leave->event;
-
+            ev.window = enter->event;
             x_display_set_last_user_time (dpyinfo, xi_event->time);
-            x_detect_focus_change (dpyinfo, any, event, &inev.ie);
+
+            /* There is no need to handle entry/exit events for
+               passive focus from non-top windows at all, since they
+               are an inferiors of the frame's top window, which will
+               get virtual events.  */
+            if (any)
+              x_detect_focus_change (dpyinfo, any, event, &inev.ie);
+
+            if (!any)
+              any = x_any_window_to_frame (dpyinfo, enter->event);
+
             {
 #ifdef HAVE_XWIDGETS
               struct xwidget_view *xwidget_view = xwidget_view_from_window (enter->event);
@@ -10221,11 +10301,12 @@ handle_one_xevent (struct x_display_info *dpyinfo,
               x_note_mouse_movement (dpyinfo->last_mouse_glyph_frame, &ev);
 #endif
             goto XI_OTHER;
+
           case XI_Leave:
             ev.x = lrint (leave->event_x);
             ev.y = lrint (leave->event_y);
             ev.window = leave->event;
-            any = x_any_window_to_frame (dpyinfo, leave->event);
+            any = x_top_window_to_frame (dpyinfo, leave->event);
 
 #ifdef HAVE_XWIDGETS
             {
@@ -10243,7 +10324,12 @@ handle_one_xevent (struct x_display_info *dpyinfo,
 #endif
 
             x_display_set_last_user_time (dpyinfo, xi_event->time);
-            x_detect_focus_change (dpyinfo, any, event, &inev.ie);
+
+            if (any)
+              x_detect_focus_change (dpyinfo, any, event, &inev.ie);
+
+            if (!any)
+              any = x_any_window_to_frame (dpyinfo, leave->event);
 
 #ifndef USE_X_TOOLKIT
             f = x_top_window_to_frame (dpyinfo, leave->event);
@@ -11167,6 +11253,13 @@ handle_one_xevent (struct x_display_info *dpyinfo,
           case XI_PropertyEvent:
           case XI_HierarchyChanged:
           case XI_DeviceChanged:
+
+#ifdef XISlaveSwitch
+            if (xi_event->evtype == XI_DeviceChanged
+                && (((XIDeviceChangedEvent *) xi_event)->reason
+                    == XISlaveSwitch))
+              goto XI_OTHER;
+#endif
             x_init_master_valuators (dpyinfo);
             goto XI_OTHER;
 #ifdef XI_TouchBegin
@@ -11433,6 +11526,22 @@ handle_one_xevent (struct x_display_info *dpyinfo,
 
                   x_find_modifier_meanings (dpyinfo);
                 }
+              else
+                {
+                  dpyinfo->xkb_desc = XkbGetMap (dpyinfo->display,
+                                                 (XkbKeySymsMask
+                                                  | XkbKeyTypesMask
+                                                  | XkbModifierMapMask
+                                                  | XkbVirtualModsMask),
+                                                 XkbUseCoreKbd);
+
+                  if (dpyinfo->xkb_desc)
+                    XkbGetNames (dpyinfo->display,
+                                 XkbGroupNamesMask | XkbVirtualModNamesMask,
+                                 dpyinfo->xkb_desc);
+                }
+
+              XkbRefreshKeyboardMapping (&xkbevent->map);
             }
         }
 #endif
diff --git a/src/xwidget.c b/src/xwidget.c
index 7d6d256a191..45879b15cbe 100644
--- a/src/xwidget.c
+++ b/src/xwidget.c
@@ -1447,8 +1447,8 @@ xwidget_motion_or_crossing (struct xwidget_view *view, const XEvent *event)
 #ifdef HAVE_XINPUT2
   else if (event->type == GenericEvent)
     {
-      xg_event->crossing.x = (gdouble) xev->event_x;
-      xg_event->crossing.y = (gdouble) xev->event_y;
+      xg_event->crossing.x = x;
+      xg_event->crossing.y = y;
       xg_event->crossing.x_root = (gdouble) xev->root_x;
       xg_event->crossing.y_root = (gdouble) xev->root_y;
       xg_event->crossing.time = xev->time;