/**
* seahorse_widget_destroy:
* @swidget: #SeahorseWidget to destroy
*
* Unrefs @swidget.
**/
void
seahorse_widget_destroy (SeahorseWidget *swidget)
{
GtkWidget *widget;
gchar *widthkey, *heightkey;
gint width, height;
g_return_if_fail (swidget != NULL && SEAHORSE_IS_WIDGET (swidget));
widget = seahorse_widget_get_toplevel (swidget);
/* Don't save window size for dialogs */
if (!GTK_IS_DIALOG (widget)) {
/* Save window size */
gtk_window_get_size (GTK_WINDOW (widget), &width, &height);
widthkey = g_strdup_printf ("%s%s%s", WINDOW_SIZE, swidget->name, "_width");
seahorse_gconf_set_integer (widthkey, width);
heightkey = g_strdup_printf ("%s%s%s", WINDOW_SIZE, swidget->name, "_height");
seahorse_gconf_set_integer (heightkey, height);
g_free (widthkey);
g_free (heightkey);
}
/* Destroy Widget */
if (!swidget->destroying) {
swidget->destroying = TRUE;
g_object_unref (swidget);
}
}
static GObject*
seahorse_widget_constructor (GType type, guint n_props, GObjectConstructParam* props)
{
SeahorseWidget *swidget;
GObject *obj;
GtkWindow *window;
gint width, height;
gchar *widthkey, *heightkey;
obj = G_OBJECT_CLASS (parent_class)->constructor (type, n_props, props);
swidget = SEAHORSE_WIDGET (obj);
/* Load window size for windows that aren't dialogs */
window = GTK_WINDOW (seahorse_widget_get_toplevel (swidget));
if (!GTK_IS_DIALOG (window)) {
widthkey = g_strdup_printf ("%s%s%s", WINDOW_SIZE, swidget->name, "_width");
width = seahorse_gconf_get_integer (widthkey);
heightkey = g_strdup_printf ("%s%s%s", WINDOW_SIZE, swidget->name, "_height");
height = seahorse_gconf_get_integer (heightkey);
if (width > 0 && height > 0)
gtk_window_resize (window, width, height);
g_free (widthkey);
g_free (heightkey);
}
return obj;
}
/**
* seahorse_widget_show_help
* @swidget: The #SeahorseWidget.
*
* Show help appropriate for the top level widget.
*/
void
seahorse_widget_show_help (SeahorseWidget *swidget)
{
GError *error = NULL;
gchar *document = NULL;
GtkWidget *dialog = NULL;
if (g_str_equal (swidget->name, "key-manager") ||
g_str_equal (swidget->name, "keyserver-results")) {
document = g_strdup ("ghelp:" PACKAGE "?introduction");
} else {
document = g_strdup_printf ("ghelp:" PACKAGE "?%s", swidget->name);
}
if (!g_app_info_launch_default_for_uri (document, NULL, &error)) {
dialog = gtk_message_dialog_new (GTK_WINDOW (seahorse_widget_get_toplevel (swidget)),
GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
_("Could not display help: %s"), error->message);
g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (gtk_widget_destroy), NULL);
gtk_widget_show (dialog);
}
g_free (document);
if (error)
g_error_free (error);
}
/**
* operation: The operation to create a new progress window for
*
* Creates a new progress window and adds the operation to it.
*
* Returns FALSE
**/
static gboolean
progress_show (SeahorseOperation *operation)
{
SeahorseWidget *swidget;
GtkWidget *w;
const gchar *title;
gchar *t;
if (!seahorse_operation_is_running (operation)) {
/* Matches the ref in seahorse_progress_show */
g_object_unref (operation);
return FALSE;
}
swidget = seahorse_widget_new_allow_multiple ("progress", NULL);
g_return_val_if_fail (swidget != NULL, FALSE);
/* Release our reference on the operation when this window is destroyed */
g_object_set_data_full (G_OBJECT (swidget), "operation", operation,
(GDestroyNotify)g_object_unref);
w = GTK_WIDGET (seahorse_widget_get_widget (swidget, swidget->name));
gtk_window_move (GTK_WINDOW (w), 10, 10);
/* Setup the title */
title = (const gchar*)g_object_get_data (G_OBJECT (operation), "progress-title");
if (title) {
/* The window title */
w = GTK_WIDGET (seahorse_widget_get_widget (swidget, swidget->name));
g_return_val_if_fail (w != NULL, FALSE);
gtk_window_set_title (GTK_WINDOW (w), title);
/* The main message title */
w = GTK_WIDGET (seahorse_widget_get_widget (swidget, "operation-title"));
g_return_val_if_fail (w != NULL, FALSE);
t = g_strdup_printf ("<b>%s</b>", title);
gtk_label_set_markup (GTK_LABEL (w), t);
g_free (t);
}
/* The details */
progress_operation_update (operation, NULL,
seahorse_operation_get_progress (operation), swidget);
g_signal_connect (operation, "progress",
G_CALLBACK (progress_operation_update), swidget);
/* Cancel events */
g_signal_connect (seahorse_widget_get_toplevel (swidget), "delete_event",
G_CALLBACK (progress_delete_event), operation);
/* Done and cleanup */
w = GTK_WIDGET (seahorse_widget_get_widget (swidget, swidget->name));
g_signal_connect (w, "destroy", G_CALLBACK (progress_destroy), operation);
g_signal_connect (operation, "done", G_CALLBACK (progress_operation_done), swidget);
return FALSE;
}
G_MODULE_EXPORT void
on_prefs_keyserver_add_clicked (GtkButton *button,
gpointer user_data)
{
SeahorseWidget *sw = SEAHORSE_WIDGET (user_data);
SeahorseWidget *swidget;
gchar **types;
GtkWidget *widget;
gint response;
gchar *result = NULL;
GtkTreeView *treeview;
GtkTreeStore *store;
GtkTreeIter iter;
guint i;
swidget = seahorse_widget_new_allow_multiple ("add-keyserver",
GTK_WINDOW (seahorse_widget_get_widget (sw, sw->name)));
g_return_if_fail (swidget != NULL);
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "keyserver-type"));
g_return_if_fail (widget != NULL);
/* The list of types */
types = seahorse_servers_get_types ();
/* Save these away for later */
g_object_set_data_full (G_OBJECT (swidget), "keyserver-types", types,
(GDestroyNotify)g_strfreev);
/* The description for the key server types, plus custom */
for (i = 0; types[i] != NULL; i++)
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget),
seahorse_servers_get_description (types[i]));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget),
_("Custom"));
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
response = gtk_dialog_run (GTK_DIALOG (seahorse_widget_get_toplevel (swidget)));
if (response == GTK_RESPONSE_ACCEPT) {
result = calculate_keyserver_uri (swidget);
if (result != NULL) {
treeview = GTK_TREE_VIEW (seahorse_widget_get_widget (sw, "keyservers"));
g_return_if_fail (treeview != NULL);
store = GTK_TREE_STORE (gtk_tree_view_get_model (treeview));
gtk_tree_store_append (store, &iter, NULL);
gtk_tree_store_set (store, &iter, KEYSERVER_COLUMN, result, -1);
}
g_free (result);
}
seahorse_widget_destroy (swidget);
}
static gboolean
on_timeout_show_progress (gpointer user_data)
{
TrackedTask *task = NULL;
SeahorseWidget *swidget;
GtkWidget *widget;
GtkWindow *window;
gchar *text;
/* Guard against going away before we display */
if (tracked_tasks)
task = g_hash_table_lookup (tracked_tasks, user_data);
if (task == NULL)
return FALSE; /* don't call again */
swidget = seahorse_widget_new_allow_multiple ("progress", NULL);
g_return_val_if_fail (swidget != NULL, FALSE);
window = GTK_WINDOW (seahorse_widget_get_toplevel (swidget));
g_signal_connect (window, "delete_event",
G_CALLBACK (on_window_delete_event), task->cancellable);
gtk_window_move (window, 10, 10);
/* Setup the title */
if (task->title) {
gtk_window_set_title (window, task->title);
/* The main message title */
widget = seahorse_widget_get_widget (swidget, "progress-title");
text = g_strdup_printf ("<b>%s</b>", task->title);
gtk_label_set_markup (GTK_LABEL (widget), text);
g_free (text);
}
/* Setup the notice */
if (task->notice) {
widget = seahorse_widget_get_widget (swidget, "progress-notice");
gtk_label_set_label (GTK_LABEL (widget), task->notice);
gtk_widget_show (widget);
}
/* Setup the cancel button */
widget = seahorse_widget_get_widget (swidget, "progress-cancel");
g_signal_connect (widget, "clicked", G_CALLBACK (on_cancel_button_clicked),
task->cancellable);
/* Allow attach to work */
task->showing = FALSE;
seahorse_progress_attach (task->cancellable, swidget->gtkbuilder);
gtk_widget_show (GTK_WIDGET (window));
g_object_unref (swidget);
return FALSE; /* don't call again */
}
void
properties_cb (GtkAction *action, SeahorseApplet *sapplet)
{
SeahorseWidget *swidget;
GtkWidget *widget;
GdkPixbuf *pixbuf;
swidget = seahorse_widget_new ("applet-preferences", NULL);
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, swidget->name));
pixbuf = gtk_widget_render_icon (widget,
ICON_CLIPBOARD_DEFAULT,
(GtkIconSize)-1,
NULL);
gtk_window_set_icon (GTK_WINDOW (widget), pixbuf);
g_object_unref(pixbuf);
/* Preferences window is already open */
if (!swidget)
return;
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "show-clipboard-state"));
if (widget && GTK_IS_CHECK_BUTTON (widget))
seahorse_check_button_gconf_attach (GTK_CHECK_BUTTON (widget), SHOW_CLIPBOARD_STATE_KEY);
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "display-encrypted-clipboard"));
if (widget && GTK_IS_CHECK_BUTTON (widget))
seahorse_check_button_gconf_attach (GTK_CHECK_BUTTON (widget), DISPLAY_CLIPBOARD_ENC_KEY);
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "display-decrypted-clipboard"));
if (widget && GTK_IS_CHECK_BUTTON (widget))
seahorse_check_button_gconf_attach (GTK_CHECK_BUTTON (widget), DISPLAY_CLIPBOARD_DEC_KEY);
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "display-verified-clipboard"));
if (widget && GTK_IS_CHECK_BUTTON (widget))
seahorse_check_button_gconf_attach (GTK_CHECK_BUTTON (widget), DISPLAY_CLIPBOARD_VER_KEY);
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "close"));
g_signal_connect (widget, "clicked", G_CALLBACK (close_props), swidget);
widget = seahorse_widget_get_toplevel (swidget);
g_signal_connect (widget, "delete-event", G_CALLBACK (win_destroyed), swidget);
seahorse_widget_show (swidget);
}
G_MODULE_EXPORT void
on_ssh_export_button_clicked (GtkWidget *widget, SeahorseWidget *swidget)
{
SeahorseSource *sksrc;
SeahorseObject *object;
GFile *file;
GtkDialog *dialog;
guchar *results;
gsize n_results;
gchar* uri = NULL;
GError *err = NULL;
object = SEAHORSE_OBJECT_WIDGET (swidget)->object;
g_return_if_fail (SEAHORSE_IS_SSH_KEY (object));
sksrc = seahorse_object_get_source (object);
g_return_if_fail (SEAHORSE_IS_SSH_SOURCE (sksrc));
dialog = seahorse_util_chooser_save_new (_("Export Complete Key"),
GTK_WINDOW (seahorse_widget_get_toplevel (swidget)));
seahorse_util_chooser_show_key_files (dialog);
seahorse_util_chooser_set_filename (dialog, object);
uri = seahorse_util_chooser_save_prompt (dialog);
if (!uri)
return;
results = seahorse_ssh_source_export_private (SEAHORSE_SSH_SOURCE (sksrc),
SEAHORSE_SSH_KEY (object),
&n_results, &err);
if (results) {
g_return_if_fail (err == NULL);
file = g_file_new_for_uri (uri);
g_file_replace_contents_async (file, (gchar*)results, n_results, NULL, FALSE,
G_FILE_CREATE_PRIVATE, NULL,
(GAsyncReadyCallback)export_complete, results);
}
if (err) {
seahorse_util_handle_error (err, _("Couldn't export key."));
g_clear_error (&err);
}
g_free (uri);
}
void
seahorse_keyserver_results_show (SeahorseOperation* op, GtkWindow* parent, const char* search_text)
{
SeahorseKeyserverResults* res;
GtkWindow *window;
g_return_if_fail (SEAHORSE_IS_OPERATION (op));
g_return_if_fail (parent == NULL || GTK_IS_WINDOW (parent));
g_return_if_fail (search_text != NULL);
res = g_object_new (SEAHORSE_TYPE_KEYSERVER_RESULTS, "name", "keyserver-results", "search", search_text, NULL);
/* Destorys itself with destroy */
g_object_ref_sink (res);
if (parent != NULL) {
window = GTK_WINDOW (seahorse_widget_get_toplevel (SEAHORSE_WIDGET (res)));
gtk_window_set_transient_for (window, parent);
}
seahorse_progress_status_set_operation (SEAHORSE_WIDGET (res), op);
}
/**
* seahorse_util_handle_error:
* @error: The #GError to print, and clear
* @desc: The heading of the box
* @...: Parameters to insert into the format string desc.
*
* Displays an error box. The message is the error message.
* Won't display cancel errors.
*/
void
seahorse_util_handle_error (GError **error,
gpointer parent,
const char* description,
...)
{
gchar *text = NULL;
GtkWidget *widget = NULL;
va_list ap;
if (!error || !(*error) ||
g_error_matches (*error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
g_clear_error (error);
return;
}
va_start (ap, description);
if (description)
text = g_strdup_vprintf (description, ap);
va_end (ap);
if (parent == NULL)
widget = NULL;
else if (GTK_IS_WIDGET (parent))
widget = GTK_WIDGET (parent);
else if (GTK_IS_WINDOW (parent))
widget = GTK_WIDGET (parent);
else if (SEAHORSE_IS_WIDGET (parent))
widget = seahorse_widget_get_toplevel (parent);
else
g_warning ("unsupported 'parent' argument passed to seahorse_util_handle_error() ");
g_dbus_error_strip_remote_error (*error);
seahorse_util_show_error (widget, text,
(*error)->message ? (*error)->message : "");
g_free (text);
g_clear_error (error);
}
static void
do_main (SeahorseWidget *swidget)
{
SeahorseObject *object;
SeahorseSSHKey *skey;
GtkWidget *widget;
gchar *text;
const gchar *label;
const gchar *template;
object = SEAHORSE_OBJECT_WIDGET (swidget)->object;
skey = SEAHORSE_SSH_KEY (object);
/* Image */
widget = GTK_WIDGET (gtk_builder_get_object (swidget->gtkbuilder, "key-image"));
if (widget)
gtk_image_set_from_stock (GTK_IMAGE (widget), SEAHORSE_STOCK_KEY_SSH, GTK_ICON_SIZE_DIALOG);
/* Name and title */
label = seahorse_object_get_label (object);
widget = GTK_WIDGET (gtk_builder_get_object (swidget->gtkbuilder, "comment-entry"));
if (widget)
gtk_entry_set_text (GTK_ENTRY (widget), label);
widget = seahorse_widget_get_toplevel (swidget);
gtk_window_set_title (GTK_WINDOW (widget), label);
/* Key id */
widget = GTK_WIDGET (gtk_builder_get_object (swidget->gtkbuilder, "id-label"));
if (widget) {
label = seahorse_object_get_identifier (object);
gtk_label_set_text (GTK_LABEL (widget), label);
}
/* Put in message */
widget = seahorse_widget_get_widget (swidget, "trust-message");
g_return_if_fail (widget != NULL);
static gboolean
step_process_multiple (FilesCtx *ctx,
const gchar **orig_uris,
GError **err)
{
SeahorseWidget *swidget;
gboolean done = FALSE;
FileInfo *pkg_info = NULL;
gchar *package = NULL;
gchar *ext;
GFile *file, *parent;
gboolean ok = FALSE;
GtkWidget *dlg;
guint nfolders, nfiles;
gchar *uris[2];
gchar *uri;
GList *l;
g_assert (err && !*err);
for (l = ctx->finfos, nfolders = nfiles = 0; l; l = g_list_next (l)) {
FileInfo *finfo = (FileInfo*)l->data;
if (g_file_info_get_file_type (finfo->info) == G_FILE_TYPE_DIRECTORY)
++nfolders;
else
++nfiles;
}
/* In the case of one or less files, no dialog */
if(nfolders == 0 && nfiles <= 1)
return TRUE;
/* The package extension */
if ((ext = g_settings_get_string (seahorse_tool_settings, "package-extension")) == NULL)
ext = g_strdup (".zip"); /* Yes this happens when the schema isn't installed */
/* Figure out a good URI for our package */
for (l = ctx->finfos; l; l = g_list_next (l)) {
if (l->data) {
pkg_info = (FileInfo*)(l->data);
break;
}
}
/* This sets up but doesn't run the dialog */
swidget = prepare_dialog (ctx, nfolders, nfiles, pkg_info->info, ext);
g_free (ext);
dlg = seahorse_widget_get_toplevel (swidget);
/* Inhibit popping up of progress dialog */
seahorse_tool_progress_block (TRUE);
while (!done) {
switch (gtk_dialog_run (GTK_DIALOG (dlg)))
{
case GTK_RESPONSE_HELP:
/* TODO: Implement help */
break;
case GTK_RESPONSE_OK:
package = get_results (swidget);
ok = TRUE;
/* Fall through */
default:
done = TRUE;
break;
}
}
/* Let progress dialog pop up */
seahorse_tool_progress_block (FALSE);
seahorse_widget_destroy (swidget);
/* Cancelled */
if (!ok)
return FALSE;
/* No package was selected? */
if (!package)
return TRUE;
/* A package was selected */
/* Make a new path based on the first uri */
parent = g_file_get_parent (pkg_info->file);
if (!parent)
parent = pkg_info->file;
file = g_file_get_child_for_display_name (parent, package, err);
if (!file)
return FALSE;
uri = g_file_get_uri (file);
g_return_val_if_fail (uri, FALSE);
g_object_unref (file);
if (!seahorse_util_uris_package (uri, orig_uris)) {
g_free (uri);
return FALSE;
}
/* Free all file info */
g_list_foreach (ctx->finfos, (GFunc)free_file_info, NULL);
g_list_free (ctx->finfos);
ctx->finfos = NULL;
/* Reload up the new file, as what to encrypt */
uris[0] = uri;
uris[1] = NULL;
ok = step_check_uris (ctx, (const gchar**)uris, err);
g_free (uri);
return ok;
}
