+ } else if (e->type == FocusIn) {
+ if (client &&
+ e->xfocus.detail == NotifyInferior)
+ {
+ ob_debug_type(OB_DEBUG_FOCUS,
+ "Focus went to the frame window");
+
+ focus_left_screen = FALSE;
+
+ focus_fallback(FALSE, config_focus_under_mouse, TRUE, TRUE);
+
+ /* We don't get a FocusOut for this case, because it's just moving
+ from our Inferior up to us. This happens when iconifying a
+ window with RevertToParent focus */
+ frame_adjust_focus(client->frame, FALSE);
+ /* focus_set_client(NULL) has already been called */
+ client_calc_layer(client);
+ }
+ else if (e->xfocus.detail == NotifyPointerRoot ||
+ e->xfocus.detail == NotifyDetailNone ||
+ e->xfocus.detail == NotifyInferior ||
+ e->xfocus.detail == NotifyNonlinear)
+ {
+ XEvent ce;
+
+ ob_debug_type(OB_DEBUG_FOCUS,
+ "Focus went to root or pointer root/none\n");
+
+ if (e->xfocus.detail == NotifyInferior ||
+ e->xfocus.detail == NotifyNonlinear)
+ {
+ focus_left_screen = FALSE;
+ }
+
+ /* If another FocusIn is in the queue then don't fallback yet. This
+ fixes the fun case of:
+ window map -> send focusin
+ window unmap -> get focusout
+ window map -> send focusin
+ get first focus out -> fall back to something (new window
+ hasn't received focus yet, so something else) -> send focusin
+ which means the "something else" is the last thing to get a
+ focusin sent to it, so the new window doesn't end up with focus.
+
+ But if the other focus in is something like PointerRoot then we
+ still want to fall back.
+ */
+ if (XCheckIfEvent(obt_display, &ce, event_look_for_focusin_client,
+ NULL))
+ {
+ XPutBackEvent(obt_display, &ce);
+ ob_debug_type(OB_DEBUG_FOCUS,
+ " but another FocusIn is coming\n");
+ } else {
+ /* Focus has been reverted.
+
+ FocusOut events come after UnmapNotify, so we don't need to
+ worry about focusing an invalid window
+ */
+
+ if (!focus_left_screen)
+ focus_fallback(FALSE, config_focus_under_mouse,
+ TRUE, TRUE);
+ }
+ }
+ else if (!client)
+ {
+ ob_debug_type(OB_DEBUG_FOCUS,
+ "Focus went to a window that is already gone\n");
+
+ /* If you send focus to a window and then it disappears, you can
+ get the FocusIn for it, after it is unmanaged.
+ Just wait for the next FocusOut/FocusIn pair, but make note that
+ the window that was focused no longer is. */
+ focus_set_client(NULL);
+ }
+ else if (client != focus_client) {
+ focus_left_screen = FALSE;
+ frame_adjust_focus(client->frame, TRUE);
+ focus_set_client(client);
+ client_calc_layer(client);
+ client_bring_helper_windows(client);
+ }
+ } else if (e->type == FocusOut) {
+ XEvent ce;
+
+ /* Look for the followup FocusIn */
+ if (!XCheckIfEvent(obt_display, &ce, event_look_for_focusin, NULL)) {
+ /* There is no FocusIn, this means focus went to a window that
+ is not being managed, or a window on another screen. */
+ Window win, root;
+ gint i;
+ guint u;
+ obt_display_ignore_errors(TRUE);
+ if (XGetInputFocus(obt_display, &win, &i) &&
+ XGetGeometry(obt_display, win, &root, &i,&i,&u,&u,&u,&u) &&
+ root != RootWindow(obt_display, ob_screen))
+ {
+ ob_debug_type(OB_DEBUG_FOCUS,
+ "Focus went to another screen !\n");
+ focus_left_screen = TRUE;
+ }
+ else
+ ob_debug_type(OB_DEBUG_FOCUS,
+ "Focus went to a black hole !\n");
+ obt_display_ignore_errors(FALSE);
+ /* nothing is focused */
+ focus_set_client(NULL);
+ } else {
+ /* Focus moved, so process the FocusIn event */
+ ObEventData ed = { .ignored = FALSE };
+ event_process(&ce, &ed);
+ if (ed.ignored) {
+ /* The FocusIn was ignored, this means it was on a window
+ that isn't a client. */
+ ob_debug_type(OB_DEBUG_FOCUS,
+ "Focus went to an unmanaged window 0x%x !\n",
+ ce.xfocus.window);
+ focus_fallback(TRUE, config_focus_under_mouse, TRUE, TRUE);
+ }
+ }
+
+ if (client && client != focus_client) {
+ frame_adjust_focus(client->frame, FALSE);
+ /* focus_set_client(NULL) has already been called in this
+ section or by focus_fallback */
+ client_calc_layer(client);
+ }
+ }