diff --git a/src/core/bell.c b/src/core/bell.c index 8c7da04d0..c8fd1ddc7 100644 --- a/src/core/bell.c +++ b/src/core/bell.c @@ -230,6 +230,35 @@ bell_flash_window_frame (MetaWindow *window) bell_unflash_frame, window->frame, NULL); } +static MetaWindow * +get_flash_window (MetaDisplay *display, + XkbAnyEvent *xkb_ev) +{ + XkbBellNotifyEvent *xkb_bell_event; + MetaWindow *window; + + g_assert (xkb_ev->xkb_type == XkbBellNotify); + + xkb_bell_event = (XkbBellNotifyEvent *) xkb_ev; + window = meta_display_lookup_x_window (display, xkb_bell_event->window); + + if (!window && + g_hash_table_size (display->focus_info) == 1) + { + GHashTableIter iter; + MetaFocusInfo *info; + + /* If there is only one focused window, use it */ + g_hash_table_iter_init (&iter, display->focus_info); + + if (g_hash_table_iter_next (&iter, NULL, (gpointer *) &info) && + info->focus_window && info->focus_window->frame) + window = info->focus_window; + } + + return window; +} + /** * Flashes the frame of the focussed window. If there is no focussed window, * flashes the screen. @@ -241,15 +270,11 @@ static void bell_flash_frame (MetaDisplay *display, XkbAnyEvent *xkb_ev) { - XkbBellNotifyEvent *xkb_bell_event = (XkbBellNotifyEvent *) xkb_ev; MetaWindow *window; g_assert (xkb_ev->xkb_type == XkbBellNotify); - window = meta_display_lookup_x_window (display, xkb_bell_event->window); - if (!window && (display->focus_window)) - { - window = display->focus_window; - } + window = get_flash_window (display, xkb_ev); + if (window && window->frame) { bell_flash_window_frame (window); @@ -310,9 +335,7 @@ meta_bell_notify (MetaDisplay *display, ca_proplist_sets (p, CA_PROP_EVENT_DESCRIPTION, _("Bell event")); ca_proplist_sets (p, CA_PROP_CANBERRA_CACHE_CONTROL, "permanent"); - window = meta_display_lookup_x_window (display, xkb_bell_event->window); - if (!window && (display->focus_window) && (display->focus_window->frame)) - window = display->focus_window; + window = get_flash_window (display, xkb_ev); if (window) { diff --git a/src/core/display-private.h b/src/core/display-private.h index b0cea08da..cee3aef17 100644 --- a/src/core/display-private.h +++ b/src/core/display-private.h @@ -58,6 +58,7 @@ typedef struct _MetaWindowPropHooks MetaWindowPropHooks; typedef struct MetaEdgeResistanceData MetaEdgeResistanceData; typedef struct _MetaGrabInfo MetaGrabInfo; +typedef struct _MetaFocusInfo MetaFocusInfo; typedef void (* MetaWindowPingFunc) (MetaDisplay *display, Window xwindow, @@ -126,6 +127,26 @@ struct _MetaGrabInfo int grab_resize_timeout_id; }; +struct _MetaFocusInfo +{ + /* This is the actual window from focus events, + * not the one we last set + */ + MetaWindow *focus_window; + + /* 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; +}; + struct _MetaDisplay { GObject parent_instance; @@ -144,22 +165,8 @@ struct _MetaDisplay #include #undef item - /* This is the actual window from focus events, - * not the one we last set - */ - MetaWindow *focus_window; - - /* 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; + /* keyboard -> MetaFocusInfo hashtable */ + GHashTable *focus_info; /* last user interaction time in any app */ guint32 last_user_time; @@ -478,5 +485,8 @@ void meta_display_remove_grab_info (MetaDisplay *display, MetaGrabInfo * meta_display_get_grab_info (MetaDisplay *display, MetaDevice *device); +MetaFocusInfo * meta_display_get_focus_info (MetaDisplay *display, + MetaDevice *device); + #endif diff --git a/src/core/display.c b/src/core/display.c index 08e9ac959..b4dec8b89 100644 --- a/src/core/display.c +++ b/src/core/display.c @@ -189,7 +189,8 @@ static void prefs_changed_callback (MetaPreference pref, static void sanity_check_timestamps (MetaDisplay *display, guint32 known_good_timestamp); -MetaGroup* get_focussed_group (MetaDisplay *display); +MetaGroup* get_focussed_group (MetaDisplay *display, + MetaDevice *keyboard); static void meta_display_get_property(GObject *object, @@ -202,7 +203,16 @@ meta_display_get_property(GObject *object, switch (prop_id) { case PROP_FOCUS_WINDOW: - g_value_set_object (value, display->focus_window); + { + MetaFocusInfo *focus_info; + MetaDevice *device; + + /* Always follow the VCK focus */ + device = meta_device_map_lookup (display->device_map, + META_CORE_KEYBOARD_ID); + focus_info = meta_display_get_focus_info (display, device); + g_value_set_object (value, focus_info->focus_window); + } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); @@ -468,8 +478,6 @@ meta_display_open (void) the_display->pending_pings = NULL; the_display->autoraise_timeout_id = 0; the_display->autoraise_window = NULL; - the_display->focus_window = NULL; - the_display->expected_focus_window = NULL; the_display->mouse_mode = TRUE; /* Only relevant for mouse or sloppy focus */ the_display->allow_terminal_deactivation = TRUE; /* Only relevant for when a @@ -551,6 +559,8 @@ meta_display_open (void) the_display->current_grabs = g_hash_table_new_full (NULL, NULL, NULL, (GDestroyNotify) g_free); + the_display->focus_info = g_hash_table_new_full (NULL, NULL, NULL, + (GDestroyNotify) g_free); the_display->edge_resistance_info = g_hash_table_new (NULL, NULL); #ifdef HAVE_XSYNC @@ -784,7 +794,6 @@ meta_display_open (void) DefaultRootWindow (the_display->xdisplay), PropertyChangeMask); - the_display->last_focus_time = timestamp; the_display->last_user_time = timestamp; the_display->compositor = NULL; @@ -1954,8 +1963,14 @@ event_callback (XEvent *event, /* This is from our synchronous grab since * it has no modifiers and was on the client window */ + MetaFocusInfo *focus_info; + MetaDevice *keyboard; int mode; + /* This is a pointer event, get the paired keyboard */ + keyboard = meta_device_get_paired_device (device); + focus_info = meta_display_get_focus_info (display, keyboard); + /* When clicking a different app in click-to-focus * in application-based mode, and the different * app is not a dock or desktop, eat the focus click. @@ -1965,9 +1980,9 @@ event_callback (XEvent *event, !window->has_focus && window->type != META_WINDOW_DOCK && window->type != META_WINDOW_DESKTOP && - (display->focus_window == NULL || + (focus_info == NULL || focus_info->focus_window == NULL || !meta_window_same_application (window, - display->focus_window))) + focus_info->focus_window))) mode = AsyncPointer; /* eat focus click */ else mode = ReplayPointer; /* give event back */ @@ -2051,6 +2066,9 @@ event_callback (XEvent *event, detail != NotifyInferior && meta_display_focus_sentinel_clear (display)) { + MetaFocusInfo *focus_info; + MetaDevice *keyboard; + switch (meta_prefs_get_focus_mode ()) { case META_FOCUS_MODE_SLOPPY: @@ -2082,6 +2100,10 @@ event_callback (XEvent *event, "Auto raise is disabled\n"); } } + + keyboard = meta_device_get_paired_device (device); + focus_info = meta_display_get_focus_info (display, keyboard); + /* In mouse focus mode, we defocus when the mouse *enters* * the DESKTOP window, instead of defocusing on LeaveNotify. * This is because having the mouse enter override-redirect @@ -2093,12 +2115,14 @@ event_callback (XEvent *event, */ if (window->type == META_WINDOW_DESKTOP && meta_prefs_get_focus_mode() == META_FOCUS_MODE_MOUSE && - display->expected_focus_window != NULL) + focus_info->expected_focus_window != NULL) { meta_topic (META_DEBUG_FOCUS, - "Unsetting focus from %s due to mouse entering " + "Unsetting focus on device %d " + "from %s due to mouse entering " "the DESKTOP window\n", - display->expected_focus_window->desc); + meta_device_get_id (keyboard), + focus_info->expected_focus_window->desc); meta_display_focus_the_no_focus_window (display, window->screen, evtime); @@ -4165,12 +4189,18 @@ meta_display_increment_event_serial (MetaDisplay *display) void meta_display_update_active_window_hint (MetaDisplay *display) { + MetaFocusInfo *focus_info; + MetaDevice *keyboard; GSList *tmp; gulong data[1]; - if (display->focus_window) - data[0] = display->focus_window->xwindow; + keyboard = meta_device_map_lookup (display->device_map, + META_CORE_KEYBOARD_ID); + focus_info = meta_display_get_focus_info (display, keyboard); + + if (focus_info && focus_info->focus_window) + data[0] = focus_info->focus_window->xwindow; else data[0] = None; @@ -4558,23 +4588,29 @@ meta_display_window_has_pending_pings (MetaDisplay *display, } MetaGroup* -get_focussed_group (MetaDisplay *display) +get_focussed_group (MetaDisplay *display, + MetaDevice *keyboard) { - if (display->focus_window) - return display->focus_window->group; + MetaFocusInfo *focus_info; + + focus_info = meta_display_get_focus_info (display, keyboard); + + if (focus_info && focus_info->focus_window) + return focus_info->focus_window->group; else return NULL; } -#define IN_TAB_CHAIN(w,t) (((t) == META_TAB_LIST_NORMAL && META_WINDOW_IN_NORMAL_TAB_CHAIN (w)) \ +#define IN_TAB_CHAIN(w,d,t) (((t) == META_TAB_LIST_NORMAL && META_WINDOW_IN_NORMAL_TAB_CHAIN (w)) \ || ((t) == META_TAB_LIST_DOCKS && META_WINDOW_IN_DOCK_TAB_CHAIN (w)) \ - || ((t) == META_TAB_LIST_GROUP && META_WINDOW_IN_GROUP_TAB_CHAIN (w, get_focussed_group(w->display)))) + || ((t) == META_TAB_LIST_GROUP && META_WINDOW_IN_GROUP_TAB_CHAIN (w, get_focussed_group(w->display, d)))) static MetaWindow* find_tab_forward (MetaDisplay *display, MetaTabList type, MetaScreen *screen, MetaWorkspace *workspace, + MetaDevice *device, GList *start, gboolean skip_first) { @@ -4592,7 +4628,7 @@ find_tab_forward (MetaDisplay *display, MetaWindow *window = tmp->data; if (window->screen == screen && - IN_TAB_CHAIN (window, type)) + IN_TAB_CHAIN (window, device, type)) return window; tmp = tmp->next; @@ -4603,7 +4639,7 @@ find_tab_forward (MetaDisplay *display, { MetaWindow *window = tmp->data; - if (IN_TAB_CHAIN (window, type)) + if (IN_TAB_CHAIN (window, device, type)) return window; tmp = tmp->next; @@ -4617,6 +4653,7 @@ find_tab_backward (MetaDisplay *display, MetaTabList type, MetaScreen *screen, MetaWorkspace *workspace, + MetaDevice *device, GList *start, gboolean skip_last) { @@ -4633,7 +4670,7 @@ find_tab_backward (MetaDisplay *display, MetaWindow *window = tmp->data; if (window->screen == screen && - IN_TAB_CHAIN (window, type)) + IN_TAB_CHAIN (window, device, type)) return window; tmp = tmp->prev; @@ -4644,7 +4681,7 @@ find_tab_backward (MetaDisplay *display, { MetaWindow *window = tmp->data; - if (IN_TAB_CHAIN (window, type)) + if (IN_TAB_CHAIN (window, device, type)) return window; tmp = tmp->prev; @@ -4654,11 +4691,12 @@ find_tab_backward (MetaDisplay *display, } /** - * meta_display_get_tab_list: + * meta_display_get_device_tab_list: * @display: a #MetaDisplay * @type: type of tab list * @screen: a #MetaScreen * @workspace: origin workspace + * @device: keyboard triggering Alt-TAB * * Determine the list of windows that should be displayed for Alt-TAB * functionality. The windows are returned in most recently used order. @@ -4666,10 +4704,11 @@ find_tab_backward (MetaDisplay *display, * Returns: (transfer container) (element-type Meta.Window): List of windows */ GList* -meta_display_get_tab_list (MetaDisplay *display, - MetaTabList type, - MetaScreen *screen, - MetaWorkspace *workspace) +meta_display_get_device_tab_list (MetaDisplay *display, + MetaTabList type, + MetaScreen *screen, + MetaWorkspace *workspace, + MetaDevice *device) { GList *tab_list; @@ -4689,7 +4728,7 @@ meta_display_get_tab_list (MetaDisplay *display, if (!window->minimized && window->screen == screen && - IN_TAB_CHAIN (window, type)) + IN_TAB_CHAIN (window, device, type)) tab_list = g_list_prepend (tab_list, window); tmp = tmp->next; @@ -4706,7 +4745,7 @@ meta_display_get_tab_list (MetaDisplay *display, if (window->minimized && window->screen == screen && - IN_TAB_CHAIN (window, type)) + IN_TAB_CHAIN (window, device, type)) tab_list = g_list_prepend (tab_list, window); tmp = tmp->next; @@ -4729,7 +4768,7 @@ meta_display_get_tab_list (MetaDisplay *display, /* Check to see if it demands attention */ if (l_window->wm_state_demands_attention && l_window->workspace!=workspace && - IN_TAB_CHAIN (l_window, type)) + IN_TAB_CHAIN (l_window, device, type)) { /* if it does, add it to the popup */ tab_list = g_list_prepend (tab_list, l_window); @@ -4742,6 +4781,107 @@ meta_display_get_tab_list (MetaDisplay *display, return tab_list; } +/** + * meta_display_get_tab_list: + * @display: a #MetaDisplay + * @type: type of tab list + * @screen: a #MetaScreen + * @workspace: origin workspace + * + * Determine the list of windows that should be displayed for Alt-TAB + * functionality. The windows are returned in most recently used order. + * + * Returns: (transfer container) (element-type Meta.Window): List of windows + */ +GList* +meta_display_get_tab_list (MetaDisplay *display, + MetaTabList type, + MetaScreen *screen, + MetaWorkspace *workspace) +{ + MetaDevice *keyboard; + + keyboard = meta_device_map_lookup (display->device_map, + META_CORE_KEYBOARD_ID); + + return meta_display_get_device_tab_list (display, type, + screen, workspace, + keyboard); +} + +/** + * meta_display_get_device_tab_next: + * @display: a #MetaDisplay + * @type: type of tab list + * @screen: a #MetaScreen + * @workspace: origin workspace + * @window: (allow-none): starting window + * @device: keyboard triggering Alt-TAB + * @backward: If %TRUE, look for the previous window. + * + * Determine the next window that should be displayed for Alt-TAB + * functionality. + * + * Returns: (transfer none): Next window + * + */ +MetaWindow* +meta_display_get_device_tab_next (MetaDisplay *display, + MetaTabList type, + MetaScreen *screen, + MetaWorkspace *workspace, + MetaWindow *window, + MetaDevice *device, + gboolean backward) +{ + gboolean skip; + GList *tab_list; + MetaWindow *ret; + tab_list = meta_display_get_tab_list(display, + type, + screen, + workspace); + + if (tab_list == NULL) + return NULL; + + if (window != NULL) + { + g_assert (window->display == display); + + if (backward) + ret = find_tab_backward (display, type, screen, workspace, + device, + g_list_find (tab_list, + window), + TRUE); + else + ret = find_tab_forward (display, type, screen, workspace, + device, + g_list_find (tab_list, + window), + TRUE); + } + else + { + MetaFocusInfo *focus_info; + + focus_info = meta_display_get_focus_info (display, device); + + skip = focus_info->focus_window != NULL && + tab_list->data == focus_info->focus_window; + if (backward) + ret = find_tab_backward (display, type, screen, workspace, + device, tab_list, skip); + else + ret = find_tab_forward (display, type, screen, workspace, + device, tab_list, skip); + } + + g_list_free (tab_list); + return ret; +} + /** * meta_display_get_tab_next: * @display: a #MetaDisplay @@ -4765,46 +4905,51 @@ meta_display_get_tab_next (MetaDisplay *display, MetaWindow *window, gboolean backward) { - gboolean skip; - GList *tab_list; - MetaWindow *ret; - tab_list = meta_display_get_tab_list(display, - type, - screen, - workspace); + MetaDevice *keyboard; - if (tab_list == NULL) - return NULL; - - if (window != NULL) - { - g_assert (window->display == display); - - if (backward) - ret = find_tab_backward (display, type, screen, workspace, - g_list_find (tab_list, - window), - TRUE); - else - ret = find_tab_forward (display, type, screen, workspace, - g_list_find (tab_list, - window), - TRUE); - } + keyboard = meta_device_map_lookup (display->device_map, + META_CORE_KEYBOARD_ID); + + return meta_display_get_device_tab_next (display, type, + screen, workspace, + window, keyboard, + backward); +} + +/** + * meta_display_get_device_tab_current: + * @display: a #MetaDisplay + * @type: type of tab list + * @screen: a #MetaScreen + * @workspace: origin workspace + * @device: keyboard triggering alt-TAB + * + * Determine the active window that should be displayed for Alt-TAB. + * + * Returns: (transfer none): Current window + * + */ +MetaWindow* +meta_display_get_device_tab_current (MetaDisplay *display, + MetaTabList type, + MetaScreen *screen, + MetaWorkspace *workspace, + MetaDevice *device) +{ + MetaFocusInfo *focus_info; + MetaWindow *window; + + focus_info = meta_display_get_focus_info (display, device); + window = focus_info->focus_window; + + if (window != NULL && + window->screen == screen && + IN_TAB_CHAIN (window, device, type) && + (workspace == NULL || + meta_window_located_on_workspace (window, workspace))) + return window; else - { - skip = display->focus_window != NULL && - tab_list->data == display->focus_window; - if (backward) - ret = find_tab_backward (display, type, screen, workspace, - tab_list, skip); - else - ret = find_tab_forward (display, type, screen, workspace, - tab_list, skip); - } - - g_list_free (tab_list); - return ret; + return NULL; } /** @@ -4825,18 +4970,14 @@ meta_display_get_tab_current (MetaDisplay *display, MetaScreen *screen, MetaWorkspace *workspace) { - MetaWindow *window; + MetaDevice *keyboard; - window = display->focus_window; - - if (window != NULL && - window->screen == screen && - IN_TAB_CHAIN (window, type) && - (workspace == NULL || - meta_window_located_on_workspace (window, workspace))) - return window; - else - return NULL; + keyboard = meta_device_map_lookup (display->device_map, + META_CORE_KEYBOARD_ID); + + return meta_display_get_device_tab_current (display, type, + screen, workspace, + keyboard); } int @@ -5351,15 +5492,29 @@ static void sanity_check_timestamps (MetaDisplay *display, guint32 timestamp) { - if (XSERVER_TIME_IS_BEFORE (timestamp, display->last_focus_time)) + MetaFocusInfo *focus_info; + MetaDevice *keyboard; + GHashTableIter iter; + + g_hash_table_iter_init (&iter, display->focus_info); + + while (g_hash_table_iter_next (&iter, + (gpointer *) &keyboard, + (gpointer *) &focus_info)) { - meta_warning ("last_focus_time (%u) is greater than comparison " - "timestamp (%u). This most likely represents a buggy " - "client sending inaccurate timestamps in messages such as " - "_NET_ACTIVE_WINDOW. Trying to work around...\n", - display->last_focus_time, timestamp); - display->last_focus_time = timestamp; + if (XSERVER_TIME_IS_BEFORE (timestamp, focus_info->last_focus_time)) + { + meta_warning ("last_focus_time (%u) for device %d is greater than comparison " + "timestamp (%u). This most likely represents a buggy " + "client sending inaccurate timestamps in messages such as " + "_NET_ACTIVE_WINDOW. Trying to work around...\n", + focus_info->last_focus_time, + meta_device_get_id (keyboard), + timestamp); + focus_info->last_focus_time = timestamp; + } } + if (XSERVER_TIME_IS_BEFORE (timestamp, display->last_user_time)) { GSList *windows; @@ -5396,14 +5551,19 @@ sanity_check_timestamps (MetaDisplay *display, static gboolean timestamp_too_old (MetaDisplay *display, MetaWindow *window, + MetaDevice *device, guint32 *timestamp) { + MetaFocusInfo *focus_info; + /* 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). */ + focus_info = meta_display_get_focus_info (display, device); + if (*timestamp == CurrentTime) { meta_warning ("Got a request to focus %s with a timestamp of 0. This " @@ -5413,31 +5573,34 @@ timestamp_too_old (MetaDisplay *display, *timestamp = meta_display_get_current_time_roundtrip (display); return FALSE; } - else if (XSERVER_TIME_IS_BEFORE (*timestamp, display->last_focus_time)) + else if (XSERVER_TIME_IS_BEFORE (*timestamp, focus_info->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 " + "Ignoring focus request for device %d, %s since %u " "is less than %u and %u.\n", + meta_device_get_id (device), window ? window->desc : "the no_focus_window", *timestamp, display->last_user_time, - display->last_focus_time); + focus_info->last_focus_time); return TRUE; } else { meta_topic (META_DEBUG_FOCUS, - "Received focus request for %s which is newer than most " + "Received focus request for device %d, %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", + meta_device_get_id (device), window ? window->desc : "the no_focus_window", display->last_user_time, *timestamp, - display->last_focus_time); - *timestamp = display->last_focus_time; + focus_info->last_focus_time); + *timestamp = focus_info->last_focus_time; return FALSE; } } @@ -5446,23 +5609,29 @@ timestamp_too_old (MetaDisplay *display, } void -meta_display_set_input_focus_window (MetaDisplay *display, - MetaWindow *window, - gboolean focus_frame, - guint32 timestamp) +meta_display_set_keyboard_focus (MetaDisplay *display, + MetaWindow *window, + MetaDevice *keyboard, + gboolean focus_frame, + guint32 timestamp) { - if (timestamp_too_old (display, window, ×tamp)) + MetaFocusInfo *focus_info; + Window xwindow; + + if (timestamp_too_old (display, window, keyboard, ×tamp)) return; + xwindow = focus_frame ? window->frame->xwindow : window->xwindow; + meta_error_trap_push (display); - XSetInputFocus (display->xdisplay, - focus_frame ? window->frame->xwindow : window->xwindow, - RevertToPointerRoot, - timestamp); + meta_device_keyboard_set_focus_window (META_DEVICE_KEYBOARD (keyboard), + xwindow, timestamp); meta_error_trap_pop (display); - display->expected_focus_window = window; - display->last_focus_time = timestamp; + focus_info = meta_display_get_focus_info (display, keyboard); + + focus_info->expected_focus_window = window; + focus_info->last_focus_time = timestamp; display->active_screen = window->screen; if (window != display->autoraise_window) @@ -5470,24 +5639,56 @@ meta_display_set_input_focus_window (MetaDisplay *display, } void -meta_display_focus_the_no_focus_window (MetaDisplay *display, - MetaScreen *screen, - guint32 timestamp) +meta_display_unset_keyboard_focus (MetaDisplay *display, + MetaScreen *screen, + MetaDevice *keyboard, + guint32 timestamp) { - if (timestamp_too_old (display, NULL, ×tamp)) + MetaFocusInfo *focus_info; + + if (timestamp_too_old (display, NULL, keyboard, ×tamp)) return; - XSetInputFocus (display->xdisplay, - screen->no_focus_window, - RevertToPointerRoot, - timestamp); - display->expected_focus_window = NULL; - display->last_focus_time = timestamp; + meta_device_keyboard_set_focus_window (META_DEVICE_KEYBOARD (keyboard), + screen->no_focus_window, + timestamp); + + focus_info = meta_display_get_focus_info (display, keyboard); + + focus_info->expected_focus_window = NULL; + focus_info->last_focus_time = timestamp; display->active_screen = screen; meta_display_remove_autoraise_callback (display); } +void +meta_display_set_input_focus_window (MetaDisplay *display, + MetaWindow *window, + gboolean focus_frame, + guint32 timestamp) +{ + MetaDevice *keyboard; + + keyboard = meta_device_map_lookup (display->device_map, + META_CORE_KEYBOARD_ID); + meta_display_set_keyboard_focus (display, window, keyboard, + focus_frame, timestamp); +} + +void +meta_display_focus_the_no_focus_window (MetaDisplay *display, + MetaScreen *screen, + guint32 timestamp) +{ + MetaDevice *keyboard; + + keyboard = meta_device_map_lookup (display->device_map, + META_CORE_KEYBOARD_ID); + meta_display_unset_keyboard_focus (display, screen, keyboard, + timestamp); +} + void meta_display_remove_autoraise_callback (MetaDisplay *display) { @@ -5552,6 +5753,30 @@ meta_display_has_shape (MetaDisplay *display) return META_DISPLAY_HAS_SHAPE (display); } +/** + * meta_display_get_keyboard_focus_window: + * @display: a #MetaDisplay + * @keyboard: keyboard to get current focus window for + * + * Returns the window that is currently receiving events for + * the keyboard @keyboard. 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.) + * + * Returns: (transfer none): window receiving @keyboard focus + **/ +MetaWindow * +meta_display_get_keyboard_focus_window (MetaDisplay *display, + MetaDevice *keyboard) +{ + MetaFocusInfo *focus_info; + + focus_info = meta_display_get_focus_info (display, keyboard); + + return focus_info->focus_window; +} + /** * meta_display_get_focus_window: * @display: a #MetaDisplay @@ -5567,7 +5792,12 @@ meta_display_has_shape (MetaDisplay *display) MetaWindow * meta_display_get_focus_window (MetaDisplay *display) { - return display->focus_window; + MetaDevice *keyboard; + + keyboard = meta_device_map_lookup (display->device_map, + META_CORE_KEYBOARD_ID); + + return meta_display_get_keyboard_focus_window (display, keyboard); } int @@ -5689,3 +5919,28 @@ meta_display_get_grab_info (MetaDisplay *display, return info; } + +MetaFocusInfo * +meta_display_get_focus_info (MetaDisplay *display, + MetaDevice *device) +{ + MetaFocusInfo *info; + + if (!device) + return NULL; + + info = g_hash_table_lookup (display->focus_info, device); + + if (!info) + { + if (!META_IS_DEVICE_KEYBOARD (device)) + device = meta_device_get_paired_device (device); + + info = g_slice_new0 (MetaFocusInfo); + info->last_focus_time = display->current_time; + + g_hash_table_insert (display->focus_info, device, info); + } + + return info; +} diff --git a/src/core/keybindings.c b/src/core/keybindings.c index 7eed4ae18..ce00ecf0e 100644 --- a/src/core/keybindings.c +++ b/src/core/keybindings.c @@ -3108,20 +3108,26 @@ handle_activate_window_menu (MetaDisplay *display, MetaKeyBinding *binding, gpointer dummy) { - if (display->focus_window) + MetaFocusInfo *focus_info; + MetaDevice *device; + + device = meta_input_event_get_device (display, event); + focus_info = meta_display_get_focus_info (display, device); + + if (focus_info->focus_window) { Time evtime; int x, y; - meta_window_get_position (display->focus_window, + meta_window_get_position (focus_info->focus_window, &x, &y); if (meta_ui_get_direction() == META_UI_DIRECTION_RTL) - x += display->focus_window->rect.width; + x += focus_info->focus_window->rect.width; evtime = meta_input_event_get_time (display, event); - meta_window_show_menu (display->focus_window, + meta_window_show_menu (focus_info->focus_window, x, y, 0, evtime); diff --git a/src/core/place.c b/src/core/place.c index fa94186bd..9c657897a 100644 --- a/src/core/place.c +++ b/src/core/place.c @@ -354,10 +354,17 @@ avoid_being_obscured_as_second_modal_dialog (MetaWindow *window, * know about the modal-to-the-main-window part. */ - MetaWindow *focus_window; + MetaWindow *focus_window = NULL; + MetaFocusInfo *focus_info; MetaRectangle overlap; + MetaDevice *pointer, *keyboard; - focus_window = window->display->focus_window; + pointer = meta_window_guess_grab_pointer (window); + keyboard = meta_device_get_paired_device (pointer); + focus_info = meta_display_get_focus_info (window->display, keyboard); + + if (focus_window) + focus_window = focus_info->focus_window; if (window->denied_focus_and_not_transient && window->wm_state_modal && /* FIXME: Maybe do this for all transients? */ @@ -913,8 +920,16 @@ meta_window_place (MetaWindow *window, gboolean found_fit; MetaWindow *focus_window; MetaRectangle overlap; + MetaDevice *pointer, *keyboard; + MetaFocusInfo *focus_info; - focus_window = window->display->focus_window; + pointer = meta_window_guess_grab_pointer (window); + keyboard = meta_device_get_paired_device (pointer); + + focus_info = meta_display_get_focus_info (window->display, keyboard); + g_assert (focus_info != NULL); + + focus_window = focus_info->focus_window; g_assert (focus_window != NULL); /* No need to do anything if the window doesn't overlap at all */ diff --git a/src/core/stack.c b/src/core/stack.c index c3917c6d8..2dfcd5fff 100644 --- a/src/core/stack.c +++ b/src/core/stack.c @@ -211,13 +211,23 @@ meta_stack_thaw (MetaStack *stack) stack_sync_to_server (stack); } +typedef struct _FocusedForeachData FocusedForeachData; + +struct _FocusedForeachData +{ + MetaWindow *window; + gboolean focused_transient; +}; + static gboolean is_focused_foreach (MetaWindow *window, void *data) { - if (window == window->display->expected_focus_window) + FocusedForeachData *focused_data = data; + + if (window == focused_data->window) { - *((gboolean*) data) = TRUE; + focused_data->focused_transient = TRUE; return FALSE; } return TRUE; @@ -240,6 +250,9 @@ get_standalone_layer (MetaWindow *window) { MetaStackLayer layer; gboolean focused_transient = FALSE; + MetaFocusInfo *focus_info; + MetaDevice *keyboard; + FocusedForeachData focused_data = { 0 }; switch (window->type) { @@ -263,20 +276,30 @@ get_standalone_layer (MetaWindow *window) case META_WINDOW_OVERRIDE_OTHER: layer = META_LAYER_OVERRIDE_REDIRECT; break; - default: + default: + /* FIXME: How about other keyboards? should + * we allow fullscreen for non-VCP/K anyway? + */ + keyboard = meta_device_map_lookup (window->display->device_map, + META_CORE_KEYBOARD_ID); + + focus_info = meta_display_get_focus_info (window->display, keyboard); + focused_data.window = focus_info->expected_focus_window; + meta_window_foreach_transient (window, is_focused_foreach, - &focused_transient); + &focused_data); if (window->wm_state_below) layer = META_LAYER_BOTTOM; else if (window->fullscreen && (focused_transient || - window == window->display->expected_focus_window || - window->display->expected_focus_window == NULL || - (window->display->expected_focus_window != NULL && + !focus_info || + window == focus_info->expected_focus_window || + focus_info->expected_focus_window == NULL || + (focus_info->expected_focus_window != NULL && windows_on_different_monitor (window, - window->display->expected_focus_window)))) + focus_info->expected_focus_window)))) layer = META_LAYER_FULLSCREEN; else if (window->wm_state_above) layer = META_LAYER_TOP; diff --git a/src/core/window-private.h b/src/core/window-private.h index fe15abd5d..20a9e1e68 100644 --- a/src/core/window-private.h +++ b/src/core/window-private.h @@ -318,6 +318,12 @@ struct _MetaWindow /* if TRUE, application is buggy and SYNC resizing is turned off */ guint disable_sync : 1; + /* if TRUE, window didn't yet get the FocusIn for window->focus_keyboard */ + guint expecting_focus_in : 1; + + /* Keyboard currently owning the window focus, or NULL */ + MetaDevice *focus_keyboard; + /* if non-NULL, the bounds of the window frame */ cairo_region_t *frame_bounds; @@ -398,6 +404,9 @@ struct _MetaWindow /* Current grab op for this window, or NULL */ MetaGrabInfo *cur_grab; + + /* Focus info if the window is focused, or NULL */ + MetaFocusInfo *cur_focus; }; struct _MetaWindowClass @@ -647,6 +656,7 @@ void meta_window_update_monitor (MetaWindow *window); void meta_window_update_on_all_workspaces (MetaWindow *window); void meta_window_propagate_focus_appearance (MetaWindow *window, + MetaDevice *keyboard, gboolean focused); MetaDevice * meta_window_guess_grab_pointer (MetaWindow *window); diff --git a/src/core/window-props.c b/src/core/window-props.c index 42438c2fb..49ec4d0cb 100644 --- a/src/core/window-props.c +++ b/src/core/window-props.c @@ -1471,7 +1471,9 @@ reload_transient_for (MetaWindow *window, MetaWindow *parent = NULL; if (meta_window_appears_focused (window) && window->xtransient_for != None) - meta_window_propagate_focus_appearance (window, FALSE); + meta_window_propagate_focus_appearance (window, + window->focus_keyboard, + FALSE); window->xtransient_for = None; @@ -1537,7 +1539,9 @@ reload_transient_for (MetaWindow *window, meta_window_queue (window, META_QUEUE_MOVE_RESIZE); if (meta_window_appears_focused (window) && window->xtransient_for != None) - meta_window_propagate_focus_appearance (window, TRUE); + meta_window_propagate_focus_appearance (window, + window->focus_keyboard, + TRUE); } static void diff --git a/src/core/window.c b/src/core/window.c index dc05ce841..cb67c0c2c 100644 --- a/src/core/window.c +++ b/src/core/window.c @@ -1481,6 +1481,7 @@ void meta_window_unmanage (MetaWindow *window, guint32 timestamp) { + MetaFocusInfo *focus_info = NULL; GList *tmp; meta_verbose ("Unmanaging 0x%lx\n", window->xwindow); @@ -1527,6 +1528,10 @@ meta_window_unmanage (MetaWindow *window, * group if window->unmanaging */ + if (window->focus_keyboard) + focus_info = meta_display_get_focus_info (window->display, + window->focus_keyboard); + /* If we have the focus, focus some other window. * This is done first, so that if the unmap causes * an EnterNotify the EnterNotify will have final say @@ -1534,22 +1539,24 @@ meta_window_unmanage (MetaWindow *window, * invariants. */ if (meta_window_appears_focused (window)) - meta_window_propagate_focus_appearance (window, FALSE); - if (window->has_focus) + meta_window_propagate_focus_appearance (window, + window->focus_keyboard, + FALSE); + + if (window->focus_keyboard) { - meta_topic (META_DEBUG_FOCUS, - "Focusing default window since we're unmanaging %s\n", - window->desc); - meta_workspace_focus_default_window (window->screen->active_workspace, - 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; + if (window->expecting_focus_in) + { + meta_topic (META_DEBUG_FOCUS, + "Focusing default window since expected focus window freed %s\n", + window->desc); + focus_info->expected_focus_window = NULL; + } + else + meta_topic (META_DEBUG_FOCUS, + "Focusing default window since we're unmanaging %s\n", + window->desc); + meta_workspace_focus_default_window (window->screen->active_workspace, window, timestamp); @@ -1579,10 +1586,14 @@ meta_window_unmanage (MetaWindow *window, g_assert (window->cur_grab == NULL); - if (window->display->focus_window == window) + if (focus_info && + focus_info->focus_window == window) { - window->display->focus_window = NULL; - g_object_notify (G_OBJECT (window->display), "focus-window"); + focus_info->focus_window = NULL; + + if (window->focus_keyboard && + meta_device_get_id (window->focus_keyboard) == META_CORE_KEYBOARD_ID) + g_object_notify (G_OBJECT (window->display), "focus-window"); } if (window->maximized_horizontally || window->maximized_vertically) @@ -2349,12 +2360,17 @@ meta_window_queue (MetaWindow *window, guint queuebits) } static gboolean -intervening_user_event_occurred (MetaWindow *window) +intervening_user_event_occurred (MetaWindow *window, + MetaDevice *keyboard) { guint32 compare; - MetaWindow *focus_window; + MetaWindow *focus_window = NULL; + MetaFocusInfo *focus_info; - focus_window = window->display->focus_window; + focus_info = meta_display_get_focus_info (window->display, keyboard); + + if (focus_info) + focus_window = focus_info->focus_window; meta_topic (META_DEBUG_STARTUP, "COMPARISON:\n" @@ -2503,12 +2519,15 @@ __window_is_terminal (MetaWindow *window) */ static void window_state_on_map (MetaWindow *window, - gboolean *takes_focus, - gboolean *places_on_top) + MetaDevice *keyboard, + gboolean *takes_focus, + gboolean *places_on_top) { gboolean intervening_events; + MetaFocusInfo *focus_info; - intervening_events = intervening_user_event_occurred (window); + intervening_events = intervening_user_event_occurred (window, keyboard); + focus_info = meta_display_get_focus_info (window->display, keyboard); *takes_focus = !intervening_events; *places_on_top = *takes_focus; @@ -2530,11 +2549,11 @@ window_state_on_map (MetaWindow *window, * terminals due to new window map, but the latter is a much easier * approximation to enforce so we do that. */ - if (*takes_focus && + if (*takes_focus && focus_info && meta_prefs_get_focus_new_windows () == META_FOCUS_NEW_WINDOWS_STRICT && !window->display->allow_terminal_deactivation && - __window_is_terminal (window->display->focus_window) && - !meta_window_is_ancestor_of_transient (window->display->focus_window, + __window_is_terminal (focus_info->focus_window) && + !meta_window_is_ancestor_of_transient (focus_info->focus_window, window)) { meta_topic (META_DEBUG_FOCUS, @@ -2765,20 +2784,30 @@ meta_window_show (MetaWindow *window) gboolean takes_focus_on_map; gboolean place_on_top_on_map; gboolean needs_stacking_adjustment; - MetaWindow *focus_window; + MetaWindow *focus_window = NULL; gboolean toplevel_was_mapped; gboolean toplevel_now_mapped; gboolean notify_demands_attention = FALSE; + MetaDevice *pointer, *keyboard; + MetaFocusInfo *focus_info; meta_topic (META_DEBUG_WINDOW_STATE, "Showing window %s, shaded: %d iconic: %d placed: %d\n", window->desc, window->shaded, window->iconic, window->placed); + pointer = meta_window_guess_grab_pointer (window); + keyboard = meta_device_get_paired_device (pointer); + toplevel_was_mapped = meta_window_toplevel_is_mapped (window); - focus_window = window->display->focus_window; /* May be NULL! */ + focus_info = meta_display_get_focus_info (window->display, keyboard); + + if (focus_info) + focus_window = focus_info->focus_window; + did_show = FALSE; - window_state_on_map (window, &takes_focus_on_map, &place_on_top_on_map); + window_state_on_map (window, keyboard, + &takes_focus_on_map, &place_on_top_on_map); needs_stacking_adjustment = FALSE; meta_topic (META_DEBUG_WINDOW_STATE, @@ -3109,14 +3138,13 @@ meta_window_hide (MetaWindow *window) invalidate_work_areas (window); } - /* The check on expected_focus_window is a temporary workaround for + /* The check on expected_focus_in 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) + if (window->has_focus && window->expecting_focus_in) { MetaWindow *not_this_one = NULL; MetaWorkspace *my_workspace = meta_window_get_workspace (window); @@ -5312,13 +5340,22 @@ meta_window_focus (MetaWindow *window, if (window->take_focus) { + MetaFocusInfo *focus_info; + MetaDevice *keyboard; + meta_topic (META_DEBUG_FOCUS, "Sending WM_TAKE_FOCUS to %s since take_focus = true\n", window->desc); meta_window_send_icccm_message (window, window->display->atom_WM_TAKE_FOCUS, timestamp); - window->display->expected_focus_window = window; + + keyboard = meta_device_get_paired_device (device); + focus_info = meta_display_get_focus_info (window->display, keyboard); + + focus_info->expected_focus_window = window; + window->focus_keyboard = keyboard; + window->expecting_focus_in = TRUE; } } @@ -5858,7 +5895,16 @@ meta_window_configure_request (MetaWindow *window, if (event->xconfigurerequest.value_mask & CWStackMode) { MetaWindow *active_window; - active_window = window->display->expected_focus_window; + MetaDevice *pointer, *keyboard; + MetaFocusInfo *focus_info; + + pointer = meta_window_guess_grab_pointer (window); + keyboard = meta_device_get_paired_device (pointer); + focus_info = meta_display_get_focus_info (window->display, keyboard); + + if (focus_info) + active_window = focus_info->expected_focus_window; + if (meta_prefs_get_disable_workarounds ()) { meta_topic (META_DEBUG_STACK, @@ -6477,17 +6523,26 @@ meta_window_client_message (MetaWindow *window, */ void meta_window_propagate_focus_appearance (MetaWindow *window, + MetaDevice *keyboard, gboolean focused) { MetaWindow *child, *parent, *focus_window; + MetaFocusInfo *focus_info; if (!meta_prefs_get_attach_modal_dialogs ()) return; - focus_window = window->display->focus_window; - child = window; parent = meta_window_get_transient_for (child); + + if (keyboard) + { + focus_info = meta_display_get_focus_info (window->display, keyboard); + focus_window = focus_info->focus_window; + } + else + focus_window = NULL; + while (parent && (!focused || child->type == META_WINDOW_MODAL_DIALOG)) { gboolean child_focus_state_changed; @@ -6508,7 +6563,7 @@ meta_window_propagate_focus_appearance (MetaWindow *window, } if (child_focus_state_changed && !parent->has_focus && - parent != window->display->expected_focus_window) + (!focus_info || parent != focus_info->expected_focus_window)) { g_object_notify (G_OBJECT (parent), "appears-focused"); if (parent->frame) @@ -6525,6 +6580,8 @@ meta_window_notify_focus (MetaWindow *window, XEvent *event) { guint evtype, mode, detail; + MetaFocusInfo *focus_info = NULL; + MetaDevice *keyboard; Window xwindow; /* note the event can be on either the window or the frame, @@ -6550,14 +6607,19 @@ meta_window_notify_focus (MetaWindow *window, meta_input_event_get_crossing_details (window->display, event, &mode, &detail); xwindow = meta_input_event_get_window (window->display, event); + keyboard = meta_input_event_get_device (window->display, event); } else { xwindow = event->xany.window; evtype = event->type; mode = detail = 0; + keyboard = window->focus_keyboard; } + if (keyboard) + focus_info = meta_display_get_focus_info (window->display, keyboard); + meta_topic (META_DEBUG_FOCUS, "Focus %s event received on %s 0x%lx (%s) " "mode %s detail %s\n", @@ -6611,17 +6673,22 @@ meta_window_notify_focus (MetaWindow *window, { if (window->override_redirect) { - window->display->focus_window = NULL; - g_object_notify (G_OBJECT (window->display), "focus-window"); + focus_info->focus_window = NULL; + + if (meta_device_get_id (keyboard) == META_CORE_KEYBOARD_ID) + g_object_notify (G_OBJECT (window->display), "focus-window"); + return FALSE; } - if (window != window->display->focus_window) + if (window != focus_info->focus_window) { meta_topic (META_DEBUG_FOCUS, "* Focus --> %s\n", window->desc); - window->display->focus_window = window; + focus_info->focus_window = window; window->has_focus = TRUE; + window->focus_keyboard = keyboard; + window->expecting_focus_in = FALSE; /* Move to the front of the focusing workspace's MRU list. * We should only be "removing" it from the MRU list if it's @@ -6679,7 +6746,9 @@ meta_window_notify_focus (MetaWindow *window, 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 (meta_device_get_id (keyboard) == META_CORE_KEYBOARD_ID) + g_object_notify (G_OBJECT (window->display), "focus-window"); if (!window->attached_focus_window) { @@ -6687,7 +6756,7 @@ meta_window_notify_focus (MetaWindow *window, if (window->frame) meta_frame_queue_draw (window->frame); } - meta_window_propagate_focus_appearance (window, TRUE); + meta_window_propagate_focus_appearance (window, keyboard, TRUE); } } else if (evtype == FocusOut || @@ -6703,7 +6772,8 @@ meta_window_notify_focus (MetaWindow *window, return TRUE; } - if (window == window->display->focus_window) + if (focus_info && + window == focus_info->focus_window) { meta_topic (META_DEBUG_FOCUS, "%s is now the previous focus window due to being focused out or unmapped\n", @@ -6712,11 +6782,18 @@ meta_window_notify_focus (MetaWindow *window, meta_topic (META_DEBUG_FOCUS, "* Focus --> NULL (was %s)\n", window->desc); - meta_window_propagate_focus_appearance (window, FALSE); + meta_window_propagate_focus_appearance (window, keyboard, FALSE); + focus_info->focus_window = NULL; + + if (meta_device_get_id (keyboard) == META_CORE_KEYBOARD_ID) + g_object_notify (G_OBJECT (window->display), "focus-window"); - window->display->focus_window = NULL; - g_object_notify (G_OBJECT (window->display), "focus-window"); window->has_focus = FALSE; + window->focus_keyboard = NULL; + window->expecting_focus_in = FALSE; + + if (meta_device_get_id (keyboard) == META_CORE_KEYBOARD_ID) + g_object_notify (G_OBJECT (window->display), "focus-window"); if (!window->attached_focus_window) { diff --git a/src/meta/display.h b/src/meta/display.h index 19d53e2f2..ab3a7eae7 100644 --- a/src/meta/display.h +++ b/src/meta/display.h @@ -75,6 +75,9 @@ gboolean meta_display_has_shape (MetaDisplay *display); MetaScreen *meta_display_screen_for_root (MetaDisplay *display, Window xroot); + +MetaWindow *meta_display_get_keyboard_focus_window (MetaDisplay *display, + MetaDevice *keyboard); MetaWindow *meta_display_get_focus_window (MetaDisplay *display); gboolean meta_display_xwindow_is_a_no_focus_window (MetaDisplay *display, @@ -109,6 +112,26 @@ MetaWindow* meta_display_get_tab_current (MetaDisplay *display, MetaScreen *screen, MetaWorkspace *workspace); +GList* meta_display_get_device_tab_list (MetaDisplay *display, + MetaTabList type, + MetaScreen *screen, + MetaWorkspace *workspace, + MetaDevice *device); + +MetaWindow* meta_display_get_device_tab_next (MetaDisplay *display, + MetaTabList type, + MetaScreen *screen, + MetaWorkspace *workspace, + MetaWindow *window, + MetaDevice *device, + gboolean backward); + +MetaWindow* meta_display_get_device_tab_current (MetaDisplay *display, + MetaTabList type, + MetaScreen *screen, + MetaWorkspace *workspace, + MetaDevice *device); + gboolean meta_display_begin_grab_op (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, @@ -134,6 +157,16 @@ MetaKeyBindingAction meta_display_get_keybinding_action (MetaDisplay *display, unsigned int keycode, unsigned long mask); +void meta_display_set_keyboard_focus (MetaDisplay *display, + MetaWindow *window, + MetaDevice *keyboard, + gboolean focus_frame, + guint32 timestamp); +void meta_display_unset_keyboard_focus (MetaDisplay *display, + MetaScreen *screen, + MetaDevice *keyboard, + guint32 timestamp); + /* meta_display_set_input_focus_window is like XSetInputFocus, except * that (a) it can't detect timestamps later than the current time, * since Mutter isn't part of the XServer, and thus gives erroneous diff --git a/src/ui/tabpopup.c b/src/ui/tabpopup.c index 8c8c23d96..1ed94a0b1 100644 --- a/src/ui/tabpopup.c +++ b/src/ui/tabpopup.c @@ -858,12 +858,21 @@ static WnckWindowDisplayInfo meta_convert_meta_to_wnck (MetaWindow *window, MetaScreen *screen) { WnckWindowDisplayInfo wnck_window; + MetaFocusInfo *focus_info; + GHashTableIter iter; + wnck_window.icon = window->icon; wnck_window.mini_icon = window->mini_icon; wnck_window.is_active = FALSE; - if (window == window->display->expected_focus_window) - wnck_window.is_active = TRUE; + + g_hash_table_iter_init (&iter, window->display->focus_info); + + while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &focus_info)) + { + if (window == focus_info->expected_focus_window) + wnck_window.is_active = TRUE; + } if (window->frame) {