static gboolean
panel_app_info_launch_uris (GAppInfo *appinfo,
GList *uris,
GdkScreen *screen,
guint32 timestamp,
GError **error)
{
GdkAppLaunchContext *context;
GError *local_error;
GdkDisplay *display;
g_return_val_if_fail (G_IS_APP_INFO (appinfo), FALSE);
g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
display = gdk_screen_get_display (screen);
context = gdk_display_get_app_launch_context (display);
gdk_app_launch_context_set_screen (context, screen);
gdk_app_launch_context_set_timestamp (context, timestamp);
local_error = NULL;
g_app_info_launch_uris (appinfo, uris,
(GAppLaunchContext *) context,
&local_error);
g_object_unref (context);
return _panel_launch_handle_error (g_app_info_get_name (appinfo),
screen, local_error, error);
}
NS_IMETHODIMP
nsGIOMimeApp::Launch(const nsACString& aUri)
{
char *uri = strdup(PromiseFlatCString(aUri).get());
if (!uri)
return NS_ERROR_OUT_OF_MEMORY;
GList *uris = g_list_append(NULL, uri);
if (!uris) {
g_free(uri);
return NS_ERROR_OUT_OF_MEMORY;
}
GError *error = NULL;
gboolean result = g_app_info_launch_uris(mApp, uris, NULL, &error);
g_free(uri);
g_list_free(uris);
if (!result) {
g_warning("Cannot launch application: %s", error->message);
g_error_free(error);
return NS_ERROR_FAILURE;
}
return NS_OK;
}
gboolean
panel_app_info_launch_uris (GAppInfo *appinfo,
GList *uris,
GdkScreen *screen,
guint32 timestamp,
GError **error)
{
GdkAppLaunchContext *context;
GError *local_error;
gboolean retval;
g_return_val_if_fail (G_IS_APP_INFO (appinfo), FALSE);
g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
context = gdk_app_launch_context_new ();
gdk_app_launch_context_set_screen (context, screen);
gdk_app_launch_context_set_timestamp (context, timestamp);
local_error = NULL;
retval = g_app_info_launch_uris (appinfo, uris,
(GAppLaunchContext *) context,
&local_error);
g_object_unref (context);
if ((local_error == NULL) && (retval == TRUE))
return TRUE;
return _panel_launch_handle_error (g_app_info_get_name (appinfo),
screen, local_error, error);
}
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);
}
}
/**
* g_app_info_launch_default_for_uri:
* @uri: the uri to show
* @launch_context: an optional #GAppLaunchContext.
* @error: a #GError.
*
* Utility function that launches the default application
* registered to handle the specified uri. Synchronous I/O
* is done on the uri to detect the type of the file if
* required.
*
* Returns: %TRUE on success, %FALSE on error.
**/
gboolean
g_app_info_launch_default_for_uri (const char *uri,
GAppLaunchContext *launch_context,
GError **error)
{
GAppInfo *app_info;
GFile *file;
GList l;
gboolean res;
file = g_file_new_for_uri (uri);
app_info = g_file_query_default_handler (file, NULL, error);
g_object_unref (file);
if (app_info == NULL)
return FALSE;
/* Use the uri, not the GFile, as the GFile roundtrip may
* affect the uri which we don't want (for instance for a
* mailto: uri).
*/
l.data = (char *)uri;
l.next = l.prev = NULL;
res = g_app_info_launch_uris (app_info, &l,
launch_context, error);
g_object_unref (app_info);
return res;
}
void
open_file_with_application (GFile *file)
{
GAppInfo *application;
gchar *primary;
GFileInfo *info;
gchar *uri_scheme;
const char *content;
gboolean local = FALSE;
info = g_file_query_info (file,
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
G_FILE_QUERY_INFO_NONE,
NULL,
NULL);
if (!info) return;
uri_scheme = g_file_get_uri_scheme (file);
if (g_ascii_strcasecmp(uri_scheme,"file") == 0) local = TRUE;
content = g_file_info_get_content_type (info);
application = g_app_info_get_default_for_type (content, TRUE);
if (!application) {
primary = g_strdup_printf (_("Could not open folder \"%s\""),
g_file_get_basename (file));
message (primary,
_("There is no installed viewer capable "
"of displaying the folder."),
GTK_MESSAGE_ERROR,
baobab.window);
g_free (primary);
}
else {
GList *uris = NULL;
gchar *uri;
uri = g_file_get_uri (file);
uris = g_list_append (uris, uri);
g_app_info_launch_uris (application, uris, NULL, NULL);
g_list_free (uris);
g_free (uri);
}
g_free (uri_scheme);
if (application)
g_object_unref (application);
g_object_unref (info);
}
gboolean fm_launch_desktop_entry(GAppLaunchContext* ctx, const char* file_or_id, GList* uris, GError** err)
{
GKeyFile* kf = g_key_file_new();
gboolean loaded;
gboolean ret = FALSE;
if(g_path_is_absolute(file_or_id))
loaded = g_key_file_load_from_file(kf, file_or_id, 0, err);
else
{
char* tmp = g_strconcat("applications/", file_or_id, NULL);
loaded = g_key_file_load_from_data_dirs(kf, tmp, NULL, 0, err);
g_free(tmp);
}
if(loaded)
{
GList* _uris = NULL;
GAppInfo* app = NULL;
char* type = g_key_file_get_string(kf, G_KEY_FILE_DESKTOP_GROUP, "Type", NULL);
if(type)
{
if(strcmp(type, "Application") == 0)
app = g_desktop_app_info_new_from_keyfile(kf);
else if(strcmp(type, "Link") == 0)
{
char* url = g_key_file_get_string(kf, G_KEY_FILE_DESKTOP_GROUP, "URL", NULL);
if(url)
{
char* scheme = g_uri_parse_scheme(url);
if(scheme)
{
/* Damn! this actually relies on gconf to work. */
/* FIXME: use our own way to get a usable browser later. */
app = g_app_info_get_default_for_uri_scheme(scheme);
uris = _uris = g_list_prepend(NULL, url);
g_free(scheme);
}
}
}
else if(strcmp(type, "Directory") == 0)
{
/* FIXME: how should this work? It's not defined in the spec. */
}
if(app)
ret = g_app_info_launch_uris(app, uris, ctx, err);
}
}
g_key_file_free(kf);
return ret;
}
static gboolean
_app_info_launch_uris (GAppInfo *appinfo,
GList *uris,
GAppLaunchContext *launch_context,
GError **error)
{
OlAppInfo *info = OL_APP_INFO (appinfo);
/* TODO: implement launching. */
GAppInfo* app = g_app_info_create_from_commandline (info->cmdline, "", 0, NULL);
gboolean ret = g_app_info_launch_uris (app, uris, launch_context, error);
g_object_unref (G_OBJECT (app));
return ret;
}
/**
* g_app_info_launch_default_for_uri:
* @uri: the uri to show
* @launch_context: (allow-none): an optional #GAppLaunchContext.
* @error: a #GError.
*
* Utility function that launches the default application
* registered to handle the specified uri. Synchronous I/O
* is done on the uri to detect the type of the file if
* required.
*
* Returns: %TRUE on success, %FALSE on error.
**/
gboolean
g_app_info_launch_default_for_uri (const char *uri,
GAppLaunchContext *launch_context,
GError **error)
{
char *uri_scheme;
GAppInfo *app_info = NULL;
GList l;
gboolean res;
/* g_file_query_default_handler() calls
* g_app_info_get_default_for_uri_scheme() too, but we have to do it
* here anyway in case GFile can't parse @uri correctly.
*/
uri_scheme = g_uri_parse_scheme (uri);
if (uri_scheme && uri_scheme[0] != '\0')
app_info = g_app_info_get_default_for_uri_scheme (uri_scheme);
g_free (uri_scheme);
if (!app_info)
{
GFile *file;
file = g_file_new_for_uri (uri);
app_info = g_file_query_default_handler (file, NULL, error);
g_object_unref (file);
if (app_info == NULL)
return FALSE;
/* We still use the original @uri rather than calling
* g_file_get_uri(), because GFile might have modified the URI
* in ways we don't want (eg, removing the fragment identifier
* from a file: URI).
*/
}
l.data = (char *)uri;
l.next = l.prev = NULL;
res = g_app_info_launch_uris (app_info, &l,
launch_context, error);
g_object_unref (app_info);
return res;
}
NS_IMETHODIMP
nsGIOMimeApp::Launch(const nsACString& aUri)
{
GList uris = { 0 };
PromiseFlatCString flatUri(aUri);
uris.data = const_cast<char*>(flatUri.get());
GError *error = NULL;
gboolean result = g_app_info_launch_uris(mApp, &uris, NULL, &error);
if (!result) {
g_warning("Cannot launch application: %s", error->message);
g_error_free(error);
return NS_ERROR_FAILURE;
}
return NS_OK;
}
gboolean
photos_glib_app_info_launch_uri (GAppInfo *appinfo,
const gchar *uri,
GAppLaunchContext *launch_context,
GError **error)
{
GList *uris = NULL;
gboolean ret_val;
g_return_val_if_fail (G_IS_APP_INFO (appinfo), FALSE);
g_return_val_if_fail (uri != NULL && uri[0] != '\0', FALSE);
g_return_val_if_fail (launch_context == NULL || G_IS_APP_LAUNCH_CONTEXT (launch_context), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
uris = g_list_prepend (uris, g_strdup (uri));
ret_val = g_app_info_launch_uris (appinfo, uris, launch_context, error);
g_list_free_full (uris, g_free);
return ret_val;
}
static void
activate_open_with_application_item (GtkMenuItem *menuitem,
gpointer data)
{
GthBrowser *browser = data;
GList *items;
GList *file_list;
GList *uris;
GList *scan;
GAppInfo *appinfo;
GdkAppLaunchContext *context;
GError *error = NULL;
items = gth_file_selection_get_selected (GTH_FILE_SELECTION (gth_browser_get_file_list_view (browser)));
file_list = gth_file_list_get_files (GTH_FILE_LIST (gth_browser_get_file_list (browser)), items);
uris = NULL;
for (scan = file_list; scan; scan = scan->next) {
GthFileData *file_data = scan->data;
uris = g_list_prepend (uris, g_file_get_uri (file_data->file));
}
uris = g_list_reverse (uris);
appinfo = g_object_get_data (G_OBJECT (menuitem), "appinfo");
g_return_if_fail (G_IS_APP_INFO (appinfo));
context = gdk_display_get_app_launch_context (gtk_widget_get_display (GTK_WIDGET (browser)));
gdk_app_launch_context_set_timestamp (context, 0);
gdk_app_launch_context_set_icon (context, g_app_info_get_icon (appinfo));
if (! g_app_info_launch_uris (appinfo, uris, G_APP_LAUNCH_CONTEXT (context), &error)) {
_gtk_error_dialog_from_gerror_show (GTK_WINDOW (browser),
_("Could not perform the operation"),
error);
g_clear_error (&error);
}
g_object_unref (context);
g_list_free (uris);
_g_object_list_unref (file_list);
_gtk_tree_path_list_free (items);
}
gboolean
panel_show_uri_force_mime_type (GdkScreen *screen,
const gchar *uri,
const gchar *mime_type,
guint32 timestamp,
GError **error)
{
GFile *file;
GAppInfo *appinfo;
gboolean ret;
GdkDisplay *display;
GdkAppLaunchContext *context;
GList *uris;
g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
g_return_val_if_fail (uri != NULL, FALSE);
g_return_val_if_fail (mime_type != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
file = g_file_new_for_uri (uri);
appinfo = g_app_info_get_default_for_type (mime_type,
!g_file_is_native (file));
g_object_unref (file);
if (appinfo == NULL) {
/* no application for the mime type, so let's fallback on
* automatic detection */
return panel_show_uri (screen, uri, timestamp, error);
}
uris = g_list_append (NULL, (gpointer)uri);
display = gdk_screen_get_display (screen);
context = gdk_display_get_app_launch_context (display);
ret = g_app_info_launch_uris (appinfo, uris, G_APP_LAUNCH_CONTEXT(context), error);
g_object_unref (context);
g_list_free (uris);
g_object_unref (appinfo);
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);
}
}
static bool
launch_gthumb_import (MpdStorageDeviceTile *self,
GError **error)
{
MpdStorageDeviceTilePrivate *priv = GET_PRIVATE (self);
GAppInfo *appinfo;
GList uris = { NULL, };
appinfo = (GAppInfo *) g_desktop_app_info_new ("gthumb-import.desktop");
if (NULL == appinfo)
{
*error = g_error_new (MPD_STORAGE_DEVICE_TILE_ERROR,
0,
"%s : Failed to open \"gthumb-import.desktop\"",
G_STRLOC);
return false;
}
uris.data = priv->mount_point;
g_debug ("gthumb-imported.desktop %s", priv->mount_point);
return g_app_info_launch_uris (appinfo, &uris, NULL, error);
}
static gboolean
diagnostics_label_activate_link_cb (GtkLabel *label,
const gchar *uri,
gpointer user_data)
{
GisFinishedPage *self = GIS_FINISHED_PAGE (user_data);
GisFinishedPagePrivate *priv = gis_finished_page_get_instance_private (self);
g_autoptr(GList) uris = g_list_prepend (NULL, (gchar *) uri);
g_autoptr(GError) error = NULL;
/* We cannot rely on the default handler, because the FBE session is
* configured to associate a dummy handler (namely `/bin/true`) with all MIME
* types. So, explicitly launch gedit. (If it's not installed, there should
* be no link in this label, and this handler should not be connected.)
*/
g_return_val_if_fail (priv->gedit != NULL, FALSE);
if (g_app_info_launch_uris (G_APP_INFO (priv->gedit), uris, NULL,
&error))
return TRUE;
g_warning ("Failed to launch gedit for %s: %s", uri, error->message);
return FALSE;
}
void
nemo_launch_application_by_uri (GAppInfo *application,
GList *uris,
GtkWindow *parent_window)
{
char *uri;
GList *locations, *l;
GFile *location;
NemoFile *file;
gboolean result;
GError *error;
GdkDisplay *display;
GdkAppLaunchContext *launch_context;
NemoIconInfo *icon;
int count, total;
g_assert (uris != NULL);
/* count the number of uris with local paths */
count = 0;
total = g_list_length (uris);
locations = NULL;
for (l = uris; l != NULL; l = l->next) {
uri = l->data;
location = g_file_new_for_uri (uri);
if (g_file_is_native (location)) {
count++;
}
locations = g_list_prepend (locations, location);
}
locations = g_list_reverse (locations);
if (parent_window != NULL) {
display = gtk_widget_get_display (GTK_WIDGET (parent_window));
} else {
display = gdk_display_get_default ();
}
launch_context = gdk_display_get_app_launch_context (display);
if (parent_window != NULL) {
gdk_app_launch_context_set_screen (launch_context,
gtk_window_get_screen (parent_window));
}
file = nemo_file_get_by_uri (uris->data);
icon = nemo_file_get_icon (file,
48,
gtk_widget_get_scale_factor (GTK_WIDGET (parent_window)),
0);
nemo_file_unref (file);
if (icon) {
gdk_app_launch_context_set_icon_name (launch_context,
nemo_icon_info_get_used_name (icon));
g_object_unref (icon);
}
error = NULL;
if (count == total) {
/* All files are local, so we can use g_app_info_launch () with
* the file list we constructed before.
*/
result = g_app_info_launch (application,
locations,
G_APP_LAUNCH_CONTEXT (launch_context),
&error);
} else {
/* Some files are non local, better use g_app_info_launch_uris ().
*/
result = g_app_info_launch_uris (application,
uris,
G_APP_LAUNCH_CONTEXT (launch_context),
&error);
}
g_object_unref (launch_context);
if (result) {
for (l = uris; l != NULL; l = l->next) {
file = nemo_file_get_by_uri (l->data);
nemo_recent_add_file (file, application);
nemo_file_unref (file);
}
}
g_list_free_full (locations, g_object_unref);
}
gboolean
open_file_with_filemanager (GtkWidget * window,
const gchar * file)
{
GDesktopAppInfo * d_app_info;
GKeyFile * key_file;
GdkAppLaunchContext * ctx = NULL;
GList * list = NULL;
GAppInfo * g_app_info;
GFile * g_file;
gchar * command;
gchar * contents;
gchar * uri;
gboolean result = TRUE;
uri = g_filename_to_uri (file, NULL, NULL);
list = g_list_prepend (list, uri);
g_file = g_file_new_for_path (file);
g_app_info = g_file_query_default_handler (g_file, NULL, NULL);
if (strcmp (g_app_info_get_executable (g_app_info), "nautilus") == 0) {
command = g_strconcat ("nautilus ",
"--sm-disable ",
"--no-desktop ",
"--no-default-window ",
NULL);
}
else {
command = g_strconcat (g_app_info_get_executable (g_app_info),
" ", NULL);
}
contents = g_strdup_printf ("[Desktop Entry]\n"
"Name=Nautilus\n"
"Icon=file-manager\n"
"Exec=%s\n"
"Terminal=false\n"
"StartupNotify=true\n"
"Type=Application\n",
command);
key_file = g_key_file_new ();
g_key_file_load_from_data (key_file, contents, strlen(contents), G_KEY_FILE_NONE, NULL);
d_app_info = g_desktop_app_info_new_from_keyfile (key_file);
if (d_app_info != NULL) {
ctx = gdk_app_launch_context_new ();
gdk_app_launch_context_set_screen (ctx, gtk_widget_get_screen (window));
result = g_app_info_launch_uris (G_APP_INFO (d_app_info), list, G_APP_LAUNCH_CONTEXT (ctx), NULL);
}
else {
result = FALSE;
}
g_object_unref (g_app_info);
g_object_unref (d_app_info);
g_object_unref (g_file);
g_object_unref (ctx);
g_key_file_free (key_file);
g_list_free (list);
g_free (contents);
g_free (command);
g_free (uri);
return result;
}
static gboolean
activate_panel (GnomeControlCenter *shell,
const gchar *id,
const gchar **argv,
const gchar *desktop_file,
const gchar *name,
GIcon *gicon)
{
GDesktopAppInfo *appinfo;
GdkAppLaunchContext *context;
GdkScreen *screen;
GdkDisplay *display;
GError *error;
appinfo = g_desktop_app_info_new_from_filename (desktop_file);
screen = gtk_widget_get_screen (shell->priv->window);
display = gdk_screen_get_display (screen);
context = gdk_display_get_app_launch_context (display);
gdk_app_launch_context_set_screen (context, screen);
gdk_app_launch_context_set_timestamp (context, gtk_get_current_event_time ());
error = NULL;
g_app_info_launch_uris (G_APP_INFO (appinfo), NULL,
(GAppLaunchContext *) context,
&error);
if (error) {
g_printerr ("Could not launch '%s': %s\n", id, error->message);
g_clear_error (&error);
}
g_object_unref (context);
g_object_unref (appinfo);
#if 0
GnomeControlCenterPrivate *priv = shell->priv;
GType panel_type = G_TYPE_INVALID;
GList *panels, *l;
GtkWidget *box;
const gchar *icon_name;
/* check if there is an plugin that implements this panel */
panels = g_io_extension_point_get_extensions (priv->extension_point);
if (!desktop_file)
return FALSE;
if (!id)
return FALSE;
for (l = panels; l != NULL; l = l->next)
{
GIOExtension *extension;
const gchar *name;
extension = l->data;
name = g_io_extension_get_name (extension);
if (!g_strcmp0 (name, id))
{
panel_type = g_io_extension_get_type (extension);
break;
}
}
if (panel_type == G_TYPE_INVALID)
{
g_warning ("Could not find the loadable module for panel '%s'", id);
return FALSE;
}
/* create the panel plugin */
priv->current_panel = g_object_new (panel_type, "shell", shell, "argv", argv, NULL);
cc_shell_set_active_panel (CC_SHELL (shell), CC_PANEL (priv->current_panel));
gtk_widget_show (priv->current_panel);
gtk_lock_button_set_permission (GTK_LOCK_BUTTON (priv->lock_button),
cc_panel_get_permission (CC_PANEL (priv->current_panel)));
box = gtk_alignment_new (0, 0, 1, 1);
gtk_alignment_set_padding (GTK_ALIGNMENT (box), 6, 6, 6, 6);
gtk_container_add (GTK_CONTAINER (box), priv->current_panel);
gtk_widget_set_name (box, id);
notebook_add_page (priv->notebook, box);
/* switch to the new panel */
gtk_widget_show (box);
notebook_select_page (priv->notebook, box);
/* set the title of the window */
icon_name = get_icon_name_from_g_icon (gicon);
gtk_window_set_role (GTK_WINDOW (priv->window), id);
gtk_window_set_title (GTK_WINDOW (priv->window), name);
gtk_window_set_default_icon_name (icon_name);
gtk_window_set_icon_name (GTK_WINDOW (priv->window), icon_name);
priv->current_panel_box = box;
#endif
return TRUE;
}
static gboolean
exo_open_uri (const gchar *uri,
GError **error)
{
GFile *file;
gchar *scheme;
GFileInfo *file_info;
gboolean succeed = FALSE;
gboolean retval = FALSE;
GFileType file_type;
const gchar *content_type;
GAppInfo *app_info;
gchar *path;
const gchar *executable;
GList fake_list;
const gchar * const *schemes;
GError *err = NULL;
guint i;
g_return_val_if_fail (uri != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
#ifndef NDEBUG
schemes = g_vfs_get_supported_uri_schemes (g_vfs_get_default ());
scheme = g_strjoinv (", ", (gchar **) schemes);
g_debug ("vfs supported schemes: %s", scheme);
g_free (scheme);
#endif
file = g_file_new_for_uri (uri);
scheme = g_file_get_uri_scheme (file);
/* try to launch common schemes for know preferred applications */
if (scheme != NULL && exo_open_uri_known_category (uri, scheme, &retval))
{
g_free (scheme);
return retval;
}
/* handle the uri as a file, maybe we succeed... */
file_info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_TYPE ","
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
G_FILE_QUERY_INFO_NONE, NULL, &err);
if (file_info != NULL)
{
file_type = g_file_info_get_file_type (file_info);
if (file_type == G_FILE_TYPE_DIRECTORY)
{
#ifndef NDEBUG
g_debug ("file is directory, use filemanager");
#endif
/* directories should go fine with a file manager */
retval = exo_open_launch_category ("FileManager", uri);
succeed = TRUE;
}
else
{
content_type = g_file_info_get_content_type (file_info);
#ifndef NDEBUG
g_debug ("content type=%s", content_type);
#endif
if (G_LIKELY (content_type))
{
/* try to find a suitable application for this content type */
path = g_file_get_path (file);
app_info = g_app_info_get_default_for_type (content_type, path == NULL);
g_free (path);
if (app_info != NULL)
{
/* make sure we don't loop somehow */
executable = g_app_info_get_executable (app_info);
#ifndef NDEBUG
g_debug ("default executable=%s", executable);
#endif
if (executable == NULL
|| strcmp (executable, "exo-open") != 0)
{
fake_list.data = (gpointer) uri;
fake_list.prev = fake_list.next = NULL;
/* launch it */
retval = g_app_info_launch_uris (app_info, &fake_list, NULL, &err);
succeed = TRUE;
}
g_object_unref (G_OBJECT (app_info));
}
}
}
g_object_unref (G_OBJECT (file_info));
}
else if (err != NULL
&& scheme != NULL
&& err->code == G_IO_ERROR_NOT_MOUNTED)
{
/* check if the scheme is supported by gio */
schemes = g_vfs_get_supported_uri_schemes (g_vfs_get_default ());
if (G_LIKELY (schemes != NULL))
{
for (i = 0; schemes[i] != NULL; i++)
{
/* found scheme, open in file manager */
if (strcmp (scheme, schemes[i]) == 0)
{
retval = succeed = exo_open_launch_category ("FileManager", uri);
break;
}
}
}
}
g_object_unref (G_OBJECT (file));
/* our last try... */
if (!succeed)
{
#ifndef NDEBUG
g_debug ("nothing worked, try ftp(s) or gtk_show_uri()");
#endif
/* try ftp uris if the file manager/gio failed to recognize it */
if (scheme != NULL
&& (strcmp (scheme, "ftp") == 0 || strcmp (scheme, "ftps") == 0))
retval = exo_open_launch_category ("WebBrowser", uri);
else
retval = gtk_show_uri (NULL, uri, 0, error);
}
g_free (scheme);
if (!retval && error != NULL)
*error = err;
else if (err != NULL)
g_error_free (err);
return retval;
}
static void
ev_spawn (const char *uri,
GdkScreen *screen,
EvLinkDest *dest,
EvWindowRunMode mode,
const gchar *search_string,
guint timestamp)
{
GString *cmd;
gchar *path, *cmdline;
GAppInfo *app;
GdkAppLaunchContext *ctx;
GError *error = NULL;
cmd = g_string_new (NULL);
#ifdef G_OS_WIN32
{
gchar *dir;
dir = g_win32_get_package_installation_directory_of_module (NULL);
path = g_build_filename (dir, "bin", "atril", NULL);
g_free (dir);
}
#else
path = g_build_filename (BINDIR, "atril", NULL);
#endif
g_string_append_printf (cmd, " %s", path);
g_free (path);
/* Page label */
if (dest) {
const gchar *page_label;
page_label = ev_link_dest_get_page_label (dest);
if (page_label)
g_string_append_printf (cmd, " --page-label=%s", page_label);
else
g_string_append_printf (cmd, " --page-label=%d", ev_link_dest_get_page (dest));
}
/* Find string */
if (search_string) {
g_string_append_printf (cmd, " --find=%s", search_string);
}
/* Mode */
switch (mode) {
case EV_WINDOW_MODE_FULLSCREEN:
g_string_append (cmd, " -f");
break;
case EV_WINDOW_MODE_PRESENTATION:
g_string_append (cmd, " -s");
break;
default:
break;
}
cmdline = g_string_free (cmd, FALSE);
app = g_app_info_create_from_commandline (cmdline, NULL, 0, &error);
if (app != NULL) {
GList uri_list;
GList *uris = NULL;
#if GTK_CHECK_VERSION (3, 0, 0)
ctx = gdk_display_get_app_launch_context (gdk_screen_get_display (screen));
#else
ctx = gdk_app_launch_context_new ();
gdk_app_launch_context_set_display (ctx, gdk_screen_get_display (screen));
#endif
gdk_app_launch_context_set_screen (ctx, screen);
gdk_app_launch_context_set_timestamp (ctx, timestamp);
if (uri) {
uri_list.data = (gchar *)uri;
uri_list.prev = uri_list.next = NULL;
uris = &uri_list;
}
g_app_info_launch_uris (app, uris, G_APP_LAUNCH_CONTEXT (ctx), &error);
g_object_unref (app);
g_object_unref (ctx);
}
if (error != NULL) {
g_warning ("Error launching atril %s: %s\n", uri, error->message);
g_error_free (error);
}
g_free (cmdline);
}
/**
* shell_doc_system_open:
* @system: A #ShellDocSystem
* @info: A #GtkRecentInfo
* @workspace: Open on this workspace, or -1 for default
*
* Launch the default application associated with the mime type of
* @info, using its uri.
*/
void
shell_doc_system_open (ShellDocSystem *system,
GtkRecentInfo *info,
int workspace)
{
GFile *file;
GAppInfo *app_info;
gboolean needs_uri;
GAppLaunchContext *context;
context = shell_global_create_app_launch_context (shell_global_get ());
if (workspace != -1)
gdk_app_launch_context_set_desktop ((GdkAppLaunchContext *)context, workspace);
file = g_file_new_for_uri (gtk_recent_info_get_uri (info));
needs_uri = g_file_get_path (file) == NULL;
g_object_unref (file);
app_info = g_app_info_get_default_for_type (gtk_recent_info_get_mime_type (info), needs_uri);
if (app_info != NULL)
{
GList *uris;
uris = g_list_prepend (NULL, (gpointer)gtk_recent_info_get_uri (info));
g_app_info_launch_uris (app_info, uris, context, NULL);
g_list_free (uris);
}
else
{
char *app_name;
const char *app_exec;
char *app_exec_quoted;
guint count;
time_t time;
app_name = gtk_recent_info_last_application (info);
if (gtk_recent_info_get_application_info (info, app_name, &app_exec, &count, &time))
{
GRegex *regex;
/* TODO: Change this once better support for creating
GAppInfo is added to GtkRecentInfo, as right now
this relies on the fact that the file uri is
already a part of appExec, so we don't supply any
files to app_info.launch().
The 'command line' passed to
create_from_command_line is allowed to contain
'%<something>' macros that are expanded to file
name / icon name, etc, so we need to escape % as %%
*/
regex = g_regex_new ("%", 0, 0, NULL);
app_exec_quoted = g_regex_replace (regex, app_exec, -1, 0, "%%", 0, NULL);
g_regex_unref (regex);
app_info = g_app_info_create_from_commandline (app_exec_quoted, NULL, 0, NULL);
g_free (app_exec_quoted);
/* The point of passing an app launch context to
launch() is mostly to get startup notification and
associated benefits like the app appearing on the
right desktop; but it doesn't really work for now
because with the way we create the appInfo we
aren't reading the application's desktop file, and
thus don't find the StartupNotify=true in it. So,
despite passing the app launch context, no startup
notification occurs.
*/
g_app_info_launch (app_info, NULL, context, NULL);
}
g_free (app_name);
}
g_object_unref (context);
}
static gboolean
totem_disc_recorder_plugin_start_burning (TotemDiscRecorderPlugin *pi,
const char *path,
gboolean copy)
{
GtkWindow *main_window;
GdkScreen *screen;
GdkDisplay *display;
gchar *command_line;
GList *uris;
GAppInfo *info;
GdkAppLaunchContext *context;
GError *error = NULL;
char *xid_arg;
main_window = totem_object_get_main_window (pi->priv->totem);
screen = gtk_widget_get_screen (GTK_WIDGET (main_window));
display = gdk_display_get_default ();
/* Build a command line to use */
xid_arg = NULL;
#ifdef GDK_WINDOWING_X11
if (GDK_IS_X11_DISPLAY (display))
xid_arg = g_strdup_printf ("-x %d", (int) gdk_x11_window_get_xid (gtk_widget_get_window (GTK_WIDGET (main_window))));
#endif /* GDK_WINDOWING_X11 */
g_object_unref (main_window);
if (copy != FALSE)
command_line = g_strdup_printf ("brasero %s -c", xid_arg ? xid_arg : "");
else
command_line = g_strdup_printf ("brasero %s -r", xid_arg ? xid_arg : "");
/* Build the app info */
info = g_app_info_create_from_commandline (command_line, NULL,
G_APP_INFO_CREATE_SUPPORTS_URIS | G_APP_INFO_CREATE_SUPPORTS_STARTUP_NOTIFICATION, &error);
g_free (command_line);
if (error != NULL)
goto error;
/* Create a launch context and launch it */
context = gdk_display_get_app_launch_context (gtk_widget_get_display (GTK_WIDGET (main_window)));
gdk_app_launch_context_set_screen (context, screen);
uris = g_list_prepend (NULL, (gpointer) path);
g_app_info_launch_uris (info, uris, G_APP_LAUNCH_CONTEXT (context), &error);
g_list_free (uris);
g_object_unref (info);
g_object_unref (context);
if (error != NULL)
goto error;
return TRUE;
error:
main_window = totem_object_get_main_window (pi->priv->totem);
if (copy != FALSE)
totem_interface_error (_("The video disc could not be duplicated."), error->message, main_window);
else
totem_interface_error (_("The movie could not be recorded."), error->message, main_window);
g_error_free (error);
g_object_unref (main_window);
return FALSE;
}
gboolean fm_launch_files(GAppLaunchContext* ctx, GList* file_infos, FmFileLauncher* launcher, gpointer user_data)
{
GList* l;
GHashTable* hash = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, NULL);
GList* folders = NULL;
FmFileInfo* fi;
GError* err = NULL;
GAppInfo* app;
for(l = file_infos; l; l=l->next)
{
GList* fis;
fi = (FmFileInfo*)l->data;
if(fm_file_info_is_dir(fi))
folders = g_list_prepend(folders, fi);
else
{
/* FIXME: handle shortcuts, such as the items in menu:// */
if(fm_path_is_native(fi->path))
{
char* filename;
if(fm_file_info_is_desktop_entry(fi))
{
/* if it's a desktop entry file, directly launch it. */
filename = fm_path_to_str(fi->path);
if(!fm_launch_desktop_entry(ctx, filename, NULL, &err))
{
if(launcher->error)
launcher->error(ctx, err, user_data);
g_error_free(err);
err = NULL;
}
continue;
}
else if(fm_file_info_is_executable_type(fi))
{
/* if it's an executable file, directly execute it. */
filename = fm_path_to_str(fi->path);
/* FIXME: we need to use eaccess/euidaccess here. */
if(g_file_test(filename, G_FILE_TEST_IS_EXECUTABLE))
{
app = g_app_info_create_from_commandline(filename, NULL, 0, NULL);
if(app)
{
if(!g_app_info_launch(app, NULL, ctx, &err))
{
if(launcher->error)
launcher->error(ctx, err, user_data);
g_error_free(err);
err = NULL;
}
g_object_unref(app);
continue;
}
}
g_free(filename);
}
}
else /* not a native path */
{
if(fm_file_info_is_shortcut(fi) && !fm_file_info_is_dir(fi))
{
/* FIXME: special handling for shortcuts */
if(fm_path_is_xdg_menu(fi->path) && fi->target)
{
if(!fm_launch_desktop_entry(ctx, fi->target, NULL, &err))
{
if(launcher->error)
launcher->error(ctx, err, user_data);
g_error_free(err);
err = NULL;
}
continue;
}
}
}
if(fi->type && fi->type->type)
{
fis = g_hash_table_lookup(hash, fi->type->type);
fis = g_list_prepend(fis, fi);
g_hash_table_insert(hash, fi->type->type, fis);
}
}
}
if(g_hash_table_size(hash) > 0)
{
GHashTableIter it;
const char* type;
GList* fis;
g_hash_table_iter_init(&it, hash);
while(g_hash_table_iter_next(&it, &type, &fis))
{
GAppInfo* app = g_app_info_get_default_for_type(type, FALSE);
if(!app)
{
if(launcher->get_app)
{
FmMimeType* mime_type = ((FmFileInfo*)fis->data)->type;
app = launcher->get_app(fis, mime_type, user_data, NULL);
}
}
if(app)
{
for(l=fis; l; l=l->next)
{
char* uri;
fi = (FmFileInfo*)l->data;
uri = fm_path_to_uri(fi->path);
l->data = uri;
}
fis = g_list_reverse(fis);
g_app_info_launch_uris(app, fis, ctx, err);
/* free URI strings */
g_list_foreach(fis, (GFunc)g_free, NULL);
g_object_unref(app);
}
g_list_free(fis);
}
}
g_hash_table_destroy(hash);
if(folders)
{
folders = g_list_reverse(folders);
if(launcher->open_folder)
{
launcher->open_folder(ctx, folders, user_data, &err);
if(err)
{
if(launcher->error)
launcher->error(ctx, err, user_data);
g_error_free(err);
err = NULL;
}
}
g_list_free(folders);
}
return TRUE;
}
void
caja_launch_application_by_uri (GAppInfo *application,
GList *uris,
GtkWindow *parent_window)
{
char *uri, *uri_scheme;
GList *locations, *l;
GFile *location;
CajaFile *file;
gboolean result;
GError *error;
GdkAppLaunchContext *launch_context;
CajaIconInfo *icon;
int count, total;
g_assert (uris != NULL);
/* count the number of uris with local paths */
count = 0;
total = g_list_length (uris);
locations = NULL;
for (l = uris; l != NULL; l = l->next)
{
uri = l->data;
location = g_file_new_for_uri (uri);
if (g_file_is_native (location))
{
count++;
}
locations = g_list_prepend (locations, location);
}
locations = g_list_reverse (locations);
launch_context = gdk_app_launch_context_new ();
if (parent_window)
gdk_app_launch_context_set_screen (launch_context,
gtk_window_get_screen (parent_window));
file = caja_file_get_by_uri (uris->data);
icon = caja_file_get_icon (file, 48, 0);
caja_file_unref (file);
if (icon)
{
gdk_app_launch_context_set_icon_name (launch_context,
caja_icon_info_get_used_name (icon));
g_object_unref (icon);
}
error = NULL;
if (count == total)
{
/* All files are local, so we can use g_app_info_launch () with
* the file list we constructed before.
*/
result = g_app_info_launch (application,
locations,
G_APP_LAUNCH_CONTEXT (launch_context),
&error);
}
else
{
/* Some files are non local, better use g_app_info_launch_uris ().
*/
result = g_app_info_launch_uris (application,
uris,
G_APP_LAUNCH_CONTEXT (launch_context),
&error);
}
g_object_unref (launch_context);
if (!result)
{
if (error->domain == G_IO_ERROR &&
error->code == G_IO_ERROR_NOT_SUPPORTED)
{
uri_scheme = g_uri_parse_scheme (uris->data);
application_cannot_open_location (application,
file,
uri_scheme,
parent_window);
g_free (uri_scheme);
}
else
{
#ifdef NEW_MIME_COMPLETE
caja_program_chooser_show_invalid_message
(MATE_VFS_MIME_ACTION_TYPE_APPLICATION, file, parent_window);
#else
g_warning ("Cannot open app: %s\n", error->message);
#endif
}
g_error_free (error);
}
else
{
for (l = uris; l != NULL; l = l->next)
{
file = caja_file_get_by_uri (l->data);
caja_recent_add_file (file, application);
caja_file_unref (file);
}
}
g_list_free_full (locations, g_object_unref);
}
void
caja_launch_desktop_file (GdkScreen *screen,
const char *desktop_file_uri,
const GList *parameter_uris,
GtkWindow *parent_window)
{
GError *error;
char *message, *desktop_file_path;
const GList *p;
GList *files;
int total, count;
GFile *file, *desktop_file;
GDesktopAppInfo *app_info;
GdkAppLaunchContext *context;
/* Don't allow command execution from remote locations
* to partially mitigate the security
* risk of executing arbitrary commands.
*/
desktop_file = g_file_new_for_uri (desktop_file_uri);
desktop_file_path = g_file_get_path (desktop_file);
if (!g_file_is_native (desktop_file))
{
g_free (desktop_file_path);
g_object_unref (desktop_file);
eel_show_error_dialog
(_("Sorry, but you cannot execute commands from "
"a remote site."),
_("This is disabled due to security considerations."),
parent_window);
return;
}
g_object_unref (desktop_file);
app_info = g_desktop_app_info_new_from_filename (desktop_file_path);
g_free (desktop_file_path);
if (app_info == NULL)
{
eel_show_error_dialog
(_("There was an error launching the application."),
NULL,
parent_window);
return;
}
/* count the number of uris with local paths */
count = 0;
total = g_list_length ((GList *) parameter_uris);
files = NULL;
for (p = parameter_uris; p != NULL; p = p->next)
{
file = g_file_new_for_uri ((const char *) p->data);
if (g_file_is_native (file))
{
count++;
}
files = g_list_prepend (files, file);
}
/* check if this app only supports local files */
if (g_app_info_supports_files (G_APP_INFO (app_info)) &&
!g_app_info_supports_uris (G_APP_INFO (app_info)) &&
parameter_uris != NULL)
{
if (count == 0)
{
/* all files are non-local */
eel_show_error_dialog
(_("This drop target only supports local files."),
_("To open non-local files copy them to a local folder and then"
" drop them again."),
parent_window);
g_list_free_full (files, g_object_unref);
g_object_unref (app_info);
return;
}
else if (count != total)
{
/* some files are non-local */
eel_show_warning_dialog
(_("This drop target only supports local files."),
_("To open non-local files copy them to a local folder and then"
" drop them again. The local files you dropped have already been opened."),
parent_window);
}
}
error = NULL;
context = gdk_app_launch_context_new ();
/* TODO: Ideally we should accept a timestamp here instead of using GDK_CURRENT_TIME */
gdk_app_launch_context_set_timestamp (context, GDK_CURRENT_TIME);
gdk_app_launch_context_set_screen (context,
gtk_window_get_screen (parent_window));
if (count == total)
{
/* All files are local, so we can use g_app_info_launch () with
* the file list we constructed before.
*/
g_app_info_launch (G_APP_INFO (app_info),
files,
G_APP_LAUNCH_CONTEXT (context),
&error);
}
else
{
/* Some files are non local, better use g_app_info_launch_uris ().
*/
g_app_info_launch_uris (G_APP_INFO (app_info),
(GList *) parameter_uris,
G_APP_LAUNCH_CONTEXT (context),
&error);
}
if (error != NULL)
{
message = g_strconcat (_("Details: "), error->message, NULL);
eel_show_error_dialog
(_("There was an error launching the application."),
message,
parent_window);
g_error_free (error);
g_free (message);
}
g_list_free_full (files, g_object_unref);
g_object_unref (context);
g_object_unref (app_info);
}
