/**
* operation: The operation to process
* message: The message that will be pushed to the status bar
* fract: The fraction of the progress bar to fill
* swidget: The SeahorseWidget to extract the gtk widgets from
*
* This gets called whenever an operation updates it's progress status thingy.
* We update the appbar as appropriate. If operation != NULL then we only
* display the latest operation in our special list
*
**/
static void
operation_progress (SeahorseOperation *operation, const gchar *message,
gdouble fract, SeahorseWidget *swidget)
{
GtkProgressBar *progress;
GtkStatusbar *status;
guint id;
progress = GTK_PROGRESS_BAR (seahorse_widget_get_widget (swidget, "progress"));
status = GTK_STATUSBAR (seahorse_widget_get_widget (swidget, "status"));
if (!seahorse_operation_is_running (operation))
fract = 0.0;
if (message != NULL && status) {
g_return_if_fail (GTK_IS_STATUSBAR (status));
id = gtk_statusbar_get_context_id (status, "operation-progress");
gtk_statusbar_pop (status, id);
if (message[0])
gtk_statusbar_push (status, id, message);
}
if(progress) {
g_return_if_fail (GTK_IS_PROGRESS_BAR (progress));
if (fract >= 0.0) {
stop_pulse (progress);
gtk_progress_bar_set_fraction (progress, fract);
} else {
start_pulse (progress);
}
}
}
G_MODULE_EXPORT void
on_gpgme_revoke_ok_clicked (GtkButton *button,
gpointer user_data)
{
SeahorseWidget *swidget = SEAHORSE_WIDGET (user_data);
SeahorseRevokeReason reason;
SeahorseGpgmeSubkey *subkey;
const gchar *description;
gpgme_error_t err;
GtkWidget *widget;
GtkTreeModel *model;
GtkTreeIter iter;
GValue value;
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "reason"));
model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget));
gtk_combo_box_get_active_iter (GTK_COMBO_BOX (widget), &iter);
memset (&value, 0, sizeof(value));
gtk_tree_model_get_value (model, &iter, COLUMN_INT, &value);
reason = g_value_get_int (&value);
g_value_unset (&value);
description = gtk_entry_get_text (GTK_ENTRY (seahorse_widget_get_widget (swidget, "description")));
subkey = g_object_get_data (G_OBJECT (swidget), "subkey");
g_return_if_fail (SEAHORSE_IS_GPGME_SUBKEY (subkey));
err = seahorse_gpgme_key_op_revoke_subkey (subkey, reason, description);
if (!GPG_IS_OK (err))
seahorse_gpgme_handle_error (err, _("Couldn't revoke subkey"));
seahorse_widget_destroy (swidget);
}
G_MODULE_EXPORT void
on_upload_input_changed (GtkWidget *dummy, SeahorseWidget *swidget)
{
GtkWidget *widget;
const gchar *user, *host, *port;
gchar *t = NULL;
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "user-label"));
user = gtk_entry_get_text (GTK_ENTRY (widget));
g_return_if_fail (user && g_utf8_validate (user, -1, NULL));
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "host-label"));
host = gtk_entry_get_text (GTK_ENTRY (widget));
g_return_if_fail (host && g_utf8_validate (host, -1, NULL));
/* Take off port if necessary */
port = strchr (host, ':');
if (port) {
/* Copy hostname out */
g_assert (port >= host);
host = t = g_strndup (host, port - host);
}
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "ok"));
gtk_widget_set_sensitive (widget, host[0] && !seahorse_util_string_is_whitespace (host) &&
user[0] && !seahorse_util_string_is_whitespace (user));
/* Possibly allocated host */
g_free (t);
}
/**
* seahorse_prefs_new:
* @parent: The #GtkWindow to set as the preferences dialog's parent
*
* Create a new preferences window.
*
* Returns: The preferences window.
**/
SeahorseWidget *
seahorse_prefs_new (GtkWindow *parent)
{
SeahorseWidget *swidget;
#ifndef WITH_KEYSERVER
GtkWidget *widget = NULL;
#endif
swidget = seahorse_widget_new ("prefs", parent);
if (swidget != NULL) {
#ifdef WITH_KEYSERVER
setup_keyservers (swidget);
#else
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "keyserver-tab"));
g_return_val_if_fail (GTK_IS_WIDGET (widget), swidget);
seahorse_prefs_remove_tab (swidget, widget);
#endif
seahorse_widget_show (swidget);
} else {
swidget = seahorse_widget_find ("prefs");
gtk_window_present (GTK_WINDOW (seahorse_widget_get_widget (swidget, swidget->name)));
}
return swidget;
}
/**
* seahorse_widget_new:
* @name: Name of widget, filename part of gtkbuilder file, and name of main window
* @parent: GtkWindow to make the parent of the new swidget
*
* Creates a new #SeahorseWidget.
*
* Returns: The new #SeahorseWidget, or NULL if the widget already exists
**/
SeahorseWidget*
seahorse_widget_new (const gchar *name, GtkWindow *parent)
{
/* Check if have widget hash */
SeahorseWidget *swidget = seahorse_widget_find (name);
GtkWindow *window;
/* If widget already exists, present */
if (swidget != NULL) {
gtk_window_present (GTK_WINDOW (seahorse_widget_get_widget (swidget, swidget->name)));
return NULL;
}
/* If widget doesn't already exist, create & insert into hash */
swidget = g_object_new (SEAHORSE_TYPE_WIDGET, "name", name, NULL);
if(!widgets)
widgets = g_hash_table_new ((GHashFunc)g_str_hash, (GCompareFunc)g_str_equal);
g_hash_table_insert (widgets, g_strdup (name), swidget);
if (parent != NULL) {
window = GTK_WINDOW (seahorse_widget_get_widget (swidget, swidget->name));
gtk_window_set_transient_for (window, parent);
}
return swidget;
}
G_MODULE_EXPORT void
on_prefs_add_keyserver_uri_changed (GtkWidget *unused,
gpointer user_data)
{
SeahorseWidget *swidget = SEAHORSE_WIDGET (user_data);
GtkWidget *widget;
gchar **types;
gchar *t;
gint active;
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "ok"));
g_return_if_fail (widget != NULL);
t = calculate_keyserver_uri (swidget);
gtk_widget_set_sensitive (widget, t != NULL);
g_free (t);
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "keyserver-type"));
g_return_if_fail (widget != NULL);
/* Show or hide the port section based on whether 'custom' is selected */
active = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
if (active > -1) {
types = g_object_get_data (G_OBJECT (swidget), "keyserver-types");
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "port-block"));
g_return_if_fail (widget != NULL);
if (types && types[active] && types[active][0])
gtk_widget_show (widget);
else
gtk_widget_hide (widget);
}
}
/* Disconnects callbacks, destroys main window widget,
* and frees the xml definition and any other data */
static void
object_finalize (GObject *gobject)
{
SeahorseWidget *swidget;
swidget = SEAHORSE_WIDGET (gobject);
/* Remove widget from hash and destroy hash if empty */
if (widgets) {
g_hash_table_remove (widgets, swidget->name);
if (g_hash_table_size (widgets) == 0) {
g_hash_table_destroy (widgets);
widgets = NULL;
}
}
if (seahorse_widget_get_widget (swidget, swidget->name))
gtk_widget_destroy (GTK_WIDGET (seahorse_widget_get_widget (swidget, swidget->name)));
g_object_unref (swidget->gtkbuilder);
swidget->gtkbuilder = NULL;
g_free (swidget->name);
G_OBJECT_CLASS (parent_class)->finalize (gobject);
}
/**
* 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);
}
G_MODULE_EXPORT void
on_gpgme_expire_toggled (GtkWidget *widget, SeahorseWidget *swidget)
{
GtkWidget *expire;
GtkWidget *cal;
expire = GTK_WIDGET (seahorse_widget_get_widget (swidget, "expire"));
cal = GTK_WIDGET (seahorse_widget_get_widget (swidget, "calendar"));
gtk_widget_set_sensitive (cal, !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (expire)));
}
static gchar*
calculate_keyserver_uri (SeahorseWidget *swidget)
{
const gchar *scheme = NULL;
const gchar *host = NULL;
const gchar *port = NULL;
GtkWidget *widget;
gchar **types;
gint active;
gchar *uri;
gint i;
/* Figure out the scheme */
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "keyserver-type"));
g_return_val_if_fail (widget != NULL, NULL);
active = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
types = g_object_get_data (G_OBJECT (swidget), "keyserver-types");
if (active >= 0 && types) {
for (i = 0; types[i] != NULL && i < active; i++);
if (i == active && types[active] && types[active][0])
scheme = types[active];
}
/* The host */
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "keyserver-host"));
g_return_val_if_fail (widget != NULL, NULL);
host = gtk_entry_get_text (GTK_ENTRY (widget));
g_return_val_if_fail (host != NULL, NULL);
/* Custom URI? */
if (scheme == NULL) {
if (seahorse_servers_is_valid_uri (host))
return g_strdup (host);
return NULL;
}
/* The port */
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "keyserver-port"));
g_return_val_if_fail (widget != NULL, NULL);
port = gtk_entry_get_text (GTK_ENTRY (widget));
if (port && !port[0])
port = NULL;
uri = g_strdup_printf("%s://%s%s%s", scheme, host, port ? ":" : "", port ? port : "");
if (!seahorse_servers_is_valid_uri (uri)) {
g_free (uri);
uri = NULL;
}
return uri;
}
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 */
}
static void
upload_keys (SeahorseWidget *swidget)
{
GtkWidget *widget;
const gchar *cuser, *chost;
gchar *user, *host, *port;
GList *keys;
GCancellable *cancellable;
keys = (GList*)g_object_steal_data (G_OBJECT (swidget), "upload-keys");
if (keys == NULL)
return;
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "user-label"));
cuser = gtk_entry_get_text (GTK_ENTRY (widget));
g_return_if_fail (cuser && g_utf8_validate (cuser, -1, NULL));
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "host-label"));
chost = (gchar*)gtk_entry_get_text (GTK_ENTRY (widget));
g_return_if_fail (chost && g_utf8_validate (chost, -1, NULL));
user = g_strdup (cuser);
host = g_strdup (chost);
/* Port is anything past a colon */
port = strchr (host, ':');
if (port) {
*port = 0;
port++;
/* Trim and check */
seahorse_util_string_trim_whitespace (port);
if (!port[0])
port = NULL;
}
seahorse_util_string_trim_whitespace (host);
seahorse_util_string_trim_whitespace (user);
cancellable = g_cancellable_new ();
/* Start an upload process */
seahorse_ssh_op_upload_async (SEAHORSE_SSH_SOURCE (seahorse_object_get_place (keys->data)),
keys, user, host, port, cancellable, on_upload_complete, NULL);
g_free (host);
g_free (user);
seahorse_progress_show (cancellable, _("Configuring Secure Shell Keys..."), FALSE);
g_object_unref (cancellable);
}
static void
object_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
SeahorseWidget *swidget;
GtkWidget *w;
char *path;
swidget = SEAHORSE_WIDGET (object);
switch (prop_id) {
/* Loads gtkbuilder xml definition from name, connects common callbacks */
case PROP_NAME:
g_return_if_fail (swidget->name == NULL);
swidget->name = g_value_dup_string (value);
path = g_strdup_printf ("%sseahorse-%s.xml",
SEAHORSE_UIDIR, swidget->name);
swidget->gtkbuilder = gtk_builder_new ();
gtk_builder_add_from_file (swidget->gtkbuilder, path, NULL);
g_free (path);
g_return_if_fail (swidget->gtkbuilder != NULL);
gtk_builder_connect_signals (swidget->gtkbuilder, swidget);
w = GTK_WIDGET (seahorse_widget_get_widget (swidget, swidget->name));
/*TODO: glade_xml_ensure_accel (swidget->gtkbuilder);*/
gtk_window_set_icon_name (GTK_WINDOW (w), "seahorse");
break;
}
}
/**
* seahorse_widget_get_toplevel
* @swidget: The seahorse widget
*
* Return the top level widget in this seahorse widget
*
* Returns: The top level widget
**/
GtkWidget*
seahorse_widget_get_toplevel (SeahorseWidget *swidget)
{
GtkWidget *widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, swidget->name));
g_return_val_if_fail (widget != NULL, NULL);
return widget;
}
/* Perform keyserver page initialization */
static void
setup_keyservers (SeahorseWidget *swidget)
{
GtkTreeView *treeview;
SeahorseKeyserverControl *skc;
GtkTreeModel *model;
GtkTreeSelection *selection;
GtkWidget *widget;
gchar **keyservers;
keyservers = seahorse_servers_get_uris ();
populate_keyservers (swidget, keyservers);
g_strfreev (keyservers);
treeview = GTK_TREE_VIEW (seahorse_widget_get_widget (swidget, "keyservers"));
model = gtk_tree_view_get_model (treeview);
g_signal_connect (model, "row-changed", G_CALLBACK (keyserver_row_changed), swidget);
g_signal_connect (model, "row-deleted", G_CALLBACK (keyserver_row_deleted), swidget);
selection = gtk_tree_view_get_selection (treeview);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (selection, "changed", G_CALLBACK (keyserver_sel_changed), swidget);
gtk_builder_connect_signals (swidget->gtkbuilder, swidget);
g_signal_connect_object (seahorse_application_pgp_settings (NULL), "changed::keyserver",
G_CALLBACK (on_settings_keyserver_changed), swidget, 0);
widget = seahorse_widget_get_widget (swidget, "keyserver-publish");
g_return_if_fail (widget != NULL);
skc = seahorse_keyserver_control_new ("server-publish-to", _("None: Don’t publish keys"));
gtk_container_add (GTK_CONTAINER (widget), GTK_WIDGET (skc));
gtk_widget_show_all (widget);
widget = seahorse_widget_get_widget (swidget, "keyserver-publish-to-label");
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), GTK_WIDGET (skc));
widget = seahorse_widget_get_widget (swidget, "auto_retrieve");
g_return_if_fail (widget != NULL);
g_settings_bind (seahorse_application_settings (NULL), "server-auto-retrieve",
widget, "active", G_SETTINGS_BIND_DEFAULT);
widget = seahorse_widget_get_widget (swidget, "auto_sync");
g_return_if_fail (widget != NULL);
g_settings_bind (seahorse_application_settings (NULL), "server-auto-publish",
widget, "active", G_SETTINGS_BIND_DEFAULT);
}
/**
* seahorse_prefs_add_tab
* @swidget: The preferences window
* @label: Label for the tab to be added
* @tab: Tab to be added
*
* Add a tab to the preferences window
**/
void
seahorse_prefs_add_tab (SeahorseWidget *swidget, GtkWidget *label, GtkWidget *tab)
{
GtkWidget *widget;
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "notebook"));
gtk_widget_show (label);
gtk_notebook_prepend_page (GTK_NOTEBOOK (widget), tab, label);
}
void
seahorse_widget_set_sensitive (SeahorseWidget *swidget, const char *identifier,
gboolean sensitive)
{
GtkWidget *widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, identifier));
g_return_if_fail (widget != NULL);
gtk_widget_set_sensitive (widget, sensitive);
}
G_MODULE_EXPORT void
on_gpgme_expire_ok_clicked (GtkButton *button,
gpointer user_data)
{
SeahorseWidget *swidget = SEAHORSE_WIDGET (user_data);
GtkWidget *widget;
SeahorseGpgmeSubkey *subkey;
gpgme_error_t err;
time_t expiry = 0;
struct tm when;
subkey = SEAHORSE_GPGME_SUBKEY (g_object_get_data (G_OBJECT (swidget), "subkey"));
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "expire"));
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) {
memset (&when, 0, sizeof (when));
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "calendar"));
gtk_calendar_get_date (GTK_CALENDAR (widget), (guint*)&(when.tm_year),
(guint*)&(when.tm_mon), (guint*)&(when.tm_mday));
when.tm_year -= 1900;
expiry = mktime (&when);
if (expiry <= time (NULL)) {
seahorse_util_show_error (widget, _("Invalid expiry date"),
_("The expiry date must be in the future"));
return;
}
}
widget = seahorse_widget_get_widget (swidget, "all-controls");
gtk_widget_set_sensitive (widget, FALSE);
g_object_ref (swidget);
g_object_ref (subkey);
if (expiry != (time_t)seahorse_pgp_subkey_get_expires (SEAHORSE_PGP_SUBKEY (subkey))) {
err = seahorse_gpgme_key_op_set_expires (subkey, expiry);
if (!GPG_IS_OK (err))
seahorse_gpgme_handle_error (err, _("Couldn't change expiry date"));
}
g_object_unref (subkey);
g_object_unref (swidget);
seahorse_widget_destroy (swidget);
}
/**
* seahorse_upload_show
* @keys: Upload a certain set of SSH keys
*
* Prompt a dialog to upload keys.
**/
void
seahorse_ssh_upload_prompt (GList *keys, GtkWindow *parent)
{
SeahorseWidget *swidget;
GtkWindow *win;
GtkWidget *w;
g_return_if_fail (keys != NULL);
swidget = seahorse_widget_new_allow_multiple ("ssh-upload", parent);
g_return_if_fail (swidget != NULL);
win = GTK_WINDOW (GTK_WIDGET (seahorse_widget_get_widget (swidget, swidget->name)));
/* Default to the users current name */
w = GTK_WIDGET (seahorse_widget_get_widget (swidget, "user-label"));
gtk_entry_set_text (GTK_ENTRY (w), g_get_user_name ());
/* Focus the host */
w = GTK_WIDGET (seahorse_widget_get_widget (swidget, "host-label"));
gtk_widget_grab_focus (w);
keys = g_list_copy (keys);
g_object_set_data_full (G_OBJECT (swidget), "upload-keys", keys,
(GDestroyNotify)g_list_free);
on_upload_input_changed (NULL, swidget);
for (;;) {
switch (gtk_dialog_run (GTK_DIALOG (win))) {
case GTK_RESPONSE_HELP:
/* TODO: Help */
continue;
case GTK_RESPONSE_ACCEPT:
upload_keys (swidget);
break;
default:
break;
};
break;
}
seahorse_widget_destroy (swidget);
}
/**
* seahorse_widget_show:
* @swidget: #SeahorseWidget to show
*
* Show the toplevel widget in the gtkbuilder file.
**/
void
seahorse_widget_show (SeahorseWidget *swidget)
{
GtkWidget *widget;
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, swidget->name));
g_return_if_fail (widget != NULL);
gtk_widget_show (widget);
}
void
seahorse_gpgme_expires_new (SeahorseGpgmeSubkey *subkey, GtkWindow *parent)
{
SeahorseWidget *swidget;
GtkWidget *date, *expire;
gulong expires;
gchar *title;
const gchar *label;
g_return_if_fail (subkey != NULL && SEAHORSE_IS_GPGME_SUBKEY (subkey));
swidget = seahorse_widget_new_allow_multiple ("expires", parent);
g_return_if_fail (swidget != NULL);
g_object_set_data_full (G_OBJECT (swidget), "subkey",
g_object_ref (subkey), g_object_unref);
date = GTK_WIDGET (seahorse_widget_get_widget (swidget, "calendar"));
g_return_if_fail (date != NULL);
expire = GTK_WIDGET (seahorse_widget_get_widget (swidget, "expire"));
expires = seahorse_pgp_subkey_get_expires (SEAHORSE_PGP_SUBKEY (subkey));
if (!expires) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (expire), TRUE);
gtk_widget_set_sensitive (date, FALSE);
} else {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (expire), FALSE);
gtk_widget_set_sensitive (date, TRUE);
}
if (expires) {
struct tm t;
time_t time = (time_t)expires;
if (gmtime_r (&time, &t)) {
gtk_calendar_select_month (GTK_CALENDAR (date), t.tm_mon, t.tm_year + 1900);
gtk_calendar_select_day (GTK_CALENDAR (date), t.tm_mday);
}
}
label = seahorse_pgp_subkey_get_description (SEAHORSE_PGP_SUBKEY (subkey));
title = g_strdup_printf (_("Expiry: %s"), label);
gtk_window_set_title (GTK_WINDOW (seahorse_widget_get_widget (swidget, swidget->name)), title);
g_free (title);
}
/* Get the package name and selection */
static gchar*
get_results (SeahorseWidget *swidget)
{
const gchar* name;
const gchar* t;
gchar *full_name, *ext;
GtkWidget *w;
gboolean sep;
w = GTK_WIDGET (seahorse_widget_get_widget (swidget, "do-separate"));
sep = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w));
g_settings_set_boolean (seahorse_tool_settings, "separate-files", sep);
/* no packaging */
if(!sep) {
w = GTK_WIDGET (seahorse_widget_get_widget (swidget, "package-name"));
name = gtk_entry_get_text (GTK_ENTRY (w));
w = GTK_WIDGET (seahorse_widget_get_widget (swidget, "package-extension"));
ext = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (w));
/* No paths */
t = strrchr(name, '/');
name = t ? ++t : name;
/* If someone goes out of their way to delete the file name,
* we're simply unimpressed and put back a default. */
if(name[0] == 0)
name = "encrypted-package";
full_name = g_strdup_printf("%s%s", name, ext);
/* Save the extension */
g_settings_set_string (seahorse_tool_settings, "package-extension", ext);
return full_name;
}
return NULL;
}
/**
* seahorse_preferences_show:
* @tabid: The id of the tab to show
*
* Creates a new or shows the current preferences dialog.
**/
void
seahorse_prefs_show (GtkWindow *parent, const gchar *tabid)
{
SeahorseWidget *swidget = seahorse_prefs_new (parent);
GtkWidget *tab;
if (tabid) {
tab = seahorse_widget_get_widget (swidget, tabid);
g_return_if_fail (tab);
seahorse_prefs_select_tab (swidget, tab);
}
}
void
seahorse_widget_set_visible (SeahorseWidget *swidget, const char *identifier,
gboolean visible)
{
GtkWidget *widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, identifier));
g_return_if_fail (widget != NULL);
if (visible)
gtk_widget_show (widget);
else
gtk_widget_hide (widget);
}
/* User wants to remove selected rows */
G_MODULE_EXPORT void
on_prefs_keyserver_remove_clicked (GtkWidget *button,
gpointer user_data)
{
SeahorseWidget *swidget = SEAHORSE_WIDGET (user_data);
GtkTreeView *treeview;
GtkTreeSelection *selection;
treeview = GTK_TREE_VIEW (seahorse_widget_get_widget (swidget, "keyservers"));
selection = gtk_tree_view_get_selection (treeview);
gtk_tree_selection_selected_foreach (selection, remove_row, NULL);
}
/**
* operation: The SeahorseOperation to use
* message: An optional message to display
* fract: The fraction finished
* swidget: the SeahorseWidget to get the widgets from
*
* Progress window update. Similar to operation_progress
*
**/
static void
progress_operation_update (SeahorseOperation *operation, const gchar *message,
gdouble fract, SeahorseWidget *swidget)
{
GtkProgressBar *progress;
GtkWidget *w;
const gchar *t;
w = GTK_WIDGET (seahorse_widget_get_widget (swidget, "operation-details"));
g_return_if_fail (w != NULL);
t = seahorse_operation_get_message (operation);
gtk_label_set_text (GTK_LABEL (w), t ? t : "");
progress = GTK_PROGRESS_BAR (seahorse_widget_get_widget (swidget, "operation-bar"));
g_return_if_fail (w != NULL);
if (fract >= 0.0) {
stop_pulse (progress);
gtk_progress_bar_set_fraction (progress, fract);
} else {
start_pulse (progress);
}
}
/**
* seahorse_prefs_remove_tab:
* @swidget: The preferences window
* @tab: The tab to be removed
*
* Removes a tab from the preferences window
**/
void
seahorse_prefs_remove_tab (SeahorseWidget *swidget, GtkWidget *tab)
{
GtkWidget *tabs;
gint pos;
g_return_if_fail (GTK_IS_WIDGET (tab));
tabs = GTK_WIDGET (seahorse_widget_get_widget (swidget, "notebook"));
g_return_if_fail (GTK_IS_NOTEBOOK (tabs));
pos = gtk_notebook_page_num (GTK_NOTEBOOK (tabs), tab);
if (pos != -1)
gtk_notebook_remove_page (GTK_NOTEBOOK (tabs), pos);
}
/**
* seahorse_widget_new_allow_multiple:
* @name: Name of widget, filename part of gtkbuilder file, and name of main window
* @parent: GtkWindow to make the parent of the new swidget
*
* Creates a new #SeahorseWidget without checking if it already exists.
*
* Returns: The new #SeahorseWidget
**/
SeahorseWidget*
seahorse_widget_new_allow_multiple (const gchar *name, GtkWindow *parent)
{
GtkWindow *window;
SeahorseWidget *swidget = g_object_new (SEAHORSE_TYPE_WIDGET, "name", name, NULL);
if (parent != NULL) {
window = GTK_WINDOW (seahorse_widget_get_widget (swidget, swidget->name));
gtk_window_set_transient_for (window, parent);
}
gtk_builder_connect_signals (swidget->gtkbuilder, NULL);
return swidget;
}
static void
passphrase_done (SeahorseOperation *op, SeahorseWidget *swidget)
{
GError *err = NULL;
GtkWidget *w;
if (!seahorse_operation_is_successful (op)) {
seahorse_operation_copy_error (op, &err);
seahorse_util_handle_error (err, _("Couldn't change passphrase for key."));
g_clear_error (&err);
}
w = GTK_WIDGET (seahorse_widget_get_widget (swidget, "passphrase-button"));
g_return_if_fail (w != NULL);
gtk_widget_set_sensitive (w, TRUE);
}
