summaryrefslogtreecommitdiffstats
path: root/src/shell-window-tracker.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/shell-window-tracker.c')
-rw-r--r--src/shell-window-tracker.c850
1 files changed, 850 insertions, 0 deletions
diff --git a/src/shell-window-tracker.c b/src/shell-window-tracker.c
new file mode 100644
index 0000000..5c9d2ec
--- /dev/null
+++ b/src/shell-window-tracker.c
@@ -0,0 +1,850 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+#include "config.h"
+
+#include <string.h>
+#include <stdlib.h>
+
+#include <meta/display.h>
+#include <meta/group.h>
+#include <meta/util.h>
+#include <meta/window.h>
+#include <meta/meta-workspace-manager.h>
+#include <meta/meta-startup-notification.h>
+
+#include "shell-window-tracker-private.h"
+#include "shell-app-private.h"
+#include "shell-global.h"
+#include "st.h"
+
+/* This file includes modified code from
+ * desktop-data-engine/engine-dbus/hippo-application-monitor.c
+ * in the functions collecting application usage data.
+ * Written by Owen Taylor, originally licensed under LGPL 2.1.
+ * Copyright Red Hat, Inc. 2006-2008
+ */
+
+/**
+ * SECTION:shell-window-tracker
+ * @short_description: Associate windows with applications
+ *
+ * Maintains a mapping from windows to applications (.desktop file ids).
+ * It currently implements this with some heuristics on the WM_CLASS X11
+ * property (and some static override regexps); in the future, we want to
+ * have it also track through startup-notification.
+ */
+
+struct _ShellWindowTracker
+{
+ GObject parent;
+
+ ShellApp *focus_app;
+
+ /* <MetaWindow * window, ShellApp *app> */
+ GHashTable *window_to_app;
+};
+
+G_DEFINE_TYPE (ShellWindowTracker, shell_window_tracker, G_TYPE_OBJECT);
+
+enum {
+ PROP_0,
+ PROP_FOCUS_APP
+};
+
+enum {
+ STARTUP_SEQUENCE_CHANGED,
+ TRACKED_WINDOWS_CHANGED,
+
+ LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0 };
+
+static void shell_window_tracker_finalize (GObject *object);
+static void set_focus_app (ShellWindowTracker *tracker,
+ ShellApp *new_focus_app);
+static void on_focus_window_changed (MetaDisplay *display, GParamSpec *spec, ShellWindowTracker *tracker);
+
+static void track_window (ShellWindowTracker *tracker, MetaWindow *window);
+static void disassociate_window (ShellWindowTracker *tracker, MetaWindow *window);
+
+static ShellApp * shell_startup_sequence_get_app (MetaStartupSequence *sequence);
+
+static void
+shell_window_tracker_get_property (GObject *gobject,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ ShellWindowTracker *tracker = SHELL_WINDOW_TRACKER (gobject);
+
+ switch (prop_id)
+ {
+ case PROP_FOCUS_APP:
+ g_value_set_object (value, tracker->focus_app);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+shell_window_tracker_class_init (ShellWindowTrackerClass *klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+ gobject_class->get_property = shell_window_tracker_get_property;
+ gobject_class->finalize = shell_window_tracker_finalize;
+
+ g_object_class_install_property (gobject_class,
+ PROP_FOCUS_APP,
+ g_param_spec_object ("focus-app",
+ "Focus App",
+ "Focused application",
+ SHELL_TYPE_APP,
+ G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
+
+ signals[STARTUP_SEQUENCE_CHANGED] = g_signal_new ("startup-sequence-changed",
+ SHELL_TYPE_WINDOW_TRACKER,
+ G_SIGNAL_RUN_LAST,
+ 0,
+ NULL, NULL, NULL,
+ G_TYPE_NONE, 1, META_TYPE_STARTUP_SEQUENCE);
+ signals[TRACKED_WINDOWS_CHANGED] = g_signal_new ("tracked-windows-changed",
+ SHELL_TYPE_WINDOW_TRACKER,
+ G_SIGNAL_RUN_LAST,
+ 0,
+ NULL, NULL, NULL,
+ G_TYPE_NONE, 0);
+}
+
+static gboolean
+check_app_id_prefix (ShellApp *app,
+ const char *prefix)
+{
+ if (prefix == NULL)
+ return TRUE;
+
+ return g_str_has_prefix (shell_app_get_id (app), prefix);
+}
+
+/*
+ * get_app_from_window_wmclass:
+ *
+ * Looks only at the given window, and attempts to determine
+ * an application based on WM_CLASS. If one can't be determined,
+ * return %NULL.
+ *
+ * Return value: (transfer full): A newly-referenced #ShellApp, or %NULL
+ */
+static ShellApp *
+get_app_from_window_wmclass (MetaWindow *window)
+{
+ ShellApp *app;
+ ShellAppSystem *appsys;
+ const char *wm_class;
+ const char *wm_instance;
+ const char *sandbox_id;
+ g_autofree char *app_prefix = NULL;
+
+ appsys = shell_app_system_get_default ();
+
+ sandbox_id = meta_window_get_sandboxed_app_id (window);
+ if (sandbox_id)
+ app_prefix = g_strdup_printf ("%s.", sandbox_id);
+
+ /* Notes on the heuristics used here:
+ much of the complexity here comes from the desire to support
+ Chrome apps.
+
+ From https://bugzilla.gnome.org/show_bug.cgi?id=673657#c13
+
+ Currently chrome sets WM_CLASS as follows (the first string is the 'instance',
+ the second one is the 'class':
+
+ For the normal browser:
+ WM_CLASS(STRING) = "chromium", "Chromium"
+
+ For a bookmarked page (through 'Tools -> Create application shortcuts')
+ WM_CLASS(STRING) = "wiki.gnome.org__GnomeShell_ApplicationBased", "Chromium"
+
+ For an application from the chrome store (with a .desktop file created through
+ right click, "Create shortcuts" from Chrome's apps overview)
+ WM_CLASS(STRING) = "crx_blpcfgokakmgnkcojhhkbfbldkacnbeo", "Chromium"
+
+ The .desktop file has a matching StartupWMClass, but the name differs, e.g. for
+ the store app (youtube) there is
+
+ .local/share/applications/chrome-blpcfgokakmgnkcojhhkbfbldkacnbeo-Default.desktop
+
+ with
+
+ StartupWMClass=crx_blpcfgokakmgnkcojhhkbfbldkacnbeo
+
+ Note that chromium (but not google-chrome!) includes a StartupWMClass=chromium
+ in their .desktop file, so we must match the instance first.
+
+ Also note that in the good case (regular gtk+ app without hacks), instance and
+ class are the same except for case and there is no StartupWMClass at all.
+ */
+
+ /* first try a match from WM_CLASS (instance part) to StartupWMClass */
+ wm_instance = meta_window_get_wm_class_instance (window);
+ app = shell_app_system_lookup_startup_wmclass (appsys, wm_instance);
+ if (app != NULL && check_app_id_prefix (app, app_prefix))
+ return g_object_ref (app);
+
+ /* then try a match from WM_CLASS to StartupWMClass */
+ wm_class = meta_window_get_wm_class (window);
+ app = shell_app_system_lookup_startup_wmclass (appsys, wm_class);
+ if (app != NULL && check_app_id_prefix (app, app_prefix))
+ return g_object_ref (app);
+
+ /* then try a match from WM_CLASS (instance part) to .desktop */
+ app = shell_app_system_lookup_desktop_wmclass (appsys, wm_instance);
+ if (app != NULL && check_app_id_prefix (app, app_prefix))
+ return g_object_ref (app);
+
+ /* finally, try a match from WM_CLASS to .desktop */
+ app = shell_app_system_lookup_desktop_wmclass (appsys, wm_class);
+ if (app != NULL && check_app_id_prefix (app, app_prefix))
+ return g_object_ref (app);
+
+ return NULL;
+}
+
+/*
+ * get_app_from_id:
+ * @window: a #MetaWindow
+ *
+ * Looks only at the given window, and attempts to determine
+ * an application based on %id. If one can't be determined,
+ * return %NULL.
+ *
+ * Return value: (transfer full): A newly-referenced #ShellApp, or %NULL
+ */
+static ShellApp *
+get_app_from_id (MetaWindow *window,
+ const char *id)
+{
+ ShellApp *app;
+ ShellAppSystem *appsys;
+ g_autofree char *desktop_file = NULL;
+
+ g_return_val_if_fail (id != NULL, NULL);
+
+ appsys = shell_app_system_get_default ();
+
+ desktop_file = g_strconcat (id, ".desktop", NULL);
+ app = shell_app_system_lookup_app (appsys, desktop_file);
+ if (app)
+ return g_object_ref (app);
+
+ return NULL;
+}
+
+/*
+ * get_app_from_gapplication_id:
+ * @window: a #MetaWindow
+ *
+ * Looks only at the given window, and attempts to determine
+ * an application based on _GTK_APPLICATION_ID. If one can't be determined,
+ * return %NULL.
+ *
+ * Return value: (transfer full): A newly-referenced #ShellApp, or %NULL
+ */
+static ShellApp *
+get_app_from_gapplication_id (MetaWindow *window)
+{
+ const char *id;
+
+ id = meta_window_get_gtk_application_id (window);
+ if (!id)
+ return NULL;
+
+ return get_app_from_id (window, id);
+}
+
+/*
+ * get_app_from_sandboxed_app_id:
+ * @window: a #MetaWindow
+ *
+ * Looks only at the given window, and attempts to determine
+ * an application based on its Flatpak or Snap ID. If one can't be determined,
+ * return %NULL.
+ *
+ * Return value: (transfer full): A newly-referenced #ShellApp, or %NULL
+ */
+static ShellApp *
+get_app_from_sandboxed_app_id (MetaWindow *window)
+{
+ const char *id;
+
+ id = meta_window_get_sandboxed_app_id (window);
+ if (!id)
+ return NULL;
+
+ return get_app_from_id (window, id);
+}
+
+/*
+ * get_app_from_window_group:
+ * @monitor: a #ShellWindowTracker
+ * @window: a #MetaWindow
+ *
+ * Check other windows in the group for @window to see if we have
+ * an application for one of them.
+ *
+ * Return value: (transfer full): A newly-referenced #ShellApp, or %NULL
+ */
+static ShellApp*
+get_app_from_window_group (ShellWindowTracker *tracker,
+ MetaWindow *window)
+{
+ ShellApp *result;
+ GSList *group_windows;
+ MetaGroup *group;
+ GSList *iter;
+
+ group = meta_window_get_group (window);
+ if (group == NULL)
+ return NULL;
+
+ group_windows = meta_group_list_windows (group);
+
+ result = NULL;
+ /* Try finding a window in the group of type NORMAL; if we
+ * succeed, use that as our source. */
+ for (iter = group_windows; iter; iter = iter->next)
+ {
+ MetaWindow *group_window = iter->data;
+
+ if (meta_window_get_window_type (group_window) != META_WINDOW_NORMAL)
+ continue;
+
+ result = g_hash_table_lookup (tracker->window_to_app, group_window);
+ if (result)
+ break;
+ }
+
+ g_slist_free (group_windows);
+
+ if (result)
+ g_object_ref (result);
+
+ return result;
+}
+
+/*
+ * get_app_from_window_pid:
+ * @tracker: a #ShellWindowTracker
+ * @window: a #MetaWindow
+ *
+ * Check if the pid associated with @window corresponds to an
+ * application.
+ *
+ * Return value: (transfer full): A newly-referenced #ShellApp, or %NULL
+ */
+static ShellApp *
+get_app_from_window_pid (ShellWindowTracker *tracker,
+ MetaWindow *window)
+{
+ ShellApp *result;
+ pid_t pid;
+
+ if (meta_window_is_remote (window))
+ return NULL;
+
+ pid = meta_window_get_pid (window);
+
+ if (pid < 1)
+ return NULL;
+
+ result = shell_window_tracker_get_app_from_pid (tracker, pid);
+ if (result != NULL)
+ g_object_ref (result);
+
+ return result;
+}
+
+/**
+ * get_app_for_window:
+ *
+ * Determines the application associated with a window, using
+ * all available information such as the window's MetaGroup,
+ * and what we know about other windows.
+ *
+ * Returns: (transfer full): a #ShellApp, or NULL if none is found
+ */
+static ShellApp *
+get_app_for_window (ShellWindowTracker *tracker,
+ MetaWindow *window)
+{
+ ShellApp *result = NULL;
+ MetaWindow *transient_for;
+ const char *startup_id;
+
+ transient_for = meta_window_get_transient_for (window);
+ if (transient_for != NULL)
+ return get_app_for_window (tracker, transient_for);
+
+ /* First, we check whether we already know about this window,
+ * if so, just return that.
+ */
+ if (meta_window_get_window_type (window) == META_WINDOW_NORMAL
+ || meta_window_is_remote (window))
+ {
+ result = g_hash_table_lookup (tracker->window_to_app, window);
+ if (result != NULL)
+ {
+ g_object_ref (result);
+ return result;
+ }
+ }
+
+ if (meta_window_is_remote (window))
+ return _shell_app_new_for_window (window);
+
+ /* Check if the app's WM_CLASS specifies an app; this is
+ * canonical if it does.
+ */
+ result = get_app_from_window_wmclass (window);
+ if (result != NULL)
+ return result;
+
+ /* Check if the window was opened from within a sandbox; if this
+ * is the case, a corresponding .desktop file is guaranteed to match;
+ */
+ result = get_app_from_sandboxed_app_id (window);
+ if (result != NULL)
+ return result;
+
+ /* Check if the window has a GApplication ID attached; this is
+ * canonical if it does
+ */
+ result = get_app_from_gapplication_id (window);
+ if (result != NULL)
+ return result;
+
+ result = get_app_from_window_pid (tracker, window);
+ if (result != NULL)
+ return result;
+
+ /* Now we check whether we have a match through startup-notification */
+ startup_id = meta_window_get_startup_id (window);
+ if (startup_id)
+ {
+ GSList *iter, *sequences;
+
+ sequences = shell_window_tracker_get_startup_sequences (tracker);
+ for (iter = sequences; iter; iter = iter->next)
+ {
+ MetaStartupSequence *sequence = iter->data;
+ const char *id = meta_startup_sequence_get_id (sequence);
+ if (strcmp (id, startup_id) != 0)
+ continue;
+
+ result = shell_startup_sequence_get_app (sequence);
+ if (result)
+ {
+ result = g_object_ref (result);
+ break;
+ }
+ }
+ }
+
+ /* If we didn't get a startup-notification match, see if we matched
+ * any other windows in the group.
+ */
+ if (result == NULL)
+ result = get_app_from_window_group (tracker, window);
+
+ /* Our last resort - we create a fake app from the window */
+ if (result == NULL)
+ result = _shell_app_new_for_window (window);
+
+ return result;
+}
+
+static void
+update_focus_app (ShellWindowTracker *self)
+{
+ MetaWindow *new_focus_win;
+ ShellApp *new_focus_app;
+
+ new_focus_win = meta_display_get_focus_window (shell_global_get_display (shell_global_get ()));
+
+ /* we only consider an app focused if the focus window can be clearly
+ * associated with a running app; this is the case if the focus window
+ * or one of its parents is visible in the taskbar, e.g.
+ * - 'nautilus' should appear focused when its about dialog has focus
+ * - 'nautilus' should not appear focused when the DESKTOP has focus
+ */
+ while (new_focus_win && meta_window_is_skip_taskbar (new_focus_win))
+ new_focus_win = meta_window_get_transient_for (new_focus_win);
+
+ new_focus_app = new_focus_win ? shell_window_tracker_get_window_app (self, new_focus_win) : NULL;
+
+ if (new_focus_app)
+ {
+ shell_app_update_window_actions (new_focus_app, new_focus_win);
+ shell_app_update_app_actions (new_focus_app, new_focus_win);
+ }
+
+ set_focus_app (self, new_focus_app);
+
+ g_clear_object (&new_focus_app);
+}
+
+static void
+tracked_window_changed (ShellWindowTracker *self,
+ MetaWindow *window)
+{
+ /* It's simplest to just treat this as a remove + add. */
+ disassociate_window (self, window);
+ track_window (self, window);
+ /* also just recalculate the focused app, in case it was the focused
+ window that changed */
+ update_focus_app (self);
+}
+
+static void
+on_wm_class_changed (MetaWindow *window,
+ GParamSpec *pspec,
+ gpointer user_data)
+{
+ ShellWindowTracker *self = SHELL_WINDOW_TRACKER (user_data);
+ tracked_window_changed (self, window);
+}
+
+static void
+on_gtk_application_id_changed (MetaWindow *window,
+ GParamSpec *pspec,
+ gpointer user_data)
+{
+ ShellWindowTracker *self = SHELL_WINDOW_TRACKER (user_data);
+ tracked_window_changed (self, window);
+}
+
+static void
+track_window (ShellWindowTracker *self,
+ MetaWindow *window)
+{
+ ShellApp *app;
+
+ app = get_app_for_window (self, window);
+ if (!app)
+ return;
+
+ /* At this point we've stored the association from window -> application */
+ g_hash_table_insert (self->window_to_app, window, app);
+
+ g_signal_connect (window, "notify::wm-class", G_CALLBACK (on_wm_class_changed), self);
+ g_signal_connect (window, "notify::gtk-application-id", G_CALLBACK (on_gtk_application_id_changed), self);
+
+ _shell_app_add_window (app, window);
+
+ g_signal_emit (self, signals[TRACKED_WINDOWS_CHANGED], 0);
+}
+
+static void
+shell_window_tracker_on_window_added (MetaWorkspace *workspace,
+ MetaWindow *window,
+ gpointer user_data)
+{
+ ShellWindowTracker *self = SHELL_WINDOW_TRACKER (user_data);
+ MetaWindowType window_type = meta_window_get_window_type (window);
+
+ if (window_type == META_WINDOW_NORMAL ||
+ window_type == META_WINDOW_DIALOG ||
+ window_type == META_WINDOW_UTILITY ||
+ window_type == META_WINDOW_MODAL_DIALOG)
+ track_window (self, window);
+}
+
+static void
+disassociate_window (ShellWindowTracker *self,
+ MetaWindow *window)
+{
+ ShellApp *app;
+
+ app = g_hash_table_lookup (self->window_to_app, window);
+ if (!app)
+ return;
+
+ g_object_ref (app);
+
+ g_hash_table_remove (self->window_to_app, window);
+
+ _shell_app_remove_window (app, window);
+ g_signal_handlers_disconnect_by_func (window, G_CALLBACK (on_wm_class_changed), self);
+ g_signal_handlers_disconnect_by_func (window, G_CALLBACK (on_gtk_application_id_changed), self);
+
+ g_signal_emit (self, signals[TRACKED_WINDOWS_CHANGED], 0);
+
+ g_object_unref (app);
+}
+
+static void
+shell_window_tracker_on_window_removed (MetaWorkspace *workspace,
+ MetaWindow *window,
+ gpointer user_data)
+{
+ disassociate_window (SHELL_WINDOW_TRACKER (user_data), window);
+}
+
+static void
+load_initial_windows (ShellWindowTracker *tracker)
+{
+ MetaDisplay *display = shell_global_get_display (shell_global_get ());
+ MetaWorkspaceManager *workspace_manager =
+ meta_display_get_workspace_manager (display);
+ GList *workspaces;
+ GList *l;
+
+ workspaces = meta_workspace_manager_get_workspaces (workspace_manager);
+ for (l = workspaces; l; l = l->next)
+ {
+ MetaWorkspace *workspace = l->data;
+ GList *windows = meta_workspace_list_windows (workspace);
+ GList *window_iter;
+
+ for (window_iter = windows; window_iter; window_iter = window_iter->next)
+ {
+ MetaWindow *window = window_iter->data;
+ track_window (tracker, window);
+ }
+
+ g_list_free (windows);
+ }
+}
+
+static void
+shell_window_tracker_on_n_workspaces_changed (MetaWorkspaceManager *workspace_manager,
+ GParamSpec *pspec,
+ gpointer user_data)
+{
+ ShellWindowTracker *self = SHELL_WINDOW_TRACKER (user_data);
+ GList *workspaces;
+ GList *l;
+
+ workspaces = meta_workspace_manager_get_workspaces (workspace_manager);
+ for (l = workspaces; l; l = l->next)
+ {
+ MetaWorkspace *workspace = l->data;
+
+ /* This pair of disconnect/connect is idempotent if we were
+ * already connected, while ensuring we get connected for
+ * new workspaces.
+ */
+ g_signal_handlers_disconnect_by_func (workspace,
+ shell_window_tracker_on_window_added,
+ self);
+ g_signal_handlers_disconnect_by_func (workspace,
+ shell_window_tracker_on_window_removed,
+ self);
+
+ g_signal_connect (workspace, "window-added",
+ G_CALLBACK (shell_window_tracker_on_window_added), self);
+ g_signal_connect (workspace, "window-removed",
+ G_CALLBACK (shell_window_tracker_on_window_removed), self);
+ }
+}
+
+static void
+init_window_tracking (ShellWindowTracker *self)
+{
+ MetaDisplay *display = shell_global_get_display (shell_global_get ());
+ MetaWorkspaceManager *workspace_manager =
+ meta_display_get_workspace_manager (display);
+
+ g_signal_connect (workspace_manager, "notify::n-workspaces",
+ G_CALLBACK (shell_window_tracker_on_n_workspaces_changed), self);
+ g_signal_connect (display, "notify::focus-window",
+ G_CALLBACK (on_focus_window_changed), self);
+
+ shell_window_tracker_on_n_workspaces_changed (workspace_manager, NULL, self);
+}
+
+static void
+on_startup_sequence_changed (MetaStartupNotification *sn,
+ MetaStartupSequence *sequence,
+ ShellWindowTracker *self)
+{
+ ShellApp *app;
+
+ app = shell_startup_sequence_get_app (sequence);
+ if (app)
+ _shell_app_handle_startup_sequence (app, sequence);
+
+ g_signal_emit (G_OBJECT (self), signals[STARTUP_SEQUENCE_CHANGED], 0, sequence);
+}
+
+static void
+shell_window_tracker_init (ShellWindowTracker *self)
+{
+ MetaDisplay *display = shell_global_get_display (shell_global_get ());
+ MetaStartupNotification *sn = meta_display_get_startup_notification (display);
+
+ self->window_to_app = g_hash_table_new_full (g_direct_hash, g_direct_equal,
+ NULL, (GDestroyNotify) g_object_unref);
+
+
+ g_signal_connect (sn, "changed",
+ G_CALLBACK (on_startup_sequence_changed), self);
+
+ load_initial_windows (self);
+ init_window_tracking (self);
+}
+
+static void
+shell_window_tracker_finalize (GObject *object)
+{
+ ShellWindowTracker *self = SHELL_WINDOW_TRACKER (object);
+
+ g_hash_table_destroy (self->window_to_app);
+
+ G_OBJECT_CLASS (shell_window_tracker_parent_class)->finalize(object);
+}
+
+/**
+ * shell_window_tracker_get_window_app:
+ * @tracker: An app monitor instance
+ * @metawin: A #MetaWindow
+ *
+ * Returns: (transfer full): Application associated with window
+ */
+ShellApp *
+shell_window_tracker_get_window_app (ShellWindowTracker *tracker,
+ MetaWindow *metawin)
+{
+ ShellApp *app;
+
+ app = g_hash_table_lookup (tracker->window_to_app, metawin);
+ if (app)
+ g_object_ref (app);
+
+ return app;
+}
+
+
+/**
+ * shell_window_tracker_get_app_from_pid:
+ * @tracker: A #ShellAppSystem
+ * @pid: A Unix process identifier
+ *
+ * Look up the application corresponding to a process.
+ *
+ * Returns: (transfer none): A #ShellApp, or %NULL if none
+ */
+ShellApp *
+shell_window_tracker_get_app_from_pid (ShellWindowTracker *tracker,
+ int pid)
+{
+ GSList *running = shell_app_system_get_running (shell_app_system_get_default());
+ GSList *iter;
+ ShellApp *result = NULL;
+
+ for (iter = running; iter; iter = iter->next)
+ {
+ ShellApp *app = iter->data;
+ GSList *pids = shell_app_get_pids (app);
+ GSList *pids_iter;
+
+ for (pids_iter = pids; pids_iter; pids_iter = pids_iter->next)
+ {
+ int app_pid = GPOINTER_TO_INT (pids_iter->data);
+ if (app_pid == pid)
+ {
+ result = app;
+ break;
+ }
+ }
+ g_slist_free (pids);
+
+ if (result != NULL)
+ break;
+ }
+
+ g_slist_free (running);
+
+ return result;
+}
+
+static void
+set_focus_app (ShellWindowTracker *tracker,
+ ShellApp *new_focus_app)
+{
+ if (new_focus_app == tracker->focus_app)
+ return;
+
+ if (tracker->focus_app != NULL)
+ g_object_unref (tracker->focus_app);
+
+ tracker->focus_app = new_focus_app;
+
+ if (tracker->focus_app != NULL)
+ g_object_ref (tracker->focus_app);
+
+ g_object_notify (G_OBJECT (tracker), "focus-app");
+}
+
+static void
+on_focus_window_changed (MetaDisplay *display,
+ GParamSpec *spec,
+ ShellWindowTracker *tracker)
+{
+ update_focus_app (tracker);
+}
+
+/**
+ * shell_window_tracker_get_startup_sequences:
+ * @tracker:
+ *
+ * Returns: (transfer none) (element-type MetaStartupSequence): Currently active startup sequences
+ */
+GSList *
+shell_window_tracker_get_startup_sequences (ShellWindowTracker *self)
+{
+ ShellGlobal *global = shell_global_get ();
+ MetaDisplay *display = shell_global_get_display (global);
+ MetaStartupNotification *sn = meta_display_get_startup_notification (display);
+
+ return meta_startup_notification_get_sequences (sn);
+}
+
+static ShellApp *
+shell_startup_sequence_get_app (MetaStartupSequence *sequence)
+{
+ const char *appid;
+ char *basename;
+ ShellAppSystem *appsys;
+ ShellApp *app;
+
+ appid = meta_startup_sequence_get_application_id (sequence);
+ if (!appid)
+ return NULL;
+
+ basename = g_path_get_basename (appid);
+ appsys = shell_app_system_get_default ();
+ app = shell_app_system_lookup_app (appsys, basename);
+ g_free (basename);
+ return app;
+}
+
+/**
+ * shell_window_tracker_get_default:
+ *
+ * Return Value: (transfer none): The global #ShellWindowTracker instance
+ */
+ShellWindowTracker *
+shell_window_tracker_get_default (void)
+{
+ static ShellWindowTracker *instance;
+
+ if (instance == NULL)
+ instance = g_object_new (SHELL_TYPE_WINDOW_TRACKER, NULL);
+
+ return instance;
+}