Update Occitan translation

In the past, MetaWindowGroup was allocated the size of the screen and
painted the size of the screen because it contained the screen background,
but now we also have the "top window group" which contains only popup
windows, so the allocation doesn't properly reflect the paint bounds
of the window group. Compute the paint bounds accurately from the
children.

https://bugzilla.gnome.org/show_bug.cgi?id=719669

.gitignore

@@ -62,7 +62,6 @@ mutter-message
 mutter-window-demo
 focus-window
 test-attached
-test-focus
 test-gravity
 test-resizing
 test-size-hints

NEWS

@@ -1,29 +1,38 @@
-3.9.2
+3.8.4
+=====
+* Workaround failure to bring back shell interface after fullscreen game in some situations [Adel; #701224]
+* Fix sluggish and stuck pointers moving windows [Adel, Jasper: #699777]
+* Reduce log spew [Adel, Jasper; #702564, #703970]
+* Touch screen fixes [Jasper: #697192]
+* Fix rendering of large background images [Jasper, Ray: #702283]
+
+Contributors:
+ Adel Gadllah, Jasper St. Pierre, Ray Strode
+
+3.8.3
 =====
-* Add meta_window_can_close() function [Jasper; #699269]
 * Add support for string-array preferences [Florian; #700223]
-* Fix a potential race condition with _NET_WM_MOVERESIZE [Jasper; #699777]
 * Fix shade window action [Stef; #693714]
-* Remove overlay_group [Giovanni; #700735]
-* Improve tracking of the focus window [Dan, Jasper; #647706]
 * Add API to freeze/unfreeze the keyboard [Rui; #697001]
 * Grab and emit a signal when XK_ISO_Next_Group is pressed [Rui; #697002]
-* Misc bug fixes and cleanups [Dieter, Jasper, Rui; #699636, #700735, #697000]
+* Ensure events are always reported to the grab window [Rui; #701219]
+* Use new clutter_stage_set_paint_callback() function to prevent dropping
+  frames with frame synced toolkits [Owen; #698794]
 
 Contributors:
-  Giovanni Campagna, Rui Matos, Florian Müllner, Jasper St. Pierre,
-  Dieter Verfaillie, Stef Walter, Dan Winship
+  Rui Matos, Florian Müllner, Stef Walter, Owen W. Taylor
 
-Translations:
-  Kjartan Maraas [nb], Ján Kyselica [sk]
-
-3.9.1
+3.8.2
 =====
 * Fix miscellaneous memory leaks [Pavel; #698710]
-* Misc fixes and cleanups [Stef, Simon; #698179, #697758]
+* Fix binding remaining grabbed after clearing all strokes [Rui; #697000]
+* Misc fixes [Stef; #698179]
 
 Contributors:
-  Simon McVittie, Pavel Vasin, Stef Walter
+  Rui Matos, Pavel Vasin, Stef Walter
+
+Translations:
+  Kjartan Maraas [nb]
 
 3.8.1
 =====

configure.ac

@@ -1,8 +1,8 @@
 AC_PREREQ(2.50)
 
 m4_define([mutter_major_version], [3])
-m4_define([mutter_minor_version], [9])
-m4_define([mutter_micro_version], [2])
+m4_define([mutter_minor_version], [8])
+m4_define([mutter_micro_version], [4])
 
 m4_define([mutter_version],
           [mutter_major_version.mutter_minor_version.mutter_micro_version])
@@ -73,7 +73,7 @@ MUTTER_PC_MODULES="
    cairo >= 1.10.0
    gsettings-desktop-schemas >= 3.7.3
    xcomposite >= 0.2 xfixes xrender xdamage xi >= 1.6.0
-   $CLUTTER_PACKAGE >= 1.13.5
+   $CLUTTER_PACKAGE >= 1.14.3
    cogl-1.0 >= 1.13.3
 "
 

po/nb.po

@@ -4,10 +4,10 @@
 #
 msgid ""
 msgstr ""
-"Project-Id-Version: mutter 3.9.x\n"
+"Project-Id-Version: mutter 3.8.x\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2013-05-28 09:47+0200\n"
-"PO-Revision-Date: 2013-05-28 09:48+0200\n"
+"POT-Creation-Date: 2013-05-13 10:30+0200\n"
+"PO-Revision-Date: 2013-04-03 14:11+0200\n"
 "Last-Translator: Kjartan Maraas <kmaraas@gnome.org>\n"
 "Language-Team: Norwegian bokmål <i18n-no@lister.ping.uio.no>\n"
 "Language: \n"
@@ -205,7 +205,7 @@ msgstr "Visning delt til høyre"
 
 #. This probably means that a non-WM compositor like xcompmgr is running;
 #. * we have no way to get it to exit
-#: ../src/compositor/compositor.c:571
+#: ../src/compositor/compositor.c:568
 #, c-format
 msgid ""
 "Another compositing manager is already running on screen %i on display \"%s"
@@ -250,17 +250,17 @@ msgstr "_Vent"
 msgid "_Force Quit"
 msgstr "_Tvungen nedstenging"
 
-#: ../src/core/display.c:421
+#: ../src/core/display.c:401
 #, c-format
 msgid "Missing %s extension required for compositing"
 msgstr "Mangler utvidelsen %s som kreves for komposittfunksjon"
 
-#: ../src/core/display.c:513
+#: ../src/core/display.c:493
 #, c-format
 msgid "Failed to open X Window System display '%s'\n"
 msgstr "Feil under åpning av X Window System skjerm «%s»\n"
 
-#: ../src/core/keybindings.c:1138
+#: ../src/core/keybindings.c:970
 #, c-format
 msgid ""
 "Some other program is already using the key %s with modifiers %x as a "
@@ -269,7 +269,7 @@ msgstr ""
 "Et annet program bruker allerede nøkkelen %s med modifikatorer %x som "
 "binding\n"
 
-#: ../src/core/keybindings.c:1335
+#: ../src/core/keybindings.c:1151
 #, c-format
 msgid "\"%s\" is not a valid accelerator\n"
 msgstr "«%s» er ikke en gyldig aksellerator\n"
@@ -333,7 +333,7 @@ msgstr "Skriv versjonsnummer"
 msgid "Mutter plugin to use"
 msgstr "Mutter-tillegg som skal brukes"
 
-#: ../src/core/prefs.c:1210
+#: ../src/core/prefs.c:1095
 msgid ""
 "Workarounds for broken applications disabled. Some applications may not "
 "behave properly.\n"
@@ -341,12 +341,12 @@ msgstr ""
 "Funksjonalitet for å gå rundt ødelagte programmer er deaktivert. Noen "
 "programmer vil kanskje ikke oppføre seg korrekt.\n"
 
-#: ../src/core/prefs.c:1285
+#: ../src/core/prefs.c:1170
 #, c-format
 msgid "Could not parse font description \"%s\" from GSettings key %s\n"
 msgstr "Kunne ikke tolke skriftbeskrivelsen «%s» fra GSettings-nøkkel %s\n"
 
-#: ../src/core/prefs.c:1351
+#: ../src/core/prefs.c:1236
 #, c-format
 msgid ""
 "\"%s\" found in configuration database is not a valid value for mouse button "
@@ -355,7 +355,7 @@ msgstr ""
 "«%s» funnet i konfigurasjonsdatabasen er ikke en gyldig verdi for endring av "
 "musknapp\n"
 
-#: ../src/core/prefs.c:1928
+#: ../src/core/prefs.c:1789
 #, c-format
 msgid ""
 "\"%s\" found in configuration database is not a valid value for keybinding "
@@ -364,7 +364,7 @@ msgstr ""
 "«%s» funnet i konfigurasjonsdatabasen er ikke en gyldig verdi for "
 "tastaturbinding «%s»\n"
 
-#: ../src/core/prefs.c:2018
+#: ../src/core/prefs.c:1888
 #, c-format
 msgid "Workspace %d"
 msgstr "Arbeidsområde %d"
@@ -492,7 +492,7 @@ msgid "Window manager error: "
 msgstr "Feil i vindushåndterer: "
 
 #. first time through
-#: ../src/core/window.c:7505
+#: ../src/core/window.c:7598
 #, c-format
 msgid ""
 "Window %s sets SM_CLIENT_ID on itself, instead of on the WM_CLIENT_LEADER "
@@ -508,7 +508,7 @@ msgstr ""
 #. * MWM but not WM_NORMAL_HINTS are basically broken. We complain
 #. * about these apps but make them work.
 #.
-#: ../src/core/window.c:8229
+#: ../src/core/window.c:8322
 #, c-format
 msgid ""
 "Window %s sets an MWM hint indicating it isn't resizable, but sets min size "

src/compositor/compositor.c

@@ -53,15 +53,17 @@
  *
  * # Containers #
  *
- * There's two containers in the stage that are used to place window actors, here
+ * There's three containers in the stage that can be used to place actors, here
  * are listed in the order in which they are painted:
  *
  * - window group, accessible with meta_get_window_group_for_screen()
  * - top window group, accessible with meta_get_top_window_group_for_screen()
+ * - overlay group, accessible with meta_get_overlay_group_for_screen()
  *
  * Mutter will place actors representing windows in the window group, except for
  * override-redirect windows (ie. popups and menus) which will be placed in the
- * top window group.
+ * top window group. Mutter won't put any actors in the overlay group, but it's
+ * intended for compositors to place there panel, dashes, status bars, etc.
  */
 
 #include <config.h>
@@ -253,6 +255,23 @@ meta_get_stage_for_screen (MetaScreen *screen)
   return info->stage;
 }
 
+/**
+ * meta_get_overlay_group_for_screen:
+ * @screen: a #MetaScreen
+ *
+ * Returns: (transfer none): The overlay group corresponding to @screen
+ */
+ClutterActor *
+meta_get_overlay_group_for_screen (MetaScreen *screen)
+{
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+
+  if (!info)
+    return NULL;
+
+  return info->overlay_group;
+}
+
 /**
  * meta_get_window_group_for_screen:
  * @screen: a #MetaScreen
@@ -369,28 +388,6 @@ meta_empty_stage_input_region (MetaScreen *screen)
   meta_set_stage_input_region (screen, region);
 }
 
-void
-meta_focus_stage_window (MetaScreen *screen,
-                         guint32     timestamp)
-{
-  ClutterStage *stage;
-  Window window;
-
-  stage = CLUTTER_STAGE (meta_get_stage_for_screen (screen));
-  if (!stage)
-    return;
-
-  window = clutter_x11_get_stage_window (stage);
-
-  if (window == None)
-    return;
-
-  meta_display_set_input_focus_xwindow (screen->display,
-                                        screen,
-                                        window,
-                                        timestamp);
-}
-
 gboolean
 meta_begin_modal_for_plugin (MetaScreen       *screen,
                              MetaPlugin       *plugin,
@@ -517,20 +514,20 @@ meta_check_end_modal (MetaScreen *screen)
     {
       meta_end_modal_for_plugin (screen,
                                    compositor->modal_plugin,
-                                   CurrentTime);
+
+                                 CurrentTime);
     }
 }
 
-static gboolean
-after_stage_paint (gpointer data)
+static void
+after_stage_paint (ClutterStage *stage,
+                   gpointer      data)
 {
   MetaCompScreen *info = (MetaCompScreen*) data;
   GList *l;
 
   for (l = info->windows; l; l = l->next)
     meta_window_actor_post_paint (l->data);
-
-  return TRUE;
 }
 
 static void
@@ -611,9 +608,10 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
 
   info->stage = clutter_stage_new ();
 
-  clutter_threads_add_repaint_func_full (CLUTTER_REPAINT_FLAGS_POST_PAINT,
-                                         after_stage_paint,
-                                         info, NULL);
+  clutter_stage_set_paint_callback (CLUTTER_STAGE (info->stage),
+                                    after_stage_paint,
+                                    info,
+                                    NULL);
 
   clutter_stage_set_sync_delay (CLUTTER_STAGE (info->stage), META_SYNC_DELAY);
 
@@ -641,6 +639,9 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
     XISetMask (mask.mask, XI_FocusIn);
     XISetMask (mask.mask, XI_FocusOut);
     XISetMask (mask.mask, XI_Motion);
+    XIClearMask (mask.mask, XI_TouchBegin);
+    XIClearMask (mask.mask, XI_TouchEnd);
+    XIClearMask (mask.mask, XI_TouchUpdate);
     XISelectEvents (xdisplay, xwin, &mask, 1);
 
     event_mask = ExposureMask | PropertyChangeMask | StructureNotifyMask;
@@ -652,9 +653,11 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
 
   info->window_group = meta_window_group_new (screen);
   info->top_window_group = meta_window_group_new (screen);
+  info->overlay_group = clutter_actor_new ();
 
   clutter_actor_add_child (info->stage, info->window_group);
   clutter_actor_add_child (info->stage, info->top_window_group);
+  clutter_actor_add_child (info->stage, info->overlay_group);
 
   info->plugin_mgr = meta_plugin_manager_new (screen);
 
@@ -685,6 +688,8 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
       info->pending_input_region = None;
     }
 
+  clutter_actor_show (info->overlay_group);
+
   /* Map overlay window before redirecting windows offscreen so we catch their
    * contents until we show the stage.
    */
@@ -1565,8 +1570,10 @@ void
 meta_enable_unredirect_for_screen (MetaScreen *screen)
 {
   MetaCompScreen *info = meta_screen_get_compositor_data (screen);
-  if (info != NULL)
-   info->disable_unredirect_count = MAX(0, info->disable_unredirect_count - 1);
+  if (info != NULL && info->disable_unredirect_count == 0)
+    g_warning ("Called enable_unredirect_for_screen while unredirection is enabled.");
+  if (info != NULL && info->disable_unredirect_count > 0)
+   info->disable_unredirect_count = info->disable_unredirect_count - 1;
 }
 
 #define FLASH_TIME_MS 50

src/compositor/meta-background.c

@@ -891,7 +891,7 @@ meta_background_load_gradient (MetaBackground             *self,
   pixels[7] = second_color->alpha;
 
   texture = cogl_texture_new_from_data (width, height,
-                                        COGL_TEXTURE_NO_SLICING,
+                                        COGL_TEXTURE_NONE,
                                         COGL_PIXEL_FORMAT_RGBA_8888,
                                         COGL_PIXEL_FORMAT_ANY,
                                         4,
@@ -1031,7 +1031,6 @@ meta_background_load_file_finish (MetaBackground  *self,
                                   GAsyncResult    *result,
                                   GError         **error)
 {
-  static CoglUserDataKey key;
   GTask *task;
   LoadFileTaskData *task_data;
   CoglTexture *texture;
@@ -1077,12 +1076,6 @@ meta_background_load_file_finish (MetaBackground  *self,
       goto out;
     }
 
-  cogl_object_set_user_data (COGL_OBJECT (texture),
-                             &key,
-                             g_object_ref (pixbuf),
-                             (CoglUserDataDestroyCallback)
-                             g_object_unref);
-
   ensure_pipeline (self);
   unset_texture (self);
   set_style (self, task_data->style);

src/compositor/meta-window-actor.c

@@ -1993,6 +1993,73 @@ meta_window_actor_sync_visibility (MetaWindowActor *self)
     }
 }
 
+#define TAU (2*M_PI)
+
+static void
+install_corners (MetaWindow       *window,
+                 MetaFrameBorders *borders,
+                 cairo_t          *cr)
+{
+  float top_left, top_right, bottom_left, bottom_right;
+  int x, y;
+  MetaRectangle outer;
+
+  meta_frame_get_corner_radiuses (window->frame,
+                                  &top_left,
+                                  &top_right,
+                                  &bottom_left,
+                                  &bottom_right);
+
+  meta_window_get_outer_rect (window, &outer);
+
+  /* top left */
+  x = borders->invisible.left;
+  y = borders->invisible.top;
+
+  cairo_arc (cr,
+             x + top_left,
+             y + top_left,
+             top_left,
+             2 * TAU / 4,
+             3 * TAU / 4);
+
+  /* top right */
+  x = borders->invisible.left + outer.width - top_right;
+  y = borders->invisible.top;
+
+  cairo_arc (cr,
+             x,
+             y + top_right,
+             top_right,
+             3 * TAU / 4,
+             4 * TAU / 4);
+
+  /* bottom right */
+  x = borders->invisible.left + outer.width - bottom_right;
+  y = borders->invisible.top + outer.height - bottom_right;
+
+  cairo_arc (cr,
+             x,
+             y,
+             bottom_right,
+             0 * TAU / 4,
+             1 * TAU / 4);
+
+  /* bottom left */
+  x = borders->invisible.left;
+  y = borders->invisible.top + outer.height - bottom_left;
+
+  cairo_arc (cr,
+             x + bottom_left,
+             y,
+             bottom_left,
+             1 * TAU / 4,
+             2 * TAU / 4);
+
+  cairo_set_source_rgba (cr, 1, 1, 1, 1);
+  cairo_fill (cr);
+}
+
 static cairo_region_t *
 scan_visible_region (guchar         *mask_data,
                      int             stride,
@@ -2032,6 +2099,7 @@ scan_visible_region (guchar         *mask_data,
 
 static void
 build_and_scan_frame_mask (MetaWindowActor       *self,
+                           MetaFrameBorders      *borders,
                            cairo_rectangle_int_t *client_area,
                            cairo_region_t        *shape_region)
 {
@@ -2077,7 +2145,7 @@ build_and_scan_frame_mask (MetaWindowActor       *self,
       gdk_cairo_region (cr, frame_paint_region);
       cairo_clip (cr);
 
-      meta_frame_get_mask (priv->window->frame, cr);
+      install_corners (priv->window, borders, cr);
 
       cairo_surface_flush (surface);
       scanned_region = scan_visible_region (mask_data, stride, frame_paint_region);
@@ -2243,7 +2311,7 @@ check_needs_reshape (MetaWindowActor *self)
        * and scans the mask looking for all opaque pixels,
        * adding it to region.
        */
-      build_and_scan_frame_mask (self, &client_area, region);
+      build_and_scan_frame_mask (self, &borders, &client_area, region);
     }
 
   priv->shape_region = region;

src/compositor/meta-window-group.c

@@ -250,11 +250,30 @@ meta_window_group_paint (ClutterActor *actor)
   g_list_free (children);
 }
 
+/* Adapted from clutter_actor_update_default_paint_volume() */
 static gboolean
-meta_window_group_get_paint_volume (ClutterActor       *actor,
+meta_window_group_get_paint_volume (ClutterActor       *self,
                                     ClutterPaintVolume *volume)
 {
-  return clutter_paint_volume_set_from_allocation (volume, actor);
+  ClutterActorIter iter;
+  ClutterActor *child;
+
+  clutter_actor_iter_init (&iter, self);
+  while (clutter_actor_iter_next (&iter, &child))
+    {
+      const ClutterPaintVolume *child_volume;
+
+      if (!CLUTTER_ACTOR_IS_MAPPED (child))
+        continue;
+
+      child_volume = clutter_actor_get_transformed_paint_volume (child, self);
+      if (child_volume == NULL)
+        return FALSE;
+
+      clutter_paint_volume_union (volume, child_volume);
+    }
+
+  return TRUE;
 }
 
 static void

src/core/display-private.h

@@ -103,17 +103,19 @@ struct _MetaDisplay
 #include <meta/atomnames.h>
 #undef item
 
-  /* The window and serial of the most recent FocusIn event. */
-  Window server_focus_window;
-  gulong server_focus_serial;
-
-  /* Our best guess as to the "currently" focused window (that is, the
-   * window that we expect will be focused at the point when the X
-   * server processes our next request), and the serial of the request
-   * or event that caused this.
+  /* This is the actual window from focus events,
+   * not the one we last set
    */
   MetaWindow *focus_window;
-  gulong focus_serial;
+
+  /* window we are expecting a FocusIn event for or the current focus
+   * window if we are not expecting any FocusIn/FocusOut events; not
+   * perfect because applications can call XSetInputFocus directly.
+   * (It could also be messed up if a timestamp later than current
+   * time is sent to meta_display_set_input_focus_window, though that
+   * would be a programming error).  See bug 154598 for more info.
+   */
+  MetaWindow *expected_focus_window;
 
   /* last timestamp passed to XSetInputFocus */
   guint32 last_focus_time;
@@ -468,9 +470,4 @@ gboolean meta_display_process_barrier_event (MetaDisplay    *display,
                                              XIBarrierEvent *event);
 #endif /* HAVE_XI23 */
 
-void meta_display_set_input_focus_xwindow (MetaDisplay *display,
-                                           MetaScreen  *screen,
-                                           Window       window,
-                                           guint32      timestamp);
-
 #endif

src/core/display.c

@@ -539,9 +539,7 @@ meta_display_open (void)
   the_display->autoraise_timeout_id = 0;
   the_display->autoraise_window = NULL;
   the_display->focus_window = NULL;
-  the_display->focus_serial = 0;
-  the_display->server_focus_window = None;
-  the_display->server_focus_serial = 0;
+  the_display->expected_focus_window = NULL;
   the_display->grab_old_window_stacking = NULL;
 
   the_display->mouse_mode = TRUE; /* Only relevant for mouse or sloppy focus */
@@ -1654,12 +1652,12 @@ meta_display_mouse_mode_focus (MetaDisplay *display,
        * alternative mechanism works great.
        */
       if (meta_prefs_get_focus_mode() == G_DESKTOP_FOCUS_MODE_MOUSE &&
-          display->focus_window != NULL)
+          display->expected_focus_window != NULL)
         {
           meta_topic (META_DEBUG_FOCUS,
                       "Unsetting focus from %s due to mouse entering "
                       "the DESKTOP window\n",
-                      display->focus_window->desc);
+                      display->expected_focus_window->desc);
           meta_display_focus_the_no_focus_window (display,
                                                   window->screen,
                                                   timestamp);
@@ -1873,219 +1871,6 @@ get_input_event (MetaDisplay *display,
   return NULL;
 }
 
-static void
-update_focus_window (MetaDisplay *display,
-                     MetaWindow  *window,
-                     gulong       serial)
-{
-  display->focus_serial = serial;
-
-  if (window == display->focus_window)
-    return;
-
-  if (display->focus_window)
-    {
-      MetaWindow *previous;
-
-      meta_topic (META_DEBUG_FOCUS,
-                  "%s is now the previous focus window due to being focused out or unmapped\n",
-                  display->focus_window->desc);
-
-      /* Make sure that signals handlers invoked by
-       * meta_window_set_focused_internal() don't see
-       * display->focus_window->has_focus == FALSE
-       */
-      previous = display->focus_window;
-      display->focus_window = NULL;
-
-      meta_window_set_focused_internal (previous, FALSE);
-    }
-
-  display->focus_window = window;
-
-  if (display->focus_window)
-    {
-      meta_topic (META_DEBUG_FOCUS, "* Focus --> %s with serial %lu\n",
-                  display->focus_window->desc, serial);
-      meta_window_set_focused_internal (display->focus_window, TRUE);
-    }
-  else
-    meta_topic (META_DEBUG_FOCUS, "* Focus --> NULL with serial %lu\n", serial);
-
-  g_object_notify (G_OBJECT (display), "focus-window");
-  meta_display_update_active_window_hint (display);
-}
-
-static gboolean
-timestamp_too_old (MetaDisplay *display,
-                   guint32     *timestamp)
-{
-  /* FIXME: If Soeren's suggestion in bug 151984 is implemented, it will allow
-   * us to sanity check the timestamp here and ensure it doesn't correspond to
-   * a future time (though we would want to rename to
-   * timestamp_too_old_or_in_future).
-   */
-
-  if (*timestamp == CurrentTime)
-    {
-      *timestamp = meta_display_get_current_time_roundtrip (display);
-      return FALSE;
-    }
-  else if (XSERVER_TIME_IS_BEFORE (*timestamp, display->last_focus_time))
-    {
-      if (XSERVER_TIME_IS_BEFORE (*timestamp, display->last_user_time))
-        return TRUE;
-      else
-        {
-          *timestamp = display->last_focus_time;
-          return FALSE;
-        }
-    }
-
-  return FALSE;
-}
-
-static void
-request_xserver_input_focus_change (MetaDisplay *display,
-                                    MetaScreen  *screen,
-                                    Window       xwindow,
-                                    guint32      timestamp)
-{
-  MetaWindow *meta_window;
-
-  if (timestamp_too_old (display, &timestamp))
-    return;
-
-  meta_window = meta_display_lookup_x_window (display, xwindow);
-
-  meta_error_trap_push (display);
-  update_focus_window (display,
-                       meta_window,
-                       XNextRequest (display->xdisplay));
-
-  XSetInputFocus (display->xdisplay,
-                  xwindow,
-                  RevertToPointerRoot,
-                  timestamp);
-  meta_error_trap_pop (display);
-
-  display->last_focus_time = timestamp;
-  display->active_screen = screen;
-
-  if (meta_window == NULL || meta_window != display->autoraise_window)
-    meta_display_remove_autoraise_callback (display);
-}
-
-static void
-handle_window_focus_event (MetaDisplay  *display,
-                           MetaWindow   *window,
-                           XIEnterEvent *event,
-                           unsigned long serial)
-{
-  MetaWindow *focus_window;
-#ifdef WITH_VERBOSE_MODE
-  const char *window_type;
-
-  /* Note the event can be on either the window or the frame,
-   * we focus the frame for shaded windows
-   */
-  if (window)
-    {
-      if (event->event == window->xwindow)
-        window_type = "client window";
-      else if (window->frame && event->event == window->frame->xwindow)
-        window_type = "frame window";
-      else
-        window_type = "unknown client window";
-    }
-  else if (meta_display_xwindow_is_a_no_focus_window (display, event->event))
-    window_type = "no_focus_window";
-  else if (meta_display_screen_for_root (display, event->event))
-    window_type = "root window";
-  else
-    window_type = "unknown window";
-
-  meta_topic (META_DEBUG_FOCUS,
-              "Focus %s event received on %s 0x%lx (%s) "
-              "mode %s detail %s serial %lu\n",
-              event->evtype == XI_FocusIn ? "in" :
-              event->evtype == XI_FocusOut ? "out" :
-              "???",
-              window ? window->desc : "",
-              event->event, window_type,
-              meta_event_mode_to_string (event->mode),
-              meta_event_detail_to_string (event->mode),
-              event->serial);
-#endif
-
-  /* FIXME our pointer tracking is broken; see how
-   * gtk+/gdk/x11/gdkevents-x11.c or XFree86/xc/programs/xterm/misc.c
-   * for how to handle it the correct way.  In brief you need to track
-   * pointer focus and regular focus, and handle EnterNotify in
-   * PointerRoot mode with no window manager.  However as noted above,
-   * accurate focus tracking will break things because we want to keep
-   * windows "focused" when using keybindings on them, and also we
-   * sometimes "focus" a window by focusing its frame or
-   * no_focus_window; so this all needs rethinking massively.
-   *
-   * My suggestion is to change it so that we clearly separate
-   * actual keyboard focus tracking using the xterm algorithm,
-   * and mutter's "pretend" focus window, and go through all
-   * the code and decide which one should be used in each place;
-   * a hard bit is deciding on a policy for that.
-   *
-   * http://bugzilla.gnome.org/show_bug.cgi?id=90382
-   */
-
-  /* We ignore grabs, though this is questionable. It may be better to
-   * increase the intelligence of the focus window tracking.
-   *
-   * The problem is that keybindings for windows are done with
-   * XGrabKey, which means focus_window disappears and the front of
-   * the MRU list gets confused from what the user expects once a
-   * keybinding is used.
-   */
-
-  if (event->mode == XINotifyGrab ||
-      event->mode == XINotifyUngrab ||
-      /* From WindowMaker, ignore all funky pointer root events */
-      event->detail > XINotifyNonlinearVirtual)
-    {
-      meta_topic (META_DEBUG_FOCUS,
-                  "Ignoring focus event generated by a grab or other weirdness\n");
-      return;
-    }
-
-  if (event->evtype == XI_FocusIn)
-    {
-      display->server_focus_window = event->event;
-      display->server_focus_serial = serial;
-      focus_window = window;
-    }
-  else if (event->evtype == XI_FocusOut)
-    {
-      if (event->detail == XINotifyInferior)
-        {
-          /* This event means the client moved focus to a subwindow */
-          meta_topic (META_DEBUG_FOCUS,
-                      "Ignoring focus out with NotifyInferior\n");
-          return;
-        }
-
-      display->server_focus_window = None;
-      display->server_focus_serial = serial;
-      focus_window = NULL;
-    }
-  else
-    g_return_if_reached ();
-
-  if (display->server_focus_serial >= display->focus_serial)
-    {
-      update_focus_window (display, focus_window,
-                           display->server_focus_serial);
-    }
-}
-
 /**
  * event_callback:
  * @event: The event that just happened
@@ -2128,18 +1913,7 @@ event_callback (XEvent   *event,
   filter_out_event = FALSE;
   display->current_time = event_get_time (display, event);
   display->monitor_cache_invalidated = TRUE;
-
-  if (event->xany.serial > display->focus_serial &&
-      display->focus_window &&
-      display->focus_window->xwindow != display->server_focus_window)
-    {
-      meta_topic (META_DEBUG_FOCUS, "Earlier attempt to focus %s failed\n",
-                  display->focus_window->desc);
-      update_focus_window (display,
-                           meta_display_lookup_x_window (display, display->server_focus_window),
-                           display->server_focus_serial);
-    }
-
+  
   modified = event_get_modified_window (display, event);
 
   input_event = get_input_event (display, event);
@@ -2596,19 +2370,40 @@ event_callback (XEvent   *event,
           break;
         case XI_FocusIn:
         case XI_FocusOut:
-          /* libXi does not properly copy the serial to the XIEnterEvent, so pull it
-           * from the parent XAnyEvent.
-           * See: https://bugs.freedesktop.org/show_bug.cgi?id=64687
-           */
-          handle_window_focus_event (display, window, enter_event, event->xany.serial);
-          if (!window)
+          if (window)
+            {
+              meta_window_notify_focus (window, enter_event);
+            }
+          else if (meta_display_xwindow_is_a_no_focus_window (display,
+                                                              enter_event->event))
+            {
+              meta_topic (META_DEBUG_FOCUS,
+                          "Focus %s event received on no_focus_window 0x%lx "
+                          "mode %s detail %s\n",
+                          enter_event->evtype == XI_FocusIn ? "in" :
+                          enter_event->evtype == XI_FocusOut ? "out" :
+                          "???",
+                          enter_event->event,
+                          meta_event_mode_to_string (enter_event->mode),
+                          meta_event_detail_to_string (enter_event->detail));
+            }
+          else
             {
-              /* Check if the window is a root window. */
               MetaScreen *screen =
                 meta_display_screen_for_root(display,
                                              enter_event->event);
               if (screen == NULL)
                 break;
+
+              meta_topic (META_DEBUG_FOCUS,
+                          "Focus %s event received on root window 0x%lx "
+                          "mode %s detail %s\n",
+                          enter_event->evtype == XI_FocusIn ? "in" :
+                          enter_event->evtype == XI_FocusOut ? "out" :
+                          "???",
+                          enter_event->event,
+                          meta_event_mode_to_string (enter_event->mode),
+                          meta_event_detail_to_string (enter_event->detail));
           
               if (enter_event->evtype == XI_FocusIn &&
                   enter_event->mode == XINotifyDetailNone)
@@ -2746,6 +2541,13 @@ event_callback (XEvent   *event,
                                   window->unmaps_pending);
                     }
                 }
+
+              /* Unfocus on UnmapNotify, do this after the possible
+               * window_free above so that window_free can see if window->has_focus
+               * and move focus to another window
+               */
+              if (window)
+                meta_window_lost_focus (window);
             }
           break;
         case MapNotify:
@@ -3755,6 +3557,12 @@ meta_spew_event (MetaDisplay *display,
   if (event->type == (display->damage_event_base + XDamageNotify))
     return;
 
+  if (event->type == (display->xsync_event_base + XSyncAlarmNotify))
+    return;
+
+  if (event->type == PropertyNotify && event->xproperty.atom == display->atom__NET_WM_USER_TIME)
+    return;
+
   input_event = get_input_event (display, event);
 
   if (input_event)
@@ -5779,74 +5587,98 @@ sanity_check_timestamps (MetaDisplay *display,
     }
 }
 
+static gboolean
+timestamp_too_old (MetaDisplay *display,
+                   MetaWindow  *window,
+                   guint32     *timestamp)
+{
+  /* FIXME: If Soeren's suggestion in bug 151984 is implemented, it will allow
+   * us to sanity check the timestamp here and ensure it doesn't correspond to
+   * a future time (though we would want to rename to 
+   * timestamp_too_old_or_in_future).
+   */
+
+  if (*timestamp == CurrentTime)
+    {
+      meta_warning ("Got a request to focus %s with a timestamp of 0.  This "
+                    "shouldn't happen!\n",
+                    window ? window->desc : "the no_focus_window");
+      *timestamp = meta_display_get_current_time_roundtrip (display);
+      return FALSE;
+    }
+  else if (XSERVER_TIME_IS_BEFORE (*timestamp, display->last_focus_time))
+    {
+      if (XSERVER_TIME_IS_BEFORE (*timestamp, display->last_user_time))
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Ignoring focus request for %s since %u "
+                      "is less than %u and %u.\n",
+                      window ? window->desc : "the no_focus_window",
+                      *timestamp,
+                      display->last_user_time,
+                      display->last_focus_time);
+          return TRUE;
+        }
+      else
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Received focus request for %s which is newer than most "
+                      "recent user_time, but less recent than "
+                      "last_focus_time (%u < %u < %u); adjusting "
+                      "accordingly.  (See bug 167358)\n",
+                      window ? window->desc : "the no_focus_window",
+                      display->last_user_time,
+                      *timestamp,
+                      display->last_focus_time);
+          *timestamp = display->last_focus_time;
+          return FALSE;
+        }
+    }
+
+  return FALSE;
+}
+
 void
 meta_display_set_input_focus_window (MetaDisplay *display, 
                                      MetaWindow  *window,
                                      gboolean     focus_frame,
                                      guint32      timestamp)
 {
-  request_xserver_input_focus_change (display,
-                                      window->screen,
-                                      focus_frame ? window->frame->xwindow : window->xwindow,
-                                      timestamp);
-}
-
-void
-meta_display_request_take_focus (MetaDisplay *display,
-                                 MetaWindow  *window,
-                                 guint32      timestamp)
-{
-  if (timestamp_too_old (display, &timestamp))
+  if (timestamp_too_old (display, window, &timestamp))
     return;
 
-  meta_topic (META_DEBUG_FOCUS, "WM_TAKE_FOCUS(%s, %u)\n",
-              window->desc, timestamp);
+  meta_error_trap_push (display);
+  XSetInputFocus (display->xdisplay,
+                  focus_frame ? window->frame->xwindow : window->xwindow,
+                  RevertToPointerRoot,
+                  timestamp);
+  meta_error_trap_pop (display);
 
-  if (window != display->focus_window)
-    {
-      /* The "Globally Active Input" window case, where the window
-       * doesn't want us to call XSetInputFocus on it, but does
-       * want us to send a WM_TAKE_FOCUS.
-       *
-       * We can't just set display->focus_window to @window, since we
-       * we don't know when (or even if) the window will actually take
-       * focus, so we could end up being wrong for arbitrarily long.
-       * But we also can't leave it set to the current window, or else
-       * bug #597352 would come back. So we focus the no_focus_window
-       * now (and set display->focus_window to that), send the
-       * WM_TAKE_FOCUS, and then just forget about @window
-       * until/unless we get a FocusIn.
-       */
-      meta_display_focus_the_no_focus_window (display,
-                                              window->screen,
-                                              timestamp);
-    }
-  meta_window_send_icccm_message (window,
-                                  display->atom_WM_TAKE_FOCUS,
-                                  timestamp);
+  display->expected_focus_window = window;
+  display->last_focus_time = timestamp;
+  display->active_screen = window->screen;
+
+  if (window != display->autoraise_window)
+    meta_display_remove_autoraise_callback (window->display);
 }
 
 void
-meta_display_set_input_focus_xwindow (MetaDisplay *display,
-                                      MetaScreen  *screen,
-                                      Window       window,
-                                      guint32      timestamp)
-{
-  request_xserver_input_focus_change (display,
-                                      screen,
-                                      window,
-                                      timestamp);
-}
-
-void
-meta_display_focus_the_no_focus_window (MetaDisplay *display,
+meta_display_focus_the_no_focus_window (MetaDisplay *display, 
                                         MetaScreen  *screen,
                                         guint32      timestamp)
 {
-  request_xserver_input_focus_change (display,
-                                      screen,
-                                      screen->no_focus_window,
-                                      timestamp);
+  if (timestamp_too_old (display, NULL, &timestamp))
+    return;
+
+  XSetInputFocus (display->xdisplay,
+                  screen->no_focus_window,
+                  RevertToPointerRoot,
+                  timestamp);
+  display->expected_focus_window = NULL;
+  display->last_focus_time = timestamp;
+  display->active_screen = screen;
+
+  meta_display_remove_autoraise_callback (display);
 }
 
 void
@@ -5966,9 +5798,11 @@ meta_display_has_shape (MetaDisplay *display)
  * meta_display_get_focus_window:
  * @display: a #MetaDisplay
  *
- * Get our best guess as to the "currently" focused window (that is,
- * the window that we expect will be focused at the point when the X
- * server processes our next request).
+ * Get the window that, according to events received from X server,
+ * currently has the input focus. We may have already sent a request
+ * to the X server to move the focus window elsewhere. (The
+ * expected_focus_window records where we've last set the input
+ * focus.)
  *
  * Return Value: (transfer none): The current focus window
  */

src/core/frame.c

@@ -332,6 +332,19 @@ meta_frame_calc_borders (MetaFrame        *frame,
                                borders);
 }
 
+void
+meta_frame_get_corner_radiuses (MetaFrame *frame,
+                                float     *top_left,
+                                float     *top_right,
+                                float     *bottom_left,
+                                float     *bottom_right)
+{
+  meta_ui_get_corner_radiuses (frame->window->screen->ui,
+                               frame->xwindow,
+                               top_left, top_right,
+                               bottom_left, bottom_right);
+}
+
 gboolean
 meta_frame_sync_to_window (MetaFrame *frame,
                            int        resize_gravity,
@@ -387,14 +400,6 @@ meta_frame_get_frame_bounds (MetaFrame *frame)
                                    frame->rect.height);
 }
 
-void
-meta_frame_get_mask (MetaFrame                    *frame,
-                     cairo_t                      *cr)
-{
-  meta_ui_get_frame_mask (frame->window->screen->ui, frame->xwindow,
-                          frame->rect.width, frame->rect.height, cr);
-}
-
 void
 meta_frame_queue_draw (MetaFrame *frame)
 {

src/core/frame.h

@@ -63,6 +63,12 @@ Window         meta_frame_get_xwindow (MetaFrame *frame);
 void meta_frame_calc_borders      (MetaFrame        *frame,
                                    MetaFrameBorders *borders);
 
+void meta_frame_get_corner_radiuses (MetaFrame *frame,
+                                     float     *top_left,
+                                     float     *top_right,
+                                     float     *bottom_left,
+                                     float     *bottom_right);
+
 gboolean meta_frame_sync_to_window (MetaFrame         *frame,
                                     int                gravity,
                                     gboolean           need_move,
@@ -70,9 +76,6 @@ gboolean meta_frame_sync_to_window (MetaFrame         *frame,
 
 cairo_region_t *meta_frame_get_frame_bounds (MetaFrame *frame);
 
-void meta_frame_get_mask (MetaFrame *frame,
-                          cairo_t   *cr);
-
 void meta_frame_set_screen_cursor (MetaFrame	*frame,
 				   MetaCursor	cursor);
 

src/core/keybindings.c

@@ -1480,7 +1480,7 @@ grab_keyboard (MetaDisplay *display,
                               timestamp,
                               None,
                               grab_mode, grab_mode,
-                              True, /* owner_events */
+                              False, /* owner_events */
                               &mask);
 
   if (grab_status != Success)

src/core/screen-private.h

@@ -187,6 +187,9 @@ MetaWindow*   meta_screen_get_mouse_window     (MetaScreen                 *scre
                                                 MetaWindow                 *not_this_one);
 
 const MetaMonitorInfo* meta_screen_get_current_monitor_info   (MetaScreen    *screen);
+const MetaMonitorInfo* meta_screen_get_current_monitor_info_for_pos   (MetaScreen    *screen,
+                                                                       int x,
+                                                                       int y);
 const MetaMonitorInfo* meta_screen_get_monitor_for_rect   (MetaScreen    *screen,
                                                            MetaRectangle *rect);
 const MetaMonitorInfo* meta_screen_get_monitor_for_window (MetaScreen    *screen,

src/core/screen.c

@@ -2216,6 +2216,65 @@ meta_screen_get_current_monitor_info (MetaScreen *screen)
     return &screen->monitor_infos[monitor_index];
 }
 
+const MetaMonitorInfo*
+meta_screen_get_current_monitor_info_for_pos (MetaScreen *screen,
+                                              int x,
+                                              int y)
+{
+    int monitor_index;
+    monitor_index = meta_screen_get_current_monitor_for_pos (screen, x, y);
+    return &screen->monitor_infos[monitor_index];
+}
+
+
+/**
+ * meta_screen_get_current_monitor_for_pos:
+ * @screen: a #MetaScreen
+ * @x: The x coordinate
+ * @y: The y coordinate
+ *
+ * Gets the index of the monitor that contains the passed coordinates.
+ *
+ * Return value: a monitor index
+ */
+int
+meta_screen_get_current_monitor_for_pos (MetaScreen *screen,
+                                         int x,
+                                         int y)
+{
+  if (screen->n_monitor_infos == 1)
+    return 0;
+  else if (screen->display->monitor_cache_invalidated)
+    {
+      int i;
+      MetaRectangle pointer_position;
+      pointer_position.x = x;
+      pointer_position.y = y;
+      pointer_position.width = pointer_position.height = 1;
+
+      screen->display->monitor_cache_invalidated = FALSE;
+      screen->last_monitor_index = 0;
+
+      for (i = 0; i < screen->n_monitor_infos; i++)
+        {
+          if (meta_rectangle_contains_rect (&screen->monitor_infos[i].rect,
+                                            &pointer_position))
+            {
+              screen->last_monitor_index = i;
+              break;
+            }
+        }
+
+      meta_topic (META_DEBUG_XINERAMA,
+                  "Rechecked current monitor, now %d\n",
+                  screen->last_monitor_index);
+
+    }
+
+    return screen->last_monitor_index;
+}
+
+
 /**
  * meta_screen_get_current_monitor:
  * @screen: a #MetaScreen
@@ -2241,11 +2300,7 @@ meta_screen_get_current_monitor (MetaScreen *screen)
       XIButtonState buttons;
       XIModifierState mods;
       XIGroupState group;
-      int i;
-      MetaRectangle pointer_position;
 
-      screen->display->monitor_cache_invalidated = FALSE;
-      
       XIQueryPointer (screen->display->xdisplay,
                       META_VIRTUAL_CORE_POINTER_ID,
                       screen->xroot,
@@ -2260,24 +2315,7 @@ meta_screen_get_current_monitor (MetaScreen *screen)
                       &group);
       free (buttons.mask);
 
-      pointer_position.x = root_x_return;
-      pointer_position.y = root_y_return;
-      pointer_position.width = pointer_position.height = 1;
-
-      screen->last_monitor_index = 0;
-      for (i = 0; i < screen->n_monitor_infos; i++)
-        {
-          if (meta_rectangle_contains_rect (&screen->monitor_infos[i].rect,
-                                            &pointer_position))
-            {
-              screen->last_monitor_index = i;
-              break;
-            }
-        }
-      
-      meta_topic (META_DEBUG_XINERAMA,
-                  "Rechecked current monitor, now %d\n",
-                  screen->last_monitor_index);
+      meta_screen_get_current_monitor_for_pos (screen, root_x_return, root_y_return);
     }
 
   return screen->last_monitor_index;
@@ -3001,7 +3039,7 @@ meta_screen_resize (MetaScreen *screen,
 
   /* Fix up monitor for all windows on this screen */
   windows = meta_display_list_windows (screen->display,
-                                       META_LIST_DEFAULT);
+                                       META_LIST_INCLUDE_OVERRIDE_REDIRECT);
   for (tmp = windows; tmp != NULL; tmp = tmp->next)
     {
       MetaWindow *window = tmp->data;

src/core/stack.c

@@ -278,7 +278,7 @@ static gboolean
 is_focused_foreach (MetaWindow *window,
                     void       *data)
 {
-  if (window->has_focus)
+  if (window == window->display->expected_focus_window)
     {
       *((gboolean*) data) = TRUE;
       return FALSE;
@@ -335,11 +335,11 @@ get_standalone_layer (MetaWindow *window)
         layer = META_LAYER_BOTTOM;
       else if (window->fullscreen &&
                (focused_transient ||
-                window == window->display->focus_window ||
-                window->display->focus_window == NULL ||
-                (window->display->focus_window != NULL &&
+                window == window->display->expected_focus_window ||
+                window->display->expected_focus_window == NULL ||
+                (window->display->expected_focus_window != NULL &&
                  windows_on_different_monitor (window,
-                                               window->display->focus_window))))
+                                               window->display->expected_focus_window))))
         layer = META_LAYER_FULLSCREEN;
       else if (window->wm_state_above && !META_WINDOW_MAXIMIZED (window))
         layer = META_LAYER_TOP;

src/core/window-private.h

@@ -277,7 +277,7 @@ struct _MetaWindow
   /* EWHH demands attention flag */
   guint wm_state_demands_attention : 1;
   
-  /* TRUE iff window == window->display->focus_window */
+  /* this flag tracks receipt of focus_in focus_out */
   guint has_focus : 1;
 
   /* Have we placed this window? */
@@ -590,8 +590,9 @@ gboolean meta_window_property_notify   (MetaWindow *window,
                                         XEvent     *event);
 gboolean meta_window_client_message    (MetaWindow *window,
                                         XEvent     *event);
-void     meta_window_set_focused_internal (MetaWindow *window,
-                                           gboolean    focused);
+gboolean meta_window_notify_focus      (MetaWindow *window,
+                                        XIEnterEvent *event);
+void     meta_window_lost_focus        (MetaWindow *window);
 
 void     meta_window_set_current_workspace_hint (MetaWindow *window);
 

src/core/window.c

@@ -145,6 +145,8 @@ static void meta_window_move_between_rects (MetaWindow          *window,
 static void unmaximize_window_before_freeing (MetaWindow        *window);
 static void unminimize_window_and_all_transient_parents (MetaWindow *window);
 
+static void meta_window_update_monitor (MetaWindow *window);
+
 /* Idle handlers for the three queues (run with meta_later_add()). The
  * "data" parameter in each case will be a GINT_TO_POINTER of the
  * index into the queue arrays to use.
@@ -1754,6 +1756,16 @@ meta_window_unmanage (MetaWindow  *window,
                                            window,
                                            timestamp);
     }
+  else if (window->display->expected_focus_window == window)
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "Focusing default window since expected focus window freed %s\n",
+                  window->desc);
+      window->display->expected_focus_window = NULL;
+      meta_workspace_focus_default_window (window->screen->active_workspace,
+                                           window,
+                                           timestamp);
+    }
   else
     {
       meta_topic (META_DEBUG_FOCUS,
@@ -1761,8 +1773,6 @@ meta_window_unmanage (MetaWindow  *window,
                   window->desc);
     }
 
-  g_assert (window->display->focus_window != window);
-
   if (window->struts)
     {
       meta_free_gslist_and_elements (window->struts);
@@ -1785,6 +1795,12 @@ meta_window_unmanage (MetaWindow  *window,
 
   g_assert (window->display->grab_window != window);
 
+  if (window->display->focus_window == window)
+    {
+      window->display->focus_window = NULL;
+      g_object_notify (G_OBJECT (window->display), "focus-window");
+    }
+
   if (window->maximized_horizontally || window->maximized_vertically)
     unmaximize_window_before_freeing (window);
 
@@ -3318,7 +3334,14 @@ meta_window_hide (MetaWindow *window)
       invalidate_work_areas (window);
     }
 
-  if (window->has_focus)
+  /* The check on expected_focus_window is a temporary workaround for
+   *  https://bugzilla.gnome.org/show_bug.cgi?id=597352
+   * We may have already switched away from this window but not yet
+   * gotten FocusIn/FocusOut events. A more complete comprehensive
+   * fix for these type of issues is described in the bug.
+   */
+  if (window->has_focus &&
+      window == window->display->expected_focus_window)
     {
       MetaWindow *not_this_one = NULL;
       MetaWorkspace *my_workspace = meta_window_get_workspace (window);
@@ -4767,6 +4790,12 @@ meta_window_update_for_monitors_changed (MetaWindow *window)
   if (window->type == META_WINDOW_DESKTOP)
     return;
 
+  if (window->override_redirect)
+    {
+      meta_window_update_monitor (window);
+      return;
+    }
+
   old = window->monitor;
 
   /* Start on primary */
@@ -5954,10 +5983,10 @@ meta_window_focus (MetaWindow  *window,
           meta_topic (META_DEBUG_FOCUS,
                       "Sending WM_TAKE_FOCUS to %s since take_focus = true\n",
                       window->desc);
-
-          meta_display_request_take_focus (window->display,
-                                           window,
-                                           timestamp);
+          meta_window_send_icccm_message (window,
+                                          window->display->atom_WM_TAKE_FOCUS,
+                                          timestamp);
+          window->display->expected_focus_window = window;
         }
     }
 
@@ -6497,7 +6526,7 @@ meta_window_configure_request (MetaWindow *window,
   if (event->xconfigurerequest.value_mask & CWStackMode)
     {
       MetaWindow *active_window;
-      active_window = window->display->focus_window;
+      active_window = window->display->expected_focus_window;
       if (meta_prefs_get_disable_workarounds ())
         {
           meta_topic (META_DEBUG_STACK,
@@ -7176,7 +7205,8 @@ meta_window_propagate_focus_appearance (MetaWindow *window,
           parent->attached_focus_window = NULL;
         }
 
-      if (child_focus_state_changed && !parent->has_focus)
+      if (child_focus_state_changed && !parent->has_focus &&
+          parent != window->display->expected_focus_window)
         {
           meta_window_appears_focused_changed (parent);
         }
@@ -7187,85 +7217,23 @@ meta_window_propagate_focus_appearance (MetaWindow *window,
 }
 
 void
-meta_window_set_focused_internal (MetaWindow *window,
-                                  gboolean    focused)
+meta_window_lost_focus (MetaWindow *window)
 {
-  if (focused)
+  if (window == window->display->focus_window)
     {
-      window->has_focus = TRUE;
-      if (window->override_redirect)
-        return;
+      meta_topic (META_DEBUG_FOCUS,
+                  "%s is now the previous focus window due to being focused out or unmapped\n",
+                  window->desc);
 
-      /* Move to the front of the focusing workspace's MRU list.
-       * We should only be "removing" it from the MRU list if it's
-       * not already there.  Note that it's possible that we might
-       * be processing this FocusIn after we've changed to a
-       * different workspace; we should therefore update the MRU
-       * list only if the window is actually on the active
-       * workspace.
-       */
-      if (window->screen->active_workspace &&
-          meta_window_located_on_workspace (window,
-                                            window->screen->active_workspace))
-        {
-          GList* link;
-          link = g_list_find (window->screen->active_workspace->mru_list,
-                              window);
-          g_assert (link);
-
-          window->screen->active_workspace->mru_list =
-            g_list_remove_link (window->screen->active_workspace->mru_list,
-                                link);
-          g_list_free (link);
-
-          window->screen->active_workspace->mru_list =
-            g_list_prepend (window->screen->active_workspace->mru_list,
-                            window);
-        }
-
-      if (window->frame)
-        meta_frame_queue_draw (window->frame);
-
-      meta_error_trap_push (window->display);
-      XInstallColormap (window->display->xdisplay,
-                        window->colormap);
-      meta_error_trap_pop (window->display);
-
-      /* move into FOCUSED_WINDOW layer */
-      meta_window_update_layer (window);
-
-      /* Ungrab click to focus button since the sync grab can interfere
-       * with some things you might do inside the focused window, by
-       * causing the client to get funky enter/leave events.
-       *
-       * The reason we usually have a passive grab on the window is
-       * so that we can intercept clicks and raise the window in
-       * response. For click-to-focus we don't need that since the
-       * focused window is already raised. When raise_on_click is
-       * FALSE we also don't need that since we don't do anything
-       * when the window is clicked.
-       *
-       * There is dicussion in bugs 102209, 115072, and 461577
-       */
-      if (meta_prefs_get_focus_mode () == G_DESKTOP_FOCUS_MODE_CLICK ||
-          !meta_prefs_get_raise_on_click())
-        meta_display_ungrab_focus_window_button (window->display, window);
-
-      g_signal_emit (window, window_signals[FOCUS], 0);
-
-      if (!window->attached_focus_window)
-        meta_window_appears_focused_changed (window);
-
-      meta_window_propagate_focus_appearance (window, TRUE);
-    }
-  else
-    {
-      window->has_focus = FALSE;
-      if (window->override_redirect)
-        return;
+      meta_topic (META_DEBUG_FOCUS,
+                  "* Focus --> NULL (was %s)\n", window->desc);
 
       meta_window_propagate_focus_appearance (window, FALSE);
 
+      window->display->focus_window = NULL;
+      g_object_notify (G_OBJECT (window->display), "focus-window");
+      window->has_focus = FALSE;
+
       if (!window->attached_focus_window)
         meta_window_appears_focused_changed (window);
 
@@ -7284,6 +7252,176 @@ meta_window_set_focused_internal (MetaWindow *window,
     }
 }
 
+gboolean
+meta_window_notify_focus (MetaWindow   *window,
+                          XIEnterEvent *event)
+{
+  /* note the event can be on either the window or the frame,
+   * we focus the frame for shaded windows
+   */
+
+  /* The event can be FocusIn, FocusOut, or UnmapNotify.
+   * On UnmapNotify we have to pretend it's focus out,
+   * because we won't get a focus out if it occurs, apparently.
+   */
+
+  /* We ignore grabs, though this is questionable.
+   * It may be better to increase the intelligence of
+   * the focus window tracking.
+   *
+   * The problem is that keybindings for windows are done with
+   * XGrabKey, which means focus_window disappears and the front of
+   * the MRU list gets confused from what the user expects once a
+   * keybinding is used.
+   */
+  meta_topic (META_DEBUG_FOCUS,
+              "Focus %s event received on %s 0x%lx (%s) "
+              "mode %s detail %s\n",
+              event->evtype == XI_FocusIn ? "in" :
+              event->evtype == XI_FocusOut ? "out" :
+              "???",
+              window->desc, event->event,
+              event->event == window->xwindow ?
+              "client window" :
+              (window->frame && event->event == window->frame->xwindow) ?
+              "frame window" :
+              "unknown window",
+              meta_event_mode_to_string (event->mode),
+              meta_event_detail_to_string (event->detail));
+
+  /* FIXME our pointer tracking is broken; see how
+   * gtk+/gdk/x11/gdkevents-x11.c or XFree86/xc/programs/xterm/misc.c
+   * handle it for the correct way.  In brief you need to track
+   * pointer focus and regular focus, and handle EnterNotify in
+   * PointerRoot mode with no window manager.  However as noted above,
+   * accurate focus tracking will break things because we want to keep
+   * windows "focused" when using keybindings on them, and also we
+   * sometimes "focus" a window by focusing its frame or
+   * no_focus_window; so this all needs rethinking massively.
+   *
+   * My suggestion is to change it so that we clearly separate
+   * actual keyboard focus tracking using the xterm algorithm,
+   * and mutter's "pretend" focus window, and go through all
+   * the code and decide which one should be used in each place;
+   * a hard bit is deciding on a policy for that.
+   *
+   * http://bugzilla.gnome.org/show_bug.cgi?id=90382
+   */
+
+  if ((event->evtype == XI_FocusIn ||
+       event->evtype == XI_FocusOut) &&
+      (event->mode == NotifyGrab ||
+       event->mode == NotifyUngrab ||
+       /* From WindowMaker, ignore all funky pointer root events */
+       event->detail > NotifyNonlinearVirtual))
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "Ignoring focus event generated by a grab or other weirdness\n");
+      return TRUE;
+    }
+
+  if (event->evtype == XI_FocusIn)
+    {
+      if (window->override_redirect)
+        {
+          window->display->focus_window = NULL;
+          g_object_notify (G_OBJECT (window->display), "focus-window");
+          return FALSE;
+        }
+
+      if (window != window->display->focus_window)
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "* Focus --> %s\n", window->desc);
+          window->display->focus_window = window;
+          window->has_focus = TRUE;
+
+          /* Move to the front of the focusing workspace's MRU list.
+           * We should only be "removing" it from the MRU list if it's
+           * not already there.  Note that it's possible that we might
+           * be processing this FocusIn after we've changed to a
+           * different workspace; we should therefore update the MRU
+           * list only if the window is actually on the active
+           * workspace.
+           */
+          if (window->screen->active_workspace &&
+              meta_window_located_on_workspace (window,
+                                                window->screen->active_workspace))
+            {
+              GList* link;
+              link = g_list_find (window->screen->active_workspace->mru_list,
+                                  window);
+              g_assert (link);
+
+              window->screen->active_workspace->mru_list =
+                g_list_remove_link (window->screen->active_workspace->mru_list,
+                                    link);
+              g_list_free (link);
+
+              window->screen->active_workspace->mru_list =
+                g_list_prepend (window->screen->active_workspace->mru_list,
+                                window);
+            }
+
+          if (window->frame)
+            meta_frame_queue_draw (window->frame);
+
+          meta_error_trap_push (window->display);
+          XInstallColormap (window->display->xdisplay,
+                            window->colormap);
+          meta_error_trap_pop (window->display);
+
+          /* move into FOCUSED_WINDOW layer */
+          meta_window_update_layer (window);
+
+          /* Ungrab click to focus button since the sync grab can interfere
+           * with some things you might do inside the focused window, by
+           * causing the client to get funky enter/leave events.
+           *
+           * The reason we usually have a passive grab on the window is
+           * so that we can intercept clicks and raise the window in
+           * response. For click-to-focus we don't need that since the
+           * focused window is already raised. When raise_on_click is
+           * FALSE we also don't need that since we don't do anything
+           * when the window is clicked.
+           *
+           * There is dicussion in bugs 102209, 115072, and 461577
+           */
+          if (meta_prefs_get_focus_mode () == G_DESKTOP_FOCUS_MODE_CLICK ||
+              !meta_prefs_get_raise_on_click())
+            meta_display_ungrab_focus_window_button (window->display, window);
+
+          g_signal_emit (window, window_signals[FOCUS], 0);
+          g_object_notify (G_OBJECT (window->display), "focus-window");
+
+          if (!window->attached_focus_window)
+            meta_window_appears_focused_changed (window);
+
+          meta_window_propagate_focus_appearance (window, TRUE);
+        }
+    }
+  else if (event->evtype == XI_FocusOut)
+    {
+      if (event->detail == NotifyInferior)
+        {
+          /* This event means the client moved focus to a subwindow */
+          meta_topic (META_DEBUG_FOCUS,
+                      "Ignoring focus out on %s with NotifyInferior\n",
+                      window->desc);
+          return TRUE;
+        }
+      else
+        {
+          meta_window_lost_focus (window);
+        }
+    }
+
+  /* Now set _NET_ACTIVE_WINDOW hint */
+  meta_display_update_active_window_hint (window->display);
+
+  return FALSE;
+}
+
 static gboolean
 process_property_notify (MetaWindow     *window,
                          XPropertyEvent *event)
@@ -8916,7 +9054,7 @@ update_move (MetaWindow  *window,
        * refers to the monitor which contains the largest part of the window,
        * the latter to the one where the pointer is located.
        */
-      monitor = meta_screen_get_current_monitor_info (window->screen);
+      monitor = meta_screen_get_current_monitor_info_for_pos (window->screen, x, y);
       meta_window_get_work_area_for_monitor (window,
                                              monitor->number,
                                              &work_area);
@@ -11125,9 +11263,3 @@ meta_window_compute_tile_match (MetaWindow *window)
       window->tile_match = match;
     }
 }
-
-gboolean
-meta_window_can_close (MetaWindow *window)
-{
-  return window->has_close_func;
-}

src/core/workspace.c

@@ -78,6 +78,7 @@ static void
 meta_workspace_finalize (GObject *object)
 {
   /* Actual freeing done in meta_workspace_remove() for now */
+  G_OBJECT_CLASS (meta_workspace_parent_class)->finalize (object);
 }
 
 static void

src/meta/compositor-mutter.h

@@ -35,6 +35,7 @@
 
 /* Public compositor API */
 ClutterActor *meta_get_stage_for_screen         (MetaScreen *screen);
+ClutterActor *meta_get_overlay_group_for_screen (MetaScreen *screen);
 Window        meta_get_overlay_window           (MetaScreen *screen);
 GList        *meta_get_window_actors            (MetaScreen *screen);
 ClutterActor *meta_get_window_group_for_screen  (MetaScreen *screen);
@@ -46,7 +47,5 @@ void        meta_enable_unredirect_for_screen   (MetaScreen *screen);
 void meta_set_stage_input_region     (MetaScreen    *screen,
                                       XserverRegion  region);
 void meta_empty_stage_input_region   (MetaScreen    *screen);
-void meta_focus_stage_window         (MetaScreen    *screen,
-                                      guint32        timestamp);
 
 #endif

src/meta/display.h

@@ -165,10 +165,6 @@ void meta_display_set_input_focus_window   (MetaDisplay *display,
                                             gboolean     focus_frame,
                                             guint32      timestamp);
 
-void meta_display_request_take_focus       (MetaDisplay *display,
-                                            MetaWindow  *window,
-                                            guint32      timestamp);
-
 /* meta_display_focus_the_no_focus_window is called when the
  * designated no_focus_window should be focused, but is otherwise the
  * same as meta_display_set_input_focus_window

src/meta/screen.h

@@ -78,6 +78,9 @@ MetaWorkspace * meta_screen_get_active_workspace (MetaScreen *screen);
 int  meta_screen_get_n_monitors       (MetaScreen    *screen);
 int  meta_screen_get_primary_monitor  (MetaScreen    *screen);
 int  meta_screen_get_current_monitor  (MetaScreen    *screen);
+int  meta_screen_get_current_monitor_for_pos  (MetaScreen    *screen,
+                                               int x,
+                                               int y);
 void meta_screen_get_monitor_geometry (MetaScreen    *screen,
                                        int            monitor,
                                        MetaRectangle *geometry);

src/meta/window.h

@@ -237,6 +237,4 @@ void meta_window_begin_grab_op (MetaWindow *window,
                                 gboolean    frame_action,
                                 guint32     timestamp);
 
-gboolean meta_window_can_close (MetaWindow *window);
-
 #endif

src/ui/frames.c

@@ -739,6 +739,22 @@ meta_ui_frame_get_corner_radiuses (MetaFrames  *frames,
     *bottom_right = fgeom.bottom_right_corner_rounded_radius + sqrt(fgeom.bottom_right_corner_rounded_radius);
 }
 
+void
+meta_frames_get_corner_radiuses (MetaFrames *frames,
+                                 Window      xwindow,
+                                 float      *top_left,
+                                 float      *top_right,
+                                 float      *bottom_left,
+                                 float      *bottom_right)
+{
+  MetaUIFrame *frame;
+
+  frame = meta_frames_lookup_window (frames, xwindow);
+
+  meta_ui_frame_get_corner_radiuses (frames, frame, top_left, top_right,
+                                     bottom_left, bottom_right);
+}
+
 void
 meta_frames_reset_bg (MetaFrames *frames,
                       Window  xwindow)
@@ -1835,102 +1851,6 @@ clip_region_to_visible_frame_border (cairo_region_t *region,
   cairo_region_destroy (frame_border);
 }
 
-#define TAU (2*M_PI)
-
-/*
- * Draw the opaque and semi-opaque pixels of this frame into a mask.
- *
- * (0,0) in Cairo coordinates is assumed to be the top left corner of the
- * invisible border.
- *
- * The parts of @cr's surface in the clip region are assumed to be
- * initialized to fully-transparent, and the clip region is assumed to
- * contain the invisible border and the visible parts of the frame, but
- * not the client area.
- *
- * This function uses @cr to draw pixels of arbitrary color (it will
- * typically be drawing in a %CAIRO_FORMAT_A8 surface, so the color is
- * discarded anyway) with appropriate alpha values to reproduce this
- * frame's alpha channel, as a mask to be applied to an opaque pixmap.
- *
- * @frame: This frame
- * @xwindow: The X window for the frame, which has the client window as a child
- * @width: The width of the framed window including any invisible borders
- * @height: The height of the framed window including any invisible borders
- * @cr: Used to draw the resulting mask
- */
-void
-meta_frames_get_mask (MetaFrames          *frames,
-                      Window               xwindow,
-                      guint                width,
-                      guint                height,
-                      cairo_t             *cr)
-{
-  MetaUIFrame *frame = meta_frames_lookup_window (frames, xwindow);
-  float top_left, top_right, bottom_left, bottom_right;
-  int x, y;
-  MetaFrameBorders borders;
-
-  if (frame == NULL)
-    meta_bug ("No such frame 0x%lx\n", xwindow);
-
-  cairo_save (cr);
-
-  meta_ui_frame_get_borders (frames, frame, &borders);
-  meta_ui_frame_get_corner_radiuses (frames, frame,
-                                     &top_left, &top_right,
-                                     &bottom_left, &bottom_right);
-
-  /* top left */
-  x = borders.invisible.left;
-  y = borders.invisible.top;
-
-  cairo_arc (cr,
-             x + top_left,
-             y + top_left,
-             top_left,
-             2 * TAU / 4,
-             3 * TAU / 4);
-
-  /* top right */
-  x = width - borders.invisible.right - top_right;
-  y = borders.invisible.top;
-
-  cairo_arc (cr,
-             x,
-             y + top_right,
-             top_right,
-             3 * TAU / 4,
-             4 * TAU / 4);
-
-  /* bottom right */
-  x = width - borders.invisible.right - bottom_right;
-  y = height - borders.invisible.bottom - bottom_right;
-
-  cairo_arc (cr,
-             x,
-             y,
-             bottom_right,
-             0 * TAU / 4,
-             1 * TAU / 4);
-
-  /* bottom left */
-  x = borders.invisible.left;
-  y = height - borders.invisible.bottom - bottom_left;
-
-  cairo_arc (cr,
-             x + bottom_left,
-             y,
-             bottom_left,
-             1 * TAU / 4,
-             2 * TAU / 4);
-
-  cairo_set_source_rgba (cr, 1, 1, 1, 1);
-  cairo_fill (cr);
-
-  cairo_restore (cr);
-}
-
 static gboolean
 meta_frames_draw (GtkWidget *widget,
                   cairo_t   *cr)

src/ui/frames.h

@@ -140,11 +140,12 @@ cairo_region_t *meta_frames_get_frame_bounds (MetaFrames *frames,
                                               int         window_width,
                                               int         window_height);
 
-void meta_frames_get_mask (MetaFrames *frames,
-                           Window      xwindow,
-                           guint       width,
-                           guint       height,
-                           cairo_t    *cr);
+void meta_frames_get_corner_radiuses (MetaFrames *frames,
+                                      Window      xwindow,
+                                      float      *top_left,
+                                      float      *top_right,
+                                      float      *bottom_left,
+                                      float      *bottom_right);
 
 void meta_frames_move_resize_frame (MetaFrames *frames,
 				    Window      xwindow,

src/ui/tabpopup.c

@@ -857,7 +857,10 @@ meta_convert_meta_to_wnck (MetaWindow *window, MetaScreen *screen)
   WnckWindowDisplayInfo wnck_window;
   wnck_window.icon = window->icon;
   wnck_window.mini_icon = window->mini_icon;
-  wnck_window.is_active = window->has_focus;
+  
+  wnck_window.is_active = FALSE;
+  if (window == window->display->expected_focus_window)
+    wnck_window.is_active = TRUE;
 
   if (window->frame)
     {

src/ui/theme.c

@@ -1880,7 +1880,7 @@ debug_print_tokens (PosToken *tokens,
 /**
  * pos_tokenize:
  * @expr: The expression
- * @tokens_p: (out): The resulting tokens
+ * @tokens_p: (out) The resulting tokens
  * @n_tokens_p: (out): The number of resulting tokens
  * @err: (out):  set to the problem if there was a problem
  

src/ui/ui.c

@@ -324,16 +324,6 @@ meta_ui_free (MetaUI *ui)
   g_free (ui);
 }
 
-void
-meta_ui_get_frame_mask (MetaUI  *ui,
-                        Window   frame_xwindow,
-                        guint    width,
-                        guint    height,
-                        cairo_t *cr)
-{
-  meta_frames_get_mask (ui->frames, frame_xwindow, width, height, cr);
-}
-
 void
 meta_ui_get_frame_borders (MetaUI *ui,
                            Window frame_xwindow,
@@ -343,6 +333,19 @@ meta_ui_get_frame_borders (MetaUI *ui,
                            borders);
 }
 
+void
+meta_ui_get_corner_radiuses (MetaUI *ui,
+                             Window  xwindow,
+                             float  *top_left,
+                             float  *top_right,
+                             float  *bottom_left,
+                             float  *bottom_right)
+{
+  meta_frames_get_corner_radiuses (ui->frames, xwindow,
+                                   top_left, top_right,
+                                   bottom_left, bottom_right);
+}
+
 Window
 meta_ui_create_frame_window (MetaUI *ui,
                              Display *xdisplay,

src/ui/ui.h

@@ -66,13 +66,6 @@ void meta_ui_theme_get_frame_borders (MetaUI *ui,
 void meta_ui_get_frame_borders (MetaUI *ui,
                                 Window frame_xwindow,
                                 MetaFrameBorders *borders);
-
-void meta_ui_get_frame_mask (MetaUI *ui,
-                             Window frame_xwindow,
-                             guint width,
-                             guint height,
-                             cairo_t *cr);
-
 Window meta_ui_create_frame_window (MetaUI *ui,
                                     Display *xdisplay,
                                     Visual *xvisual,
@@ -109,6 +102,13 @@ cairo_region_t *meta_ui_get_frame_bounds (MetaUI  *ui,
                                           int      window_width,
                                           int      window_height);
 
+void meta_ui_get_corner_radiuses (MetaUI *ui,
+                                  Window  xwindow,
+                                  float  *top_left,
+                                  float  *top_right,
+                                  float  *bottom_left,
+                                  float  *bottom_right);
+
 void meta_ui_queue_frame_draw (MetaUI *ui,
                                Window xwindow);
 

src/wm-tester/Makefile.am

@@ -19,10 +19,7 @@ test_size_hints_SOURCES=			\
 test_attached_SOURCES=				\
 	test-attached.c
 
-test_focus_SOURCES=				\
-	test-focus.c
-
-noinst_PROGRAMS=wm-tester test-gravity test-resizing focus-window test-size-hints test-attached test-focus
+noinst_PROGRAMS=wm-tester test-gravity test-resizing focus-window test-size-hints test-attached
 
 wm_tester_LDADD= @MUTTER_LIBS@
 test_gravity_LDADD= @MUTTER_LIBS@
@@ -30,4 +27,3 @@ test_resizing_LDADD= @MUTTER_LIBS@
 test_size_hints_LDADD= @MUTTER_LIBS@
 focus_window_LDADD= @MUTTER_LIBS@
 test_attached_LDADD= @MUTTER_LIBS@
-test_focus_LDADD= @MUTTER_LIBS@

src/wm-tester/test-focus.c

@@ -1,362 +0,0 @@
-#include <gtk/gtk.h>
-#include <gdk/gdkx.h>
-#include <X11/Xatom.h>
-
-GtkWidget *main_window;
-GtkWidget *noinput_window, *passive_window, *local_window;
-GtkWidget *global_window, *lame_window, *grabby_window, *dying_window;
-
-static void
-clear_on_destroy (GtkWidget *widget, gpointer user_data)
-{
-  GtkWidget **widget_pointer = user_data;
-
-  *widget_pointer = NULL;
-}
-
-static void
-disable_take_focus (GtkWidget *window)
-{
-  GdkDisplay *display;
-  GdkWindow *gdkwindow;
-  Atom *protocols, wm_take_focus;
-  int n_protocols, i;
-
-  gtk_widget_realize (window);
-  gdkwindow = gtk_widget_get_window (window);
-  display = gdk_window_get_display (gdkwindow);
-
-  wm_take_focus = gdk_x11_get_xatom_by_name_for_display (display, "WM_TAKE_FOCUS");
-  XGetWMProtocols (GDK_DISPLAY_XDISPLAY (display),
-                   GDK_WINDOW_XID (gdkwindow),
-                   &protocols, &n_protocols);
-  for (i = 0; i < n_protocols; i++)
-    {
-      if (protocols[i] == wm_take_focus)
-        {
-          protocols[i] = protocols[n_protocols - 1];
-          n_protocols--;
-          break;
-        }
-    }
-  XSetWMProtocols (GDK_DISPLAY_XDISPLAY (display),
-                   GDK_WINDOW_XID (gdkwindow),
-                   protocols, n_protocols);
-  XFree (protocols);
-}
-
-static void
-clear_input_hint (GtkWidget *window)
-{
-  /* This needs to be called after gtk_widget_show, otherwise
-   * GTK+ will overwrite it. */
-  GdkWindow *gdkwindow = gtk_widget_get_window (window);
-  XWMHints *wm_hints;
-
-  wm_hints = XGetWMHints (GDK_DISPLAY_XDISPLAY (gdk_window_get_display (gdkwindow)),
-                          GDK_WINDOW_XID (gdkwindow));
-
-  wm_hints->flags |= InputHint;
-  wm_hints->input = False;
-
-  XSetWMHints (GDK_DISPLAY_XDISPLAY (gdk_window_get_display (gdkwindow)),
-               GDK_WINDOW_XID (gdkwindow),
-               wm_hints);
-
-  XFree (wm_hints);
-}
-
-static void
-active_notify (GObject    *obj,
-               GParamSpec *pspec,
-               gpointer    user_data)
-{
-  GtkLabel *label = user_data;
-
-  if (gtk_window_is_active (GTK_WINDOW (obj)))
-    gtk_label_set_text (label, "Focused");
-  else
-    gtk_label_set_text (label, "Not focused");
-}
-
-static void
-make_focused_label (GtkWidget *toplevel,
-                    GtkWidget *parent)
-{
-  GtkWidget *label;
-
-  label = gtk_label_new ("");
-  gtk_widget_show (label);
-
-  gtk_container_add (GTK_CONTAINER (parent), label);
-
-  g_signal_connect (toplevel, "notify::is-active",
-                    G_CALLBACK (active_notify), label);
-  active_notify (G_OBJECT (toplevel), NULL, label);
-}
-
-static void
-setup_test_dialog (GtkWidget *toplevel)
-{
-  make_focused_label (toplevel, toplevel);
-  gtk_widget_set_size_request (toplevel, 200, 200);
-}
-
-static void
-noinput_clicked (GtkButton *button, gpointer user_data)
-{
-  if (noinput_window)
-    gtk_window_present_with_time (GTK_WINDOW (noinput_window), gtk_get_current_event_time ());
-  else
-    {
-      noinput_window = g_object_new (GTK_TYPE_WINDOW,
-                                     "type", GTK_WINDOW_TOPLEVEL,
-                                     "title", "No Input",
-                                     "accept-focus", FALSE,
-                                     NULL);
-      setup_test_dialog (noinput_window);
-      g_signal_connect (noinput_window, "destroy",
-                        G_CALLBACK (clear_on_destroy), &noinput_window);
-      disable_take_focus (noinput_window);
-      gtk_widget_show (noinput_window);
-    }
-}
-
-static void
-passive_clicked (GtkButton *button, gpointer user_data)
-{
-  if (passive_window)
-    gtk_window_present_with_time (GTK_WINDOW (passive_window), gtk_get_current_event_time ());
-  else
-    {
-      passive_window = g_object_new (GTK_TYPE_WINDOW,
-                                     "type", GTK_WINDOW_TOPLEVEL,
-                                     "title", "Passive Input",
-                                     "accept-focus", TRUE,
-                                     NULL);
-      setup_test_dialog (passive_window);
-      g_signal_connect (passive_window, "destroy",
-                        G_CALLBACK (clear_on_destroy), &passive_window);
-      disable_take_focus (passive_window);
-      gtk_widget_show (passive_window);
-    }
-}
-
-static void
-local_clicked (GtkButton *button, gpointer user_data)
-{
-  if (local_window)
-    gtk_window_present_with_time (GTK_WINDOW (local_window), gtk_get_current_event_time ());
-  else
-    {
-      local_window = g_object_new (GTK_TYPE_WINDOW,
-                                   "type", GTK_WINDOW_TOPLEVEL,
-                                   "title", "Locally Active Input",
-                                   "accept-focus", TRUE,
-                                   NULL);
-      setup_test_dialog (local_window);
-      g_signal_connect (local_window, "destroy",
-                        G_CALLBACK (clear_on_destroy), &local_window);
-      gtk_widget_show (local_window);
-    }
-}
-
-static void
-global_clicked (GtkButton *button, gpointer user_data)
-{
-  if (global_window)
-    gtk_window_present_with_time (GTK_WINDOW (global_window), gtk_get_current_event_time ());
-  else
-    {
-      /* gtk will only process WM_TAKE_FOCUS messages if accept-focus
-       * is TRUE. So we set that property and then manually clear the
-       * Input WMHint.
-       */
-      global_window = g_object_new (GTK_TYPE_WINDOW,
-                                    "type", GTK_WINDOW_TOPLEVEL,
-                                    "title", "Globally Active Input",
-                                    "accept-focus", TRUE,
-                                    NULL);
-      setup_test_dialog (global_window);
-      g_signal_connect (global_window, "destroy",
-                        G_CALLBACK (clear_on_destroy), &global_window);
-      gtk_widget_show (global_window);
-      clear_input_hint (global_window);
-    }
-}
-
-static void
-lame_clicked (GtkButton *button, gpointer user_data)
-{
-  if (lame_window)
-    gtk_window_present_with_time (GTK_WINDOW (lame_window), gtk_get_current_event_time ());
-  else
-    {
-      lame_window = g_object_new (GTK_TYPE_WINDOW,
-                                  "type", GTK_WINDOW_TOPLEVEL,
-                                  "title", "Lame Globally Active Input",
-                                  "accept-focus", FALSE,
-                                  NULL);
-      setup_test_dialog (lame_window);
-      g_signal_connect (lame_window, "destroy",
-                        G_CALLBACK (clear_on_destroy), &lame_window);
-      gtk_widget_show (lame_window);
-    }
-}
-
-static void
-grabby_active_changed (GObject *object, GParamSpec *param, gpointer user_data)
-{
-  if (gtk_window_is_active (GTK_WINDOW (grabby_window)))
-    {
-      GdkWindow *gdkwindow = gtk_widget_get_window (grabby_window);
-      guint32 now = gdk_x11_get_server_time (gdkwindow);
-
-      gtk_window_present_with_time (GTK_WINDOW (main_window), now - 1);
-      XSetInputFocus (GDK_DISPLAY_XDISPLAY (gdk_window_get_display (gdkwindow)),
-                      GDK_WINDOW_XID (gdkwindow),
-                      RevertToParent,
-                      now);
-    }
-}
-
-static void
-grabby_clicked (GtkButton *button, gpointer user_data)
-{
-  if (grabby_window)
-    gtk_window_present_with_time (GTK_WINDOW (grabby_window), gtk_get_current_event_time ());
-  else
-    {
-      grabby_window = g_object_new (GTK_TYPE_WINDOW,
-                                    "type", GTK_WINDOW_TOPLEVEL,
-                                    "title", "Focus-grabbing Window",
-                                    "accept-focus", TRUE,
-                                    /* Because mutter maps windows
-                                     * asynchronously, our trick won't
-                                     * work if we try to do it when the
-                                     * window is first mapped.
-                                     */
-                                    "focus-on-map", FALSE,
-                                    NULL);
-      setup_test_dialog (grabby_window);
-      g_signal_connect (grabby_window, "destroy",
-                        G_CALLBACK (clear_on_destroy), &grabby_window);
-      g_signal_connect (grabby_window, "notify::is-active",
-                        G_CALLBACK (grabby_active_changed), NULL);
-      gtk_widget_show (grabby_window);
-    }
-}
-
-static void
-dying_clicked (GtkButton *button, gpointer user_data)
-{
-  if (dying_window)
-    {
-      gtk_window_present_with_time (GTK_WINDOW (dying_window), gtk_get_current_event_time ());
-      gtk_widget_destroy (dying_window);
-    }
-  else
-    {
-      GtkWidget *label;
-
-      dying_window = g_object_new (GTK_TYPE_WINDOW,
-                                   "type", GTK_WINDOW_TOPLEVEL,
-                                   "title", "Dying Window",
-                                   "accept-focus", TRUE,
-                                   /* As with grabby window */
-                                   "focus-on-map", FALSE,
-                                   NULL);
-      setup_test_dialog (dying_window);
-      g_signal_connect (dying_window, "destroy",
-                        G_CALLBACK (clear_on_destroy), &dying_window);
-
-      label = gtk_label_new ("Click button again to test");
-      gtk_container_add (GTK_CONTAINER (dying_window), label);
-      gtk_widget_set_size_request (dying_window, 200, 200);
-
-      gtk_widget_show_all (dying_window);
-    }
-}
-
-static void
-main_window_destroyed (GtkWidget *widget, gpointer user_data)
-{
-  gtk_main_quit ();
-}
-
-int
-main (int argc, char **argv)
-{
-  GtkWidget *vbox, *button;
-
-  gtk_init (&argc, &argv);
-
-  main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
-  gtk_window_set_title (GTK_WINDOW (main_window), "Focus Tester");
-
-  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
-  gtk_box_set_homogeneous (GTK_BOX (vbox), 8);
-  gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
-  gtk_container_add (GTK_CONTAINER (main_window), vbox);
-
-  make_focused_label (main_window, vbox);
-
-  /* ICCCM "No Input" mode; Input hint False, WM_TAKE_FOCUS absent */
-  button = gtk_button_new_with_label ("No Input Window");
-  g_signal_connect (button, "clicked", G_CALLBACK (noinput_clicked), NULL);
-  gtk_container_add (GTK_CONTAINER (vbox), button);
-
-  /* ICCCM "Passive" mode; Input hint True, WM_TAKE_FOCUS absent */
-  button = gtk_button_new_with_label ("Passive Input Window");
-  g_signal_connect (button, "clicked", G_CALLBACK (passive_clicked), NULL);
-  gtk_container_add (GTK_CONTAINER (vbox), button);
-
-  /* ICCCM "Locally Active" mode; Input hint True, WM_TAKE_FOCUS present.
-   * This is the behavior of GtkWindows with accept_focus==TRUE.
-   */
-  button = gtk_button_new_with_label ("Locally Active Window");
-  g_signal_connect (button, "clicked", G_CALLBACK (local_clicked), NULL);
-  gtk_container_add (GTK_CONTAINER (vbox), button);
-
-  /* ICCCM "Globally Active" mode; Input hint False, WM_TAKE_FOCUS present,
-   * and the window responds to WM_TAKE_FOCUS by calling XSetInputFocus.
-   */
-  button = gtk_button_new_with_label ("Globally Active Window");
-  g_signal_connect (button, "clicked", G_CALLBACK (global_clicked), NULL);
-  gtk_container_add (GTK_CONTAINER (vbox), button);
-
-  /* "Lame" Globally Active mode; like "Globally Active", except that
-   * the window does not respond to WM_TAKE_FOCUS. This is the
-   * behavior of GtkWindows with accept_focus==FALSE.
-   */
-  button = gtk_button_new_with_label ("Globally Lame Window");
-  g_signal_connect (button, "clicked", G_CALLBACK (lame_clicked), NULL);
-  gtk_container_add (GTK_CONTAINER (vbox), button);
-
-  /* "Grabby" window; when you activate the window, it asks the wm to
-   * focus the main window, but then forcibly grabs focus back with
-   * a newer timestamp, causing the wm to be temporarily confused
-   * about what window is focused and triggering the "Earlier attempt
-   * to focus ... failed" codepath.
-   */
-  button = gtk_button_new_with_label ("Grabby Window");
-  g_signal_connect (button, "clicked", G_CALLBACK (grabby_clicked), NULL);
-  gtk_container_add (GTK_CONTAINER (vbox), button);
-
-  /* "Dying" window; we create the window on the first click, then
-   * activate it and destroy it on the second click, causing mutter to
-   * do an XSetInputFocus but not receive the corresponding FocusIn.
-   */
-  button = gtk_button_new_with_label ("Dying Window");
-  g_signal_connect (button, "clicked", G_CALLBACK (dying_clicked), NULL);
-  gtk_container_add (GTK_CONTAINER (vbox), button);
-
-  gtk_widget_show_all (main_window);
-
-  g_signal_connect (main_window, "destroy",
-                    G_CALLBACK (main_window_destroyed), NULL);
-
-  gtk_main ();
-
-  return 0;
-}