static void
recent_documents_activate_cb (GtkRecentChooser *chooser,
gpointer data)
{
GtkRecentInfo *recent_info;
const char *uri;
const char *mime_type;
GdkScreen *screen;
GError *error = NULL;
screen = gtk_widget_get_screen (GTK_WIDGET (chooser));
recent_info = gtk_recent_chooser_get_current_item (chooser);
uri = gtk_recent_info_get_uri (recent_info);
mime_type = gtk_recent_info_get_mime_type (recent_info);
//FIXME gtk_recent_info_get_application_info() could be useful
if (show_uri (uri, mime_type, screen, &error) != TRUE) {
char *uri_utf8;
uri_utf8 = g_filename_to_utf8 (uri, -1, NULL, NULL, NULL);
//FIXME this could fail... Maybe we want gtk_recent_info_get_display_name()
if (error) {
char *primary;
primary = g_strdup_printf (_("Could not open recently used document \"%s\""),
uri_utf8);
panel_error_dialog (NULL, screen,
"cannot_open_recent_doc", TRUE,
primary, error->message);
g_free (primary);
g_error_free (error);
} else {
char *primary;
char *secondary;
primary = g_strdup_printf (_("Could not open recently used document \"%s\""),
uri_utf8);
secondary = g_strdup_printf (_("An unknown error occurred while trying to open \"%s\"."),
uri_utf8);
panel_error_dialog (NULL, screen,
"cannot_open_recent_doc", TRUE,
primary, secondary);
g_free (primary);
g_free (secondary);
}
g_free (uri_utf8);
}
/* we can unref it only after having used the data we fetched from it */
gtk_recent_info_unref (recent_info);
}
static void
volume_mount_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
PanelVolumeMountData *mount_data = user_data;
GError *error;
char *primary;
char *name;
error = NULL;
if (!g_volume_mount_finish (G_VOLUME (source_object), res, &error)) {
if (error->code != G_IO_ERROR_FAILED_HANDLED) {
name = g_volume_get_name (G_VOLUME (source_object));
primary = g_strdup_printf (_("Unable to mount %s"),
name);
g_free (name);
panel_error_dialog (NULL, mount_data->screen,
"cannot_mount_volume", TRUE,
primary, error->message);
g_free (primary);
}
g_error_free (error);
}
//FIXME: should we activate the root of the new mount?
g_object_unref (mount_data->mount_op);
g_slice_free (PanelVolumeMountData, mount_data);
}
void
launcher_launch (Launcher *launcher,
GtkWidget *widget)
{
char *type;
g_return_if_fail (launcher != NULL);
g_return_if_fail (launcher->key_file != NULL);
launcher_do_zoom_animation (widget);
type = panel_key_file_get_string (launcher->key_file, "Type");
if (type && !strcmp (type, "Link"))
launch_url (launcher);
else {
GError *error = NULL;
panel_launch_key_file (launcher->key_file, NULL,
launcher_get_screen (launcher), &error);
if (error) {
GtkWidget *error_dialog;
error_dialog = panel_error_dialog (
NULL,
launcher_get_screen (launcher),
"cannot_launch_application",
TRUE,
_("Could not launch application"),
error->message);
launcher_register_error_dialog (launcher, error_dialog);
g_clear_error (&error);
}
}
g_free (type);
}
void panel_lock_screen_action(GdkScreen* screen, const char* action)
{
GError* error = NULL;
char* command = NULL;
g_return_if_fail(GDK_IS_SCREEN (screen));
g_return_if_fail(action != NULL);
if (strcmp(action, "prefs") != 0 && panel_lockdown_get_disable_lock_screen())
{
return;
}
command = panel_lock_screen_action_get_command(action);
if (!command)
{
return;
}
#if GTK_CHECK_VERSION (3, 0, 0)
if (!mate_gdk_spawn_command_line_on_screen(screen, command, &error))
#else
if (!gdk_spawn_command_line_on_screen(screen, command, &error))
#endif
{
char* primary = g_strdup_printf(_("Could not execute '%s'"), command);
panel_error_dialog (NULL, screen, "cannot_exec_screensaver", TRUE, primary, error->message);
g_free(primary);
g_error_free(error);
}
g_free(command);
}
static void
launch_url (Launcher *launcher)
{
char *url;
GdkScreen *screen;
g_return_if_fail (launcher != NULL);
g_return_if_fail (launcher->key_file != NULL);
/* FIXME panel_ditem_launch() should be enough for this! */
url = panel_key_file_get_string (launcher->key_file, "URL");
screen = launcher_get_screen (launcher);
if (!url || *url == 0) {
GtkWidget *error_dialog;
error_dialog = panel_error_dialog (NULL, screen,
"no_url_dialog", TRUE,
_("Could not show this URL"),
_("No URL was specified."));
launcher_register_error_dialog (launcher, error_dialog);
g_free (url);
return;
}
panel_show_uri (screen, url, gtk_get_current_event_time (), NULL);
g_free (url);
}
/* Connect Server
*/
static void
panel_action_connect_server (GtkWidget *widget)
{
GdkScreen *screen;
char *command;
GError *error;
screen = gtk_widget_get_screen (GTK_WIDGET (widget));
error = NULL;
if (panel_is_program_in_path ("caja-connect-server"))
command = g_strdup ("caja-connect-server");
else if (panel_is_program_in_path ("nautilus-connect-server"))
command = g_strdup ("nautilus-connect-server");
else
command = g_strdup ("nemo-connect-server");
mate_gdk_spawn_command_line_on_screen (screen, command, &error);
g_free (command);
if (error) {
panel_error_dialog (NULL, screen,
"cannot_connect_server",
TRUE,
_("Could not connect to server"),
error->message);
g_clear_error (&error);
}
}
static void
drive_poll_for_media_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GdkScreen *screen;
GError *error;
char *primary;
char *name;
error = NULL;
if (!g_drive_poll_for_media_finish (G_DRIVE (source_object),
res, &error)) {
if (error->code != G_IO_ERROR_FAILED_HANDLED) {
screen = GDK_SCREEN (user_data);
name = g_drive_get_name (G_DRIVE (source_object));
primary = g_strdup_printf (_("Unable to scan %s for media changes"),
name);
g_free (name);
panel_error_dialog (NULL, screen,
"cannot_scan_drive", TRUE,
primary, error->message);
g_free (primary);
}
g_error_free (error);
}
//FIXME: should we mount the volume and activate the root of the new
//mount?
}
static gboolean
panel_run_dialog_launch_command (PanelRunDialog *dialog,
const char *command,
const char *locale_command)
{
GdkScreen *screen;
gboolean result;
GError *error = NULL;
char **argv;
int argc;
GPid pid;
if (!command_is_executable (locale_command, &argc, &argv))
return FALSE;
screen = gtk_window_get_screen (GTK_WINDOW (dialog->run_dialog));
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->terminal_checkbox)))
mate_desktop_prepend_terminal_to_vector (&argc, &argv);
#if GTK_CHECK_VERSION (3, 0, 0)
result = g_spawn_async (NULL, /* working directory */
argv,
NULL, /* envp */
G_SPAWN_SEARCH_PATH,
NULL,
NULL,
&pid,
&error);
#else
result = gdk_spawn_on_screen (screen,
NULL, /* working directory */
argv,
NULL, /* envp */
G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
NULL, /* child setup func */
NULL, /* user data */
&pid, /* child pid */
&error);
#endif
if (!result) {
char *primary;
primary = g_markup_printf_escaped (_("Could not run command '%s'"),
command);
panel_error_dialog (GTK_WINDOW (dialog->run_dialog), NULL,
"cannot_spawn_command", TRUE,
primary, error->message);
g_free (primary);
g_error_free (error);
} else {
g_child_watch_add (pid, dummy_child_watch, NULL);
}
g_strfreev (argv);
return result;
}
static void
launcher_error_reported (GtkWidget *dialog,
const char *primary,
const char *secondary,
gpointer data)
{
panel_error_dialog (GTK_WINDOW (dialog), NULL,
"error_editing_launcher", TRUE,
primary, secondary);
}
void
panel_run_dialog_present (GdkScreen *screen,
guint32 activate_time)
{
GtkBuilder *gui;
GError *error;
if (panel_lockdown_get_disable_command_line ())
return;
if (static_dialog) {
gtk_window_set_screen (GTK_WINDOW (static_dialog->run_dialog), screen);
gtk_window_present_with_time (GTK_WINDOW (static_dialog->run_dialog),
activate_time);
gtk_widget_grab_focus (static_dialog->combobox);
return;
}
gui = gtk_builder_new ();
gtk_builder_set_translation_domain (gui, GETTEXT_PACKAGE);
error = NULL;
gtk_builder_add_from_file (gui,
BUILDERDIR "/panel-run-dialog.ui",
&error);
if (error) {
char *secondary;
secondary = g_strdup_printf (_("Unable to load file '%s': %s."),
BUILDERDIR"/panel-run-dialog.ui",
error->message);
panel_error_dialog (NULL, screen, "cannot_display_run_dialog",
TRUE,
_("Could not display run dialog"),
secondary);
g_free (secondary);
g_error_free (error);
g_object_unref (gui);
return;
}
static_dialog = panel_run_dialog_new (screen, gui, activate_time);
g_signal_connect_swapped (static_dialog->run_dialog, "destroy",
G_CALLBACK (panel_run_dialog_static_dialog_destroyed),
static_dialog);
gtk_window_present_with_time (GTK_WINDOW (static_dialog->run_dialog),
activate_time);
g_object_unref (gui);
}
static void
_panel_show_help_error_dialog (const gchar *doc,
GdkScreen *screen,
const gchar *message)
{
char *primary;
primary = g_markup_printf_escaped (_("Could not display help document '%s'"),
doc);
panel_error_dialog (NULL, screen, "cannot_show_help", TRUE,
primary, message);
g_free (primary);
}
static void
_panel_show_error_dialog (const gchar *uri,
GdkScreen *screen,
const gchar *message)
{
char *primary;
primary = g_markup_printf_escaped (_("Could not open location '%s'"),
uri);
panel_error_dialog (NULL, screen, "cannot_show_url", TRUE,
primary, message);
g_free (primary);
}
static void
panel_context_menu_delete_panel (PanelToplevel *toplevel)
{
if (panel_toplevel_is_last_unattached (toplevel)) {
panel_error_dialog (GTK_WINDOW (toplevel),
gtk_window_get_screen (GTK_WINDOW (toplevel)),
"cannot_delete_last_panel", TRUE,
_("Cannot delete this panel"),
_("You must always have at least one panel."));
return;
}
panel_delete (toplevel);
}
void
panel_properties_dialog_present (PanelToplevel *toplevel)
{
PanelPropertiesDialog *dialog;
GtkBuilder *gui;
GError *error;
if (!panel_properties_dialog_quark)
panel_properties_dialog_quark =
g_quark_from_static_string ("panel-properties-dialog");
dialog = g_object_get_qdata (G_OBJECT (toplevel), panel_properties_dialog_quark);
if (dialog) {
gtk_window_set_screen (GTK_WINDOW (dialog->properties_dialog),
gtk_window_get_screen (GTK_WINDOW (toplevel)));
gtk_window_present (GTK_WINDOW (dialog->properties_dialog));
return;
}
gui = gtk_builder_new ();
gtk_builder_set_translation_domain (gui, GETTEXT_PACKAGE);
error = NULL;
gtk_builder_add_from_file (gui,
BUILDERDIR "/panel-properties-dialog.ui",
&error);
if (error) {
char *secondary;
secondary = g_strdup_printf (_("Unable to load file '%s': %s."),
BUILDERDIR"/panel-properties-dialog.ui",
error->message);
panel_error_dialog (GTK_WINDOW (toplevel),
gtk_window_get_screen (GTK_WINDOW (toplevel)),
"cannot_display_properties_dialog", TRUE,
_("Could not display properties dialog"),
secondary);
g_free (secondary);
g_error_free (error);
g_object_unref (gui);
return;
}
dialog = panel_properties_dialog_new (toplevel, gui);
g_object_unref (gui);
}
void
panel_launcher_create_from_info (PanelToplevel *toplevel,
PanelObjectPackType pack_type,
int pack_index,
gboolean exec_info,
const char *exec_or_uri,
const char *name,
const char *comment,
const char *icon)
{
GKeyFile *key_file;
char *location;
GError *error;
key_file = panel_key_file_new_desktop ();
/* set current language and the "C" locale to this name,
* this is kind of evil... */
panel_key_file_set_string (key_file, "Name", name);
panel_key_file_set_string (key_file, "Comment", comment);
panel_key_file_set_string (key_file, "Icon", icon);
panel_key_file_set_locale_string (key_file, "Name", name);
panel_key_file_set_locale_string (key_file, "Comment", comment);
panel_key_file_set_locale_string (key_file, "Icon", icon);
if (exec_info) {
panel_key_file_set_string (key_file, "Exec", exec_or_uri);
panel_key_file_set_string (key_file, "Type", "Application");
} else {
panel_key_file_set_string (key_file, "URL", exec_or_uri);
panel_key_file_set_string (key_file, "Type", "Link");
}
location = panel_make_unique_desktop_uri (NULL, exec_or_uri);
error = NULL;
if (panel_key_file_to_file (key_file, location, &error)) {
panel_launcher_create (toplevel, pack_type, pack_index, location);
} else {
panel_error_dialog (GTK_WINDOW (toplevel),
gtk_window_get_screen (GTK_WINDOW (toplevel)),
"cannot_save_launcher", TRUE,
_("Could not save launcher"),
error->message);
g_error_free (error);
}
g_key_file_free (key_file);
}
void
panel_show_help (GdkScreen *screen,
const char *doc_name,
const char *linkid)
{
GError *error = NULL;
if (!gnome_help_display_desktop_on_screen (NULL, "user-guide", doc_name, linkid, screen, &error)) {
panel_error_dialog (NULL, screen, "cannot_show_help", TRUE,
_("Could not display help document"),
error != NULL ? error->message : NULL);
g_clear_error (&error);
}
}
static void
activate_uri (GtkWidget *menuitem,
const char *path)
{
GError *error = NULL;
GFile *file;
GdkScreen *screen;
char *escaped;
char *scheme;
char *url;
screen = menuitem_to_screen (menuitem);
scheme = g_uri_parse_scheme (path);
if (scheme) {
url = g_strdup (path);
g_free (scheme);
} else {
file = g_file_new_for_path (path);
url = g_file_get_uri (file);
g_object_unref (file);
}
if (g_str_has_prefix (url, "x-nautilus-search:")) {
//FIXME: this is ugly...
char *command;
command = g_strdup_printf ("nautilus --no-desktop %s", url);
gdk_spawn_command_line_on_screen (screen, command, &error);
} else
gnome_url_show_on_screen (url, screen, &error);
if (error != NULL) {
if (error->code != GNOME_URL_ERROR_CANCELLED) {
char *primary;
escaped = g_markup_escape_text (url, -1);
primary = g_strdup_printf (_("Could not open location '%s'"),
escaped);
g_free (escaped);
panel_error_dialog (NULL, screen,
"cannot_show_url", TRUE,
primary, error->message);
g_free (primary);
}
g_error_free (error);
}
g_free (url);
}
static void
_panel_launch_error_dialog (const gchar *name,
GdkScreen *screen,
const gchar *message)
{
char *primary;
if (name)
primary = g_markup_printf_escaped (_("Could not launch '%s'"),
name);
else
primary = g_strdup (_("Could not launch application"));
panel_error_dialog (NULL, screen, "cannot_launch", TRUE,
primary, message);
g_free (primary);
}
void
panel_menu_item_activate_desktop_file (GtkWidget *menuitem,
const char *path)
{
GError *error;
error = NULL;
panel_launch_desktop_file (path, NULL,
menuitem_to_screen (menuitem), &error);
if (error) {
panel_error_dialog (NULL, menuitem_to_screen (menuitem),
"cannot_launch_entry", TRUE,
_("Could not launch menu item"),
error->message);
g_error_free (error);
}
}
static void
drag_data_received_cb (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
GtkSelectionData *selection_data,
guint info,
guint time,
Launcher *launcher)
{
GError *error = NULL;
char **uris;
int i;
GList *file_list;
launcher_do_zoom_animation (widget);
file_list = NULL;
uris = g_uri_list_extract_uris ((const char *) gtk_selection_data_get_data (selection_data));
for (i = 0; uris[i]; i++)
file_list = g_list_prepend (file_list, uris[i]);
file_list = g_list_reverse (file_list);
panel_launch_key_file (launcher->key_file, file_list,
launcher_get_screen (launcher), &error);
g_list_free (file_list);
g_strfreev (uris);
if (error) {
GtkWidget *error_dialog;
error_dialog = panel_error_dialog (NULL,
launcher_get_screen (launcher),
"cannot_use_dropped_item",
TRUE,
_("Could not use dropped item"),
error->message);
launcher_register_error_dialog (launcher, error_dialog);
g_clear_error (&error);
}
gtk_drag_finish (context, TRUE, FALSE, time);
}
void
panel_menu_button_invoke_menu (PanelMenuButton *button,
const char *callback_name)
{
GdkScreen *screen;
g_return_if_fail (PANEL_IS_MENU_BUTTON (button));
g_return_if_fail (callback_name != NULL);
screen = gtk_widget_get_screen (GTK_WIDGET (button));
if (!strcmp (callback_name, "help")) {
panel_show_help (screen, "user-guide.xml", "gospanel-37");
} else if (!strcmp (callback_name, "edit")) {
GError *error = NULL;
panel_launch_desktop_file ("alacarte.desktop",
"alacarte-editor",
screen,
&error);
if (error) {
g_error_free (error);
error = NULL;
panel_launch_desktop_file ("gmenu-simple-editor.desktop",
"gmenu-simple-editor",
screen,
&error);
}
if (error) {
char *primary;
primary = g_strdup_printf (_("Could not execute '%s'"),
"gmenu-simple-editor");
panel_error_dialog (NULL, screen,
"cannot_exec_gmenu-simple-editor",
TRUE,
primary, error->message);
g_free (primary);
g_error_free (error);
}
}
}
static void
volume_mount_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
PanelVolumeMountData *mount_data = user_data;
GError *error;
error = NULL;
if (!g_volume_mount_finish (G_VOLUME (source_object), res, &error)) {
char *primary;
char *name;
if (error->code != G_IO_ERROR_FAILED_HANDLED) {
name = g_volume_get_name (G_VOLUME (source_object));
primary = g_strdup_printf (_("Unable to mount %s"),
name);
g_free (name);
panel_error_dialog (NULL, mount_data->screen,
"cannot_mount_volume", TRUE,
primary, error->message);
g_free (primary);
}
g_error_free (error);
} else {
GMount *mount;
GFile *root;
char *rooturi;
mount = g_volume_get_mount (G_VOLUME (source_object));
root = g_mount_get_root (mount);
rooturi = g_file_get_uri (root);
activate_uri_on_screen (rooturi, mount_data->screen);
g_object_unref (mount);
g_object_unref (root);
g_free (rooturi);
}
g_object_unref (mount_data->mount_op);
g_slice_free (PanelVolumeMountData, mount_data);
}
/* Connect Server
*/
static void
panel_action_connect_server (GtkWidget *widget)
{
GdkScreen *screen;
GError *error;
screen = gtk_widget_get_screen (GTK_WIDGET (widget));
error = NULL;
gdk_spawn_command_line_on_screen (screen, "caja-connect-server",
&error);
if (error) {
panel_error_dialog (NULL, screen,
"cannot_connect_server",
TRUE,
_("Could not connect to server"),
error->message);
g_clear_error (&error);
}
}
/* Connect Server
*/
static void
panel_action_connect_server (GtkWidget *widget)
{
GdkScreen *screen;
GAppInfo *app_info;
GError *error;
screen = gtk_widget_get_screen (GTK_WIDGET (widget));
error = NULL;
app_info = g_app_info_create_from_commandline ("nautilus-connect-server",
_("Connect to server"),
G_APP_INFO_CREATE_NONE,
&error);
if (!error) {
GdkAppLaunchContext *launch_context;
GdkDisplay *display;
display = gdk_screen_get_display (screen);
launch_context = gdk_display_get_app_launch_context (display);
gdk_app_launch_context_set_screen (launch_context, screen);
g_app_info_launch (app_info, NULL,
G_APP_LAUNCH_CONTEXT (launch_context),
&error);
g_object_unref (launch_context);
g_object_unref (app_info);
}
if (error) {
panel_error_dialog (NULL, screen,
"cannot_connect_server",
TRUE,
_("Could not connect to server"),
error->message);
g_clear_error (&error);
}
}
void
panel_properties_dialog_present (PanelToplevel *toplevel)
{
PanelPropertiesDialog *dialog;
GladeXML *gui;
if (!panel_properties_dialog_quark)
panel_properties_dialog_quark =
g_quark_from_static_string ("panel-properties-dialog");
dialog = g_object_get_qdata (G_OBJECT (toplevel), panel_properties_dialog_quark);
if (dialog) {
gtk_window_set_screen (GTK_WINDOW (dialog->properties_dialog),
gtk_window_get_screen (GTK_WINDOW (toplevel)));
gtk_window_present (GTK_WINDOW (dialog->properties_dialog));
return;
}
gui = glade_xml_new (GLADEDIR "/panel-properties-dialog.glade",
"panel_properties_dialog",
NULL);
if (gui == NULL) {
char *secondary;
secondary = g_strdup_printf (_("Unable to load file '%s'."),
GLADEDIR"/panel-properties-dialog.glade");
panel_error_dialog (GTK_WINDOW (toplevel),
gtk_window_get_screen (GTK_WINDOW (toplevel)),
"cannot_display_properties_dialog", TRUE,
_("Could not display properties dialog"),
secondary);
g_free (secondary);
return;
}
dialog = panel_properties_dialog_new (toplevel, gui);
g_object_unref (gui);
}
static void
panel_run_dialog_execute (PanelRunDialog *dialog)
{
GError *error;
gboolean result;
char *command;
char *disk;
char *scheme;
command = g_strdup (panel_run_dialog_get_combo_text (dialog));
command = g_strchug (command);
if (!command || !command [0]) {
g_free (command);
return;
}
/* evil eggies, do not translate! */
#if !GTK_CHECK_VERSION (3, 0, 0)
/* FIXME re-add once GTK3 support is fixed */
if (!strcmp (command, "free the fish")) {
start_screen_check ();
g_free (command);
gtk_widget_destroy (dialog->run_dialog);
return;
} else if (!strcmp (command, "gegls from outer space")) {
start_geginv ();
g_free (command);
gtk_widget_destroy (dialog->run_dialog);
return;
}
#endif
error = NULL;
disk = g_locale_from_utf8 (command, -1, NULL, NULL, &error);
if (!disk || error) {
char *primary;
primary = g_strdup_printf (_("Could not convert '%s' from UTF-8"),
command);
panel_error_dialog (GTK_WINDOW (dialog->run_dialog), NULL,
"cannot_convert_command_from_utf8", TRUE,
primary, error->message);
g_free (primary);
g_error_free (error);
return;
}
result = FALSE;
scheme = g_uri_parse_scheme (disk);
/* if it's an absolute path or not a URI, it's possibly an executable,
* so try it before displaying it */
if (g_path_is_absolute (disk) || !scheme)
result = panel_run_dialog_launch_command (dialog, command, disk);
if (!result) {
GFile *file;
char *uri;
GdkScreen *screen;
file = panel_util_get_file_optional_homedir (command);
uri = g_file_get_uri (file);
g_object_unref (file);
screen = gtk_window_get_screen (GTK_WINDOW (dialog->run_dialog));
result = panel_show_uri (screen, uri,
gtk_get_current_event_time (), NULL);
g_free (uri);
}
if (result) {
/* only save working commands in history */
_panel_run_save_recent_programs_list
(dialog, GTK_COMBO_BOX (dialog->combobox), command);
/* only close the dialog if we successfully showed or launched
* something */
gtk_widget_destroy (dialog->run_dialog);
}
g_free (command);
g_free (disk);
g_free (scheme);
}
