ClutterActor *
_make_settings_launcher (MnbPeoplePanel *people_panel)
{
ClutterActor *table;
ClutterActor *icon_tex;
ClutterActor *button;
GAppInfo *app_info;
gchar *button_str;
app_info = (GAppInfo *)g_desktop_app_info_new ("empathy-accounts.desktop");
table = mx_table_new ();
mx_table_set_column_spacing (MX_TABLE (table), 16);
app_info = (GAppInfo *)g_desktop_app_info_new ("empathy-accounts.desktop");
icon_tex = g_object_new (MX_TYPE_ICON,
"icon-name", "netbook-empathy-accounts",
NULL);
mx_table_insert_actor_with_properties (MX_TABLE (table),
icon_tex,
0, 0,
"x-expand", FALSE,
"y-expand", TRUE,
"x-fill", FALSE,
"y-fill", FALSE,
NULL);
button_str = g_strdup_printf (_("Open %s"),
g_app_info_get_name (app_info));
button = mx_button_new_with_label (button_str);
g_free (button_str);
g_signal_connect (button,
"clicked",
(GCallback)_settings_launcher_button_clicked_cb,
people_panel);
mx_table_insert_actor_with_properties (MX_TABLE (table),
button,
0, 1,
"x-expand", FALSE,
"y-expand", TRUE,
"x-fill", FALSE,
"y-fill", FALSE,
NULL);
g_object_unref (app_info);
return table;
}
static void
_settings_launcher_button_clicked_cb (MxButton *button,
gpointer userdata)
{
MnbPeoplePanelPrivate *priv = GET_PRIVATE (userdata);
GDesktopAppInfo *app_info;
GError *error = NULL;
const gchar *args[2] = { NULL, };
app_info = g_desktop_app_info_new ("empathy-accounts.desktop");
args[0] = g_app_info_get_commandline (G_APP_INFO (app_info));
args[1] = NULL;
if (!g_spawn_async (NULL,
(gchar **)args,
NULL,
G_SPAWN_SEARCH_PATH,
NULL,
NULL,
NULL,
&error))
{
g_warning (G_STRLOC ": Error starting empathy-accounts: %s",
error->message);
g_clear_error (&error);
} else {
if (priv->panel_client)
mpl_panel_client_hide (priv->panel_client);
}
g_object_unref (app_info);
}
static MxAction *
_action_new_from_desktop_file (const gchar *desktop_file_id)
{
GDesktopAppInfo *dai;
dai = g_desktop_app_info_new (desktop_file_id);
if (dai)
{
MxAction *action;
GAppInfo *ai;
GIcon *icon;
ai = G_APP_INFO (dai);
action = mx_action_new_full (g_app_info_get_name (ai),
g_app_info_get_display_name (ai),
G_CALLBACK (_app_launcher_cb),
(gpointer)g_app_info_get_commandline (ai));
icon = g_app_info_get_icon (ai);
if (icon)
{
gchar *icon_name;
icon_name = g_icon_to_string (icon);
mx_action_set_icon (action, icon_name);
g_free (icon_name);
}
return action;
}
return NULL;
}
GDesktopAppInfo* guess_desktop_file(char const* app_id)
{
char* basename = g_strconcat(app_id, ".desktop", NULL);
GDesktopAppInfo* desktop_file = g_desktop_app_info_new(basename);
g_free(basename);
return desktop_file;
}
static void
notification_cb (NotifyNotification *notification,
gchar *action,
gpointer user_data)
{
GAppLaunchContext *ctx;
GDesktopAppInfo *app;
GError *error;
/* TODO: Hmm, would be nice to set the screen, timestamp etc etc */
ctx = g_app_launch_context_new ();
app = g_desktop_app_info_new ("gnome-online-accounts-panel.desktop");
error = NULL;
if (!g_app_info_launch (G_APP_INFO (app),
NULL, /* files */
ctx,
&error))
{
goa_warning ("Error launching: %s (%s, %d)",
error->message, g_quark_to_string (error->domain), error->code);
g_error_free (error);
}
g_object_unref (app);
g_object_unref (ctx);
}
void
LauncherApplication::setDesktopFile(const QString& desktop_file)
{
QString oldDesktopFile = this->desktop_file();
QByteArray byte_array = desktop_file.toUtf8();
gchar *file = byte_array.data();
if(desktop_file.startsWith("/")) {
/* It looks like a full path to a desktop file */
m_appInfo.reset((GAppInfo*)g_desktop_app_info_new_from_filename(file));
} else {
/* It might just be a desktop file name; let GIO look for the actual
desktop file for us */
/* The docs for g_desktop_app_info_new() says it respects "-" to "/"
substitution as per XDG Menu Spec, but it only seems to work for
exactly 1 substitution where as Wine programs often require many.
Bottom line: We must do some manual trial and error to find desktop
files in deeply nested directories.
Same workaround is implemented in Unity: plugins/unityshell/src/PlacesView.cpp:731
References:
https://bugzilla.gnome.org/show_bug.cgi?id=654566
https://bugs.launchpad.net/unity-2d/+bug/794471
*/
int slash_index;
do {
m_appInfo.reset((GAppInfo*)g_desktop_app_info_new(file));
slash_index = byte_array.indexOf("-");
if (slash_index == -1) {
break;
}
byte_array.replace(slash_index, 1, "/");
file = byte_array.data();
} while (m_appInfo.isNull());
}
/* setDesktopFile(…) may be called with the same desktop file, when e.g. the
contents of the file have changed. Some properties may have changed. */
QString newDesktopFile = this->desktop_file();
if (newDesktopFile != oldDesktopFile) {
Q_EMIT desktopFileChanged(newDesktopFile);
}
/* Emit the Changed signal on all properties that can depend on m_appInfo
m_application's properties take precedence over m_appInfo's
*/
if (m_appInfo != NULL) {
if (m_application == NULL) {
Q_EMIT nameChanged(name());
Q_EMIT iconChanged(icon());
}
Q_EMIT executableChanged(executable());
}
/* Update the list of static shortcuts
(quicklist entries defined in the desktop file). */
m_staticShortcuts.reset(indicator_desktop_shortcuts_new(newDesktopFile.toUtf8().constData(), "Unity"));
monitorDesktopFile(newDesktopFile);
}
static void
maybe_add_app_id (CcNotificationsPanel *panel,
const char *canonical_app_id)
{
Application *app;
gchar *path;
gchar *full_app_id;
GSettings *settings;
GAppInfo *app_info;
if (g_hash_table_contains (panel->known_applications,
canonical_app_id))
return;
path = g_strconcat (APP_PREFIX, canonical_app_id, "/", NULL);
settings = g_settings_new_with_path (APP_SCHEMA, path);
full_app_id = g_settings_get_string (settings, "application-id");
app_info = G_APP_INFO (g_desktop_app_info_new (full_app_id));
if (app_info == NULL) {
/* The application cannot be found, probably it was uninstalled */
g_object_unref (settings);
} else {
app = g_slice_new (Application);
app->canonical_app_id = g_strdup (canonical_app_id);
app->settings = settings;
app->app_info = app_info;
add_application (panel, app);
}
g_free (path);
g_free (full_app_id);
}
static void
edit_menus_cb (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
const gchar *application;
GDesktopAppInfo *app_info;
application = "alacarte.desktop";
app_info = g_desktop_app_info_new (application);
if (app_info == NULL)
{
GtkWidget *dialog;
dialog = gtk_message_dialog_new (NULL, 0,
GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
_("Please install the '%s' application."),
application);
g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL);
gtk_window_present (GTK_WINDOW (dialog));
return;
}
gp_menu_utils_app_info_launch (app_info);
}
static void
on_open_with_easytag (NautilusMenuItem *item,
gpointer data)
{
GList *files;
GDesktopAppInfo *appinfo;
files = g_object_get_data (G_OBJECT (item), "files");
appinfo = g_desktop_app_info_new ("easytag.desktop");
if (appinfo)
{
GdkAppLaunchContext *context;
GList *l;
GList *uris = NULL;
for (l = files; l != NULL; l = g_list_next (l))
{
uris = g_list_append (uris,
nautilus_file_info_get_uri (l->data));
}
context = gdk_display_get_app_launch_context (gdk_display_get_default ());
g_app_info_launch_uris (G_APP_INFO (appinfo), uris,
G_APP_LAUNCH_CONTEXT (context), NULL);
}
}
static gchar *
gtk_application_window_get_app_desktop_name (void)
{
gchar *retval = NULL;
#ifdef HAVE_GIO_UNIX
GDesktopAppInfo *app_info;
const gchar *app_name = NULL;
gchar *desktop_file;
desktop_file = g_strconcat (g_get_prgname (), ".desktop", NULL);
app_info = g_desktop_app_info_new (desktop_file);
g_free (desktop_file);
if (app_info != NULL)
app_name = g_app_info_get_name (G_APP_INFO (app_info));
if (app_name != NULL)
retval = g_strdup (app_name);
g_clear_object (&app_info);
#endif /* HAVE_GIO_UNIX */
return retval;
}
static VALUE
rg_initialize(VALUE self, VALUE desktop_id)
{
G_INITIALIZE(self, g_desktop_app_info_new(RVAL2CSTR(desktop_id)));
return Qnil;
}
static void
gis_finished_page_constructed (GObject *object)
{
GisFinishedPage *page = GIS_FINISHED_PAGE (object);
GisFinishedPagePrivate *priv = gis_finished_page_get_instance_private (page);
g_autoptr(GClosure) closure = NULL;
G_OBJECT_CLASS (gis_finished_page_parent_class)->constructed (object);
gis_page_set_complete (GIS_PAGE (page), TRUE);
g_signal_connect (priv->restart_button, "clicked", G_CALLBACK (reboot_cb), page);
priv->gedit = g_desktop_app_info_new ("org.gnome.gedit.desktop");
if (priv->gedit != NULL)
g_signal_connect (priv->diagnostics_label, "activate-link",
G_CALLBACK (diagnostics_label_activate_link_cb), page);
/* Use Ctrl+U to write unattended config */
priv->accel_group = gtk_accel_group_new ();
closure = g_cclosure_new_swap (G_CALLBACK (write_unattended_config_cb), page, NULL);
gtk_accel_group_connect (priv->accel_group, GDK_KEY_u, GDK_CONTROL_MASK, 0, closure);
gtk_widget_show (GTK_WIDGET (page));
}
static GtkHotkeyInfo*
get_hotkey_info_from_key_file (GKeyFile *keyfile,
const gchar *app_id,
const gchar *key_id,
GError **error)
{
GtkHotkeyInfo *info = NULL;
gchar *group, *description, *app_info_id, *signature;
GAppInfo *app_info = NULL;
g_return_val_if_fail (keyfile != NULL, NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
g_return_val_if_fail (app_id != NULL, NULL);
g_return_val_if_fail (key_id != NULL, NULL);
group = g_strconcat (HOTKEY_GROUP, key_id, NULL);
description = g_key_file_get_string (keyfile, group, "Description", NULL);
app_info_id = g_key_file_get_string (keyfile, group, "AppInfo", NULL);
signature = g_key_file_get_string (keyfile, group, "Signature", NULL);
if (!g_key_file_has_group (keyfile, group)) {
g_set_error (error, GTK_HOTKEY_REGISTRY_ERROR,
GTK_HOTKEY_REGISTRY_ERROR_UNKNOWN_KEY,
"Keyfile has no group "HOTKEY_GROUP"%s", key_id);
goto clean_up;
}
if (!signature) {
g_set_error (error, GTK_HOTKEY_REGISTRY_ERROR,
GTK_HOTKEY_REGISTRY_ERROR_BAD_SIGNATURE,
"No 'Signature' defined for hotkey '%s' for application '%s'",
key_id, app_id);
goto clean_up;
}
if (app_info_id) {
app_info = G_APP_INFO(g_desktop_app_info_new (app_info_id));
if (!G_IS_APP_INFO(app_info)) {
g_set_error (error, GTK_HOTKEY_REGISTRY_ERROR,
GTK_HOTKEY_REGISTRY_ERROR_MISSING_APP,
"Keyfile refering to 'AppInfo = %s', but no application"
"by that id is registered on the system", app_info_id);
goto clean_up;
}
}
info = gtk_hotkey_info_new (app_id, key_id, signature, app_info);
if (description)
gtk_hotkey_info_set_description (info, description);
clean_up:
g_free (group);
if (signature) g_free (signature);
if (description) g_free (description);
if (app_info_id) g_free (app_info_id);
if (app_info) g_object_unref (app_info);
return info;
}
/**
* fm_app_menu_view_dup_selected_app
* @view: a widget
*
* Retrieves selected application from the widget.
* The returned data should be freed with g_object_unref() after usage.
*
* Before 1.0.0 this call had name fm_app_menu_view_get_selected_app.
*
* Returns: (transfer full): selected application descriptor.
*
* Since: 0.1.0
*/
GAppInfo* fm_app_menu_view_dup_selected_app(GtkTreeView* view)
{
char* id = fm_app_menu_view_dup_selected_app_desktop_id(view);
if(id)
{
GDesktopAppInfo* app = g_desktop_app_info_new(id);
g_free(id);
return G_APP_INFO(app);
}
return NULL;
}
/**
* gs_utils_get_desktop_app_info:
* @id: A desktop ID, e.g. "gimp.desktop"
*
* Gets a a #GDesktopAppInfo taking into account the kde4- prefix.
*
* Returns: a #GDesktopAppInfo for a specific ID, or %NULL
*/
GDesktopAppInfo *
gs_utils_get_desktop_app_info (const gchar *id)
{
GDesktopAppInfo *app_info;
/* try to get the standard app-id */
app_info = g_desktop_app_info_new (id);
/* KDE is a special project because it believes /usr/share/applications
* isn't KDE enough. For this reason we support falling back to the
* "kde4-" prefixed ID to avoid educating various self-righteous
* upstreams about the correct ID to use in the AppData file. */
if (app_info == NULL) {
g_autofree gchar *kde_id = NULL;
kde_id = g_strdup_printf ("%s-%s", "kde4", id);
app_info = g_desktop_app_info_new (kde_id);
}
return app_info;
}
static ClutterActor *
_make_messenger_launcher_tile (MnbPeoplePanel *panel)
{
ClutterActor *table;
ClutterActor *icon_tex;
ClutterActor *button;
GAppInfo *app_info;
gchar *button_str;
ClutterActor *bin;
bin = mx_frame_new ();
clutter_actor_set_name (bin, "people-panel-messenger-launcher-tile");
table = mx_table_new ();
mx_bin_set_child (MX_BIN (bin), table);
mx_table_set_column_spacing (MX_TABLE (table), 16);
app_info = (GAppInfo *)g_desktop_app_info_new ("empathy.desktop");
icon_tex = g_object_new (MX_TYPE_ICON,
"icon-name", "netbook-empathy",
NULL);
mx_table_add_actor_with_properties (MX_TABLE (table),
icon_tex,
0, 0,
"x-expand", FALSE,
"y-expand", TRUE,
"x-fill", FALSE,
"y-fill", FALSE,
NULL);
button_str = g_strdup_printf (_("Open %s"),
g_app_info_get_name (app_info));
button = mx_button_new_with_label (button_str);
g_free (button_str);
g_signal_connect (button,
"clicked",
(GCallback)_messenger_launcher_button_clicked_cb,
panel);
mx_table_add_actor_with_properties (MX_TABLE (table),
button,
0, 1,
"x-expand", FALSE,
"y-expand", TRUE,
"x-fill", FALSE,
"y-fill", FALSE,
NULL);
g_object_unref (app_info);
return bin;
}
gboolean
empathy_launch_external_app (const gchar *desktop_file,
const gchar *args,
GError **error)
{
GDesktopAppInfo *desktop_info;
gboolean result;
GError *err = NULL;
desktop_info = g_desktop_app_info_new (desktop_file);
if (desktop_info == NULL)
{
DEBUG ("%s not found", desktop_file);
g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
"%s not found", desktop_file);
return FALSE;
}
if (args == NULL)
{
result = launch_app_info (G_APP_INFO (desktop_info), error);
}
else
{
gchar *cmd;
GAppInfo *app_info;
/* glib doesn't have API to start a desktop file with args... (#637875) */
cmd = g_strdup_printf ("%s %s", g_app_info_get_commandline (
(GAppInfo *) desktop_info), args);
app_info = g_app_info_create_from_commandline (cmd, NULL, 0, &err);
if (app_info == NULL)
{
DEBUG ("Failed to launch '%s': %s", cmd, err->message);
g_free (cmd);
g_object_unref (desktop_info);
g_propagate_error (error, err);
return FALSE;
}
result = launch_app_info (app_info, error);
g_object_unref (app_info);
g_free (cmd);
}
g_object_unref (desktop_info);
return result;
}
static void
search_panel_add_one_provider (CcSearchPanel *self,
GFile *provider)
{
gchar *path, *desktop_id;
GKeyFile *keyfile;
GAppInfo *app_info;
GError *error = NULL;
gboolean default_disabled;
path = g_file_get_path (provider);
keyfile = g_key_file_new ();
g_key_file_load_from_file (keyfile, path, G_KEY_FILE_NONE, &error);
if (error != NULL)
{
g_warning ("Error loading %s: %s - search provider will be ignored",
path, error->message);
goto out;
}
if (!g_key_file_has_group (keyfile, SHELL_PROVIDER_GROUP))
goto out;
desktop_id = g_key_file_get_string (keyfile, SHELL_PROVIDER_GROUP,
"DesktopId", &error);
if (error != NULL)
{
g_warning ("Unable to read desktop ID from %s: %s - search provider will be ignored",
path, error->message);
goto out;
}
app_info = G_APP_INFO (g_desktop_app_info_new (desktop_id));
g_free (desktop_id);
if (app_info == NULL)
goto out;
default_disabled = g_key_file_get_boolean (keyfile, SHELL_PROVIDER_GROUP,
"DefaultDisabled", NULL);
search_panel_add_one_app_info (self, app_info, !default_disabled);
g_object_unref (app_info);
out:
g_free (path);
g_clear_error (&error);
g_key_file_unref (keyfile);
}
static void
fsearch_window_action_open_with (GSimpleAction *action,
GVariant *variant,
gpointer user_data)
{
FsearchApplicationWindow *self = user_data;
GtkTreeSelection *selection = fsearch_application_window_get_listview_selection (self);
GList *file_list = NULL;
if (selection) {
guint selected_rows = gtk_tree_selection_count_selected_rows (selection);
if (selected_rows <= 10) {
gtk_tree_selection_selected_foreach (selection, open_with_cb, &file_list);
}
}
GDesktopAppInfo *app_info = NULL;
GdkAppLaunchContext *launch_context = NULL;
const char *app_id = g_variant_get_string (variant, NULL);
if (!app_id) {
goto out;
}
app_info = g_desktop_app_info_new (app_id);
if (!app_info) {
goto out;
}
GdkDisplay *display = gtk_widget_get_display (GTK_WIDGET (self));
launch_context = gdk_display_get_app_launch_context (display);
if (!launch_context) {
goto out;
}
g_app_info_launch (G_APP_INFO (app_info), file_list, G_APP_LAUNCH_CONTEXT (launch_context), NULL);
out:
if (launch_context) {
g_object_unref (launch_context);
launch_context = NULL;
}
if (app_info) {
g_object_unref (app_info);
app_info = NULL;
}
if (file_list) {
g_list_free_full (file_list, g_object_unref);
file_list = NULL;
}
}
QUrl DeclarativeDragItemWithUrl::decodeUri(const QString& uri)
{
if (uri.startsWith("application://")) {
QString desktopFileName = uri.mid(14);
QByteArray bytes = desktopFileName.toUtf8();
GObjectScopedPointer<GDesktopAppInfo> appInfo(g_desktop_app_info_new(bytes.constData()));
if (appInfo.isNull()) {
return QUrl(uri);
}
QString filePath = QString::fromUtf8(g_desktop_app_info_get_filename(appInfo.data()));
return QUrl("file://" + filePath);
} else {
return QUrl(uri);
}
}
static GDesktopAppInfo *
setup_app_info_for_id (const gchar *id)
{
GDesktopAppInfo *app_info;
gchar *desktop_file_name;
gchar **strv;
strv = g_strsplit (id, ":", 2);
desktop_file_name = g_strdup_printf ("ibus-setup-%s.desktop", strv[0]);
g_strfreev (strv);
app_info = g_desktop_app_info_new (desktop_file_name);
g_free (desktop_file_name);
return app_info;
}
static gboolean
app_is_stale (ShellApp *app)
{
GDesktopAppInfo *info;
gboolean is_stale;
if (shell_app_is_window_backed (app))
return FALSE;
info = g_desktop_app_info_new (shell_app_get_id (app));
is_stale = (info == NULL);
if (info)
g_object_unref (info);
return is_stale;
}
static void
new_index_changed_cb (MxComboBox *combo,
GParamSpec *pspec,
MnbPeoplePanel *self)
{
MnbPeoplePanelPrivate *priv = GET_PRIVATE (self);
gint index = mx_combo_box_get_index (combo);
GDesktopAppInfo *app_info;
GError *error = NULL;
const gchar *args[4] = { NULL, };
const gchar *option;
if (index == 0)
option = "--new-contact";
else if (index == 1)
option = "--join-chatroom";
else
return;
app_info = g_desktop_app_info_new ("empathy.desktop");
args[0] = g_app_info_get_commandline (G_APP_INFO (app_info));
args[1] = "--start-hidden";
args[2] = option;
args[3] = NULL;
if (!g_spawn_async (NULL,
(gchar **)args,
NULL,
G_SPAWN_SEARCH_PATH,
NULL,
NULL,
NULL,
&error))
{
g_warning (G_STRLOC ": Error starting empathy: %s", error->message);
g_clear_error (&error);
} else
{
if (priv->panel_client)
mpl_panel_client_hide (priv->panel_client);
}
g_object_unref (app_info);
}
static void
gth_application_init (GthApplication *app)
{
#ifdef GDK_WINDOWING_X11
GDesktopAppInfo *app_info;
app_info = g_desktop_app_info_new ("gthumb.desktop");
if (app_info == NULL)
return;
if (g_desktop_app_info_has_key (app_info, "Name")) {
char *app_name;
app_name = g_desktop_app_info_get_string (app_info, "Name");
g_set_application_name (app_name);
g_free (app_name);
}
if (g_desktop_app_info_has_key (app_info, "Icon")) {
char *icon;
icon = g_desktop_app_info_get_string (app_info, "Icon");
if (g_path_is_absolute (icon))
gtk_window_set_default_icon_from_file (icon, NULL);
else
gtk_window_set_default_icon_name (icon);
g_free (icon);
}
g_object_unref (app_info);
#else
/* manually set name and icon */
g_set_application_name (_("gThumb"));
gtk_window_set_default_icon_name ("gthumb");
#endif
}
static void
_launch_desktop_file (ClutterActor *actor,
const gchar *desktop_id)
{
GDesktopAppInfo *app_info;
const gchar *path;
app_info = g_desktop_app_info_new (desktop_id);
if (!app_info)
return;
path = g_desktop_app_info_get_filename (app_info);
if (penge_utils_launch_for_desktop_file (actor, path))
penge_utils_signal_activated (actor);
g_object_unref (app_info);
}
static gboolean launch_desktop(const gchar *name)
{
GDesktopAppInfo *info = NULL;
GError *error = NULL;
info = g_desktop_app_info_new(name);
if (!info) {
return FALSE;
}
if (!g_app_info_launch(G_APP_INFO(info), NULL, NULL, &error)) {
if (error) {
g_printerr("Error launching %s: %s\n", name, error->message);
g_object_unref(info);
g_error_free(error);
return FALSE;
}
}
g_object_unref(info);
return TRUE;
}
/**
* shell_app_system_lookup_app:
*
* Find a #ShellApp corresponding to an id.
*
* Return value: (transfer none): The #ShellApp for id, or %NULL if none
*/
ShellApp *
shell_app_system_lookup_app (ShellAppSystem *self,
const char *id)
{
ShellAppSystemPrivate *priv = self->priv;
ShellApp *app;
GDesktopAppInfo *info;
app = g_hash_table_lookup (priv->id_to_app, id);
if (app)
return app;
info = g_desktop_app_info_new (id);
if (!info)
return NULL;
app = _shell_app_new (info);
g_hash_table_insert (priv->id_to_app, (char *) shell_app_get_id (app), app);
g_object_unref (info);
return app;
}
GAppInfo *
problem_create_app_from_env (const char **envp,
pid_t pid)
{
GDesktopAppInfo *app;
guint i;
const char *desktop, *epid;
if (envp == NULL)
return NULL;
if (pid < 0)
return NULL;
desktop = epid = NULL;
for (i = 0; envp[i] != NULL; i++)
{
if (g_str_has_prefix (envp[i], GIO_LAUNCHED_DESKTOP_FILE_PREFIX))
desktop = envp[i] + strlen (GIO_LAUNCHED_DESKTOP_FILE_PREFIX);
else if (g_str_has_prefix (envp[i], GIO_LAUNCHED_DESKTOP_FILE_PID_PREFIX))
epid = envp[i] + strlen (GIO_LAUNCHED_DESKTOP_FILE_PID_PREFIX);
if (desktop && epid)
break;
}
if (!desktop || !epid)
return NULL;
/* Verify PID */
if (atoi (epid) != pid)
return NULL;
if (*desktop == '/')
app = g_desktop_app_info_new_from_filename (desktop);
else
app = g_desktop_app_info_new (desktop);
return (GAppInfo *) app;
}
/**
* fm_launch_desktop_entry
* @ctx: (allow-none): a launch context
* @file_or_id: a desktop entry to launch
* @uris: (element-type char *): files to use in run substitutions
* @launcher: #FmFileLauncher with callbacks
* @user_data: data supplied for callbacks
*
* Launches a desktop entry with optional files.
*
* Returns: %TRUE in case of success.
*
* Since: 0.1.0
*/
gboolean fm_launch_desktop_entry(GAppLaunchContext* ctx, const char* file_or_id, GList* uris, FmFileLauncher* launcher, gpointer user_data)
{
gboolean ret = FALSE;
GAppInfo* app;
gboolean is_absolute_path = g_path_is_absolute(file_or_id);
GList* _uris = NULL;
GError* err = NULL;
/* Let GDesktopAppInfo try first. */
if(is_absolute_path)
app = (GAppInfo*)g_desktop_app_info_new_from_filename(file_or_id);
else
app = (GAppInfo*)g_desktop_app_info_new(file_or_id);
/* we handle Type=Link in FmFileInfo so if GIO failed then
it cannot be launched in fact */
if(app) {
ret = fm_app_info_launch_uris(app, uris, ctx, &err);
g_object_unref(app);
}
else if (launcher->error)
g_set_error(&err, G_IO_ERROR, G_IO_ERROR_FAILED,
_("Invalid desktop entry file: '%s'"), file_or_id);
if(err)
{
if(launcher->error)
launcher->error(ctx, err, NULL, user_data);
g_error_free(err);
}
if(_uris)
{
g_list_foreach(_uris, (GFunc)g_free, NULL);
g_list_free(_uris);
}
return ret;
}
static void
on_open_in_easytag (NautilusMenuItem *item,
gpointer data)
{
NautilusFileInfo *dir;
GDesktopAppInfo *appinfo;
dir = g_object_get_data (G_OBJECT (item), "dir");
appinfo = g_desktop_app_info_new ("easytag.desktop");
if (appinfo)
{
GdkAppLaunchContext *context;
GList *uris = NULL;
uris = g_list_append (uris, nautilus_file_info_get_uri (dir));
context = gdk_display_get_app_launch_context (gdk_display_get_default ());
g_app_info_launch_uris (G_APP_INFO (appinfo), uris,
G_APP_LAUNCH_CONTEXT (context), NULL);
}
}