4b522a02c3
When the amount of free memory on the system is somewhat low, gnome-shell will sometimes fail to launch apps, reporting the error: fork(): Cannot allocate memory fork() is failing here because while cloning the process virtual address space, Linux worries that the thread being forked may end up COWing the entire address space of the parent process (gnome-shell, which is memory-hungry), and there is not enough free memory to permit that to happen. This check is somewhat irrelevant because we are only forking to immediately exec(), which will discard the whole virtual address space anyway. This issue can be avoided by using a new optimized gspawn codepath in the latest glib development version, which uses posix_spawn() internally. For the optimized codepath to be used, we must not pass a child_setup function, so the the file descriptor management is reimplemented here using new glib API to pass fds to the child process. The old API will continue to be used on older glib versions. We must also change the spawn flags for this code path to be hit. I checked that gnome-shell's open file descriptors are all CLOEXEC so using G_SPAWN_LEAVE_DESCRIPTORS_OPEN should be safe. This will result in more resilient app launching when memory is low, since the optimized spawn path avoids cloning the virtual address space of the parent process (gnome-shell) and avoids the irrelevant memory overcommit check. https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/132
1605 lines
47 KiB
C
1605 lines
47 KiB
C
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
|
|
|
|
#include "config.h"
|
|
|
|
#include <string.h>
|
|
|
|
#include <glib/gi18n-lib.h>
|
|
|
|
#include <meta/display.h>
|
|
#include <meta/meta-workspace-manager.h>
|
|
#include <meta/meta-x11-display.h>
|
|
|
|
#include "shell-app-private.h"
|
|
#include "shell-enum-types.h"
|
|
#include "shell-global.h"
|
|
#include "shell-util.h"
|
|
#include "shell-app-system-private.h"
|
|
#include "shell-window-tracker-private.h"
|
|
#include "st.h"
|
|
#include "gtkactionmuxer.h"
|
|
#include "org-gtk-application.h"
|
|
|
|
#ifdef HAVE_SYSTEMD
|
|
#include <systemd/sd-journal.h>
|
|
#include <errno.h>
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
typedef enum {
|
|
MATCH_NONE,
|
|
MATCH_SUBSTRING, /* Not prefix, substring */
|
|
MATCH_PREFIX, /* Strict prefix */
|
|
} ShellAppSearchMatch;
|
|
|
|
/* This is mainly a memory usage optimization - the user is going to
|
|
* be running far fewer of the applications at one time than they have
|
|
* installed. But it also just helps keep the code more logically
|
|
* separated.
|
|
*/
|
|
typedef struct {
|
|
guint refcount;
|
|
|
|
/* Signal connection to dirty window sort list on workspace changes */
|
|
guint workspace_switch_id;
|
|
|
|
GSList *windows;
|
|
|
|
guint interesting_windows;
|
|
|
|
/* Whether or not we need to resort the windows; this is done on demand */
|
|
guint window_sort_stale : 1;
|
|
|
|
/* See GApplication documentation */
|
|
GDBusMenuModel *remote_menu;
|
|
GtkActionMuxer *muxer;
|
|
char *unique_bus_name;
|
|
GDBusConnection *session;
|
|
|
|
/* GDBus Proxy for getting application busy state */
|
|
ShellOrgGtkApplication *application_proxy;
|
|
GCancellable *cancellable;
|
|
|
|
} ShellAppRunningState;
|
|
|
|
/**
|
|
* SECTION:shell-app
|
|
* @short_description: Object representing an application
|
|
*
|
|
* This object wraps a #GDesktopAppInfo, providing methods and signals
|
|
* primarily useful for running applications.
|
|
*/
|
|
struct _ShellApp
|
|
{
|
|
GObject parent;
|
|
|
|
int started_on_workspace;
|
|
|
|
ShellAppState state;
|
|
|
|
GDesktopAppInfo *info; /* If NULL, this app is backed by one or more
|
|
* MetaWindow. For purposes of app title
|
|
* etc., we use the first window added,
|
|
* because it's most likely to be what we
|
|
* want (e.g. it will be of TYPE_NORMAL from
|
|
* the way shell-window-tracker.c works).
|
|
*/
|
|
|
|
ShellAppRunningState *running_state;
|
|
|
|
char *window_id_string;
|
|
char *name_collation_key;
|
|
};
|
|
|
|
enum {
|
|
PROP_0,
|
|
PROP_STATE,
|
|
PROP_BUSY,
|
|
PROP_ID,
|
|
PROP_DBUS_ID,
|
|
PROP_ACTION_GROUP,
|
|
PROP_MENU,
|
|
PROP_APP_INFO
|
|
};
|
|
|
|
enum {
|
|
WINDOWS_CHANGED,
|
|
LAST_SIGNAL
|
|
};
|
|
|
|
static guint shell_app_signals[LAST_SIGNAL] = { 0 };
|
|
|
|
static void create_running_state (ShellApp *app);
|
|
static void unref_running_state (ShellAppRunningState *state);
|
|
|
|
G_DEFINE_TYPE (ShellApp, shell_app, G_TYPE_OBJECT)
|
|
|
|
static void
|
|
shell_app_get_property (GObject *gobject,
|
|
guint prop_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
ShellApp *app = SHELL_APP (gobject);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_STATE:
|
|
g_value_set_enum (value, app->state);
|
|
break;
|
|
case PROP_BUSY:
|
|
g_value_set_boolean (value, shell_app_get_busy (app));
|
|
break;
|
|
case PROP_ID:
|
|
g_value_set_string (value, shell_app_get_id (app));
|
|
break;
|
|
case PROP_ACTION_GROUP:
|
|
if (app->running_state)
|
|
g_value_set_object (value, app->running_state->muxer);
|
|
break;
|
|
case PROP_MENU:
|
|
if (app->running_state)
|
|
g_value_set_object (value, app->running_state->remote_menu);
|
|
break;
|
|
case PROP_APP_INFO:
|
|
if (app->info)
|
|
g_value_set_object (value, app->info);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
shell_app_set_property (GObject *gobject,
|
|
guint prop_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
ShellApp *app = SHELL_APP (gobject);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_APP_INFO:
|
|
_shell_app_set_app_info (app, g_value_get_object (value));
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
const char *
|
|
shell_app_get_id (ShellApp *app)
|
|
{
|
|
if (app->info)
|
|
return g_app_info_get_id (G_APP_INFO (app->info));
|
|
return app->window_id_string;
|
|
}
|
|
|
|
static MetaWindow *
|
|
window_backed_app_get_window (ShellApp *app)
|
|
{
|
|
g_assert (app->info == NULL);
|
|
if (app->running_state)
|
|
{
|
|
g_assert (app->running_state->windows);
|
|
return app->running_state->windows->data;
|
|
}
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
static ClutterActor *
|
|
window_backed_app_get_icon (ShellApp *app,
|
|
int size)
|
|
{
|
|
MetaWindow *window = NULL;
|
|
ClutterActor *actor;
|
|
gint scale;
|
|
ShellGlobal *global;
|
|
StThemeContext *context;
|
|
|
|
global = shell_global_get ();
|
|
context = st_theme_context_get_for_stage (shell_global_get_stage (global));
|
|
g_object_get (context, "scale-factor", &scale, NULL);
|
|
|
|
size *= scale;
|
|
|
|
/* During a state transition from running to not-running for
|
|
* window-backend apps, it's possible we get a request for the icon.
|
|
* Avoid asserting here and just return an empty image.
|
|
*/
|
|
if (app->running_state != NULL)
|
|
window = window_backed_app_get_window (app);
|
|
|
|
if (window == NULL)
|
|
{
|
|
actor = clutter_texture_new ();
|
|
g_object_set (actor, "opacity", 0, "width", (float) size, "height", (float) size, NULL);
|
|
return actor;
|
|
}
|
|
|
|
actor = st_texture_cache_bind_cairo_surface_property (st_texture_cache_get_default (),
|
|
G_OBJECT (window),
|
|
"icon");
|
|
g_object_set (actor, "width", (float) size, "height", (float) size, NULL);
|
|
return actor;
|
|
}
|
|
|
|
/**
|
|
* shell_app_create_icon_texture:
|
|
*
|
|
* Look up the icon for this application, and create a #ClutterTexture
|
|
* for it at the given size.
|
|
*
|
|
* Return value: (transfer none): A floating #ClutterActor
|
|
*/
|
|
ClutterActor *
|
|
shell_app_create_icon_texture (ShellApp *app,
|
|
int size)
|
|
{
|
|
GIcon *icon;
|
|
ClutterActor *ret;
|
|
|
|
if (app->info == NULL)
|
|
return window_backed_app_get_icon (app, size);
|
|
|
|
ret = st_icon_new ();
|
|
st_icon_set_icon_size (ST_ICON (ret), size);
|
|
st_icon_set_fallback_icon_name (ST_ICON (ret), "application-x-executable");
|
|
|
|
icon = g_app_info_get_icon (G_APP_INFO (app->info));
|
|
st_icon_set_gicon (ST_ICON (ret), icon);
|
|
|
|
return ret;
|
|
}
|
|
|
|
const char *
|
|
shell_app_get_name (ShellApp *app)
|
|
{
|
|
if (app->info)
|
|
return g_app_info_get_name (G_APP_INFO (app->info));
|
|
else
|
|
{
|
|
MetaWindow *window = window_backed_app_get_window (app);
|
|
const char *name = NULL;
|
|
|
|
if (window)
|
|
name = meta_window_get_wm_class (window);
|
|
if (!name)
|
|
name = C_("program", "Unknown");
|
|
return name;
|
|
}
|
|
}
|
|
|
|
const char *
|
|
shell_app_get_description (ShellApp *app)
|
|
{
|
|
if (app->info)
|
|
return g_app_info_get_description (G_APP_INFO (app->info));
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* shell_app_is_window_backed:
|
|
*
|
|
* A window backed application is one which represents just an open
|
|
* window, i.e. there's no .desktop file assocation, so we don't know
|
|
* how to launch it again.
|
|
*/
|
|
gboolean
|
|
shell_app_is_window_backed (ShellApp *app)
|
|
{
|
|
return app->info == NULL;
|
|
}
|
|
|
|
typedef struct {
|
|
MetaWorkspace *workspace;
|
|
GSList **transients;
|
|
} CollectTransientsData;
|
|
|
|
static gboolean
|
|
collect_transients_on_workspace (MetaWindow *window,
|
|
gpointer datap)
|
|
{
|
|
CollectTransientsData *data = datap;
|
|
|
|
if (data->workspace && meta_window_get_workspace (window) != data->workspace)
|
|
return TRUE;
|
|
|
|
*data->transients = g_slist_prepend (*data->transients, window);
|
|
return TRUE;
|
|
}
|
|
|
|
/* The basic idea here is that when we're targeting a window,
|
|
* if it has transients we want to pick the most recent one
|
|
* the user interacted with.
|
|
* This function makes raising GEdit with the file chooser
|
|
* open work correctly.
|
|
*/
|
|
static MetaWindow *
|
|
find_most_recent_transient_on_same_workspace (MetaDisplay *display,
|
|
MetaWindow *reference)
|
|
{
|
|
GSList *transients, *transients_sorted, *iter;
|
|
MetaWindow *result;
|
|
CollectTransientsData data;
|
|
|
|
transients = NULL;
|
|
data.workspace = meta_window_get_workspace (reference);
|
|
data.transients = &transients;
|
|
|
|
meta_window_foreach_transient (reference, collect_transients_on_workspace, &data);
|
|
|
|
transients_sorted = meta_display_sort_windows_by_stacking (display, transients);
|
|
/* Reverse this so we're top-to-bottom (yes, we should probably change the order
|
|
* returned from the sort_windows_by_stacking function)
|
|
*/
|
|
transients_sorted = g_slist_reverse (transients_sorted);
|
|
g_slist_free (transients);
|
|
transients = NULL;
|
|
|
|
result = NULL;
|
|
for (iter = transients_sorted; iter; iter = iter->next)
|
|
{
|
|
MetaWindow *window = iter->data;
|
|
MetaWindowType wintype = meta_window_get_window_type (window);
|
|
|
|
/* Don't want to focus UTILITY types, like the Gimp toolbars */
|
|
if (wintype == META_WINDOW_NORMAL ||
|
|
wintype == META_WINDOW_DIALOG)
|
|
{
|
|
result = window;
|
|
break;
|
|
}
|
|
}
|
|
g_slist_free (transients_sorted);
|
|
return result;
|
|
}
|
|
|
|
static MetaWorkspace *
|
|
get_active_workspace (void)
|
|
{
|
|
ShellGlobal *global = shell_global_get ();
|
|
MetaDisplay *display = shell_global_get_display (global);
|
|
MetaWorkspaceManager *workspace_manager =
|
|
meta_display_get_workspace_manager (display);
|
|
|
|
return meta_workspace_manager_get_active_workspace (workspace_manager);
|
|
}
|
|
|
|
/**
|
|
* shell_app_activate_window:
|
|
* @app: a #ShellApp
|
|
* @window: (nullable): Window to be focused
|
|
* @timestamp: Event timestamp
|
|
*
|
|
* Bring all windows for the given app to the foreground,
|
|
* but ensure that @window is on top. If @window is %NULL,
|
|
* the window with the most recent user time for the app
|
|
* will be used.
|
|
*
|
|
* This function has no effect if @app is not currently running.
|
|
*/
|
|
void
|
|
shell_app_activate_window (ShellApp *app,
|
|
MetaWindow *window,
|
|
guint32 timestamp)
|
|
{
|
|
GSList *windows;
|
|
|
|
if (shell_app_get_state (app) != SHELL_APP_STATE_RUNNING)
|
|
return;
|
|
|
|
windows = shell_app_get_windows (app);
|
|
if (window == NULL && windows)
|
|
window = windows->data;
|
|
|
|
if (!g_slist_find (windows, window))
|
|
return;
|
|
else
|
|
{
|
|
GSList *windows_reversed, *iter;
|
|
ShellGlobal *global = shell_global_get ();
|
|
MetaDisplay *display = shell_global_get_display (global);
|
|
MetaWorkspace *active = get_active_workspace ();
|
|
MetaWorkspace *workspace = meta_window_get_workspace (window);
|
|
guint32 last_user_timestamp = meta_display_get_last_user_time (display);
|
|
MetaWindow *most_recent_transient;
|
|
|
|
if (meta_display_xserver_time_is_before (display, timestamp, last_user_timestamp))
|
|
{
|
|
meta_window_set_demands_attention (window);
|
|
return;
|
|
}
|
|
|
|
/* Now raise all the other windows for the app that are on
|
|
* the same workspace, in reverse order to preserve the stacking.
|
|
*/
|
|
windows_reversed = g_slist_copy (windows);
|
|
windows_reversed = g_slist_reverse (windows_reversed);
|
|
for (iter = windows_reversed; iter; iter = iter->next)
|
|
{
|
|
MetaWindow *other_window = iter->data;
|
|
|
|
if (other_window != window && meta_window_get_workspace (other_window) == workspace)
|
|
meta_window_raise (other_window);
|
|
}
|
|
g_slist_free (windows_reversed);
|
|
|
|
/* If we have a transient that the user's interacted with more recently than
|
|
* the window, pick that.
|
|
*/
|
|
most_recent_transient = find_most_recent_transient_on_same_workspace (display, window);
|
|
if (most_recent_transient
|
|
&& meta_display_xserver_time_is_before (display,
|
|
meta_window_get_user_time (window),
|
|
meta_window_get_user_time (most_recent_transient)))
|
|
window = most_recent_transient;
|
|
|
|
|
|
if (active != workspace)
|
|
meta_workspace_activate_with_focus (workspace, window, timestamp);
|
|
else
|
|
meta_window_activate (window, timestamp);
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
shell_app_update_window_actions (ShellApp *app, MetaWindow *window)
|
|
{
|
|
const char *object_path;
|
|
|
|
object_path = meta_window_get_gtk_window_object_path (window);
|
|
if (object_path != NULL)
|
|
{
|
|
GActionGroup *actions;
|
|
|
|
actions = g_object_get_data (G_OBJECT (window), "actions");
|
|
if (actions == NULL)
|
|
{
|
|
actions = G_ACTION_GROUP (g_dbus_action_group_get (app->running_state->session,
|
|
meta_window_get_gtk_unique_bus_name (window),
|
|
object_path));
|
|
g_object_set_data_full (G_OBJECT (window), "actions", actions, g_object_unref);
|
|
}
|
|
|
|
g_assert (app->running_state->muxer);
|
|
gtk_action_muxer_insert (app->running_state->muxer, "win", actions);
|
|
g_object_notify (G_OBJECT (app), "action-group");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* shell_app_activate:
|
|
* @app: a #ShellApp
|
|
*
|
|
* Like shell_app_activate_full(), but using the default workspace and
|
|
* event timestamp.
|
|
*/
|
|
void
|
|
shell_app_activate (ShellApp *app)
|
|
{
|
|
return shell_app_activate_full (app, -1, 0);
|
|
}
|
|
|
|
/**
|
|
* shell_app_activate_full:
|
|
* @app: a #ShellApp
|
|
* @workspace: launch on this workspace, or -1 for default. Ignored if
|
|
* activating an existing window
|
|
* @timestamp: Event timestamp
|
|
*
|
|
* Perform an appropriate default action for operating on this application,
|
|
* dependent on its current state. For example, if the application is not
|
|
* currently running, launch it. If it is running, activate the most
|
|
* recently used NORMAL window (or if that window has a transient, the most
|
|
* recently used transient for that window).
|
|
*/
|
|
void
|
|
shell_app_activate_full (ShellApp *app,
|
|
int workspace,
|
|
guint32 timestamp)
|
|
{
|
|
ShellGlobal *global;
|
|
|
|
global = shell_global_get ();
|
|
|
|
if (timestamp == 0)
|
|
timestamp = shell_global_get_current_time (global);
|
|
|
|
switch (app->state)
|
|
{
|
|
case SHELL_APP_STATE_STOPPED:
|
|
{
|
|
GError *error = NULL;
|
|
if (!shell_app_launch (app, timestamp, workspace, FALSE, &error))
|
|
{
|
|
char *msg;
|
|
msg = g_strdup_printf (_("Failed to launch “%s”"), shell_app_get_name (app));
|
|
shell_global_notify_error (global,
|
|
msg,
|
|
error->message);
|
|
g_free (msg);
|
|
g_clear_error (&error);
|
|
}
|
|
}
|
|
break;
|
|
case SHELL_APP_STATE_STARTING:
|
|
break;
|
|
case SHELL_APP_STATE_RUNNING:
|
|
shell_app_activate_window (app, NULL, timestamp);
|
|
break;
|
|
default:
|
|
g_assert_not_reached();
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* shell_app_open_new_window:
|
|
* @app: a #ShellApp
|
|
* @workspace: open on this workspace, or -1 for default
|
|
*
|
|
* Request that the application create a new window.
|
|
*/
|
|
void
|
|
shell_app_open_new_window (ShellApp *app,
|
|
int workspace)
|
|
{
|
|
GActionGroup *group = NULL;
|
|
const char * const *actions;
|
|
|
|
g_return_if_fail (app->info != NULL);
|
|
|
|
/* First check whether the application provides a "new-window" desktop
|
|
* action - it is a safe bet that it will open a new window, and activating
|
|
* it will trigger startup notification if necessary
|
|
*/
|
|
actions = g_desktop_app_info_list_actions (G_DESKTOP_APP_INFO (app->info));
|
|
|
|
if (g_strv_contains (actions, "new-window"))
|
|
{
|
|
shell_app_launch_action (app, "new-window", 0, workspace);
|
|
return;
|
|
}
|
|
|
|
/* Next, check whether the app exports an explicit "new-window" action
|
|
* that we can activate on the bus - the muxer will add startup notification
|
|
* information to the platform data, so this should work just as well as
|
|
* desktop actions.
|
|
*/
|
|
group = app->running_state ? G_ACTION_GROUP (app->running_state->muxer)
|
|
: NULL;
|
|
|
|
if (group &&
|
|
g_action_group_has_action (group, "app.new-window") &&
|
|
g_action_group_get_action_parameter_type (group, "app.new-window") == NULL)
|
|
{
|
|
g_action_group_activate_action (group, "app.new-window", NULL);
|
|
|
|
return;
|
|
}
|
|
|
|
/* Lastly, just always launch the application again, even if we know
|
|
* it was already running. For most applications this
|
|
* should have the effect of creating a new window, whether that's
|
|
* a second process (in the case of Calculator) or IPC to existing
|
|
* instance (Firefox). There are a few less-sensical cases such
|
|
* as say Pidgin.
|
|
*/
|
|
shell_app_launch (app, 0, workspace, FALSE, NULL);
|
|
}
|
|
|
|
/**
|
|
* shell_app_can_open_new_window:
|
|
* @app: a #ShellApp
|
|
*
|
|
* Returns %TRUE if the app supports opening a new window through
|
|
* shell_app_open_new_window() (ie, if calling that function will
|
|
* result in actually opening a new window and not something else,
|
|
* like presenting the most recently active one)
|
|
*/
|
|
gboolean
|
|
shell_app_can_open_new_window (ShellApp *app)
|
|
{
|
|
ShellAppRunningState *state;
|
|
|
|
/* Apps that are not running can always open new windows, because
|
|
activating them would open the first one */
|
|
if (!app->running_state)
|
|
return TRUE;
|
|
|
|
state = app->running_state;
|
|
|
|
/* If the app has an explicit new-window action, then it can
|
|
(or it should be able to) ...
|
|
*/
|
|
if (g_action_group_has_action (G_ACTION_GROUP (state->muxer), "app.new-window"))
|
|
return TRUE;
|
|
|
|
/* If the app doesn't have a desktop file, then nothing is possible */
|
|
if (!app->info)
|
|
return FALSE;
|
|
|
|
/* If the app is explicitly telling us, then we know for sure */
|
|
if (g_desktop_app_info_has_key (G_DESKTOP_APP_INFO (app->info),
|
|
"X-GNOME-SingleWindow"))
|
|
return !g_desktop_app_info_get_boolean (G_DESKTOP_APP_INFO (app->info),
|
|
"X-GNOME-SingleWindow");
|
|
|
|
/* If this is a unique GtkApplication, and we don't have a new-window, then
|
|
probably we can't
|
|
|
|
We don't consider non-unique GtkApplications here to handle cases like
|
|
evince, which don't export a new-window action because each window is in
|
|
a different process. In any case, in a non-unique GtkApplication each
|
|
Activate() knows nothing about the other instances, so it will show a
|
|
new window.
|
|
*/
|
|
if (state->remote_menu)
|
|
{
|
|
const char *application_id;
|
|
application_id = meta_window_get_gtk_application_id (state->windows->data);
|
|
if (application_id != NULL)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
/* In all other cases, we don't have a reliable source of information
|
|
or a decent heuristic, so we err on the compatibility side and say
|
|
yes.
|
|
*/
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* shell_app_get_state:
|
|
* @app: a #ShellApp
|
|
*
|
|
* Returns: State of the application
|
|
*/
|
|
ShellAppState
|
|
shell_app_get_state (ShellApp *app)
|
|
{
|
|
return app->state;
|
|
}
|
|
|
|
typedef struct {
|
|
ShellApp *app;
|
|
MetaWorkspace *active_workspace;
|
|
} CompareWindowsData;
|
|
|
|
static int
|
|
shell_app_compare_windows (gconstpointer a,
|
|
gconstpointer b,
|
|
gpointer datap)
|
|
{
|
|
MetaWindow *win_a = (gpointer)a;
|
|
MetaWindow *win_b = (gpointer)b;
|
|
CompareWindowsData *data = datap;
|
|
gboolean ws_a, ws_b;
|
|
gboolean vis_a, vis_b;
|
|
|
|
ws_a = meta_window_get_workspace (win_a) == data->active_workspace;
|
|
ws_b = meta_window_get_workspace (win_b) == data->active_workspace;
|
|
|
|
if (ws_a && !ws_b)
|
|
return -1;
|
|
else if (!ws_a && ws_b)
|
|
return 1;
|
|
|
|
vis_a = meta_window_showing_on_its_workspace (win_a);
|
|
vis_b = meta_window_showing_on_its_workspace (win_b);
|
|
|
|
if (vis_a && !vis_b)
|
|
return -1;
|
|
else if (!vis_a && vis_b)
|
|
return 1;
|
|
|
|
return meta_window_get_user_time (win_b) - meta_window_get_user_time (win_a);
|
|
}
|
|
|
|
/**
|
|
* shell_app_get_windows:
|
|
* @app:
|
|
*
|
|
* Get the windows which are associated with this application. The
|
|
* returned list will be sorted first by whether they're on the
|
|
* active workspace, then by whether they're visible, and finally
|
|
* by the time the user last interacted with them.
|
|
*
|
|
* Returns: (transfer none) (element-type MetaWindow): List of windows
|
|
*/
|
|
GSList *
|
|
shell_app_get_windows (ShellApp *app)
|
|
{
|
|
if (app->running_state == NULL)
|
|
return NULL;
|
|
|
|
if (app->running_state->window_sort_stale)
|
|
{
|
|
CompareWindowsData data;
|
|
data.app = app;
|
|
data.active_workspace = get_active_workspace ();
|
|
app->running_state->windows = g_slist_sort_with_data (app->running_state->windows, shell_app_compare_windows, &data);
|
|
app->running_state->window_sort_stale = FALSE;
|
|
}
|
|
|
|
return app->running_state->windows;
|
|
}
|
|
|
|
guint
|
|
shell_app_get_n_windows (ShellApp *app)
|
|
{
|
|
if (app->running_state == NULL)
|
|
return 0;
|
|
return g_slist_length (app->running_state->windows);
|
|
}
|
|
|
|
gboolean
|
|
shell_app_is_on_workspace (ShellApp *app,
|
|
MetaWorkspace *workspace)
|
|
{
|
|
GSList *iter;
|
|
|
|
if (shell_app_get_state (app) == SHELL_APP_STATE_STARTING)
|
|
{
|
|
if (app->started_on_workspace == -1 ||
|
|
meta_workspace_index (workspace) == app->started_on_workspace)
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
if (app->running_state == NULL)
|
|
return FALSE;
|
|
|
|
for (iter = app->running_state->windows; iter; iter = iter->next)
|
|
{
|
|
if (meta_window_get_workspace (iter->data) == workspace)
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static int
|
|
shell_app_get_last_user_time (ShellApp *app)
|
|
{
|
|
GSList *iter;
|
|
guint32 last_user_time;
|
|
|
|
last_user_time = 0;
|
|
|
|
if (app->running_state != NULL)
|
|
{
|
|
for (iter = app->running_state->windows; iter; iter = iter->next)
|
|
last_user_time = MAX (last_user_time, meta_window_get_user_time (iter->data));
|
|
}
|
|
|
|
return (int)last_user_time;
|
|
}
|
|
|
|
static gboolean
|
|
shell_app_is_minimized (ShellApp *app)
|
|
{
|
|
GSList *iter;
|
|
|
|
if (app->running_state == NULL)
|
|
return FALSE;
|
|
|
|
for (iter = app->running_state->windows; iter; iter = iter->next)
|
|
{
|
|
if (meta_window_showing_on_its_workspace (iter->data))
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* shell_app_compare:
|
|
* @app:
|
|
* @other: A #ShellApp
|
|
*
|
|
* Compare one #ShellApp instance to another, in the following way:
|
|
* - Running applications sort before not-running applications.
|
|
* - If one of them has non-minimized windows and the other does not,
|
|
* the one with visible windows is first.
|
|
* - Finally, the application which the user interacted with most recently
|
|
* compares earlier.
|
|
*/
|
|
int
|
|
shell_app_compare (ShellApp *app,
|
|
ShellApp *other)
|
|
{
|
|
gboolean min_app, min_other;
|
|
|
|
if (app->state != other->state)
|
|
{
|
|
if (app->state == SHELL_APP_STATE_RUNNING)
|
|
return -1;
|
|
return 1;
|
|
}
|
|
|
|
min_app = shell_app_is_minimized (app);
|
|
min_other = shell_app_is_minimized (other);
|
|
|
|
if (min_app != min_other)
|
|
{
|
|
if (min_other)
|
|
return -1;
|
|
return 1;
|
|
}
|
|
|
|
if (app->state == SHELL_APP_STATE_RUNNING)
|
|
{
|
|
if (app->running_state->windows && !other->running_state->windows)
|
|
return -1;
|
|
else if (!app->running_state->windows && other->running_state->windows)
|
|
return 1;
|
|
|
|
return shell_app_get_last_user_time (other) - shell_app_get_last_user_time (app);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
ShellApp *
|
|
_shell_app_new_for_window (MetaWindow *window)
|
|
{
|
|
ShellApp *app;
|
|
|
|
app = g_object_new (SHELL_TYPE_APP, NULL);
|
|
|
|
app->window_id_string = g_strdup_printf ("window:%d", meta_window_get_stable_sequence (window));
|
|
|
|
_shell_app_add_window (app, window);
|
|
|
|
return app;
|
|
}
|
|
|
|
ShellApp *
|
|
_shell_app_new (GDesktopAppInfo *info)
|
|
{
|
|
ShellApp *app;
|
|
|
|
app = g_object_new (SHELL_TYPE_APP,
|
|
"app-info", info,
|
|
NULL);
|
|
|
|
return app;
|
|
}
|
|
|
|
void
|
|
_shell_app_set_app_info (ShellApp *app,
|
|
GDesktopAppInfo *info)
|
|
{
|
|
g_set_object (&app->info, info);
|
|
|
|
g_clear_pointer (&app->name_collation_key, g_free);
|
|
if (app->info)
|
|
app->name_collation_key = g_utf8_collate_key (shell_app_get_name (app), -1);
|
|
}
|
|
|
|
static void
|
|
shell_app_state_transition (ShellApp *app,
|
|
ShellAppState state)
|
|
{
|
|
if (app->state == state)
|
|
return;
|
|
g_return_if_fail (!(app->state == SHELL_APP_STATE_RUNNING &&
|
|
state == SHELL_APP_STATE_STARTING));
|
|
app->state = state;
|
|
|
|
_shell_app_system_notify_app_state_changed (shell_app_system_get_default (), app);
|
|
|
|
g_object_notify (G_OBJECT (app), "state");
|
|
}
|
|
|
|
static void
|
|
shell_app_on_unmanaged (MetaWindow *window,
|
|
ShellApp *app)
|
|
{
|
|
_shell_app_remove_window (app, window);
|
|
}
|
|
|
|
static void
|
|
shell_app_on_user_time_changed (MetaWindow *window,
|
|
GParamSpec *pspec,
|
|
ShellApp *app)
|
|
{
|
|
g_assert (app->running_state != NULL);
|
|
|
|
/* Ideally we don't want to emit windows-changed if the sort order
|
|
* isn't actually changing. This check catches most of those.
|
|
*/
|
|
if (window != app->running_state->windows->data)
|
|
{
|
|
app->running_state->window_sort_stale = TRUE;
|
|
g_signal_emit (app, shell_app_signals[WINDOWS_CHANGED], 0);
|
|
}
|
|
}
|
|
|
|
static void
|
|
shell_app_sync_running_state (ShellApp *app)
|
|
{
|
|
g_return_if_fail (app->running_state != NULL);
|
|
|
|
if (app->state != SHELL_APP_STATE_STARTING)
|
|
{
|
|
if (app->running_state->interesting_windows == 0)
|
|
shell_app_state_transition (app, SHELL_APP_STATE_STOPPED);
|
|
else
|
|
shell_app_state_transition (app, SHELL_APP_STATE_RUNNING);
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
shell_app_on_skip_taskbar_changed (MetaWindow *window,
|
|
GParamSpec *pspec,
|
|
ShellApp *app)
|
|
{
|
|
g_assert (app->running_state != NULL);
|
|
|
|
/* we rely on MetaWindow:skip-taskbar only being notified
|
|
* when it actually changes; when that assumption breaks,
|
|
* we'll have to track the "interesting" windows themselves
|
|
*/
|
|
if (meta_window_is_skip_taskbar (window))
|
|
app->running_state->interesting_windows--;
|
|
else
|
|
app->running_state->interesting_windows++;
|
|
|
|
shell_app_sync_running_state (app);
|
|
}
|
|
|
|
static void
|
|
shell_app_on_ws_switch (MetaWorkspaceManager *workspace_manager,
|
|
int from,
|
|
int to,
|
|
MetaMotionDirection direction,
|
|
gpointer data)
|
|
{
|
|
ShellApp *app = SHELL_APP (data);
|
|
|
|
g_assert (app->running_state != NULL);
|
|
|
|
app->running_state->window_sort_stale = TRUE;
|
|
|
|
g_signal_emit (app, shell_app_signals[WINDOWS_CHANGED], 0);
|
|
}
|
|
|
|
gboolean
|
|
shell_app_get_busy (ShellApp *app)
|
|
{
|
|
if (app->running_state != NULL &&
|
|
app->running_state->application_proxy != NULL &&
|
|
shell_org_gtk_application_get_busy (app->running_state->application_proxy))
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
busy_changed_cb (GObject *object,
|
|
GParamSpec *pspec,
|
|
gpointer user_data)
|
|
{
|
|
ShellApp *app = user_data;
|
|
|
|
g_assert (SHELL_IS_APP (app));
|
|
|
|
g_object_notify (G_OBJECT (app), "busy");
|
|
}
|
|
|
|
static void
|
|
get_application_proxy (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
ShellApp *app = user_data;
|
|
ShellOrgGtkApplication *proxy;
|
|
|
|
g_assert (SHELL_IS_APP (app));
|
|
|
|
proxy = shell_org_gtk_application_proxy_new_finish (result, NULL);
|
|
if (proxy != NULL)
|
|
{
|
|
app->running_state->application_proxy = proxy;
|
|
g_signal_connect (proxy,
|
|
"notify::busy",
|
|
G_CALLBACK (busy_changed_cb),
|
|
app);
|
|
if (shell_org_gtk_application_get_busy (proxy))
|
|
g_object_notify (G_OBJECT (app), "busy");
|
|
}
|
|
|
|
if (app->running_state != NULL)
|
|
g_clear_object (&app->running_state->cancellable);
|
|
|
|
g_object_unref (app);
|
|
}
|
|
|
|
static void
|
|
shell_app_ensure_busy_watch (ShellApp *app)
|
|
{
|
|
ShellAppRunningState *running_state = app->running_state;
|
|
MetaWindow *window;
|
|
const gchar *object_path;
|
|
|
|
if (running_state->application_proxy != NULL ||
|
|
running_state->cancellable != NULL)
|
|
return;
|
|
|
|
if (running_state->unique_bus_name == NULL)
|
|
return;
|
|
|
|
window = g_slist_nth_data (running_state->windows, 0);
|
|
object_path = meta_window_get_gtk_application_object_path (window);
|
|
|
|
if (object_path == NULL)
|
|
return;
|
|
|
|
running_state->cancellable = g_cancellable_new();
|
|
/* Take a reference to app to make sure it isn't finalized before
|
|
get_application_proxy runs */
|
|
shell_org_gtk_application_proxy_new (running_state->session,
|
|
G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
|
|
running_state->unique_bus_name,
|
|
object_path,
|
|
running_state->cancellable,
|
|
get_application_proxy,
|
|
g_object_ref (app));
|
|
}
|
|
|
|
void
|
|
_shell_app_add_window (ShellApp *app,
|
|
MetaWindow *window)
|
|
{
|
|
if (app->running_state && g_slist_find (app->running_state->windows, window))
|
|
return;
|
|
|
|
g_object_freeze_notify (G_OBJECT (app));
|
|
|
|
if (!app->running_state)
|
|
create_running_state (app);
|
|
|
|
app->running_state->window_sort_stale = TRUE;
|
|
app->running_state->windows = g_slist_prepend (app->running_state->windows, g_object_ref (window));
|
|
g_signal_connect (window, "unmanaged", G_CALLBACK(shell_app_on_unmanaged), app);
|
|
g_signal_connect (window, "notify::user-time", G_CALLBACK(shell_app_on_user_time_changed), app);
|
|
g_signal_connect (window, "notify::skip-taskbar", G_CALLBACK(shell_app_on_skip_taskbar_changed), app);
|
|
|
|
shell_app_update_app_menu (app, window);
|
|
shell_app_ensure_busy_watch (app);
|
|
|
|
if (!meta_window_is_skip_taskbar (window))
|
|
app->running_state->interesting_windows++;
|
|
shell_app_sync_running_state (app);
|
|
|
|
g_object_thaw_notify (G_OBJECT (app));
|
|
|
|
g_signal_emit (app, shell_app_signals[WINDOWS_CHANGED], 0);
|
|
}
|
|
|
|
void
|
|
_shell_app_remove_window (ShellApp *app,
|
|
MetaWindow *window)
|
|
{
|
|
g_assert (app->running_state != NULL);
|
|
|
|
if (!g_slist_find (app->running_state->windows, window))
|
|
return;
|
|
|
|
g_signal_handlers_disconnect_by_func (window, G_CALLBACK(shell_app_on_unmanaged), app);
|
|
g_signal_handlers_disconnect_by_func (window, G_CALLBACK(shell_app_on_user_time_changed), app);
|
|
g_signal_handlers_disconnect_by_func (window, G_CALLBACK(shell_app_on_skip_taskbar_changed), app);
|
|
g_object_unref (window);
|
|
app->running_state->windows = g_slist_remove (app->running_state->windows, window);
|
|
|
|
if (!meta_window_is_skip_taskbar (window))
|
|
app->running_state->interesting_windows--;
|
|
shell_app_sync_running_state (app);
|
|
|
|
if (app->running_state->windows == NULL)
|
|
g_clear_pointer (&app->running_state, unref_running_state);
|
|
|
|
g_signal_emit (app, shell_app_signals[WINDOWS_CHANGED], 0);
|
|
}
|
|
|
|
/**
|
|
* shell_app_get_pids:
|
|
* @app: a #ShellApp
|
|
*
|
|
* Returns: (transfer container) (element-type int): An unordered list of process identifers associated with this application.
|
|
*/
|
|
GSList *
|
|
shell_app_get_pids (ShellApp *app)
|
|
{
|
|
GSList *result;
|
|
GSList *iter;
|
|
|
|
result = NULL;
|
|
for (iter = shell_app_get_windows (app); iter; iter = iter->next)
|
|
{
|
|
MetaWindow *window = iter->data;
|
|
int pid = meta_window_get_pid (window);
|
|
/* Note in the (by far) common case, app will only have one pid, so
|
|
* we'll hit the first element, so don't worry about O(N^2) here.
|
|
*/
|
|
if (!g_slist_find (result, GINT_TO_POINTER (pid)))
|
|
result = g_slist_prepend (result, GINT_TO_POINTER (pid));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void
|
|
_shell_app_handle_startup_sequence (ShellApp *app,
|
|
SnStartupSequence *sequence)
|
|
{
|
|
gboolean starting = !sn_startup_sequence_get_completed (sequence);
|
|
|
|
/* The Shell design calls for on application launch, the app title
|
|
* appears at top, and no X window is focused. So when we get
|
|
* a startup-notification for this app, transition it to STARTING
|
|
* if it's currently stopped, set it as our application focus,
|
|
* but focus the no_focus window.
|
|
*/
|
|
if (starting && shell_app_get_state (app) == SHELL_APP_STATE_STOPPED)
|
|
{
|
|
MetaDisplay *display = shell_global_get_display (shell_global_get ());
|
|
MetaX11Display *x11_display = meta_display_get_x11_display (display);
|
|
|
|
shell_app_state_transition (app, SHELL_APP_STATE_STARTING);
|
|
meta_x11_display_focus_the_no_focus_window (x11_display,
|
|
sn_startup_sequence_get_timestamp (sequence));
|
|
app->started_on_workspace = sn_startup_sequence_get_workspace (sequence);
|
|
}
|
|
|
|
if (!starting)
|
|
{
|
|
if (app->running_state && app->running_state->windows)
|
|
shell_app_state_transition (app, SHELL_APP_STATE_RUNNING);
|
|
else /* application have > 1 .desktop file */
|
|
shell_app_state_transition (app, SHELL_APP_STATE_STOPPED);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* shell_app_request_quit:
|
|
* @app: A #ShellApp
|
|
*
|
|
* Initiate an asynchronous request to quit this application.
|
|
* The application may interact with the user, and the user
|
|
* might cancel the quit request from the application UI.
|
|
*
|
|
* This operation may not be supported for all applications.
|
|
*
|
|
* Returns: %TRUE if a quit request is supported for this application
|
|
*/
|
|
gboolean
|
|
shell_app_request_quit (ShellApp *app)
|
|
{
|
|
GSList *iter;
|
|
|
|
if (shell_app_get_state (app) != SHELL_APP_STATE_RUNNING)
|
|
return FALSE;
|
|
|
|
/* TODO - check for an XSMP connection; we could probably use that */
|
|
|
|
for (iter = app->running_state->windows; iter; iter = iter->next)
|
|
{
|
|
MetaWindow *win = iter->data;
|
|
|
|
if (meta_window_is_skip_taskbar (win))
|
|
continue;
|
|
|
|
meta_window_delete (win, shell_global_get_current_time (shell_global_get ()));
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
#if !defined(HAVE_GIO_DESKTOP_LAUNCH_URIS_WITH_FDS) && defined(HAVE_SYSTEMD)
|
|
/* This sets up the launched application to log to the journal
|
|
* using its own identifier, instead of just "gnome-session".
|
|
*/
|
|
static void
|
|
app_child_setup (gpointer user_data)
|
|
{
|
|
const char *appid = user_data;
|
|
int res;
|
|
int journalfd = sd_journal_stream_fd (appid, LOG_INFO, FALSE);
|
|
if (journalfd >= 0)
|
|
{
|
|
do
|
|
res = dup2 (journalfd, 1);
|
|
while (G_UNLIKELY (res == -1 && errno == EINTR));
|
|
do
|
|
res = dup2 (journalfd, 2);
|
|
while (G_UNLIKELY (res == -1 && errno == EINTR));
|
|
(void) close (journalfd);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
wait_pid (GDesktopAppInfo *appinfo,
|
|
GPid pid,
|
|
gpointer user_data)
|
|
{
|
|
g_child_watch_add (pid, (GChildWatchFunc) g_spawn_close_pid, NULL);
|
|
}
|
|
|
|
/**
|
|
* shell_app_launch:
|
|
* @timestamp: Event timestamp, or 0 for current event timestamp
|
|
* @workspace: Start on this workspace, or -1 for default
|
|
* @discrete_gpu: Whether to start on the discrete GPU
|
|
* @error: A #GError
|
|
*/
|
|
gboolean
|
|
shell_app_launch (ShellApp *app,
|
|
guint timestamp,
|
|
int workspace,
|
|
gboolean discrete_gpu,
|
|
GError **error)
|
|
{
|
|
ShellGlobal *global;
|
|
GAppLaunchContext *context;
|
|
gboolean ret;
|
|
GSpawnFlags flags;
|
|
|
|
if (app->info == NULL)
|
|
{
|
|
MetaWindow *window = window_backed_app_get_window (app);
|
|
/* We don't use an error return if there no longer any windows, because the
|
|
* user attempting to activate a stale window backed app isn't something
|
|
* we would expect the caller to meaningfully handle or display an error
|
|
* message to the user.
|
|
*/
|
|
if (window)
|
|
meta_window_activate (window, timestamp);
|
|
return TRUE;
|
|
}
|
|
|
|
global = shell_global_get ();
|
|
context = shell_global_create_app_launch_context (global, timestamp, workspace);
|
|
if (discrete_gpu)
|
|
g_app_launch_context_setenv (context, "DRI_PRIME", "1");
|
|
|
|
/* Set LEAVE_DESCRIPTORS_OPEN in order to use an optimized gspawn
|
|
* codepath. The shell's open file descriptors should be marked CLOEXEC
|
|
* so that they are automatically closed even with this flag set.
|
|
*/
|
|
flags = G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD |
|
|
G_SPAWN_LEAVE_DESCRIPTORS_OPEN;
|
|
|
|
#ifdef HAVE_GIO_DESKTOP_LAUNCH_URIS_WITH_FDS
|
|
/* Optimized spawn path, avoiding a child_setup function */
|
|
{
|
|
int journalfd = -1;
|
|
|
|
#ifdef HAVE_SYSTEMD
|
|
journalfd = sd_journal_stream_fd (shell_app_get_id (app), LOG_INFO, FALSE);
|
|
#endif /* HAVE_SYSTEMD */
|
|
|
|
ret = g_desktop_app_info_launch_uris_as_manager_with_fds (app->info, NULL,
|
|
context,
|
|
flags,
|
|
NULL, NULL,
|
|
wait_pid, NULL,
|
|
-1,
|
|
journalfd,
|
|
journalfd,
|
|
error);
|
|
|
|
if (journalfd >= 0)
|
|
(void) close (journalfd);
|
|
}
|
|
#else /* !HAVE_GIO_DESKTOP_LAUNCH_URIS_WITH_FDS */
|
|
ret = g_desktop_app_info_launch_uris_as_manager (app->info, NULL,
|
|
context,
|
|
flags,
|
|
#ifdef HAVE_SYSTEMD
|
|
app_child_setup, (gpointer)shell_app_get_id (app),
|
|
#else
|
|
NULL, NULL,
|
|
#endif
|
|
wait_pid, NULL,
|
|
error);
|
|
#endif /* HAVE_GIO_DESKTOP_LAUNCH_URIS_WITH_FDS */
|
|
g_object_unref (context);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* shell_app_launch_action:
|
|
* @app: the #ShellApp
|
|
* @action_name: the name of the action to launch (as obtained by
|
|
* g_desktop_app_info_list_actions())
|
|
* @timestamp: Event timestamp, or 0 for current event timestamp
|
|
* @workspace: Start on this workspace, or -1 for default
|
|
*/
|
|
void
|
|
shell_app_launch_action (ShellApp *app,
|
|
const char *action_name,
|
|
guint timestamp,
|
|
int workspace)
|
|
{
|
|
ShellGlobal *global;
|
|
GAppLaunchContext *context;
|
|
|
|
global = shell_global_get ();
|
|
context = shell_global_create_app_launch_context (global, timestamp, workspace);
|
|
|
|
g_desktop_app_info_launch_action (G_DESKTOP_APP_INFO (app->info),
|
|
action_name, context);
|
|
|
|
g_object_unref (context);
|
|
}
|
|
|
|
/**
|
|
* shell_app_get_app_info:
|
|
* @app: a #ShellApp
|
|
*
|
|
* Returns: (transfer none): The #GDesktopAppInfo for this app, or %NULL if backed by a window
|
|
*/
|
|
GDesktopAppInfo *
|
|
shell_app_get_app_info (ShellApp *app)
|
|
{
|
|
return app->info;
|
|
}
|
|
|
|
static void
|
|
create_running_state (ShellApp *app)
|
|
{
|
|
MetaDisplay *display = shell_global_get_display (shell_global_get ());
|
|
MetaWorkspaceManager *workspace_manager =
|
|
meta_display_get_workspace_manager (display);
|
|
|
|
g_assert (app->running_state == NULL);
|
|
|
|
app->running_state = g_slice_new0 (ShellAppRunningState);
|
|
app->running_state->refcount = 1;
|
|
app->running_state->workspace_switch_id =
|
|
g_signal_connect (workspace_manager, "workspace-switched",
|
|
G_CALLBACK (shell_app_on_ws_switch), app);
|
|
|
|
app->running_state->session = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
|
|
g_assert (app->running_state->session != NULL);
|
|
app->running_state->muxer = gtk_action_muxer_new ();
|
|
}
|
|
|
|
void
|
|
shell_app_update_app_menu (ShellApp *app,
|
|
MetaWindow *window)
|
|
{
|
|
const gchar *unique_bus_name;
|
|
|
|
/* We assume that 'gtk-application-object-path' and
|
|
* 'gtk-app-menu-object-path' are the same for all windows which
|
|
* have it set.
|
|
*
|
|
* It could be possible, however, that the first window we see
|
|
* belonging to the app didn't have them set. For this reason, we
|
|
* take the values from the first window that has them set and ignore
|
|
* all the rest (until the app is stopped and restarted).
|
|
*/
|
|
|
|
unique_bus_name = meta_window_get_gtk_unique_bus_name (window);
|
|
|
|
if (app->running_state->remote_menu == NULL ||
|
|
g_strcmp0 (app->running_state->unique_bus_name, unique_bus_name) != 0)
|
|
{
|
|
const gchar *application_object_path;
|
|
const gchar *app_menu_object_path;
|
|
GDBusActionGroup *actions;
|
|
|
|
application_object_path = meta_window_get_gtk_application_object_path (window);
|
|
app_menu_object_path = meta_window_get_gtk_app_menu_object_path (window);
|
|
|
|
if (application_object_path == NULL || app_menu_object_path == NULL || unique_bus_name == NULL)
|
|
return;
|
|
|
|
g_clear_pointer (&app->running_state->unique_bus_name, g_free);
|
|
app->running_state->unique_bus_name = g_strdup (unique_bus_name);
|
|
g_clear_object (&app->running_state->remote_menu);
|
|
app->running_state->remote_menu = g_dbus_menu_model_get (app->running_state->session, unique_bus_name, app_menu_object_path);
|
|
actions = g_dbus_action_group_get (app->running_state->session, unique_bus_name, application_object_path);
|
|
gtk_action_muxer_insert (app->running_state->muxer, "app", G_ACTION_GROUP (actions));
|
|
g_object_unref (actions);
|
|
}
|
|
}
|
|
|
|
static void
|
|
unref_running_state (ShellAppRunningState *state)
|
|
{
|
|
MetaDisplay *display = shell_global_get_display (shell_global_get ());
|
|
MetaWorkspaceManager *workspace_manager =
|
|
meta_display_get_workspace_manager (display);
|
|
|
|
g_assert (state->refcount > 0);
|
|
|
|
state->refcount--;
|
|
if (state->refcount > 0)
|
|
return;
|
|
|
|
g_signal_handler_disconnect (workspace_manager, state->workspace_switch_id);
|
|
|
|
g_clear_object (&state->application_proxy);
|
|
|
|
if (state->cancellable != NULL)
|
|
{
|
|
g_cancellable_cancel (state->cancellable);
|
|
g_clear_object (&state->cancellable);
|
|
}
|
|
|
|
g_clear_object (&state->remote_menu);
|
|
g_clear_object (&state->muxer);
|
|
g_clear_object (&state->session);
|
|
g_clear_pointer (&state->unique_bus_name, g_free);
|
|
g_clear_pointer (&state->remote_menu, g_free);
|
|
|
|
g_slice_free (ShellAppRunningState, state);
|
|
}
|
|
|
|
/**
|
|
* shell_app_compare_by_name:
|
|
* @app: One app
|
|
* @other: The other app
|
|
*
|
|
* Order two applications by name.
|
|
*
|
|
* Returns: -1, 0, or 1; suitable for use as a comparison function
|
|
* for e.g. g_slist_sort()
|
|
*/
|
|
int
|
|
shell_app_compare_by_name (ShellApp *app, ShellApp *other)
|
|
{
|
|
return strcmp (app->name_collation_key, other->name_collation_key);
|
|
}
|
|
|
|
static void
|
|
shell_app_init (ShellApp *self)
|
|
{
|
|
self->state = SHELL_APP_STATE_STOPPED;
|
|
}
|
|
|
|
static void
|
|
shell_app_dispose (GObject *object)
|
|
{
|
|
ShellApp *app = SHELL_APP (object);
|
|
|
|
g_clear_object (&app->info);
|
|
|
|
while (app->running_state)
|
|
_shell_app_remove_window (app, app->running_state->windows->data);
|
|
|
|
/* We should have been transitioned when we removed all of our windows */
|
|
g_assert (app->state == SHELL_APP_STATE_STOPPED);
|
|
g_assert (app->running_state == NULL);
|
|
|
|
G_OBJECT_CLASS(shell_app_parent_class)->dispose (object);
|
|
}
|
|
|
|
static void
|
|
shell_app_finalize (GObject *object)
|
|
{
|
|
ShellApp *app = SHELL_APP (object);
|
|
|
|
g_free (app->window_id_string);
|
|
|
|
g_free (app->name_collation_key);
|
|
|
|
G_OBJECT_CLASS(shell_app_parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
shell_app_class_init(ShellAppClass *klass)
|
|
{
|
|
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
|
|
|
gobject_class->get_property = shell_app_get_property;
|
|
gobject_class->set_property = shell_app_set_property;
|
|
gobject_class->dispose = shell_app_dispose;
|
|
gobject_class->finalize = shell_app_finalize;
|
|
|
|
shell_app_signals[WINDOWS_CHANGED] = g_signal_new ("windows-changed",
|
|
SHELL_TYPE_APP,
|
|
G_SIGNAL_RUN_LAST,
|
|
0,
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE, 0);
|
|
|
|
/**
|
|
* ShellApp:state:
|
|
*
|
|
* The high-level state of the application, effectively whether it's
|
|
* running or not, or transitioning between those states.
|
|
*/
|
|
g_object_class_install_property (gobject_class,
|
|
PROP_STATE,
|
|
g_param_spec_enum ("state",
|
|
"State",
|
|
"Application state",
|
|
SHELL_TYPE_APP_STATE,
|
|
SHELL_APP_STATE_STOPPED,
|
|
G_PARAM_READABLE));
|
|
|
|
/**
|
|
* ShellApp:busy:
|
|
*
|
|
* Whether the application has marked itself as busy.
|
|
*/
|
|
g_object_class_install_property (gobject_class,
|
|
PROP_BUSY,
|
|
g_param_spec_boolean ("busy",
|
|
"Busy",
|
|
"Busy state",
|
|
FALSE,
|
|
G_PARAM_READABLE));
|
|
|
|
/**
|
|
* ShellApp:id:
|
|
*
|
|
* The id of this application (a desktop filename, or a special string
|
|
* like window:0xabcd1234)
|
|
*/
|
|
g_object_class_install_property (gobject_class,
|
|
PROP_ID,
|
|
g_param_spec_string ("id",
|
|
"Application id",
|
|
"The desktop file id of this ShellApp",
|
|
NULL,
|
|
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* ShellApp:action-group:
|
|
*
|
|
* The #GDBusActionGroup associated with this ShellApp, if any. See the
|
|
* documentation of #GApplication and #GActionGroup for details.
|
|
*/
|
|
g_object_class_install_property (gobject_class,
|
|
PROP_ACTION_GROUP,
|
|
g_param_spec_object ("action-group",
|
|
"Application Action Group",
|
|
"The action group exported by the remote application",
|
|
G_TYPE_ACTION_GROUP,
|
|
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
|
|
/**
|
|
* ShellApp:menu:
|
|
*
|
|
* The #GMenuProxy associated with this ShellApp, if any. See the
|
|
* documentation of #GMenuModel for details.
|
|
*/
|
|
g_object_class_install_property (gobject_class,
|
|
PROP_MENU,
|
|
g_param_spec_object ("menu",
|
|
"Application Menu",
|
|
"The primary menu exported by the remote application",
|
|
G_TYPE_MENU_MODEL,
|
|
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
|
|
/**
|
|
* ShellApp:app-info:
|
|
*
|
|
* The #GDesktopAppInfo associated with this ShellApp, if any.
|
|
*/
|
|
g_object_class_install_property (gobject_class,
|
|
PROP_APP_INFO,
|
|
g_param_spec_object ("app-info",
|
|
"DesktopAppInfo",
|
|
"The DesktopAppInfo associated with this app",
|
|
G_TYPE_DESKTOP_APP_INFO,
|
|
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
|
|
|
|
}
|