gnome-keyring r1472 - in trunk: . daemon/ui egg gcr gcr/template gcr/tests po tool



Author: nnielsen
Date: Wed Jan 21 22:08:17 2009
New Revision: 1472
URL: http://svn.gnome.org/viewvc/gnome-keyring?rev=1472&view=rev

Log:
	* daemon/ui/gkr-ask-entry.c: (moved)
	* daemon/ui/gkr-ask-entry.h: (moved)
	* daemon/ui/gkr-ask-tool.c:
	* daemon/ui/Makefile.am:
	* egg/egg-secure-entry.c: (moved from daemon/ui/gkr-ask-entry.c)
	* egg/egg-secure-entry.h: (moved from daemon/ui/gkr-ask-entry.h)
	* egg/Makefile.am:
	* gcr/gcr.h: (added)
	* gcr/gcr-import-dialog.c: (added)
	* gcr/gcr-import-dialog.glade:
	* gcr/gcr-import-dialog.h: (added)
	* gcr/gcr-importer.c:
	* gcr/gcr-importer.h:
	* gcr/gcr-internal.c: (removed)
	* gcr/gcr-internal.h:
	* gcr/gcr-library.c: (added)
	* gcr/gcr-parser.c: 
	* gcr/gcr-parser.h:
	* gcr/gcr-types.h:
	* gcr/Makefile.am:
	* gcr/tests/Makefile.am:
	* gcr/tests/unit-test-parser.c:
	* tool/gkr-tool.c:
	* tool/gkr-tool-import.c: 
	* tool/Makefile.am: Complete importer in gcr library. Make 'gnome-keyring import'
	use the new importer.

Added:
   trunk/egg/egg-secure-entry.c   (contents, props changed)
      - copied, changed from r1462, /trunk/daemon/ui/gkr-ask-entry.c
   trunk/egg/egg-secure-entry.h   (contents, props changed)
      - copied, changed from r1462, /trunk/daemon/ui/gkr-ask-entry.h
   trunk/gcr/gcr-import-dialog.c
   trunk/gcr/gcr-import-dialog.h
   trunk/gcr/gcr-library.c
   trunk/gcr/gcr.h
Removed:
   trunk/daemon/ui/gkr-ask-entry.c
   trunk/daemon/ui/gkr-ask-entry.h
   trunk/gcr/gcr-internal.c
Modified:
   trunk/ChangeLog
   trunk/daemon/ui/Makefile.am
   trunk/daemon/ui/gkr-ask-tool.c
   trunk/egg/Makefile.am
   trunk/gcr/   (props changed)
   trunk/gcr/Makefile.am
   trunk/gcr/gcr-import-dialog.glade
   trunk/gcr/gcr-importer.c
   trunk/gcr/gcr-importer.h
   trunk/gcr/gcr-internal.h
   trunk/gcr/gcr-parser.c
   trunk/gcr/gcr-parser.h
   trunk/gcr/gcr-types.h
   trunk/gcr/template/gcr-xxx.c
   trunk/gcr/template/gcr-xxx.h
   trunk/gcr/tests/Makefile.am
   trunk/gcr/tests/unit-test-parser.c
   trunk/po/ChangeLog
   trunk/po/POTFILES.skip
   trunk/tool/Makefile.am
   trunk/tool/gkr-tool-import.c
   trunk/tool/gkr-tool.c

Modified: trunk/daemon/ui/Makefile.am
==============================================================================
--- trunk/daemon/ui/Makefile.am	(original)
+++ trunk/daemon/ui/Makefile.am	Wed Jan 21 22:08:17 2009
@@ -15,13 +15,13 @@
 	$(GTK_CFLAGS)
 	
 gnome_keyring_ask_SOURCES = \
-	gkr-ask-entry.c gkr-ask-entry.h \
 	gkr-ask-tool.c gkr-ask-tool.h \
 	gkr-ask-tool-widgets.c \
 	gkr-ask-request.h
 	
 gnome_keyring_ask_LDADD = \
 	$(top_builddir)/egg/libegg-secure.la \
+	$(top_builddir)/egg/libegg-secure-entry.la \
 	$(GTK_LIBS)
 
 noinst_LTLIBRARIES=libgkr-ui.la

Modified: trunk/daemon/ui/gkr-ask-tool.c
==============================================================================
--- trunk/daemon/ui/gkr-ask-tool.c	(original)
+++ trunk/daemon/ui/gkr-ask-tool.c	Wed Jan 21 22:08:17 2009
@@ -22,10 +22,10 @@
 
 #include "config.h"
 
-#include "gkr-ask-entry.h"
 #include "gkr-ask-tool.h"
 #include "gkr-ask-request.h"
 
+#include "egg/egg-secure-entry.h"
 #include "egg/egg-secure-memory.h"
 
 #include <gtk/gtk.h>
@@ -268,7 +268,7 @@
 	int upper, lower, digit, misc;
 	gdouble pwstrength;
 
-	password = gkr_ask_entry_get_text (GKR_ASK_ENTRY (editable));
+	password = egg_secure_entry_get_text (EGG_SECURE_ENTRY (editable));
 
 	/*
 	 * This code is based on the Master Password dialog in Firefox
@@ -490,8 +490,8 @@
 	if (include_original) {
 		gtk_table_resize (GTK_TABLE (ptable), ++row, 2);	
 		label = gtk_label_new_with_mnemonic (_("_Old password:"));
-		old = gkr_ask_entry_new ();
-		gkr_ask_entry_set_visibility (GKR_ASK_ENTRY (old), FALSE);
+		old = egg_secure_entry_new ();
+		egg_secure_entry_set_visibility (EGG_SECURE_ENTRY (old), FALSE);
 		gtk_label_set_mnemonic_widget (GTK_LABEL (label), old);
 		g_signal_connect_swapped (old,
 					  "activate",
@@ -510,8 +510,8 @@
 	if (include_password) {
 		gtk_table_resize (GTK_TABLE (ptable), ++row, 2);	
 		label = gtk_label_new_with_mnemonic (_("_Password:"));
-		entry = gkr_ask_entry_new ();
-		gkr_ask_entry_set_visibility (GKR_ASK_ENTRY (entry), FALSE);
+		entry = egg_secure_entry_new ();
+		egg_secure_entry_set_visibility (EGG_SECURE_ENTRY (entry), FALSE);
 		gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);
 		g_signal_connect_swapped (entry,
 					  "activate",
@@ -532,8 +532,8 @@
 	
 		gtk_table_resize (GTK_TABLE (ptable), ++row, 2);	
 		label = gtk_label_new_with_mnemonic (_("_Confirm password:"));
-		confirm = gkr_ask_entry_new ();
-		gkr_ask_entry_set_visibility (GKR_ASK_ENTRY (confirm), FALSE);
+		confirm = egg_secure_entry_new ();
+		egg_secure_entry_set_visibility (EGG_SECURE_ENTRY (confirm), FALSE);
 		gtk_label_set_mnemonic_widget (GTK_LABEL (label), confirm);
 		g_signal_connect_swapped (confirm,
 					  "activate",
@@ -599,15 +599,15 @@
 	
 	/* Get the original password */
 	if (include_original && old != NULL && response >= GKR_ASK_RESPONSE_ALLOW) {
-		original = gkr_ask_entry_get_text (GKR_ASK_ENTRY (old));
+		original = egg_secure_entry_get_text (EGG_SECURE_ENTRY (old));
 		*original_out = egg_secure_strdup (original);
 	}
 
 	/* Get the main password entry, and confirmation */
 	if (include_password && entry != NULL && response >= GKR_ASK_RESPONSE_ALLOW) {
-		password = gkr_ask_entry_get_text (GKR_ASK_ENTRY (entry));
+		password = egg_secure_entry_get_text (EGG_SECURE_ENTRY (entry));
 		if (include_confirm && confirm != NULL) {
-			confirmation = gkr_ask_entry_get_text (GKR_ASK_ENTRY (confirm));
+			confirmation = egg_secure_entry_get_text (EGG_SECURE_ENTRY (confirm));
 			if (strcmp (password, confirmation) != 0) {
 				notice_text = create_notice (_("Passwords do not match."));
 				gtk_label_set_markup (notice,  notice_text);

Modified: trunk/egg/Makefile.am
==============================================================================
--- trunk/egg/Makefile.am	(original)
+++ trunk/egg/Makefile.am	Wed Jan 21 22:08:17 2009
@@ -3,7 +3,8 @@
 	libegg.la \
 	libegg-buffer.la \
 	libegg-creds.la \
-	libegg-secure.la
+	libegg-secure.la \
+	libegg-secure-entry.la
 
 BUILT_SOURCES = \
 	asn1-def-pk.h asn1-def-pkix.h
@@ -45,6 +46,14 @@
 libegg_secure_la_SOURCES = \
  	egg-secure-memory.c egg-secure-memory.h
 
+libegg_secure_entry_la_SOURCES = \
+ 	egg-secure-entry.c egg-secure-entry.h
+
+libegg_secure_entry_la_CFLAGS = \
+	$(GOBJECT_CFLAGS) \
+	$(GLIB_CFLAGS) \
+	$(GTK_CFLAGS)
+	
 libegg_buffer_la_SOURCES = \
 	egg-buffer.c egg-buffer.h 
  	

Copied: trunk/egg/egg-secure-entry.c (from r1462, /trunk/daemon/ui/gkr-ask-entry.c)
==============================================================================
--- /trunk/daemon/ui/gkr-ask-entry.c	(original)
+++ trunk/egg/egg-secure-entry.c	Wed Jan 21 22:08:17 2009
@@ -46,9 +46,8 @@
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
 
-#include "gkr-ask-entry.h"
-
-#include "egg/egg-secure-memory.h"
+#include "egg-secure-entry.h"
+#include "egg-secure-memory.h"
 
 #define MIN_ASK_ENTRY_WIDTH  150
 #define DRAW_TIMEOUT            20
@@ -85,87 +84,87 @@
 static guint signals[LAST_SIGNAL] = { 0 };
 
 /* GObject, GtkObject methods */
-static void gkr_ask_entry_class_init (GkrAskEntryClass *klass);
-static void gkr_ask_entry_editable_init (GtkEditableClass *iface);
-static void gkr_ask_entry_cell_editable_init (GtkCellEditableIface *iface);
-static void gkr_ask_entry_init (GkrAskEntry *entry);
-static void gkr_ask_entry_set_property (GObject *object, guint prop_id,
+static void egg_secure_entry_class_init (EggSecureEntryClass *klass);
+static void egg_secure_entry_editable_init (GtkEditableClass *iface);
+static void egg_secure_entry_cell_editable_init (GtkCellEditableIface *iface);
+static void egg_secure_entry_init (EggSecureEntry *entry);
+static void egg_secure_entry_set_property (GObject *object, guint prop_id,
                                                 const GValue *value, GParamSpec *pspec);
-static void gkr_ask_entry_get_property (GObject *object, guint prop_id,
+static void egg_secure_entry_get_property (GObject *object, guint prop_id,
                                                 GValue *value, GParamSpec *pspec);
-static void gkr_ask_entry_finalize (GObject *object);
+static void egg_secure_entry_finalize (GObject *object);
 
 /* GtkWidget methods */
-static void gkr_ask_entry_realize (GtkWidget *widget);
-static void gkr_ask_entry_unrealize (GtkWidget *widget);
-static void gkr_ask_entry_size_request (GtkWidget *widget, GtkRequisition *requisition);
-static void gkr_ask_entry_size_allocate (GtkWidget *widget, GtkAllocation *allocation);
-static void gkr_ask_entry_draw_frame (GtkWidget *widget);
-static gint gkr_ask_entry_expose (GtkWidget *widget, GdkEventExpose *event);
-static gint gkr_ask_entry_button_press (GtkWidget *widget, GdkEventButton *event);
-static gint gkr_ask_entry_button_release (GtkWidget *widget, GdkEventButton *event);
-static gint gkr_ask_entry_motion_notify (GtkWidget *widget, GdkEventMotion *event);
-static gint gkr_ask_entry_key_press (GtkWidget *widget, GdkEventKey *event);
-static gint gkr_ask_entry_key_release (GtkWidget *widget, GdkEventKey *event);
-static gint gkr_ask_entry_focus_in (GtkWidget *widget, GdkEventFocus *event);
-static gint gkr_ask_entry_focus_out (GtkWidget *widget, GdkEventFocus *event);
-static void gkr_ask_entry_grab_focus (GtkWidget *widget);
-static void gkr_ask_entry_style_set (GtkWidget *widget, GtkStyle *previous_style);
-static void gkr_ask_entry_direction_changed (GtkWidget *widget, GtkTextDirection previous_dir);
-static void gkr_ask_entry_state_changed (GtkWidget *widget, GtkStateType previous_state);
-static void gkr_ask_entry_screen_changed (GtkWidget *widget, GdkScreen *old_screen);
+static void egg_secure_entry_realize (GtkWidget *widget);
+static void egg_secure_entry_unrealize (GtkWidget *widget);
+static void egg_secure_entry_size_request (GtkWidget *widget, GtkRequisition *requisition);
+static void egg_secure_entry_size_allocate (GtkWidget *widget, GtkAllocation *allocation);
+static void egg_secure_entry_draw_frame (GtkWidget *widget);
+static gint egg_secure_entry_expose (GtkWidget *widget, GdkEventExpose *event);
+static gint egg_secure_entry_button_press (GtkWidget *widget, GdkEventButton *event);
+static gint egg_secure_entry_button_release (GtkWidget *widget, GdkEventButton *event);
+static gint egg_secure_entry_motion_notify (GtkWidget *widget, GdkEventMotion *event);
+static gint egg_secure_entry_key_press (GtkWidget *widget, GdkEventKey *event);
+static gint egg_secure_entry_key_release (GtkWidget *widget, GdkEventKey *event);
+static gint egg_secure_entry_focus_in (GtkWidget *widget, GdkEventFocus *event);
+static gint egg_secure_entry_focus_out (GtkWidget *widget, GdkEventFocus *event);
+static void egg_secure_entry_grab_focus (GtkWidget *widget);
+static void egg_secure_entry_style_set (GtkWidget *widget, GtkStyle *previous_style);
+static void egg_secure_entry_direction_changed (GtkWidget *widget, GtkTextDirection previous_dir);
+static void egg_secure_entry_state_changed (GtkWidget *widget, GtkStateType previous_state);
+static void egg_secure_entry_screen_changed (GtkWidget *widget, GdkScreen *old_screen);
 
 /* GtkEditable method implementations */
-static void gkr_ask_entry_insert_text (GtkEditable *editable, const gchar *new_text,
+static void egg_secure_entry_insert_text (GtkEditable *editable, const gchar *new_text,
                                                gint new_text_length, gint *position);
-static void gkr_ask_entry_delete_text (GtkEditable *editable, gint start_pos, gint end_pos);
-static void gkr_ask_entry_real_set_position (GtkEditable *editable, gint position);
-static gint gkr_ask_entry_get_position (GtkEditable *editable);
-static void gkr_ask_entry_set_selection_bounds (GtkEditable *editable, gint start, gint end);
-static gboolean gkr_ask_entry_get_selection_bounds (GtkEditable *editable, gint *start, gint *end);
+static void egg_secure_entry_delete_text (GtkEditable *editable, gint start_pos, gint end_pos);
+static void egg_secure_entry_real_set_position (GtkEditable *editable, gint position);
+static gint egg_secure_entry_get_position (GtkEditable *editable);
+static void egg_secure_entry_set_selection_bounds (GtkEditable *editable, gint start, gint end);
+static gboolean egg_secure_entry_get_selection_bounds (GtkEditable *editable, gint *start, gint *end);
 
 /* GtkCellEditable method implementations */
-static void gkr_ask_entry_start_editing (GtkCellEditable *cell_editable, GdkEvent *event);
+static void egg_secure_entry_start_editing (GtkCellEditable *cell_editable, GdkEvent *event);
 
 /* Default signal handlers */
-static void gkr_ask_entry_real_insert_text (GtkEditable *editable, const gchar *new_text,
+static void egg_secure_entry_real_insert_text (GtkEditable *editable, const gchar *new_text,
                                                     gint new_text_length, gint *position);
-static void gkr_ask_entry_real_delete_text (GtkEditable *editable, gint start_pos, gint end_pos);
-static void gkr_ask_entry_move_cursor (GkrAskEntry *entry, GtkMovementStep step,
+static void egg_secure_entry_real_delete_text (GtkEditable *editable, gint start_pos, gint end_pos);
+static void egg_secure_entry_move_cursor (EggSecureEntry *entry, GtkMovementStep step,
                                                gint count, gboolean extend_selection);
-static void gkr_ask_entry_insert_at_cursor (GkrAskEntry *entry, const gchar *str);
-static void gkr_ask_entry_delete_from_cursor (GkrAskEntry *entry, GtkDeleteType type, gint count);
-static void gkr_ask_entry_real_activate (GkrAskEntry *entry);
-static void gkr_ask_entry_keymap_direction_changed (GdkKeymap *keymap, GkrAskEntry *entry);
+static void egg_secure_entry_insert_at_cursor (EggSecureEntry *entry, const gchar *str);
+static void egg_secure_entry_delete_from_cursor (EggSecureEntry *entry, GtkDeleteType type, gint count);
+static void egg_secure_entry_real_activate (EggSecureEntry *entry);
+static void egg_secure_entry_keymap_direction_changed (GdkKeymap *keymap, EggSecureEntry *entry);
 
 /* IM Context Callbacks */
-static void gkr_ask_entry_commit_cb(GtkIMContext *context, const gchar *str, GkrAskEntry *entry);
-static void gkr_ask_entry_preedit_changed_cb (GtkIMContext * context, GkrAskEntry *entry);
-static gboolean gkr_ask_entry_retrieve_surrounding_cb (GtkIMContext *context, GkrAskEntry *entry);
-static gboolean gkr_ask_entry_delete_surrounding_cb (GtkIMContext *context, gint offset, 
-                                                             gint n_chars, GkrAskEntry *entry);
+static void egg_secure_entry_commit_cb(GtkIMContext *context, const gchar *str, EggSecureEntry *entry);
+static void egg_secure_entry_preedit_changed_cb (GtkIMContext * context, EggSecureEntry *entry);
+static gboolean egg_secure_entry_retrieve_surrounding_cb (GtkIMContext *context, EggSecureEntry *entry);
+static gboolean egg_secure_entry_delete_surrounding_cb (GtkIMContext *context, gint offset, 
+                                                             gint n_chars, EggSecureEntry *entry);
 
 /* Internal routines */
-static void gkr_ask_entry_enter_text (GkrAskEntry *entry, const gchar *str);
-static void gkr_ask_entry_set_positions (GkrAskEntry *entry, gint current_pos, gint selection_bound);
-static void gkr_ask_entry_draw_text (GkrAskEntry *entry);
-static void gkr_ask_entry_draw_cursor (GkrAskEntry *entry);
-static PangoLayout *gkr_ask_entry_ensure_layout(GkrAskEntry *entry, gboolean include_preedit);
-static void gkr_ask_entry_reset_layout (GkrAskEntry *entry);
-static void gkr_ask_entry_queue_draw (GkrAskEntry *entry);
-static void gkr_ask_entry_reset_im_context (GkrAskEntry *entry);
-static void gkr_ask_entry_recompute (GkrAskEntry *entry);
-static gint gkr_ask_entry_find_position (GkrAskEntry *entry, gint x);
-static void gkr_ask_entry_get_cursor_locations (GkrAskEntry *entry, gint *strong_x, gint *weak_x);
-static void gkr_ask_entry_adjust_scroll (GkrAskEntry *entry);
-static gint gkr_ask_entry_move_visually (GkrAskEntry *editable, gint start, gint count);
-static gint gkr_ask_entry_move_logically (GkrAskEntry *entry, gint start, gint count);
-static gboolean gkr_ask_entry_mnemonic_activate (GtkWidget *widget, gboolean group_cycling);
-static void gkr_ask_entry_state_changed (GtkWidget *widget, GtkStateType previous_state);
-static void gkr_ask_entry_check_cursor_blink (GkrAskEntry *entry);
-static void gkr_ask_entry_pend_cursor_blink (GkrAskEntry *entry);
-static void get_text_area_size (GkrAskEntry *entry, gint *x, gint *y, gint *width, gint *height);
-static void get_widget_window_size (GkrAskEntry *entry, gint *x, gint *y, gint *width, gint *height);
+static void egg_secure_entry_enter_text (EggSecureEntry *entry, const gchar *str);
+static void egg_secure_entry_set_positions (EggSecureEntry *entry, gint current_pos, gint selection_bound);
+static void egg_secure_entry_draw_text (EggSecureEntry *entry);
+static void egg_secure_entry_draw_cursor (EggSecureEntry *entry);
+static PangoLayout *egg_secure_entry_ensure_layout(EggSecureEntry *entry, gboolean include_preedit);
+static void egg_secure_entry_reset_layout (EggSecureEntry *entry);
+static void egg_secure_entry_queue_draw (EggSecureEntry *entry);
+static void egg_secure_entry_reset_im_context (EggSecureEntry *entry);
+static void egg_secure_entry_recompute (EggSecureEntry *entry);
+static gint egg_secure_entry_find_position (EggSecureEntry *entry, gint x);
+static void egg_secure_entry_get_cursor_locations (EggSecureEntry *entry, gint *strong_x, gint *weak_x);
+static void egg_secure_entry_adjust_scroll (EggSecureEntry *entry);
+static gint egg_secure_entry_move_visually (EggSecureEntry *editable, gint start, gint count);
+static gint egg_secure_entry_move_logically (EggSecureEntry *entry, gint start, gint count);
+static gboolean egg_secure_entry_mnemonic_activate (GtkWidget *widget, gboolean group_cycling);
+static void egg_secure_entry_state_changed (GtkWidget *widget, GtkStateType previous_state);
+static void egg_secure_entry_check_cursor_blink (EggSecureEntry *entry);
+static void egg_secure_entry_pend_cursor_blink (EggSecureEntry *entry);
+static void get_text_area_size (EggSecureEntry *entry, gint *x, gint *y, gint *width, gint *height);
+static void get_widget_window_size (EggSecureEntry *entry, gint *x, gint *y, gint *width, gint *height);
 
 #define _gtk_marshal_VOID__VOID         g_cclosure_marshal_VOID__VOID
 #define _gtk_marshal_VOID__STRING       g_cclosure_marshal_VOID__STRING
@@ -178,36 +177,36 @@
 static GtkWidgetClass *parent_class = NULL;
 
 GType
-gkr_ask_entry_get_type(void)
+egg_secure_entry_get_type(void)
 {
     static GType entry_type = 0;
 
     if (!entry_type) {
         static const GTypeInfo entry_info = {
-            sizeof(GkrAskEntryClass),
+            sizeof(EggSecureEntryClass),
             NULL,       /* base_init */
             NULL,       /* base_finalize */
-            (GClassInitFunc) gkr_ask_entry_class_init,
+            (GClassInitFunc) egg_secure_entry_class_init,
             NULL,       /* class_finalize */
             NULL,       /* class_data */
-            sizeof(GkrAskEntry),
+            sizeof(EggSecureEntry),
             0,          /* n_preallocs */
-            (GInstanceInitFunc) gkr_ask_entry_init,
+            (GInstanceInitFunc) egg_secure_entry_init,
         };
 
         static const GInterfaceInfo editable_info = {
-            (GInterfaceInitFunc) gkr_ask_entry_editable_init,    /* interface_init */
+            (GInterfaceInitFunc) egg_secure_entry_editable_init,    /* interface_init */
             NULL,       /* interface_finalize */
             NULL        /* interface_data */
         };
 
         static const GInterfaceInfo cell_editable_info = {
-            (GInterfaceInitFunc) gkr_ask_entry_cell_editable_init,   /* interface_init */
+            (GInterfaceInitFunc) egg_secure_entry_cell_editable_init,   /* interface_init */
             NULL,       /* interface_finalize */
             NULL        /* interface_data */
         };
 
-        entry_type = g_type_register_static(GTK_TYPE_WIDGET, "GkrAskEntry", &entry_info, 0);
+        entry_type = g_type_register_static(GTK_TYPE_WIDGET, "EggSecureEntry", &entry_info, 0);
         g_type_add_interface_static(entry_type, GTK_TYPE_EDITABLE, &editable_info);
         g_type_add_interface_static(entry_type, GTK_TYPE_CELL_EDITABLE, &cell_editable_info);
     }
@@ -230,7 +229,7 @@
 }
 
 static void
-gkr_ask_entry_class_init(GkrAskEntryClass *class)
+egg_secure_entry_class_init(EggSecureEntryClass *class)
 {
     GObjectClass *gobject_class = G_OBJECT_CLASS(class);
     GtkWidgetClass *widget_class;
@@ -239,33 +238,33 @@
     widget_class = (GtkWidgetClass*) class;
     parent_class = g_type_class_peek_parent (class);
 
-    gobject_class->finalize = gkr_ask_entry_finalize;
-    gobject_class->set_property = gkr_ask_entry_set_property;
-    gobject_class->get_property = gkr_ask_entry_get_property;
-
-    widget_class->realize = gkr_ask_entry_realize;
-    widget_class->unrealize = gkr_ask_entry_unrealize;
-    widget_class->size_request = gkr_ask_entry_size_request;
-    widget_class->size_allocate = gkr_ask_entry_size_allocate;
-    widget_class->expose_event = gkr_ask_entry_expose;
-    widget_class->button_press_event = gkr_ask_entry_button_press;
-    widget_class->button_release_event = gkr_ask_entry_button_release;
-    widget_class->motion_notify_event = gkr_ask_entry_motion_notify;
-    widget_class->key_press_event = gkr_ask_entry_key_press;
-    widget_class->key_release_event = gkr_ask_entry_key_release;
-    widget_class->focus_in_event = gkr_ask_entry_focus_in;
-    widget_class->focus_out_event = gkr_ask_entry_focus_out;
-    widget_class->grab_focus = gkr_ask_entry_grab_focus;
-    widget_class->style_set = gkr_ask_entry_style_set;
-    widget_class->direction_changed = gkr_ask_entry_direction_changed;
-    widget_class->state_changed = gkr_ask_entry_state_changed;
-    widget_class->screen_changed = gkr_ask_entry_screen_changed;
-    widget_class->mnemonic_activate = gkr_ask_entry_mnemonic_activate;
-
-    class->move_cursor = gkr_ask_entry_move_cursor;
-    class->insert_at_cursor = gkr_ask_entry_insert_at_cursor;
-    class->delete_from_cursor = gkr_ask_entry_delete_from_cursor;
-    class->activate = gkr_ask_entry_real_activate;
+    gobject_class->finalize = egg_secure_entry_finalize;
+    gobject_class->set_property = egg_secure_entry_set_property;
+    gobject_class->get_property = egg_secure_entry_get_property;
+
+    widget_class->realize = egg_secure_entry_realize;
+    widget_class->unrealize = egg_secure_entry_unrealize;
+    widget_class->size_request = egg_secure_entry_size_request;
+    widget_class->size_allocate = egg_secure_entry_size_allocate;
+    widget_class->expose_event = egg_secure_entry_expose;
+    widget_class->button_press_event = egg_secure_entry_button_press;
+    widget_class->button_release_event = egg_secure_entry_button_release;
+    widget_class->motion_notify_event = egg_secure_entry_motion_notify;
+    widget_class->key_press_event = egg_secure_entry_key_press;
+    widget_class->key_release_event = egg_secure_entry_key_release;
+    widget_class->focus_in_event = egg_secure_entry_focus_in;
+    widget_class->focus_out_event = egg_secure_entry_focus_out;
+    widget_class->grab_focus = egg_secure_entry_grab_focus;
+    widget_class->style_set = egg_secure_entry_style_set;
+    widget_class->direction_changed = egg_secure_entry_direction_changed;
+    widget_class->state_changed = egg_secure_entry_state_changed;
+    widget_class->screen_changed = egg_secure_entry_screen_changed;
+    widget_class->mnemonic_activate = egg_secure_entry_mnemonic_activate;
+
+    class->move_cursor = egg_secure_entry_move_cursor;
+    class->insert_at_cursor = egg_secure_entry_insert_at_cursor;
+    class->delete_from_cursor = egg_secure_entry_delete_from_cursor;
+    class->activate = egg_secure_entry_real_activate;
 
     g_object_class_install_property (gobject_class, PROP_CURSOR_POSITION,
         g_param_spec_int ("cursor_position", "Cursor Position", "The current position of the insertion cursor in chars",
@@ -311,24 +310,24 @@
 
     signals[ACTIVATE] =  g_signal_new ("activate", G_OBJECT_CLASS_TYPE (gobject_class),
                                        G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
-                                       G_STRUCT_OFFSET (GkrAskEntryClass, activate),
+                                       G_STRUCT_OFFSET (EggSecureEntryClass, activate),
                                        NULL, NULL, _gtk_marshal_VOID__VOID, G_TYPE_NONE, 0);
     widget_class->activate_signal = signals[ACTIVATE];
 
     signals[MOVE_CURSOR] = g_signal_new ("move_cursor", G_OBJECT_CLASS_TYPE (gobject_class),
                                          G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
-                                         G_STRUCT_OFFSET (GkrAskEntryClass, move_cursor),
+                                         G_STRUCT_OFFSET (EggSecureEntryClass, move_cursor),
                                          NULL, NULL, _gtk_marshal_VOID__ENUM_INT_BOOLEAN,
                                          G_TYPE_NONE, 3, GTK_TYPE_MOVEMENT_STEP, G_TYPE_INT, G_TYPE_BOOLEAN);
 
     signals[INSERT_AT_CURSOR] = g_signal_new("insert_at_cursor", G_OBJECT_CLASS_TYPE (gobject_class),
                                              G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
-                                             G_STRUCT_OFFSET (GkrAskEntryClass, insert_at_cursor), 
+                                             G_STRUCT_OFFSET (EggSecureEntryClass, insert_at_cursor), 
                                              NULL, NULL, _gtk_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
 
     signals[DELETE_FROM_CURSOR] = g_signal_new("delete_from_cursor", G_OBJECT_CLASS_TYPE (gobject_class),
                                                G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
-                                               G_STRUCT_OFFSET (GkrAskEntryClass, delete_from_cursor), 
+                                               G_STRUCT_OFFSET (EggSecureEntryClass, delete_from_cursor), 
                                                NULL, NULL, _gtk_marshal_VOID__ENUM_INT, G_TYPE_NONE, 2,
                                                GTK_TYPE_DELETE_TYPE, G_TYPE_INT);
 
@@ -385,57 +384,57 @@
 }
 
 static void
-gkr_ask_entry_editable_init (GtkEditableClass *iface)
+egg_secure_entry_editable_init (GtkEditableClass *iface)
 {
-    iface->do_insert_text = gkr_ask_entry_insert_text;
-    iface->do_delete_text = gkr_ask_entry_delete_text;
-    iface->insert_text = gkr_ask_entry_real_insert_text;
-    iface->delete_text = gkr_ask_entry_real_delete_text;
-    iface->set_selection_bounds = gkr_ask_entry_set_selection_bounds;
-    iface->get_selection_bounds = gkr_ask_entry_get_selection_bounds;
-    iface->set_position = gkr_ask_entry_real_set_position;
-    iface->get_position = gkr_ask_entry_get_position;
+    iface->do_insert_text = egg_secure_entry_insert_text;
+    iface->do_delete_text = egg_secure_entry_delete_text;
+    iface->insert_text = egg_secure_entry_real_insert_text;
+    iface->delete_text = egg_secure_entry_real_delete_text;
+    iface->set_selection_bounds = egg_secure_entry_set_selection_bounds;
+    iface->get_selection_bounds = egg_secure_entry_get_selection_bounds;
+    iface->set_position = egg_secure_entry_real_set_position;
+    iface->get_position = egg_secure_entry_get_position;
 }
 
 static void
-gkr_ask_entry_cell_editable_init (GtkCellEditableIface * iface)
+egg_secure_entry_cell_editable_init (GtkCellEditableIface * iface)
 {
-    iface->start_editing = gkr_ask_entry_start_editing;
+    iface->start_editing = egg_secure_entry_start_editing;
 }
 
 static void
-gkr_ask_entry_set_property (GObject *object, guint prop_id,
+egg_secure_entry_set_property (GObject *object, guint prop_id,
                                     const GValue *value, GParamSpec *pspec)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY(object);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY(object);
 
     switch (prop_id) {
     case PROP_MAX_LENGTH:
-        gkr_ask_entry_set_max_length(entry, g_value_get_int(value));
+        egg_secure_entry_set_max_length(entry, g_value_get_int(value));
         break;
 
     case PROP_HAS_FRAME:
-        gkr_ask_entry_set_has_frame(entry, g_value_get_boolean(value));
+        egg_secure_entry_set_has_frame(entry, g_value_get_boolean(value));
         break;
 
     case PROP_INVISIBLE_CHAR:
-        gkr_ask_entry_set_invisible_char(entry, g_value_get_uint(value));
+        egg_secure_entry_set_invisible_char(entry, g_value_get_uint(value));
         break;
 
     case PROP_ACTIVATES_DEFAULT:
-        gkr_ask_entry_set_activates_default(entry, g_value_get_boolean(value));
+        egg_secure_entry_set_activates_default(entry, g_value_get_boolean(value));
         break;
 
     case PROP_WIDTH_CHARS:
-        gkr_ask_entry_set_width_chars(entry, g_value_get_int(value));
+        egg_secure_entry_set_width_chars(entry, g_value_get_int(value));
         break;
 
     case PROP_TEXT:
-        gkr_ask_entry_set_text(entry, g_value_get_string(value));
+        egg_secure_entry_set_text(entry, g_value_get_string(value));
         break;
     
     case PROP_VISIBILITY:
-        gkr_ask_entry_set_visibility (entry, g_value_get_boolean (value));
+        egg_secure_entry_set_visibility (entry, g_value_get_boolean (value));
         break;
 
     case PROP_SCROLL_OFFSET:
@@ -447,10 +446,10 @@
 }
 
 static void
-gkr_ask_entry_get_property (GObject *object, guint prop_id,
+egg_secure_entry_get_property (GObject *object, guint prop_id,
                                     GValue *value, GParamSpec *pspec)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY(object);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY(object);
 
     switch (prop_id) {
     case PROP_CURSOR_POSITION:
@@ -478,10 +477,10 @@
         g_value_set_int(value, entry->scroll_offset);
         break;
     case PROP_TEXT:
-        g_value_set_string(value, gkr_ask_entry_get_text(entry));
+        g_value_set_string(value, egg_secure_entry_get_text(entry));
         break;
     case PROP_VISIBILITY:
-        g_value_set_boolean (value, gkr_ask_entry_get_visibility (entry));
+        g_value_set_boolean (value, egg_secure_entry_get_visibility (entry));
         break;
     
     default:
@@ -491,7 +490,7 @@
 }
 
 static void
-gkr_ask_entry_init (GkrAskEntry *entry)
+egg_secure_entry_init (EggSecureEntry *entry)
 {
     GtkStyle *style;
     GtkWidget *tempent;
@@ -526,19 +525,19 @@
     entry->im_context = gtk_im_multicontext_new ();
 
     g_signal_connect (entry->im_context, "commit",
-                      G_CALLBACK (gkr_ask_entry_commit_cb), entry);
+                      G_CALLBACK (egg_secure_entry_commit_cb), entry);
     g_signal_connect (entry->im_context, "preedit_changed",
-                      G_CALLBACK(gkr_ask_entry_preedit_changed_cb), entry);
+                      G_CALLBACK(egg_secure_entry_preedit_changed_cb), entry);
     g_signal_connect (entry->im_context, "retrieve_surrounding",
-                      G_CALLBACK(gkr_ask_entry_retrieve_surrounding_cb), entry);
+                      G_CALLBACK(egg_secure_entry_retrieve_surrounding_cb), entry);
     g_signal_connect (entry->im_context, "delete_surrounding",
-                      G_CALLBACK(gkr_ask_entry_delete_surrounding_cb), entry);
+                      G_CALLBACK(egg_secure_entry_delete_surrounding_cb), entry);
 }
 
 static void
-gkr_ask_entry_finalize (GObject *object)
+egg_secure_entry_finalize (GObject *object)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY (object);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY (object);
 
     if (entry->cached_layout)
         g_object_unref (entry->cached_layout);
@@ -561,15 +560,15 @@
 }
 
 static void
-gkr_ask_entry_realize (GtkWidget *widget)
+egg_secure_entry_realize (GtkWidget *widget)
 {
-    GkrAskEntry *entry;
+    EggSecureEntry *entry;
     GtkEditable *editable;
     GdkWindowAttr attributes;
     gint attributes_mask;
 
     GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
-    entry = GKR_ASK_ENTRY (widget);
+    entry = EGG_SECURE_ENTRY (widget);
     editable = GTK_EDITABLE (widget);
 
     attributes.window_type = GDK_WINDOW_CHILD;
@@ -615,15 +614,15 @@
 
     gtk_im_context_set_client_window (entry->im_context, entry->text_area);
 
-    gkr_ask_entry_adjust_scroll (entry);
+    egg_secure_entry_adjust_scroll (entry);
 }
 
 static void
-gkr_ask_entry_unrealize (GtkWidget *widget)
+egg_secure_entry_unrealize (GtkWidget *widget)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY (widget);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY (widget);
 
-    gkr_ask_entry_reset_layout (entry);
+    egg_secure_entry_reset_layout (entry);
 
     gtk_im_context_set_client_window (entry->im_context, NULL);
 
@@ -638,7 +637,7 @@
 }
 
 static void
-get_borders (GkrAskEntry *entry, gint *xborder, gint *yborder)
+get_borders (EggSecureEntry *entry, gint *xborder, gint *yborder)
 {
     GtkWidget *widget = GTK_WIDGET (entry);
     gint focus_width;
@@ -662,9 +661,9 @@
 }
 
 static void
-gkr_ask_entry_size_request (GtkWidget *widget, GtkRequisition *requisition)
+egg_secure_entry_size_request (GtkWidget *widget, GtkRequisition *requisition)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY (widget);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY (widget);
     PangoFontMetrics *metrics;
     gint xborder, yborder;
     PangoContext *context;
@@ -695,7 +694,7 @@
 }
 
 static void
-get_text_area_size(GkrAskEntry *entry, gint *x, gint *y, gint *width, gint *height)
+get_text_area_size(EggSecureEntry *entry, gint *x, gint *y, gint *width, gint *height)
 {
     gint xborder, yborder;
     GtkRequisition requisition;
@@ -719,7 +718,7 @@
 }
 
 static void
-get_widget_window_size (GkrAskEntry *entry, gint *x, gint *y, gint *width, gint *height)
+get_widget_window_size (EggSecureEntry *entry, gint *x, gint *y, gint *width, gint *height)
 {
     GtkRequisition requisition;
     GtkWidget *widget = GTK_WIDGET (entry);
@@ -749,9 +748,9 @@
 }
 
 static void
-gkr_ask_entry_size_allocate(GtkWidget *widget, GtkAllocation *allocation)
+egg_secure_entry_size_allocate(GtkWidget *widget, GtkAllocation *allocation)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY(widget);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY(widget);
 
     widget->allocation = *allocation;
 
@@ -771,12 +770,12 @@
 
         gdk_window_move_resize (entry->text_area, x, y, width, height);
 
-        gkr_ask_entry_recompute (entry);
+        egg_secure_entry_recompute (entry);
     }
 }
 
 static void
-gkr_ask_entry_draw_frame (GtkWidget *widget)
+egg_secure_entry_draw_frame (GtkWidget *widget)
 {
     gint x = 0, y = 0;
     gint width, height;
@@ -810,12 +809,12 @@
 }
 
 static gint
-gkr_ask_entry_expose(GtkWidget *widget, GdkEventExpose *event)
+egg_secure_entry_expose(GtkWidget *widget, GdkEventExpose *event)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY(widget);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY(widget);
 
     if (widget->window == event->window)
-        gkr_ask_entry_draw_frame(widget);
+        egg_secure_entry_draw_frame(widget);
     else if (entry->text_area == event->window) {
         gint area_width, area_height;
 
@@ -826,18 +825,18 @@
 
         if ((entry->invisible_char != 0) && GTK_WIDGET_HAS_FOCUS (widget) &&
             entry->selection_bound == entry->current_pos && entry->cursor_visible)
-            gkr_ask_entry_draw_cursor (GKR_ASK_ENTRY (widget));
+            egg_secure_entry_draw_cursor (EGG_SECURE_ENTRY (widget));
 
-        gkr_ask_entry_draw_text (GKR_ASK_ENTRY (widget));
+        egg_secure_entry_draw_text (EGG_SECURE_ENTRY (widget));
     }
 
     return FALSE;
 }
 
 static gint
-gkr_ask_entry_button_press(GtkWidget *widget, GdkEventButton *event)
+egg_secure_entry_button_press(GtkWidget *widget, GdkEventButton *event)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY (widget);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY (widget);
     gint tmp_pos;
 
     if (event->window != entry->text_area || 
@@ -852,12 +851,12 @@
         entry->in_click = FALSE;
     }
 
-    tmp_pos = gkr_ask_entry_find_position (entry, event->x + entry->scroll_offset);
+    tmp_pos = egg_secure_entry_find_position (entry, event->x + entry->scroll_offset);
 
     if (event->button == 1) {
         switch (event->type) {
         case GDK_BUTTON_PRESS:
-            gkr_ask_entry_set_positions(entry, tmp_pos, tmp_pos);
+            egg_secure_entry_set_positions(entry, tmp_pos, tmp_pos);
             break;
         default:
             break;
@@ -870,9 +869,9 @@
 }
 
 static gint
-gkr_ask_entry_button_release(GtkWidget *widget, GdkEventButton *event)
+egg_secure_entry_button_release(GtkWidget *widget, GdkEventButton *event)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY(widget);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY(widget);
 
     if (event->window != entry->text_area || entry->button != event->button)
         return FALSE;
@@ -882,9 +881,9 @@
 }
 
 static gint
-gkr_ask_entry_motion_notify(GtkWidget *widget, GdkEventMotion *event)
+egg_secure_entry_motion_notify(GtkWidget *widget, GdkEventMotion *event)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY(widget);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY(widget);
     gint tmp_pos;
 
     if (entry->mouse_cursor_obscured) {
@@ -912,10 +911,10 @@
         else if (event->y >= height)
             tmp_pos = entry->text_length;
         else
-            tmp_pos = gkr_ask_entry_find_position (entry, 
+            tmp_pos = egg_secure_entry_find_position (entry, 
                                                 event->x + entry->scroll_offset);
 
-        gkr_ask_entry_set_positions (entry, tmp_pos, -1);
+        egg_secure_entry_set_positions (entry, tmp_pos, -1);
     }
 
     return TRUE;
@@ -944,7 +943,7 @@
 }
 
 static void
-gkr_ask_entry_obscure_mouse_cursor (GkrAskEntry * entry)
+egg_secure_entry_obscure_mouse_cursor (EggSecureEntry * entry)
 {
     if (entry->mouse_cursor_obscured)
         return;
@@ -955,14 +954,14 @@
 }
 
 static gint
-gkr_ask_entry_key_press (GtkWidget *widget, GdkEventKey *event)
+egg_secure_entry_key_press (GtkWidget *widget, GdkEventKey *event)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY (widget);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY (widget);
 
-    gkr_ask_entry_pend_cursor_blink (entry);
+    egg_secure_entry_pend_cursor_blink (entry);
 
     if (gtk_im_context_filter_keypress (entry->im_context, event)) {
-        gkr_ask_entry_obscure_mouse_cursor (entry);
+        egg_secure_entry_obscure_mouse_cursor (entry);
         entry->need_im_reset = TRUE;
         return TRUE;
     }
@@ -975,9 +974,9 @@
 }
 
 static gint
-gkr_ask_entry_key_release (GtkWidget *widget, GdkEventKey *event)
+egg_secure_entry_key_release (GtkWidget *widget, GdkEventKey *event)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY (widget);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY (widget);
 
     if (gtk_im_context_filter_keypress (entry->im_context, event)) {
         entry->need_im_reset = TRUE;
@@ -988,9 +987,9 @@
 }
 
 static gint
-gkr_ask_entry_focus_in (GtkWidget *widget, GdkEventFocus *event)
+egg_secure_entry_focus_in (GtkWidget *widget, GdkEventFocus *event)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY (widget);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY (widget);
 
     gtk_widget_queue_draw (widget);
 
@@ -998,35 +997,35 @@
     gtk_im_context_focus_in (entry->im_context);
 
     g_signal_connect (gdk_keymap_get_for_display (gtk_widget_get_display (widget)), "direction_changed",
-                      G_CALLBACK (gkr_ask_entry_keymap_direction_changed), entry);
+                      G_CALLBACK (egg_secure_entry_keymap_direction_changed), entry);
 
-    gkr_ask_entry_check_cursor_blink (entry);
+    egg_secure_entry_check_cursor_blink (entry);
 
     return FALSE;
 }
 
 static gint
-gkr_ask_entry_focus_out (GtkWidget *widget, GdkEventFocus *event)
+egg_secure_entry_focus_out (GtkWidget *widget, GdkEventFocus *event)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY (widget);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY (widget);
 
     gtk_widget_queue_draw (widget);
 
     entry->need_im_reset = TRUE;
     gtk_im_context_focus_out (entry->im_context);
 
-    gkr_ask_entry_check_cursor_blink (entry);
+    egg_secure_entry_check_cursor_blink (entry);
 
     g_signal_handlers_disconnect_by_func (gdk_keymap_get_for_display (gtk_widget_get_display (widget)),
-                                          gkr_ask_entry_keymap_direction_changed, entry);
+                                          egg_secure_entry_keymap_direction_changed, entry);
 
     return FALSE;
 }
 
 static void
-gkr_ask_entry_grab_focus (GtkWidget *widget)
+egg_secure_entry_grab_focus (GtkWidget *widget)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY (widget);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY (widget);
     GtkSettings *settings = gtk_widget_get_settings (widget);
     gboolean select_on_focus = FALSE;
 
@@ -1043,19 +1042,19 @@
 }
 
 static void
-gkr_ask_entry_direction_changed(GtkWidget *widget, GtkTextDirection previous_dir)
+egg_secure_entry_direction_changed(GtkWidget *widget, GtkTextDirection previous_dir)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY (widget);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY (widget);
 
-    gkr_ask_entry_recompute (entry);
+    egg_secure_entry_recompute (entry);
 
     GTK_WIDGET_CLASS (parent_class)->direction_changed (widget, previous_dir);
 }
 
 static void
-gkr_ask_entry_state_changed (GtkWidget *widget, GtkStateType previous_state)
+egg_secure_entry_state_changed (GtkWidget *widget, GtkStateType previous_state)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY (widget);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY (widget);
 
     if (GTK_WIDGET_REALIZED (widget)) {
         gdk_window_set_background (widget->window, 
@@ -1074,18 +1073,18 @@
 }
 
 static void
-gkr_ask_entry_screen_changed (GtkWidget *widget, GdkScreen *old_screen)
+egg_secure_entry_screen_changed (GtkWidget *widget, GdkScreen *old_screen)
 {
-    gkr_ask_entry_recompute (GKR_ASK_ENTRY (widget));
+    egg_secure_entry_recompute (EGG_SECURE_ENTRY (widget));
 }
 
 /* GtkEditable method implementations */
 
 static void
-gkr_ask_entry_insert_text (GtkEditable *editable, const gchar *new_text,
+egg_secure_entry_insert_text (GtkEditable *editable, const gchar *new_text,
                                    gint new_text_length, gint * position)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY(editable);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY(editable);
     gchar *text;
 
     if (*position < 0 || *position > entry->text_length)
@@ -1107,10 +1106,10 @@
 }
 
 static void
-gkr_ask_entry_delete_text (GtkEditable* editable, gint start_pos, 
+egg_secure_entry_delete_text (GtkEditable* editable, gint start_pos, 
                                    gint end_pos)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY (editable);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY (editable);
 
     if (end_pos < 0 || end_pos > entry->text_length)
         end_pos = entry->text_length;
@@ -1127,7 +1126,7 @@
 }
 
 static void
-gkr_ask_entry_set_position_internal (GkrAskEntry *entry,
+egg_secure_entry_set_position_internal (EggSecureEntry *entry,
                                              gint position, gboolean reset_im)
 {
     if (position < 0 || position > entry->text_length)
@@ -1135,46 +1134,46 @@
 
     if (position != entry->current_pos || position != entry->selection_bound) {
         if (reset_im)
-            gkr_ask_entry_reset_im_context (entry);
-        gkr_ask_entry_set_positions (entry, position, position);
+            egg_secure_entry_reset_im_context (entry);
+        egg_secure_entry_set_positions (entry, position, position);
     }
 }
 
 static void
-gkr_ask_entry_real_set_position (GtkEditable *editable, gint position)
+egg_secure_entry_real_set_position (GtkEditable *editable, gint position)
 {
-    gkr_ask_entry_set_position_internal (GKR_ASK_ENTRY (editable),
+    egg_secure_entry_set_position_internal (EGG_SECURE_ENTRY (editable),
                                                  position, TRUE);
 }
 
 static gint
-gkr_ask_entry_get_position (GtkEditable *editable)
+egg_secure_entry_get_position (GtkEditable *editable)
 {
-    return GKR_ASK_ENTRY (editable)->current_pos;
+    return EGG_SECURE_ENTRY (editable)->current_pos;
 }
 
 static void
-gkr_ask_entry_set_selection_bounds (GtkEditable *editable,
+egg_secure_entry_set_selection_bounds (GtkEditable *editable,
                                             gint start, gint end)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY (editable);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY (editable);
 
     if (start < 0)
         start = entry->text_length;
     if (end < 0)
         end = entry->text_length;
 
-    gkr_ask_entry_reset_im_context (entry);
+    egg_secure_entry_reset_im_context (entry);
 
-    gkr_ask_entry_set_positions (entry, MIN (end, entry->text_length),
+    egg_secure_entry_set_positions (entry, MIN (end, entry->text_length),
                                          MIN (start, entry->text_length));
 }
 
 static gboolean
-gkr_ask_entry_get_selection_bounds (GtkEditable *editable, 
+egg_secure_entry_get_selection_bounds (GtkEditable *editable, 
                                             gint *start, gint *end)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY (editable);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY (editable);
 
     *start = entry->selection_bound;
     *end = entry->current_pos;
@@ -1183,11 +1182,11 @@
 }
 
 static void
-gkr_ask_entry_style_set (GtkWidget *widget, GtkStyle *previous_style)
+egg_secure_entry_style_set (GtkWidget *widget, GtkStyle *previous_style)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY (widget);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY (widget);
 
-    gkr_ask_entry_recompute (entry);
+    egg_secure_entry_recompute (entry);
 
     if (previous_style && GTK_WIDGET_REALIZED (widget)) {
         gdk_window_set_background (widget->window, 
@@ -1200,14 +1199,14 @@
 /* GtkCellEditable method implementations
  */
 static void
-gtk_cell_editable_secure_entry_activated (GkrAskEntry *entry, gpointer data)
+gtk_cell_editable_secure_entry_activated (EggSecureEntry *entry, gpointer data)
 {
     gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (entry));
     gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (entry));
 }
 
 static gboolean
-gtk_cell_editable_key_press_event (GkrAskEntry *entry, GdkEventKey *key_event, 
+gtk_cell_editable_key_press_event (EggSecureEntry *entry, GdkEventKey *key_event, 
                                    gpointer data)
 {
     if (key_event->keyval == GDK_Escape) {
@@ -1228,10 +1227,10 @@
 }
 
 static void
-gkr_ask_entry_start_editing (GtkCellEditable *cell_editable,
+egg_secure_entry_start_editing (GtkCellEditable *cell_editable,
                                      GdkEvent *event)
 {
-    GKR_ASK_ENTRY(cell_editable)->is_cell_renderer = TRUE;
+    EGG_SECURE_ENTRY(cell_editable)->is_cell_renderer = TRUE;
 
     g_signal_connect (cell_editable, "activate",
                       G_CALLBACK (gtk_cell_editable_secure_entry_activated), NULL);
@@ -1242,13 +1241,13 @@
 /* Default signal handlers */
 
 static void
-gkr_ask_entry_real_insert_text (GtkEditable *editable, const gchar *new_text,
+egg_secure_entry_real_insert_text (GtkEditable *editable, const gchar *new_text,
                                         gint new_text_length, gint *position)
 {
     gint _index;
     gint n_chars;
 
-    GkrAskEntry *entry = GKR_ASK_ENTRY (editable);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY (editable);
 
     if (new_text_length < 0)
         new_text_length = strlen (new_text);
@@ -1303,7 +1302,7 @@
 
     *position += n_chars;
 
-    gkr_ask_entry_recompute (entry);
+    egg_secure_entry_recompute (entry);
 
     entry->changed = TRUE;
     g_signal_emit_by_name (editable, "changed");
@@ -1311,10 +1310,10 @@
 }
 
 static void
-gkr_ask_entry_real_delete_text (GtkEditable *editable, gint start_pos, 
+egg_secure_entry_real_delete_text (GtkEditable *editable, gint start_pos, 
                                         gint end_pos)
 {
-    GkrAskEntry *entry = GKR_ASK_ENTRY (editable);
+    EggSecureEntry *entry = EGG_SECURE_ENTRY (editable);
 
     if (start_pos < 0)
         start_pos = 0;
@@ -1340,9 +1339,9 @@
         if (selection_bound > start_pos)
             selection_bound -= MIN(selection_bound, end_pos) - start_pos;
 
-        gkr_ask_entry_set_positions(entry, current_pos, selection_bound);
+        egg_secure_entry_set_positions(entry, current_pos, selection_bound);
 
-        gkr_ask_entry_recompute (entry);
+        egg_secure_entry_recompute (entry);
 
         entry->changed = TRUE;
         g_signal_emit_by_name (editable, "changed");
@@ -1357,13 +1356,13 @@
  * right arrow key.
  */
 static gint
-get_better_cursor_x (GkrAskEntry *entry, gint offset)
+get_better_cursor_x (EggSecureEntry *entry, gint offset)
 {
     GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET(entry)));
     PangoDirection keymap_direction = gdk_keymap_get_direction (keymap);
     gboolean split_cursor;
 
-    PangoLayout *layout = gkr_ask_entry_ensure_layout (entry, TRUE);
+    PangoLayout *layout = egg_secure_entry_ensure_layout (entry, TRUE);
     const gchar *text = pango_layout_get_text(layout);
     gint _index = g_utf8_offset_to_pointer (text, offset) - text;
 
@@ -1383,12 +1382,12 @@
 }
 
 static void
-gkr_ask_entry_move_cursor (GkrAskEntry *entry, GtkMovementStep step,
+egg_secure_entry_move_cursor (EggSecureEntry *entry, GtkMovementStep step,
                                    gint count, gboolean extend_selection)
 {
     gint new_pos = entry->current_pos;
 
-    gkr_ask_entry_reset_im_context (entry);
+    egg_secure_entry_reset_im_context (entry);
 
     if (entry->current_pos != entry->selection_bound && !extend_selection) {
         /* 
@@ -1425,10 +1424,10 @@
     } else {
         switch (step) {
         case GTK_MOVEMENT_LOGICAL_POSITIONS:
-            new_pos = gkr_ask_entry_move_logically (entry, new_pos, count);
+            new_pos = egg_secure_entry_move_logically (entry, new_pos, count);
             break;
         case GTK_MOVEMENT_VISUAL_POSITIONS:
-            new_pos = gkr_ask_entry_move_visually (entry, new_pos, count);
+            new_pos = egg_secure_entry_move_visually (entry, new_pos, count);
             break;
         case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
         case GTK_MOVEMENT_PARAGRAPH_ENDS:
@@ -1449,30 +1448,30 @@
     else
         gtk_editable_set_position (GTK_EDITABLE (entry), new_pos);
 
-    gkr_ask_entry_pend_cursor_blink (entry);
+    egg_secure_entry_pend_cursor_blink (entry);
 }
 
 static void
-gkr_ask_entry_insert_at_cursor(GkrAskEntry *entry, const gchar *str)
+egg_secure_entry_insert_at_cursor(EggSecureEntry *entry, const gchar *str)
 {
     GtkEditable *editable = GTK_EDITABLE (entry);
     gint pos = entry->current_pos;
 
-    gkr_ask_entry_reset_im_context (entry);
+    egg_secure_entry_reset_im_context (entry);
 
     gtk_editable_insert_text (editable, str, -1, &pos);
     gtk_editable_set_position (editable, pos);
 }
 
 static void
-gkr_ask_entry_delete_from_cursor (GkrAskEntry *entry, GtkDeleteType type, 
+egg_secure_entry_delete_from_cursor (EggSecureEntry *entry, GtkDeleteType type, 
                                           gint count)
 {
     GtkEditable *editable = GTK_EDITABLE (entry);
     gint start_pos = entry->current_pos;
     gint end_pos = entry->current_pos;
 
-    gkr_ask_entry_reset_im_context (entry);
+    egg_secure_entry_reset_im_context (entry);
 
     if (entry->selection_bound != entry->current_pos) {
         gtk_editable_delete_selection (editable);
@@ -1481,7 +1480,7 @@
 
     switch (type) {
     case GTK_DELETE_CHARS:
-        end_pos = gkr_ask_entry_move_logically (entry, entry->current_pos, count);
+        end_pos = egg_secure_entry_move_logically (entry, entry->current_pos, count);
         gtk_editable_delete_text (editable, MIN (start_pos, end_pos), MAX (start_pos, end_pos));
         break;
     case GTK_DELETE_DISPLAY_LINE_ENDS:
@@ -1499,11 +1498,11 @@
         break;
     }
 
-    gkr_ask_entry_pend_cursor_blink (entry);
+    egg_secure_entry_pend_cursor_blink (entry);
 }
 
 static void
-gkr_ask_entry_real_activate (GkrAskEntry *entry)
+egg_secure_entry_real_activate (EggSecureEntry *entry)
 {
     GtkWindow *window;
     GtkWidget *toplevel;
@@ -1525,22 +1524,22 @@
 }
 
 static void
-gkr_ask_entry_keymap_direction_changed (GdkKeymap *keymap, GkrAskEntry *entry)
+egg_secure_entry_keymap_direction_changed (GdkKeymap *keymap, EggSecureEntry *entry)
 {
-    gkr_ask_entry_recompute (entry);
+    egg_secure_entry_recompute (entry);
 }
 
 /* IM Context Callbacks */
 
 static void
-gkr_ask_entry_commit_cb (GtkIMContext *context, const gchar *str, 
-                                 GkrAskEntry *entry)
+egg_secure_entry_commit_cb (GtkIMContext *context, const gchar *str, 
+                                 EggSecureEntry *entry)
 {
-    gkr_ask_entry_enter_text (entry, str);
+    egg_secure_entry_enter_text (entry, str);
 }
 
 static void
-gkr_ask_entry_preedit_changed_cb (GtkIMContext *context, GkrAskEntry *entry)
+egg_secure_entry_preedit_changed_cb (GtkIMContext *context, EggSecureEntry *entry)
 {
     gchar *preedit_string;
     gint cursor_pos;
@@ -1551,11 +1550,11 @@
     entry->preedit_cursor = cursor_pos;
     g_free (preedit_string);
 
-    gkr_ask_entry_recompute (entry);
+    egg_secure_entry_recompute (entry);
 }
 
 static gboolean
-gkr_ask_entry_retrieve_surrounding_cb (GtkIMContext *context, GkrAskEntry *entry)
+egg_secure_entry_retrieve_surrounding_cb (GtkIMContext *context, EggSecureEntry *entry)
 {
     gtk_im_context_set_surrounding (context, entry->text, entry->n_bytes,
                     g_utf8_offset_to_pointer (entry->text, entry->current_pos) - entry->text);
@@ -1563,8 +1562,8 @@
 }
 
 static gboolean
-gkr_ask_entry_delete_surrounding_cb (GtkIMContext *slave, gint offset, gint n_chars,
-                                             GkrAskEntry *entry)
+egg_secure_entry_delete_surrounding_cb (GtkIMContext *slave, gint offset, gint n_chars,
+                                             EggSecureEntry *entry)
 {
     gtk_editable_delete_text (GTK_EDITABLE (entry), entry->current_pos + offset,
                               entry->current_pos + offset + n_chars);
@@ -1575,7 +1574,7 @@
 
 /* Used for im_commit_cb and inserting Unicode chars */
 static void
-gkr_ask_entry_enter_text (GkrAskEntry *entry, const gchar *str)
+egg_secure_entry_enter_text (EggSecureEntry *entry, const gchar *str)
 {
     GtkEditable *editable = GTK_EDITABLE (entry);
     gint tmp_pos;
@@ -1584,12 +1583,12 @@
         gtk_editable_delete_selection (editable);
     else {
         if (entry->overwrite_mode)
-            gkr_ask_entry_delete_from_cursor (entry, GTK_DELETE_CHARS, 1);
+            egg_secure_entry_delete_from_cursor (entry, GTK_DELETE_CHARS, 1);
     }
 
     tmp_pos = entry->current_pos;
     gtk_editable_insert_text (editable, str, strlen(str), &tmp_pos);
-    gkr_ask_entry_set_position_internal (entry, tmp_pos, FALSE);
+    egg_secure_entry_set_position_internal (entry, tmp_pos, FALSE);
 }
 
 /* 
@@ -1597,7 +1596,7 @@
  * should go through this function.
  */
 static void
-gkr_ask_entry_set_positions (GkrAskEntry *entry, gint current_pos, 
+egg_secure_entry_set_positions (EggSecureEntry *entry, gint current_pos, 
                                      gint selection_bound)
 {
     gboolean changed = FALSE;
@@ -1621,11 +1620,11 @@
     g_object_thaw_notify (G_OBJECT (entry));
 
     if (changed)
-        gkr_ask_entry_recompute (entry);
+        egg_secure_entry_recompute (entry);
 }
 
 static void
-gkr_ask_entry_reset_layout (GkrAskEntry *entry)
+egg_secure_entry_reset_layout (EggSecureEntry *entry)
 {
     if (entry->cached_layout) {
         g_object_unref (entry->cached_layout);
@@ -1634,14 +1633,14 @@
 }
 
 static void
-update_im_cursor_location (GkrAskEntry *entry)
+update_im_cursor_location (EggSecureEntry *entry)
 {
     GdkRectangle area;
     gint strong_x;
     gint strong_xoffset;
     gint area_width, area_height;
 
-    gkr_ask_entry_get_cursor_locations (entry, &strong_x, NULL);
+    egg_secure_entry_get_cursor_locations (entry, &strong_x, NULL);
     get_text_area_size (entry, NULL, NULL, &area_width, &area_height);
 
     strong_xoffset = strong_x - entry->scroll_offset;
@@ -1661,17 +1660,17 @@
 static gboolean
 recompute_idle_func (gpointer data)
 {
-    GkrAskEntry *entry;
+    EggSecureEntry *entry;
 
     GDK_THREADS_ENTER ();
 
-    entry = GKR_ASK_ENTRY (data);
+    entry = EGG_SECURE_ENTRY (data);
 
     entry->recompute_idle = 0;
 
     if (gtk_widget_has_screen (GTK_WIDGET (entry))) {
-        gkr_ask_entry_adjust_scroll (entry);
-        gkr_ask_entry_queue_draw (entry);
+        egg_secure_entry_adjust_scroll (entry);
+        egg_secure_entry_queue_draw (entry);
 
         update_im_cursor_location (entry);
     }
@@ -1682,10 +1681,10 @@
 }
 
 static void
-gkr_ask_entry_recompute (GkrAskEntry *entry)
+egg_secure_entry_recompute (EggSecureEntry *entry)
 {
-    gkr_ask_entry_reset_layout (entry);
-    gkr_ask_entry_check_cursor_blink (entry);
+    egg_secure_entry_reset_layout (entry);
+    egg_secure_entry_check_cursor_blink (entry);
 
     if (!entry->recompute_idle) {
         entry->recompute_idle = g_idle_add_full (G_PRIORITY_HIGH_IDLE + 15,  /* between resize and redraw */
@@ -1694,7 +1693,7 @@
 }
 
 static gunichar
-build_string (GkrAskEntry *entry, GString *str, gint extra)
+build_string (EggSecureEntry *entry, GString *str, gint extra)
 {
     gint i, count, char_len;
     gunichar invisible_char;
@@ -1722,7 +1721,7 @@
 }
 
 static PangoLayout *
-gkr_ask_entry_create_layout (GkrAskEntry * entry, gboolean include_preedit)
+egg_secure_entry_create_layout (EggSecureEntry * entry, gboolean include_preedit)
 {
     GtkWidget *widget = GTK_WIDGET (entry);
     PangoLayout *layout = gtk_widget_create_pango_layout (widget, NULL);
@@ -1810,13 +1809,13 @@
 }
 
 static PangoLayout *
-gkr_ask_entry_ensure_layout (GkrAskEntry *entry, gboolean include_preedit)
+egg_secure_entry_ensure_layout (EggSecureEntry *entry, gboolean include_preedit)
 {
     if (entry->preedit_length > 0 && !include_preedit != !entry->cache_includes_preedit)
-        gkr_ask_entry_reset_layout (entry);
+        egg_secure_entry_reset_layout (entry);
 
     if (!entry->cached_layout) {
-        entry->cached_layout = gkr_ask_entry_create_layout (entry, include_preedit);
+        entry->cached_layout = egg_secure_entry_create_layout (entry, include_preedit);
         entry->cache_includes_preedit = include_preedit;
     }
 
@@ -1824,7 +1823,7 @@
 }
 
 static void
-get_layout_position (GkrAskEntry *entry, gint *x, gint *y)
+get_layout_position (EggSecureEntry *entry, gint *x, gint *y)
 {
     PangoLayout *layout;
     PangoRectangle logical_rect;
@@ -1832,7 +1831,7 @@
     gint y_pos;
     PangoLayoutLine *line;
 
-    layout = gkr_ask_entry_ensure_layout (entry, TRUE);
+    layout = egg_secure_entry_ensure_layout (entry, TRUE);
 
     get_text_area_size (entry, NULL, NULL, &area_width, &area_height);
 
@@ -1863,7 +1862,7 @@
 }
 
 static void
-gkr_ask_entry_draw_text(GkrAskEntry *entry)
+egg_secure_entry_draw_text(EggSecureEntry *entry)
 {
     GtkWidget *widget;
     PangoLayoutLine *line;
@@ -1872,7 +1871,7 @@
         return;
 
     if (GTK_WIDGET_DRAWABLE (entry)) {
-        PangoLayout *layout = gkr_ask_entry_ensure_layout (entry, TRUE);
+        PangoLayout *layout = egg_secure_entry_ensure_layout (entry, TRUE);
         gint x, y;
         gint start_pos, end_pos;
 
@@ -1932,7 +1931,7 @@
 }
 
 static void
-draw_insertion_cursor (GkrAskEntry *entry, GdkRectangle *cursor_location,
+draw_insertion_cursor (EggSecureEntry *entry, GdkRectangle *cursor_location,
                        gboolean is_primary, PangoDirection direction, gboolean draw_arrow)
 {
     GtkWidget *widget = GTK_WIDGET (entry);
@@ -1948,7 +1947,7 @@
 }
 
 static void
-gkr_ask_entry_draw_cursor (GkrAskEntry * entry)
+egg_secure_entry_draw_cursor (EggSecureEntry * entry)
 {
     GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET(entry)));
     PangoDirection keymap_direction = gdk_keymap_get_direction (keymap);
@@ -1968,7 +1967,7 @@
 
         gdk_drawable_get_size (entry->text_area, NULL, &text_area_height);
 
-        gkr_ask_entry_get_cursor_locations (entry, &strong_x, &weak_x);
+        egg_secure_entry_get_cursor_locations (entry, &strong_x, &weak_x);
 
         g_object_get (gtk_widget_get_settings (widget), "gtk-split-cursor", &split_cursor, NULL);
 
@@ -2005,14 +2004,14 @@
 }
 
 static void
-gkr_ask_entry_queue_draw (GkrAskEntry *entry)
+egg_secure_entry_queue_draw (EggSecureEntry *entry)
 {
     if (GTK_WIDGET_REALIZED (entry))
         gdk_window_invalidate_rect (entry->text_area, NULL, FALSE);
 }
 
 static void
-gkr_ask_entry_reset_im_context (GkrAskEntry *entry)
+egg_secure_entry_reset_im_context (EggSecureEntry *entry)
 {
     if (entry->need_im_reset) {
         entry->need_im_reset = 0;
@@ -2021,7 +2020,7 @@
 }
 
 static gint
-gkr_ask_entry_find_position (GkrAskEntry *entry, gint x)
+egg_secure_entry_find_position (EggSecureEntry *entry, gint x)
 {
     PangoLayout *layout;
     PangoLayoutLine *line;
@@ -2031,7 +2030,7 @@
     const gchar *text;
     gint cursor_index;
 
-    layout = gkr_ask_entry_ensure_layout (entry, TRUE);
+    layout = egg_secure_entry_ensure_layout (entry, TRUE);
     text = pango_layout_get_text (layout);
     cursor_index = g_utf8_offset_to_pointer (text, entry->current_pos) - text;
 
@@ -2054,7 +2053,7 @@
 }
 
 static void
-gkr_ask_entry_get_cursor_locations (GkrAskEntry *entry, 
+egg_secure_entry_get_cursor_locations (EggSecureEntry *entry, 
                                             gint *strong_x, gint *weak_x)
 {
     if (!entry->invisible_char) {
@@ -2063,7 +2062,7 @@
         if (weak_x)
             *weak_x = 0;
     } else {
-        PangoLayout *layout = gkr_ask_entry_ensure_layout (entry, TRUE);
+        PangoLayout *layout = egg_secure_entry_ensure_layout (entry, TRUE);
         const gchar *text = pango_layout_get_text (layout);
         PangoRectangle strong_pos, weak_pos;
         gint _index;
@@ -2082,7 +2081,7 @@
 }
 
 static void
-gkr_ask_entry_adjust_scroll (GkrAskEntry *entry)
+egg_secure_entry_adjust_scroll (EggSecureEntry *entry)
 {
     gint min_offset, max_offset;
     gint text_area_width, text_width;
@@ -2098,7 +2097,7 @@
     gdk_drawable_get_size (entry->text_area, &text_area_width, NULL);
     text_area_width -= 2 * INNER_BORDER;
 
-    layout = gkr_ask_entry_ensure_layout (entry, TRUE);
+    layout = egg_secure_entry_ensure_layout (entry, TRUE);
     line = pango_layout_get_lines (layout)->data;
 
     pango_layout_line_get_extents (line, NULL, &logical_rect);
@@ -2132,7 +2131,7 @@
      * put the weak cursor on screen if possible.
      */
 
-    gkr_ask_entry_get_cursor_locations (entry, &strong_x, &weak_x);
+    egg_secure_entry_get_cursor_locations (entry, &strong_x, &weak_x);
 
     strong_xoffset = strong_x - entry->scroll_offset;
 
@@ -2157,11 +2156,11 @@
 }
 
 static gint
-gkr_ask_entry_move_visually (GkrAskEntry * entry,
+egg_secure_entry_move_visually (EggSecureEntry * entry,
                                      gint start, gint count)
 {
     gint _index;
-    PangoLayout *layout = gkr_ask_entry_ensure_layout (entry, FALSE);
+    PangoLayout *layout = egg_secure_entry_ensure_layout (entry, FALSE);
     const gchar *text;
 
     text = pango_layout_get_text (layout);
@@ -2208,7 +2207,7 @@
 }
 
 static gint
-gkr_ask_entry_move_logically (GkrAskEntry *entry,
+egg_secure_entry_move_logically (EggSecureEntry *entry,
                                       gint start, gint count)
 {
     gint new_pos = start;
@@ -2221,17 +2220,17 @@
 /* Public API */
 
 GtkWidget *
-gkr_ask_entry_new (void)
+egg_secure_entry_new (void)
 {
-    return g_object_new (GKR_TYPE_ASK_ENTRY, NULL);
+    return g_object_new (EGG_TYPE_SECURE_ENTRY, NULL);
 }
 
 void
-gkr_ask_entry_set_text (GkrAskEntry *entry, const gchar *text)
+egg_secure_entry_set_text (EggSecureEntry *entry, const gchar *text)
 {
     gint tmp_pos;
 
-    g_return_if_fail (GKR_IS_ASK_ENTRY(entry));
+    g_return_if_fail (EGG_IS_SECURE_ENTRY(entry));
     g_return_if_fail (text != NULL);
 
     /* 
@@ -2248,47 +2247,47 @@
 }
 
 void 
-gkr_ask_entry_reset_changed (GkrAskEntry *entry)
+egg_secure_entry_reset_changed (EggSecureEntry *entry)
 {
-    g_return_if_fail (GKR_IS_ASK_ENTRY (entry));
+    g_return_if_fail (EGG_IS_SECURE_ENTRY (entry));
     entry->changed = FALSE;
 }
 
 gboolean
-gkr_ask_entry_get_changed (GkrAskEntry *entry)
+egg_secure_entry_get_changed (EggSecureEntry *entry)
 {
-    g_return_val_if_fail (GKR_IS_ASK_ENTRY (entry), FALSE);
+    g_return_val_if_fail (EGG_IS_SECURE_ENTRY (entry), FALSE);
     return entry->changed;
 }
 
 void
-gkr_ask_entry_set_visibility (GkrAskEntry *entry, gboolean setting)
+egg_secure_entry_set_visibility (EggSecureEntry *entry, gboolean setting)
 {
-    g_return_if_fail (GKR_IS_ASK_ENTRY (entry));
+    g_return_if_fail (EGG_IS_SECURE_ENTRY (entry));
 
     if (setting == entry->visibility)
         return;
 
     entry->visibility = setting;
     g_object_notify (G_OBJECT (entry), "visibility");
-    gkr_ask_entry_recompute (entry);
+    egg_secure_entry_recompute (entry);
 }
 
 gboolean
-gkr_ask_entry_get_visibility (GkrAskEntry *entry)
+egg_secure_entry_get_visibility (EggSecureEntry *entry)
 {
-    g_return_val_if_fail (GKR_IS_ASK_ENTRY (entry), FALSE);
+    g_return_val_if_fail (EGG_IS_SECURE_ENTRY (entry), FALSE);
     return entry->visibility;
 }
 
 
 /**
- * gkr_ask_entry_set_invisible_char:
- * @entry: a #GkrAskEntry
+ * egg_secure_entry_set_invisible_char:
+ * @entry: a #EggSecureEntry
  * @ch: a Unicode character
  * 
  * Sets the character to use in place of the actual text when
- * gkr_ask_entry_set_visibility() has been called to set text 
+ * egg_secure_entry_set_visibility() has been called to set text 
  * to %FALSE. i.e. this is the character used in "password mode" to
  * show the user how many characters have been typed. The default
  * invisible char is an asterisk ('*').  If you set the invisible char
@@ -2297,39 +2296,39 @@
  * 
  **/
 void
-gkr_ask_entry_set_invisible_char (GkrAskEntry *entry, gunichar ch)
+egg_secure_entry_set_invisible_char (EggSecureEntry *entry, gunichar ch)
 {
-    g_return_if_fail (GKR_IS_ASK_ENTRY (entry));
+    g_return_if_fail (EGG_IS_SECURE_ENTRY (entry));
 
     if (ch == entry->invisible_char)
         return;
 
     entry->invisible_char = ch;
     g_object_notify (G_OBJECT (entry), "invisible_char");
-    gkr_ask_entry_recompute (entry);
+    egg_secure_entry_recompute (entry);
 }
 
 /**
- * gkr_ask_entry_get_invisible_char:
- * @entry: a #GkrAskEntry
+ * egg_secure_entry_get_invisible_char:
+ * @entry: a #EggSecureEntry
  *
  * Retrieves the character displayed in place of the real characters
- * for entries with visisbility set to false. See gkr_ask_entry_set_invisible_char().
+ * for entries with visisbility set to false. See egg_secure_entry_set_invisible_char().
  *
  * Return value: the current invisible char, or 0, if the entry does not
  *               show invisible text at all. 
  **/
 gunichar
-gkr_ask_entry_get_invisible_char (GkrAskEntry * entry)
+egg_secure_entry_get_invisible_char (EggSecureEntry * entry)
 {
-    g_return_val_if_fail (GKR_IS_ASK_ENTRY (entry), 0);
+    g_return_val_if_fail (EGG_IS_SECURE_ENTRY (entry), 0);
 
     return entry->invisible_char;
 }
 
 /**
- * gkr_ask_entry_get_text:
- * @entry: a #GkrAskEntry
+ * egg_secure_entry_get_text:
+ * @entry: a #EggSecureEntry
  *
  * Retrieves the contents of the entry widget.
  * See also gtk_editable_get_chars().
@@ -2340,16 +2339,16 @@
  *      stored.
  **/
 G_CONST_RETURN gchar*
-gkr_ask_entry_get_text (GkrAskEntry *entry)
+egg_secure_entry_get_text (EggSecureEntry *entry)
 {
-    g_return_val_if_fail (GKR_IS_ASK_ENTRY (entry), NULL);
+    g_return_val_if_fail (EGG_IS_SECURE_ENTRY (entry), NULL);
 
     return entry->text;
 }
 
 /**
- * gkr_ask_entry_set_max_length:
- * @entry: a #GkrAskEntry.
+ * egg_secure_entry_set_max_length:
+ * @entry: a #EggSecureEntry.
  * @max: the maximum length of the entry, or 0 for no maximum.
  *   (other than the maximum length of entries.) The value passed in will
  *   be clamped to the range 0-65536.
@@ -2359,9 +2358,9 @@
  * will be truncated to fit.
  **/
 void
-gkr_ask_entry_set_max_length(GkrAskEntry *entry, gint max)
+egg_secure_entry_set_max_length(EggSecureEntry *entry, gint max)
 {
-    g_return_if_fail (GKR_IS_ASK_ENTRY (entry));
+    g_return_if_fail (EGG_IS_SECURE_ENTRY (entry));
 
     max = CLAMP (max, 0, MAX_SIZE);
 
@@ -2373,25 +2372,25 @@
 }
 
 /**
- * gkr_ask_entry_get_max_length:
- * @entry: a #GkrAskEntry
+ * egg_secure_entry_get_max_length:
+ * @entry: a #EggSecureEntry
  *
  * Retrieves the maximum allowed length of the text in
- * @entry. See gkr_ask_entry_set_max_length().
+ * @entry. See egg_secure_entry_set_max_length().
  *
  * Return value: the maximum allowed number of characters
- *               in #GkrAskEntry, or 0 if there is no maximum.
+ *               in #EggSecureEntry, or 0 if there is no maximum.
  **/
 gint
-gkr_ask_entry_get_max_length (GkrAskEntry *entry)
+egg_secure_entry_get_max_length (EggSecureEntry *entry)
 {
-    g_return_val_if_fail (GKR_IS_ASK_ENTRY (entry), 0);
+    g_return_val_if_fail (EGG_IS_SECURE_ENTRY (entry), 0);
     return entry->text_max_length;
 }
 
 /**
- * gkr_ask_entry_set_activates_default:
- * @entry: a #GkrAskEntry
+ * egg_secure_entry_set_activates_default:
+ * @entry: a #EggSecureEntry
  * @setting: %TRUE to activate window's default widget on Enter keypress
  *
  * If @setting is %TRUE, pressing Enter in the @entry will activate the default
@@ -2405,10 +2404,10 @@
  * 
  **/
 void
-gkr_ask_entry_set_activates_default (GkrAskEntry *entry,
+egg_secure_entry_set_activates_default (EggSecureEntry *entry,
                                              gboolean setting)
 {
-    g_return_if_fail (GKR_IS_ASK_ENTRY (entry));
+    g_return_if_fail (EGG_IS_SECURE_ENTRY (entry));
     setting = setting != FALSE;
 
     if (setting != entry->activates_default) {
@@ -2418,23 +2417,23 @@
 }
 
 /**
- * gkr_ask_entry_get_activates_default:
- * @entry: a #GkrAskEntry
+ * egg_secure_entry_get_activates_default:
+ * @entry: a #EggSecureEntry
  * 
- * Retrieves the value set by gkr_ask_entry_set_activates_default().
+ * Retrieves the value set by egg_secure_entry_set_activates_default().
  * 
  * Return value: %TRUE if the entry will activate the default widget
  **/
 gboolean
-gkr_ask_entry_get_activates_default (GkrAskEntry *entry)
+egg_secure_entry_get_activates_default (EggSecureEntry *entry)
 {
-    g_return_val_if_fail (GKR_IS_ASK_ENTRY (entry), FALSE);
+    g_return_val_if_fail (EGG_IS_SECURE_ENTRY (entry), FALSE);
     return entry->activates_default;
 }
 
 /**
- * gkr_ask_entry_set_width_chars:
- * @entry: a #GkrAskEntry
+ * egg_secure_entry_set_width_chars:
+ * @entry: a #EggSecureEntry
  * @n_chars: width in chars
  *
  * Changes the size request of the entry to be about the right size
@@ -2445,9 +2444,9 @@
  * 
  **/
 void
-gkr_ask_entry_set_width_chars (GkrAskEntry *entry, gint n_chars)    
+egg_secure_entry_set_width_chars (EggSecureEntry *entry, gint n_chars)    
 {
-    g_return_if_fail (GKR_IS_ASK_ENTRY (entry));
+    g_return_if_fail (EGG_IS_SECURE_ENTRY (entry));
 
     if (entry->width_chars != n_chars) {
         entry->width_chars = n_chars;
@@ -2457,31 +2456,31 @@
 }
 
 /**
- * gkr_ask_entry_get_width_chars:
- * @entry: a #GkrAskEntry
+ * egg_secure_entry_get_width_chars:
+ * @entry: a #EggSecureEntry
  * 
- * Gets the value set by gkr_ask_entry_set_width_chars().
+ * Gets the value set by egg_secure_entry_set_width_chars().
  * 
  * Return value: number of chars to request space for, or negative if unset
  **/
 gint
-gkr_ask_entry_get_width_chars (GkrAskEntry *entry)
+egg_secure_entry_get_width_chars (EggSecureEntry *entry)
 {
-    g_return_val_if_fail (GKR_IS_ASK_ENTRY (entry), 0);
+    g_return_val_if_fail (EGG_IS_SECURE_ENTRY (entry), 0);
     return entry->width_chars;
 }
 
 /**
- * gkr_ask_entry_set_has_frame:
- * @entry: a #GkrAskEntry
+ * egg_secure_entry_set_has_frame:
+ * @entry: a #EggSecureEntry
  * @setting: new value
  * 
  * Sets whether the entry has a beveled frame around it.
  **/
 void
-gkr_ask_entry_set_has_frame (GkrAskEntry *entry, gboolean setting)
+egg_secure_entry_set_has_frame (EggSecureEntry *entry, gboolean setting)
 {
-    g_return_if_fail (GKR_IS_ASK_ENTRY (entry));
+    g_return_if_fail (EGG_IS_SECURE_ENTRY (entry));
     
     setting = (setting != FALSE);
 
@@ -2494,22 +2493,22 @@
 }
 
 /**
- * gkr_ask_entry_get_has_frame:
- * @entry: a #GkrAskEntry
+ * egg_secure_entry_get_has_frame:
+ * @entry: a #EggSecureEntry
  * 
- * Gets the value set by gkr_ask_entry_set_has_frame().
+ * Gets the value set by egg_secure_entry_set_has_frame().
  * 
  * Return value: whether the entry has a beveled frame
  **/
 gboolean
-gkr_ask_entry_get_has_frame (GkrAskEntry *entry)
+egg_secure_entry_get_has_frame (EggSecureEntry *entry)
 {
-    g_return_val_if_fail (GKR_IS_ASK_ENTRY (entry), FALSE);
+    g_return_val_if_fail (EGG_IS_SECURE_ENTRY (entry), FALSE);
     return entry->has_frame;
 }
 
 static gboolean
-gkr_ask_entry_mnemonic_activate (GtkWidget *widget, gboolean group_cycling)
+egg_secure_entry_mnemonic_activate (GtkWidget *widget, gboolean group_cycling)
 {
     gtk_widget_grab_focus (widget);
     return TRUE;
@@ -2526,7 +2525,7 @@
 #define CURSOR_PEND_MULTIPLIER 1.0
 
 static gboolean
-cursor_blinks (GkrAskEntry *entry)
+cursor_blinks (EggSecureEntry *entry)
 {
     GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (entry));
     gboolean blink;
@@ -2540,7 +2539,7 @@
 }
 
 static gint
-get_cursor_time (GkrAskEntry *entry)
+get_cursor_time (EggSecureEntry *entry)
 {
     GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (entry));
     gint time;
@@ -2551,7 +2550,7 @@
 }
 
 static void
-show_cursor (GkrAskEntry *entry)
+show_cursor (EggSecureEntry *entry)
 {
     if (!entry->cursor_visible) {
         entry->cursor_visible = TRUE;
@@ -2563,7 +2562,7 @@
 }
 
 static void
-hide_cursor(GkrAskEntry * entry)
+hide_cursor(EggSecureEntry * entry)
 {
     if (entry->cursor_visible) {
         entry->cursor_visible = FALSE;
@@ -2580,14 +2579,14 @@
 static gint
 blink_cb (gpointer data)
 {
-    GkrAskEntry *entry;
+    EggSecureEntry *entry;
 
     GDK_THREADS_ENTER ();
 
-    entry = GKR_ASK_ENTRY (data);
+    entry = EGG_SECURE_ENTRY (data);
 
     if (!GTK_WIDGET_HAS_FOCUS (entry)) {
-        g_warning ("GkrAskEntry - did not receive focus-out-event. If you\n"
+        g_warning ("EggSecureEntry - did not receive focus-out-event. If you\n"
                    "connect a handler to this signal, it must return\n"
                    "FALSE so the entry gets the event as well");
     }
@@ -2612,7 +2611,7 @@
 }
 
 static void
-gkr_ask_entry_check_cursor_blink (GkrAskEntry *entry)
+egg_secure_entry_check_cursor_blink (EggSecureEntry *entry)
 {
     if (cursor_blinks (entry)) {
         if (!entry->blink_timeout) {
@@ -2632,7 +2631,7 @@
 }
 
 static void
-gkr_ask_entry_pend_cursor_blink (GkrAskEntry *entry)
+egg_secure_entry_pend_cursor_blink (EggSecureEntry *entry)
 {
     if (cursor_blinks (entry)) {
         if (entry->blink_timeout != 0)

Copied: trunk/egg/egg-secure-entry.h (from r1462, /trunk/daemon/ui/gkr-ask-entry.h)
==============================================================================
--- /trunk/daemon/ui/gkr-ask-entry.h	(original)
+++ trunk/egg/egg-secure-entry.h	Wed Jan 21 22:08:17 2009
@@ -41,8 +41,8 @@
  * Modified for inclusion into gnome-keyring by Stef Walter 
  */
 
-#ifndef __GKR_ASK_ENTRY_H__
-#define __GKR_ASK_ENTRY_H__
+#ifndef __EGG_SECURE_ENTRY_H__
+#define __EGG_SECURE_ENTRY_H__
 
 
 #include <gtk/gtk.h>
@@ -51,17 +51,17 @@
 extern "C" {
 #endif
     
-#define GKR_TYPE_ASK_ENTRY                  (gkr_ask_entry_get_type ())
-#define GKR_ASK_ENTRY(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GKR_TYPE_ASK_ENTRY, GkrAskEntry))
-#define GKR_ASK_ENTRY_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GKR_TYPE_ASK_ENTRY, GkrAskEntryClass))
-#define GKR_IS_ASK_ENTRY(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GKR_TYPE_ASK_ENTRY))
-#define GKR_IS_ASK_ENTRY_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GKR_TYPE_ASK_ENTRY))
-#define GKR_ASK_ENTRY_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GKR_TYPE_ASK_ENTRY, GkrAskEntryClass))
+#define EGG_TYPE_SECURE_ENTRY                  (egg_secure_entry_get_type ())
+#define EGG_SECURE_ENTRY(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), EGG_TYPE_SECURE_ENTRY, EggSecureEntry))
+#define EGG_SECURE_ENTRY_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), EGG_TYPE_SECURE_ENTRY, EggSecureEntryClass))
+#define EGG_IS_SECURE_ENTRY(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EGG_TYPE_SECURE_ENTRY))
+#define EGG_IS_SECURE_ENTRY_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), EGG_TYPE_SECURE_ENTRY))
+#define EGG_SECURE_ENTRY_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), EGG_TYPE_SECURE_ENTRY, EggSecureEntryClass))
     
-typedef struct _GkrAskEntry GkrAskEntry;
-typedef struct _GkrAskEntryClass GkrAskEntryClass;
+typedef struct _EggSecureEntry EggSecureEntry;
+typedef struct _EggSecureEntryClass EggSecureEntryClass;
 
-struct _GkrAskEntry {
+struct _EggSecureEntry {
     GtkWidget widget;
 
     gchar *text;
@@ -124,15 +124,15 @@
     gboolean changed;
 };
 
-struct _GkrAskEntryClass {
+struct _EggSecureEntryClass {
     GtkWidgetClass parent_class;
 
     /* Action signals */
-    void (*activate) (GkrAskEntry *entry);
-    void (*move_cursor) (GkrAskEntry *entry, GtkMovementStep step,
+    void (*activate) (EggSecureEntry *entry);
+    void (*move_cursor) (EggSecureEntry *entry, GtkMovementStep step,
                          gint count, gboolean extend_selection);
-    void (*insert_at_cursor) (GkrAskEntry *entry, const gchar *str);
-    void (*delete_from_cursor) (GkrAskEntry *entry, GtkDeleteType type, gint count);
+    void (*insert_at_cursor) (EggSecureEntry *entry, const gchar *str);
+    void (*delete_from_cursor) (EggSecureEntry *entry, GtkDeleteType type, gint count);
 
     /* Padding for future expansion */
     void (*_gtk_reserved1) (void);
@@ -141,47 +141,47 @@
     void (*_gtk_reserved4) (void);
 };
 
-GType               gkr_ask_entry_get_type              (void) G_GNUC_CONST;
+GType               egg_secure_entry_get_type              (void) G_GNUC_CONST;
 
-GtkWidget*          gkr_ask_entry_new                   (void);
+GtkWidget*          egg_secure_entry_new                   (void);
 
-void                gkr_ask_entry_reset_changed         (GkrAskEntry *entry);
+void                egg_secure_entry_reset_changed         (EggSecureEntry *entry);
 
-gboolean            gkr_ask_entry_get_changed           (GkrAskEntry *entry);
+gboolean            egg_secure_entry_get_changed           (EggSecureEntry *entry);
 
-void                gkr_ask_entry_set_visibility        (GkrAskEntry *entry, gboolean setting);
+void                egg_secure_entry_set_visibility        (EggSecureEntry *entry, gboolean setting);
 
-gboolean            gkr_ask_entry_get_visibility        (GkrAskEntry *entry);
+gboolean            egg_secure_entry_get_visibility        (EggSecureEntry *entry);
 
-void                gkr_ask_entry_set_invisible_char    (GkrAskEntry *entry, gunichar ch);
+void                egg_secure_entry_set_invisible_char    (EggSecureEntry *entry, gunichar ch);
 
-gunichar            gkr_ask_entry_get_invisible_char    (GkrAskEntry *entry);
+gunichar            egg_secure_entry_get_invisible_char    (EggSecureEntry *entry);
 
-void                gkr_ask_entry_set_has_frame         (GkrAskEntry *entry, gboolean setting);
+void                egg_secure_entry_set_has_frame         (EggSecureEntry *entry, gboolean setting);
 
-gboolean            gkr_ask_entry_get_has_frame         (GkrAskEntry *entry);
+gboolean            egg_secure_entry_get_has_frame         (EggSecureEntry *entry);
 
 /* text is truncated if needed */
-void                gkr_ask_entry_set_max_length        (GkrAskEntry *entry, gint max);
+void                egg_secure_entry_set_max_length        (EggSecureEntry *entry, gint max);
 
-gint                gkr_ask_entry_get_max_length        (GkrAskEntry *entry);
+gint                egg_secure_entry_get_max_length        (EggSecureEntry *entry);
 
-void                gkr_ask_entry_set_activates_default (GkrAskEntry *entry, gboolean setting);
+void                egg_secure_entry_set_activates_default (EggSecureEntry *entry, gboolean setting);
 
-gboolean            gkr_ask_entry_get_activates_default (GkrAskEntry *entry);
+gboolean            egg_secure_entry_get_activates_default (EggSecureEntry *entry);
 
-void                gkr_ask_entry_set_width_chars       (GkrAskEntry *entry, gint n_chars);
+void                egg_secure_entry_set_width_chars       (EggSecureEntry *entry, gint n_chars);
 
-gint                gkr_ask_entry_get_width_chars       (GkrAskEntry *entry);
+gint                egg_secure_entry_get_width_chars       (EggSecureEntry *entry);
 
 /* Somewhat more convenient than the GtkEditable generic functions */
-void                gkr_ask_entry_set_text              (GkrAskEntry *entry, const gchar *text);
+void                egg_secure_entry_set_text              (EggSecureEntry *entry, const gchar *text);
 
 /* returns a reference to the text */
-const gchar*        gkr_ask_entry_get_text              (GkrAskEntry *entry);
+const gchar*        egg_secure_entry_get_text              (EggSecureEntry *entry);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif  /*__GKR_ASK_ENTRY_H__ */
+#endif  /*__EGG_SECURE_ENTRY_H__ */

Modified: trunk/gcr/Makefile.am
==============================================================================
--- trunk/gcr/Makefile.am	(original)
+++ trunk/gcr/Makefile.am	Wed Jan 21 22:08:17 2009
@@ -1,12 +1,24 @@
-incdir = $(includedir)/gcr
+# ------------------------------------------------------------------
+# UI BUILDER
+# 
 
-inc_HEADERS = \
-	gcr-parser.h \
-	gcr-types.h
+uidir = $(datadir)/gcr/ui/
+
+GLADE_FILES = \
+	gcr-import-dialog.glade
+	
+.glade.ui: 
+	gtk-builder-convert --skip-windows $< $@
+	
+ui_DATA = $(GLADE_FILES:.glade=.ui)
+
+# ------------------------------------------------------------------
+# LIBRARY
 
 INCLUDES = \
 	-I$(top_builddir) \
     	-I$(top_srcdir) \
+    	$(GTK_CFLAGS) \
     	$(GOBJECT_CFLAGS) \
 	$(GLIB_CFLAGS)
 
@@ -16,10 +28,18 @@
 lib_LTLIBRARIES = libgcr.la
 
 libgcr_la_SOURCES = \
-	gcr-internal.c gcr-internal.h \
+	gcr-import-dialog.c gcr-import-dialog.h \
+	gcr-importer.c gcr-importer.h  \
+	gcr-internal.h \
+	gcr-library.c \
 	gcr-parser.c gcr-parser.h \
 	gcr-types.h \
 	$(BUILT_SOURCES)
+
+libgcr_la_CFLAGS = \
+	-DPKCS11_MODULE_PATH=\""$(libdir)/gnome-keyring/gnome-keyring-pkcs11.so"\" \
+	-DGCR_API_SUBJECT_TO_CHANGE \
+	-DUIDIR=\""$(uidir)"\"
     
 libgcr_la_LDFLAGS = \
     	-version-info $(GCR_LT_RELEASE) \
@@ -27,6 +47,7 @@
     
 libgcr_la_LIBADD = \
 	$(top_builddir)/egg/libegg.la \
+	$(top_builddir)/egg/libegg-secure-entry.la \
 	$(top_builddir)/gp11/libgp11.la \
 	$(GOBJECT_LIBS) \
 	$(GLIB_LIBS)
@@ -41,17 +62,25 @@
 pkgconfigdir = $(libdir)/pkgconfig
 pkgconfig_DATA = gcr-$(GCR_MAJOR).pc
 
+gcr-$(GCR_MAJOR).pc: gcr.pc
+	cp gcr.pc gcr-$(GCR_MAJOR).pc
+
+# ----------------------------------------------------------------
+
 EXTRA_DIST = \
 	gcr.pc.in \
 	gcr-marshal.list \
-	gcr-import-dialog.glade
+	gcr-import-dialog.glade \
+	$(GLADE_FILES)
     
+CLEANFILES = \
+	$(BUILT_SOURCES) \
+    	$(ui_DATA) \
+    	$(pkgconfig_DATA)
+    	
 DISTCLEANFILES = \
-	gcr-$(GCR_MAJOR).pc
+	$(pkgconfig_DATA)
     
-gcr-$(GCR_MAJOR).pc: gcr.pc
-	cp gcr.pc gcr-$(GCR_MAJOR).pc
-
 if WITH_TESTS
 TESTS_DIR = tests
 else
@@ -60,4 +89,3 @@
 
 SUBDIRS = . \
 	$(TESTS_DIR)
-	

Added: trunk/gcr/gcr-import-dialog.c
==============================================================================
--- (empty file)
+++ trunk/gcr/gcr-import-dialog.c	Wed Jan 21 22:08:17 2009
@@ -0,0 +1,452 @@
+/* 
+ * gnome-keyring
+ * 
+ * Copyright (C) 2008 Stefan Walter
+ * 
+ * This program is free software; you can redistribute it and/or modify 
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *  
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *  
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.  
+ */
+
+#include "config.h"
+
+#include "gcr-import-dialog.h"
+#include "gcr-internal.h"
+
+#include "egg/egg-secure-entry.h"
+
+enum {
+	PROP_0,
+	PROP_SELECTED_SLOT,
+	PROP_PASSWORD,
+	PROP_PRIMARY_TEXT,
+	PROP_SECONDARY_TEXT
+};
+
+enum {
+	COLUMN_SLOT,
+	COLUMN_ICON,
+	COLUMN_LABEL,
+	N_COLUMNS
+};
+
+struct _GcrImportDialogPrivate {
+	GtkBuilder *builder;
+	EggSecureEntry *entry;
+	GtkComboBox *combo;
+	GtkListStore *slots;
+};
+
+G_DEFINE_TYPE (GcrImportDialog, _gcr_import_dialog, GTK_TYPE_DIALOG);
+
+/* -----------------------------------------------------------------------------
+ * INTERNAL 
+ */
+
+static void
+populate_slots (GcrImportDialog *self)
+{
+	GList *modules, *m;
+	GList *slots, *s;
+	GtkTreeIter iter;
+	GP11TokenInfo *info;
+	gboolean added;
+	
+	g_assert (GCR_IS_IMPORT_DIALOG (self));
+
+	if (self->pv->slots)
+		return;
+
+	self->pv->slots = gtk_list_store_new (N_COLUMNS, GP11_TYPE_SLOT, G_TYPE_STRING, G_TYPE_STRING);
+	gtk_combo_box_set_model (self->pv->combo, GTK_TREE_MODEL (self->pv->slots));
+
+	modules = _gcr_get_pkcs11_modules ();
+	g_return_if_fail (modules);
+	
+	gtk_list_store_clear (self->pv->slots);
+	
+	added = FALSE;
+	for (m = modules; m; m = g_list_next (m)) {
+		
+		g_return_if_fail (GP11_IS_MODULE (m->data));
+		slots = gp11_module_get_slots (m->data, TRUE);
+		
+		for (s = slots; s; s = g_list_next (s)) {
+			info = gp11_slot_get_token_info (s->data);
+			if (!(info->flags & CKF_WRITE_PROTECTED)) {
+				gtk_list_store_append (self->pv->slots, &iter);
+				gtk_list_store_set (self->pv->slots, &iter, 
+				                    COLUMN_LABEL, info->label,
+				                    COLUMN_SLOT, s->data,
+				                    -1);
+				added = TRUE;
+			}
+		}
+		
+		gp11_list_unref_free (slots);
+	}
+	
+	if (added)
+		gtk_combo_box_set_active (self->pv->combo, 0);
+}
+
+/* -----------------------------------------------------------------------------
+ * OBJECT 
+ */
+
+static void
+gcr_import_dialog_real_realize (GtkWidget *base)
+{
+	GcrImportDialog *self = GCR_IMPORT_DIALOG (base);
+	if (GTK_WIDGET_VISIBLE (self->pv->combo)) 
+		populate_slots (self);	
+	GTK_WIDGET_CLASS (_gcr_import_dialog_parent_class)->realize (base);
+}
+
+static GObject* 
+gcr_import_dialog_constructor (GType type, guint n_props, GObjectConstructParam *props) 
+{
+	GcrImportDialog *self = GCR_IMPORT_DIALOG (G_OBJECT_CLASS (_gcr_import_dialog_parent_class)->constructor(type, n_props, props));
+	GtkCellRenderer *renderer;
+	GtkWidget *widget;
+	
+	g_return_val_if_fail (self, NULL);
+	
+	if (!gtk_builder_add_from_file (self->pv->builder, UIDIR "gcr-import-dialog.ui", NULL))
+		g_return_val_if_reached (NULL);
+
+	/* Fill in the dialog from builder */
+	widget = GTK_WIDGET (gtk_builder_get_object (self->pv->builder, "import-dialog"));
+	g_return_val_if_fail (widget, FALSE);
+	gtk_container_add (GTK_CONTAINER (GTK_DIALOG (self)->vbox), widget);
+
+	/* Add a secure entry */
+	self->pv->entry = EGG_SECURE_ENTRY (egg_secure_entry_new ());
+	widget = GTK_WIDGET (gtk_builder_get_object (self->pv->builder, "password-area"));
+	gtk_container_add (GTK_CONTAINER (widget), GTK_WIDGET (self->pv->entry));
+	gtk_widget_show (GTK_WIDGET (self->pv->entry));
+	
+	/* Initialize the combo box */
+	self->pv->combo = GTK_COMBO_BOX (gtk_builder_get_object (self->pv->builder, "slot-combo"));
+	renderer = gtk_cell_renderer_pixbuf_new ();
+	gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self->pv->combo), renderer, FALSE);
+	gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (self->pv->combo), renderer, "icon-name", COLUMN_ICON);
+	g_object_set (renderer, "xpad", 3, NULL);
+	renderer = gtk_cell_renderer_text_new ();
+	gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self->pv->combo), renderer, TRUE);
+	gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (self->pv->combo), renderer, "text", COLUMN_LABEL);
+
+	/* Add our various buttons */
+	gtk_dialog_add_button (GTK_DIALOG (self), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
+	gtk_dialog_add_button (GTK_DIALOG (self), GTK_STOCK_OK, GTK_RESPONSE_OK);
+	
+	return G_OBJECT (self);
+}
+
+static void
+_gcr_import_dialog_init (GcrImportDialog *self)
+{
+	self->pv = G_TYPE_INSTANCE_GET_PRIVATE (self, GCR_TYPE_IMPORT_DIALOG, GcrImportDialogPrivate);
+	self->pv->builder = gtk_builder_new ();
+}
+
+static void
+gcr_import_dialog_dispose (GObject *obj)
+{
+	G_OBJECT_CLASS (_gcr_import_dialog_parent_class)->dispose (obj);
+}
+
+static void
+gcr_import_dialog_finalize (GObject *obj)
+{
+	GcrImportDialog *self = GCR_IMPORT_DIALOG (obj);
+	
+	g_object_unref (self->pv->slots);
+	self->pv->slots = NULL;
+	
+	g_object_unref (self->pv->builder);
+	self->pv->builder = NULL;
+
+	G_OBJECT_CLASS (_gcr_import_dialog_parent_class)->finalize (obj);
+}
+
+static void
+gcr_import_dialog_set_property (GObject *obj, guint prop_id, const GValue *value, 
+                                GParamSpec *pspec)
+{
+	GcrImportDialog *self = GCR_IMPORT_DIALOG (obj);
+	
+	switch (prop_id) {
+	case PROP_SELECTED_SLOT:
+		_gcr_import_dialog_set_selected_slot (self, g_value_get_object (value));
+		break;
+	case PROP_PASSWORD:
+		_gcr_import_dialog_set_password (self, g_value_get_pointer (value));
+		break;
+	case PROP_PRIMARY_TEXT:
+		_gcr_import_dialog_set_primary_text (self, g_value_get_string (value));
+		break;
+	case PROP_SECONDARY_TEXT:
+		_gcr_import_dialog_set_secondary_text (self, g_value_get_string (value));
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
+		break;
+	}
+}
+
+static void
+gcr_import_dialog_get_property (GObject *obj, guint prop_id, GValue *value, 
+                           GParamSpec *pspec)
+{
+	GcrImportDialog *self = GCR_IMPORT_DIALOG (obj);
+	
+	switch (prop_id) {
+	case PROP_SELECTED_SLOT:
+		g_value_set_object (value, _gcr_import_dialog_get_selected_slot (self));
+		break;
+	case PROP_PASSWORD:
+		g_value_set_pointer (value, (gpointer)_gcr_import_dialog_get_password (self));
+		break;
+	case PROP_PRIMARY_TEXT:
+		g_value_set_string (value, _gcr_import_dialog_get_primary_text (self));
+		break;
+	case PROP_SECONDARY_TEXT:
+		g_value_set_string (value, _gcr_import_dialog_get_secondary_text (self));
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
+		break;
+	}
+}
+
+static void
+_gcr_import_dialog_class_init (GcrImportDialogClass *klass)
+{
+	GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+	GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+	
+	gobject_class->constructor = gcr_import_dialog_constructor;
+	gobject_class->dispose = gcr_import_dialog_dispose;
+	gobject_class->finalize = gcr_import_dialog_finalize;
+	gobject_class->set_property = gcr_import_dialog_set_property;
+	gobject_class->get_property = gcr_import_dialog_get_property;
+	
+	widget_class->realize = gcr_import_dialog_real_realize;
+    
+	g_type_class_add_private (gobject_class, sizeof (GcrImportDialogPrivate));
+	
+	g_object_class_install_property (gobject_class, PROP_SELECTED_SLOT,
+	           g_param_spec_object ("selected-slot", "Selected Slot", "Selected PKCS#11 slot",
+	                                GP11_TYPE_SLOT, G_PARAM_READWRITE));
+
+	g_object_class_install_property (gobject_class, PROP_PASSWORD,
+	           g_param_spec_pointer ("password", "Password", "Pointer to password",
+	                                 G_PARAM_READWRITE));
+
+	g_object_class_install_property (gobject_class, PROP_PRIMARY_TEXT,
+	           g_param_spec_string ("primary-text", "Primary Text", "Primary dialog text",
+	                                NULL, G_PARAM_READWRITE));
+	
+	g_object_class_install_property (gobject_class, PROP_SECONDARY_TEXT,
+	           g_param_spec_string ("secondary-text", "Secondary Text", "Dialog secondary text",
+	                                NULL, G_PARAM_READWRITE));
+
+	_gcr_initialize ();
+}
+
+/* -----------------------------------------------------------------------------
+ * PUBLIC 
+ */
+
+GcrImportDialog*
+_gcr_import_dialog_new (void)
+{
+	GcrImportDialog *dialog = g_object_new (GCR_TYPE_IMPORT_DIALOG, NULL);
+	return g_object_ref_sink (dialog);
+}
+
+gboolean
+_gcr_import_dialog_run (GcrImportDialog *self, GtkWindow *parent)
+{
+	gboolean ret;
+	
+	g_return_val_if_fail (GCR_IS_IMPORT_DIALOG (self), FALSE);
+	
+	if (parent != NULL)
+		gtk_window_set_transient_for (GTK_WINDOW (self), parent);
+	
+	ret = (gtk_dialog_run (GTK_DIALOG (self)) == GTK_RESPONSE_OK);
+	
+	if (parent != NULL)
+		gtk_window_set_transient_for (GTK_WINDOW (self), NULL);
+
+	gtk_widget_hide (GTK_WIDGET (self));
+	return ret;
+}
+
+GP11Slot*
+_gcr_import_dialog_get_selected_slot (GcrImportDialog *self)
+{
+	GtkTreeIter iter;
+	GP11Slot *slot;
+	
+	g_return_val_if_fail (GCR_IMPORT_DIALOG (self), NULL);
+	
+	if (GTK_WIDGET_VISIBLE (self->pv->combo))
+		populate_slots (self);
+	else
+		return NULL;
+	
+	if (!gtk_combo_box_get_active_iter (self->pv->combo, &iter))
+		return NULL;
+	
+	gtk_tree_model_get (GTK_TREE_MODEL (self->pv->slots), &iter, COLUMN_SLOT, &slot, -1);
+	
+	/* We hold the reference to this */
+	if (slot != NULL)
+		g_object_unref (slot);
+	
+	return slot;
+}
+
+void
+_gcr_import_dialog_set_selected_slot (GcrImportDialog *self, GP11Slot *slot)
+{
+	GtkTreeIter iter;
+	GP11Slot *it_slot;
+	gboolean matched;
+
+	g_return_if_fail (GCR_IMPORT_DIALOG (self));
+	
+	if (GTK_WIDGET_VISIBLE (self->pv->combo)) 
+		populate_slots (self);
+	else
+		g_return_if_reached ();
+
+	if (slot == NULL) {
+		gtk_combo_box_set_active (self->pv->combo, -1);
+		return;
+	}
+	
+	g_return_if_fail (GP11_IS_SLOT (slot));
+	
+	matched = FALSE;
+	if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (self->pv->slots), &iter)) {
+		do {
+			gtk_tree_model_get (GTK_TREE_MODEL (self->pv->slots), &iter, COLUMN_SLOT, &it_slot, -1);
+			if (gp11_slot_equal (it_slot, slot)) 
+				matched = TRUE;
+			g_object_unref (it_slot);
+		} while (!matched && gtk_tree_model_iter_next (GTK_TREE_MODEL (self->pv->slots), &iter));
+	}
+	
+	if (matched) {
+		gtk_combo_box_set_active_iter (self->pv->combo, &iter);
+	} else {
+		gtk_combo_box_set_active (self->pv->combo, -1);
+		g_return_if_reached ();
+	}
+}
+
+void
+_gcr_import_dialog_show_selected_slot (GcrImportDialog *self)
+{
+	g_return_if_fail (GCR_IS_IMPORT_DIALOG (self));
+	gtk_widget_show (GTK_WIDGET (gtk_builder_get_object (self->pv->builder, "slot-label")));
+	gtk_widget_show (GTK_WIDGET (gtk_builder_get_object (self->pv->builder, "slot-area")));
+}
+
+void
+_gcr_import_dialog_hide_selected_slot (GcrImportDialog *self)
+{
+	g_return_if_fail (GCR_IS_IMPORT_DIALOG (self));
+	gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (self->pv->builder, "slot-label")));
+	gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (self->pv->builder, "slot-area")));
+}
+
+const gchar*
+_gcr_import_dialog_get_password (GcrImportDialog *self)
+{
+	g_return_val_if_fail (GCR_IS_IMPORT_DIALOG (self), NULL);
+	return egg_secure_entry_get_text (self->pv->entry);
+}
+
+void
+_gcr_import_dialog_set_password (GcrImportDialog *self, const gchar *password)
+{
+	g_return_if_fail (GCR_IS_IMPORT_DIALOG (self));
+	if (password == NULL)
+		password = "";
+	egg_secure_entry_set_text (self->pv->entry, password);
+}
+
+void
+_gcr_import_dialog_show_password (GcrImportDialog *self)
+{
+	g_return_if_fail (GCR_IS_IMPORT_DIALOG (self));
+	gtk_widget_show (GTK_WIDGET (gtk_builder_get_object (self->pv->builder, "password-label")));
+	gtk_widget_show (GTK_WIDGET (gtk_builder_get_object (self->pv->builder, "password-area")));	
+}
+
+void
+_gcr_import_dialog_hide_password (GcrImportDialog *self)
+{
+	g_return_if_fail (GCR_IS_IMPORT_DIALOG (self));
+	gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (self->pv->builder, "password-label")));
+	gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (self->pv->builder, "password-area")));
+}
+
+const gchar*
+_gcr_import_dialog_get_primary_text (GcrImportDialog *self)
+{
+	g_return_val_if_fail (GCR_IS_IMPORT_DIALOG (self), NULL);
+	return gtk_label_get_text (GTK_LABEL (gtk_builder_get_object (self->pv->builder, "primary-text")));
+}
+
+void
+_gcr_import_dialog_set_primary_text (GcrImportDialog *self, const gchar *text)
+{
+	gchar *label;
+	
+	g_return_if_fail (GCR_IS_IMPORT_DIALOG (self));
+	
+	if (text == NULL)
+		text = "";
+	
+	label = g_markup_printf_escaped ("<span size='large' weight='bold'>%s</span>", text);
+	gtk_label_set_markup (GTK_LABEL (gtk_builder_get_object (self->pv->builder, "primary-text")), label);
+	g_free (label);
+	
+	g_object_notify (G_OBJECT (self), "primary-text");
+}
+
+const gchar*
+_gcr_import_dialog_get_secondary_text (GcrImportDialog *self)
+{
+	g_return_val_if_fail (GCR_IS_IMPORT_DIALOG (self), NULL);
+	return gtk_label_get_text (GTK_LABEL (gtk_builder_get_object (self->pv->builder, "secondary-text")));
+}
+
+void
+_gcr_import_dialog_set_secondary_text (GcrImportDialog *self, const gchar *text)
+{
+	g_return_if_fail (GCR_IS_IMPORT_DIALOG (self));
+	
+	if (text == NULL)
+		text = "";
+	
+	gtk_label_set_markup (GTK_LABEL (gtk_builder_get_object (self->pv->builder, "secondary-text")), text);
+	g_object_notify (G_OBJECT (self), "primary-text");
+}

Modified: trunk/gcr/gcr-import-dialog.glade
==============================================================================
--- trunk/gcr/gcr-import-dialog.glade	(original)
+++ trunk/gcr/gcr-import-dialog.glade	Wed Jan 21 22:08:17 2009
@@ -1,164 +1,127 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!DOCTYPE glade-interface SYSTEM "glade-2.0.dtd">
-<!--Generated with glade3 3.4.5 on Sat Jan 17 14:53:28 2009 -->
+<!--Generated with glade3 3.4.5 on Wed Jan 21 16:01:29 2009 -->
 <glade-interface>
-  <widget class="GtkDialog" id="dialog1">
-    <property name="border_width">5</property>
-    <property name="window_position">GTK_WIN_POS_CENTER_ON_PARENT</property>
-    <property name="type_hint">GDK_WINDOW_TYPE_HINT_DIALOG</property>
-    <property name="has_separator">False</property>
-    <child internal-child="vbox">
-      <widget class="GtkVBox" id="dialog-vbox1">
+  <widget class="GtkWindow" id="window1">
+    <child>
+      <widget class="GtkVBox" id="import-dialog">
         <property name="visible">True</property>
-        <property name="spacing">2</property>
+        <property name="border_width">6</property>
+        <property name="spacing">6</property>
         <child>
-          <widget class="GtkVBox" id="vbox1">
+          <widget class="GtkHBox" id="hbox2">
             <property name="visible">True</property>
-            <property name="spacing">6</property>
+            <property name="spacing">12</property>
             <child>
-              <widget class="GtkHBox" id="hbox2">
+              <widget class="GtkImage" id="image1">
                 <property name="visible">True</property>
-                <property name="spacing">12</property>
-                <child>
-                  <widget class="GtkImage" id="image1">
-                    <property name="visible">True</property>
-                    <property name="xalign">0</property>
-                    <property name="yalign">1</property>
-                    <property name="stock">gtk-dialog-authentication</property>
-                    <property name="icon_size">6</property>
-                  </widget>
-                  <packing>
-                    <property name="expand">False</property>
-                    <property name="fill">False</property>
-                  </packing>
-                </child>
-                <child>
-                  <widget class="GtkVBox" id="vbox2">
-                    <property name="visible">True</property>
-                    <property name="spacing">6</property>
-                    <child>
-                      <widget class="GtkLabel" id="primary-text">
-                        <property name="visible">True</property>
-                        <property name="xalign">0</property>
-                        <property name="label" translatable="yes">&lt;span size='large' weight='bold'&gt;Import Certificates and Keys&lt;/span&gt;</property>
-                        <property name="use_markup">True</property>
-                      </widget>
-                    </child>
-                    <child>
-                      <widget class="GtkLabel" id="secondary-text">
-                        <property name="visible">True</property>
-                        <property name="xalign">0</property>
-                        <property name="label" translatable="yes">Secondary prompt text</property>
-                      </widget>
-                      <packing>
-                        <property name="position">1</property>
-                      </packing>
-                    </child>
-                  </widget>
-                  <packing>
-                    <property name="position">1</property>
-                  </packing>
-                </child>
+                <property name="xalign">0</property>
+                <property name="yalign">1</property>
+                <property name="stock">gtk-dialog-authentication</property>
+                <property name="icon_size">6</property>
               </widget>
               <packing>
                 <property name="expand">False</property>
+                <property name="fill">False</property>
               </packing>
             </child>
             <child>
-              <widget class="GtkTable" id="table1">
+              <widget class="GtkVBox" id="vbox2">
                 <property name="visible">True</property>
-                <property name="n_rows">2</property>
-                <property name="n_columns">2</property>
-                <property name="column_spacing">12</property>
-                <property name="row_spacing">6</property>
+                <property name="spacing">6</property>
                 <child>
-                  <widget class="GtkEntry" id="password-entry">
-                    <property name="visible">True</property>
-                    <property name="can_focus">True</property>
-                  </widget>
-                  <packing>
-                    <property name="left_attach">1</property>
-                    <property name="right_attach">2</property>
-                    <property name="top_attach">1</property>
-                    <property name="bottom_attach">2</property>
-                  </packing>
-                </child>
-                <child>
-                  <widget class="GtkComboBox" id="location-combo">
-                    <property name="visible">True</property>
-                    <property name="button_sensitivity">GTK_SENSITIVITY_ON</property>
-                  </widget>
-                  <packing>
-                    <property name="left_attach">1</property>
-                    <property name="right_attach">2</property>
-                  </packing>
-                </child>
-                <child>
-                  <widget class="GtkLabel" id="label5">
+                  <widget class="GtkLabel" id="primary-text">
                     <property name="visible">True</property>
                     <property name="xalign">0</property>
-                    <property name="label" translatable="yes">Password:</property>
+                    <property name="label" translatable="yes">&lt;span size='large' weight='bold'&gt;Import Certificates and Keys&lt;/span&gt;</property>
+                    <property name="use_markup">True</property>
+                    <property name="wrap">True</property>
                   </widget>
-                  <packing>
-                    <property name="top_attach">1</property>
-                    <property name="bottom_attach">2</property>
-                    <property name="x_options">GTK_FILL</property>
-                    <property name="y_options">GTK_FILL</property>
-                  </packing>
                 </child>
                 <child>
-                  <widget class="GtkLabel" id="label4">
+                  <widget class="GtkLabel" id="secondary-text">
                     <property name="visible">True</property>
                     <property name="xalign">0</property>
-                    <property name="label" translatable="yes">Import Into:</property>
+                    <property name="wrap">True</property>
                   </widget>
                   <packing>
-                    <property name="x_options">GTK_FILL</property>
-                    <property name="y_options">GTK_FILL</property>
+                    <property name="position">1</property>
                   </packing>
                 </child>
               </widget>
               <packing>
-                <property name="expand">False</property>
                 <property name="position">1</property>
               </packing>
             </child>
           </widget>
           <packing>
-            <property name="position">1</property>
+            <property name="expand">False</property>
           </packing>
         </child>
-        <child internal-child="action_area">
-          <widget class="GtkHButtonBox" id="dialog-action_area1">
+        <child>
+          <widget class="GtkTable" id="table1">
             <property name="visible">True</property>
-            <property name="layout_style">GTK_BUTTONBOX_END</property>
+            <property name="n_rows">2</property>
+            <property name="n_columns">2</property>
+            <property name="column_spacing">12</property>
+            <property name="row_spacing">6</property>
+            <child>
+              <widget class="GtkAlignment" id="password-area">
+                <property name="visible">True</property>
+                <child>
+                  <placeholder/>
+                </child>
+              </widget>
+              <packing>
+                <property name="left_attach">1</property>
+                <property name="right_attach">2</property>
+                <property name="top_attach">1</property>
+                <property name="bottom_attach">2</property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkAlignment" id="slot-area">
+                <property name="visible">True</property>
+                <child>
+                  <widget class="GtkComboBox" id="slot-combo">
+                    <property name="visible">True</property>
+                    <property name="button_sensitivity">GTK_SENSITIVITY_ON</property>
+                  </widget>
+                </child>
+              </widget>
+              <packing>
+                <property name="left_attach">1</property>
+                <property name="right_attach">2</property>
+              </packing>
+            </child>
             <child>
-              <widget class="GtkButton" id="button1">
+              <widget class="GtkLabel" id="password-label">
                 <property name="visible">True</property>
-                <property name="can_focus">True</property>
-                <property name="receives_default">True</property>
-                <property name="label" translatable="yes">gtk-cancel</property>
-                <property name="use_stock">True</property>
-                <property name="response_id">0</property>
+                <property name="xalign">0</property>
+                <property name="label" translatable="yes">Password:</property>
               </widget>
+              <packing>
+                <property name="top_attach">1</property>
+                <property name="bottom_attach">2</property>
+                <property name="x_options">GTK_FILL</property>
+                <property name="y_options">GTK_FILL</property>
+              </packing>
             </child>
             <child>
-              <widget class="GtkButton" id="button2">
+              <widget class="GtkLabel" id="slot-label">
                 <property name="visible">True</property>
-                <property name="can_focus">True</property>
-                <property name="receives_default">True</property>
-                <property name="label" translatable="yes">gtk-ok</property>
-                <property name="use_stock">True</property>
-                <property name="response_id">0</property>
+                <property name="xalign">0</property>
+                <property name="label" translatable="yes">Import Into:</property>
               </widget>
               <packing>
-                <property name="position">1</property>
+                <property name="x_options">GTK_FILL</property>
+                <property name="y_options">GTK_FILL</property>
               </packing>
             </child>
           </widget>
           <packing>
             <property name="expand">False</property>
-            <property name="pack_type">GTK_PACK_END</property>
+            <property name="position">1</property>
           </packing>
         </child>
       </widget>

Added: trunk/gcr/gcr-import-dialog.h
==============================================================================
--- (empty file)
+++ trunk/gcr/gcr-import-dialog.h	Wed Jan 21 22:08:17 2009
@@ -0,0 +1,86 @@
+/* 
+ * gnome-keyring
+ * 
+ * Copyright (C) 2008 Stefan Walter
+ * 
+ * This program is free software; you can redistribute it and/or modify 
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *  
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *  
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.  
+ */
+
+#ifndef __GCR_IMPORT_DIALOG_H__
+#define __GCR_IMPORT_DIALOG_H__
+
+#include "gcr.h"
+
+#include "gp11/gp11.h"
+
+#include <gtk/gtk.h>
+
+#define GCR_TYPE_IMPORT_DIALOG               (_gcr_import_dialog_get_type ())
+#define GCR_IMPORT_DIALOG(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GCR_TYPE_IMPORT_DIALOG, GcrImportDialog))
+#define GCR_IMPORT_DIALOG_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), GCR_TYPE_IMPORT_DIALOG, GcrImportDialogClass))
+#define GCR_IS_IMPORT_DIALOG(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GCR_TYPE_IMPORT_DIALOG))
+#define GCR_IS_IMPORT_DIALOG_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), GCR_TYPE_IMPORT_DIALOG))
+#define GCR_IMPORT_DIALOG_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), GCR_TYPE_IMPORT_DIALOG, GcrImportDialogClass))
+
+typedef struct _GcrImportDialog GcrImportDialog;
+typedef struct _GcrImportDialogClass GcrImportDialogClass;
+typedef struct _GcrImportDialogPrivate GcrImportDialogPrivate;
+
+struct _GcrImportDialog {
+	GtkDialog parent;
+	GcrImportDialogPrivate *pv;
+};
+
+struct _GcrImportDialogClass {
+	GtkDialogClass parent_class;
+};
+
+GType               _gcr_import_dialog_get_type               (void);
+
+GcrImportDialog*    _gcr_import_dialog_new                    (void);
+
+gboolean            _gcr_import_dialog_run                    (GcrImportDialog *self,
+                                                               GtkWindow *parent);
+
+GP11Slot*           _gcr_import_dialog_get_selected_slot      (GcrImportDialog *self);
+
+void                _gcr_import_dialog_set_selected_slot      (GcrImportDialog *self,
+                                                               GP11Slot *slot);
+
+void                _gcr_import_dialog_show_selected_slot     (GcrImportDialog *self);
+
+void                _gcr_import_dialog_hide_selected_slot     (GcrImportDialog *self);
+
+const gchar*        _gcr_import_dialog_get_password           (GcrImportDialog *self);
+
+void                _gcr_import_dialog_set_password           (GcrImportDialog *self,
+                                                               const gchar *password);
+
+void                _gcr_import_dialog_show_password          (GcrImportDialog *self);
+
+void                _gcr_import_dialog_hide_password          (GcrImportDialog *self);
+
+const gchar*        _gcr_import_dialog_get_primary_text       (GcrImportDialog *self);
+
+void                _gcr_import_dialog_set_primary_text       (GcrImportDialog *self,
+                                                               const gchar *text);
+
+const gchar*        _gcr_import_dialog_get_secondary_text     (GcrImportDialog *self);
+
+void                _gcr_import_dialog_set_secondary_text     (GcrImportDialog *self,
+                                                               const gchar *text);
+
+#endif /* __GCR_IMPORT_DIALOG_H__ */

Modified: trunk/gcr/gcr-importer.c
==============================================================================
--- trunk/gcr/gcr-importer.c	(original)
+++ trunk/gcr/gcr-importer.c	Wed Jan 21 22:08:17 2009
@@ -21,38 +21,545 @@
 
 #include "config.h"
 
+#include "gcr-import-dialog.h"
 #include "gcr-importer.h"
+#include "gcr-internal.h"
+#include "gcr-parser.h"
+
+#include <glib/gi18n-lib.h>
 
 enum {
 	PROP_0,
-	PROP_IMPORTER
+	PROP_SLOT,
+	PROP_PARSER,
+	PROP_PROMPT_BEHAVIOR
 };
 
 enum {
-	SIGNAL,
+	IMPORTED,
 	LAST_SIGNAL
 };
 
 static guint signals[LAST_SIGNAL] = { 0 };
 
-G_DEFINE_TYPE (GcrImporter, gcr_importer, G_TYPE_OBJECT);
+struct _GcrImporterPrivate {
+	GP11Slot *slot;
+	GcrParser *parser;
+	GcrImporterPromptBehavior behavior;
+	
+	/* Information about last import */
+	GError *error;
+	gboolean succeeded;
+	
+	/* State data during import */
+	gboolean processing;
+	GCancellable *cancel;
+	GInputStream *input;
+	gboolean prompted;
+	gboolean async;
+	GByteArray *buffer;
+	GP11Session *session;
+	GQueue queue;
+	
+	/* Extra async stuff */
+	GAsyncReadyCallback callback;
+	gpointer user_data;
+};
+
+/* State forward declarations */
+static void state_cancelled (GcrImporter *self, gboolean async);
+static void state_complete (GcrImporter *self, gboolean async);
+static void state_create_object (GcrImporter *self, gboolean async);
+static void state_open_session (GcrImporter *self, gboolean async);
+static void state_parse_buffer (GcrImporter *self, gboolean async);
+static void state_read_buffer (GcrImporter *self, gboolean async);
+
+static void gcr_importer_async_result (GAsyncResultIface *iface);
+G_DEFINE_TYPE_WITH_CODE (GcrImporter, gcr_importer, G_TYPE_OBJECT,
+                         G_IMPLEMENT_INTERFACE (G_TYPE_ASYNC_RESULT, gcr_importer_async_result));
+
+#define BLOCK 4096
 
 /* -----------------------------------------------------------------------------
  * INTERNAL 
  */
 
+static void
+cleanup_state_data (GcrImporter *self)
+{
+	GP11Attributes *attrs;
+	
+	if (self->pv->buffer)
+		g_byte_array_free (self->pv->buffer, TRUE);
+	self->pv->buffer = NULL;
+	
+	if (self->pv->session)
+		g_object_unref (self->pv->session);
+	self->pv->session = NULL;
+	
+	while ((attrs = g_queue_pop_head (&self->pv->queue)) != NULL)
+		gp11_attributes_unref (attrs);
+	g_assert (g_queue_is_empty (&self->pv->queue));
+	
+	if (self->pv->input)
+		g_object_unref (self->pv->input);
+	self->pv->input = NULL;
+	
+	if (self->pv->cancel)
+		g_object_unref (self->pv->cancel);
+	self->pv->cancel = NULL;
+}
+
+static void
+cleanup_import_data (GcrImporter *self)
+{
+	if (self->pv->error)
+		g_clear_error (&self->pv->error);
+	self->pv->succeeded = TRUE;
+}
+
+static void
+next_state (GcrImporter *self, void (*state) (GcrImporter*, gboolean))
+{
+	g_assert (GCR_IS_IMPORTER (self));
+	g_assert (self->pv->processing);
+	g_assert (state);
+	
+	if (self->pv->cancel && g_cancellable_is_cancelled (self->pv->cancel))
+		state = state_cancelled;
+	
+	(state) (self, self->pv->async);
+}
+
+/* ---------------------------------------------------------------------------------
+ * COMPLETE
+ */
+
+static void
+state_complete (GcrImporter *self, gboolean async)
+{
+	if (async && self->pv->callback != NULL)
+		(self->pv->callback) (G_OBJECT (self), G_ASYNC_RESULT (self), self->pv->user_data);
+	
+	cleanup_state_data (self);
+	self->pv->processing = FALSE;
+}
+
+static void
+state_failure (GcrImporter *self, gboolean async)
+{
+	self->pv->succeeded = FALSE;
+	next_state (self, state_complete);
+}
+
+static void
+state_cancelled (GcrImporter *self, gboolean async)
+{
+	if (self->pv->cancel && g_cancellable_is_cancelled (self->pv->cancel))
+		g_cancellable_cancel (self->pv->cancel);
+	if (self->pv->error)
+		g_error_free (self->pv->error);
+	self->pv->error = g_error_new_literal (GCR_DATA_ERROR, GCR_ERROR_CANCELLED, _("The operation was cancelled"));
+	next_state (self, state_failure);
+}
+
+/* ---------------------------------------------------------------------------------
+ * CREATE OBJECTS
+ */
+
+static void
+complete_create_object (GcrImporter *self, GP11Object *object, GError *error)
+{
+	if (object == NULL) {
+		g_propagate_error (&self->pv->error, error);
+		next_state (self, state_failure);
+		
+	} else {
+		g_signal_emit (self, signals[IMPORTED], 0, object);
+		g_object_unref (object);
+		next_state (self, state_create_object);
+	}
+}
+
+static void
+on_create_object (GObject *obj, GAsyncResult *res, gpointer user_data)
+{
+	GError *error = NULL;
+	GP11Object *object = gp11_session_create_object_finish (GP11_SESSION (obj), res, &error);
+	complete_create_object (GCR_IMPORTER (user_data), object, error);
+}
+
+static void
+state_create_object (GcrImporter *self, gboolean async)
+{
+	GP11Attributes *attrs;
+	GP11Object *object;
+	GError *error = NULL;
+	
+	/* No more objects */
+	if (g_queue_is_empty (&self->pv->queue)) {
+		next_state (self, state_complete);
+		
+	} else {
+		
+		/* Pop first one off the list */
+		attrs = g_queue_pop_head (&self->pv->queue);
+		g_assert (attrs);
+		
+		gp11_attributes_add_ulong (attrs, CKA_TOKEN, CK_TRUE);
+		
+		if (async) {
+			gp11_session_create_object_async (self->pv->session, attrs, self->pv->cancel, 
+			                                  on_create_object, self);
+		} else {
+			object = gp11_session_create_object_full (self->pv->session, attrs, self->pv->cancel, &error);
+			complete_create_object (self, object, error);
+		}
+	
+		gp11_attributes_unref (attrs);
+	}
+}
+
+/* ---------------------------------------------------------------------------------
+ * OPEN SESSION
+ */
+
+static void
+complete_open_session (GcrImporter *self, GP11Session *session, GError *error)
+{
+	if (!session) {
+		g_propagate_error (&self->pv->error, error);
+		next_state (self, state_failure);
+	} else {
+		self->pv->session = session;
+		next_state (self, state_create_object);
+	}
+}
+
+static void
+on_open_session (GObject *obj, GAsyncResult *res, gpointer user_data)
+{
+	GError *error = NULL;
+	GP11Session *session = gp11_slot_open_session_finish (GP11_SLOT (obj), res, &error);
+	complete_open_session (GCR_IMPORTER (user_data), session, error);
+}
+
+static void
+state_open_session (GcrImporter *self, gboolean async)
+{
+	GP11Session *session;
+	GError *error = NULL;
+	
+	if (!self->pv->slot) {
+		g_set_error (&self->pv->error, GCR_DATA_ERROR, GCR_ERROR_FAILURE, _("No location available to import to"));
+		next_state (self, state_failure);
+		
+	} else {
+		
+		if (async) {
+			gp11_slot_open_session_async (self->pv->slot, CKF_RW_SESSION, 
+			                              self->pv->cancel, on_open_session, self);
+		} else {
+			session = gp11_slot_open_session_full (self->pv->slot, CKF_RW_SESSION, 
+			                                       self->pv->cancel, &error);
+			complete_open_session (self, session, error);
+		}
+	}
+}
+
+/* ---------------------------------------------------------------------------------
+ * IMPORT PROMPT
+ */
+
+static void
+complete_import_prompt (GcrImporter *self, GcrImportDialog *dialog, gint response)
+{
+	GP11Slot *slot;
+
+	gtk_widget_hide (GTK_WIDGET (dialog));
+	self->pv->prompted = TRUE;
+
+	/* No dialog or dialog completed */
+	if (response == GTK_RESPONSE_OK) {
+
+		slot = _gcr_import_dialog_get_selected_slot (dialog);
+		gcr_importer_set_slot (self, slot);
+		next_state (self, state_open_session);
+		
+	/* The dialog was cancelled or closed */
+	} else {
+		next_state (self, state_cancelled);
+	}
+}
+
+static void
+on_prompt_response (GtkDialog *dialog, gint response, gpointer user_data)
+{
+	complete_import_prompt (GCR_IMPORTER (user_data), GCR_IMPORT_DIALOG (dialog), response);
+	g_object_unref (dialog);
+}
+
+static void 
+state_import_prompt (GcrImporter *self, gboolean async)
+{
+	GcrImportDialog *dialog;
+	gboolean prompt;
+	gint response;
+	
+	g_assert (GCR_IS_IMPORTER (self));
+	
+	/* No need to prompt */
+	if (self->pv->prompted == TRUE)
+		prompt = FALSE;
+	else if (self->pv->behavior == GCR_IMPORTER_PROMPT_ALWAYS)
+		prompt = TRUE;
+	else if (self->pv->behavior == GCR_IMPORTER_PROMPT_NEVER)
+		prompt = FALSE;
+	else 
+		prompt = self->pv->slot ? FALSE : TRUE;
+	
+	if (prompt == FALSE) {
+		next_state (self, state_open_session);
+		
+	} else {
+		
+		dialog = _gcr_import_dialog_new ();
+
+		_gcr_import_dialog_set_primary_text (dialog, _("Import Certificates/Keys"));
+		_gcr_import_dialog_hide_password (dialog);
+		
+		if (self->pv->slot) {
+			_gcr_import_dialog_set_selected_slot (dialog, self->pv->slot);
+			_gcr_import_dialog_hide_selected_slot (dialog);
+		} else {
+			_gcr_import_dialog_set_secondary_text (dialog, _("Choose a location to store the imported certificates/keys."));
+		}
+			
+		/* Prompt without blocking main loop */
+		if (async) {
+			g_signal_connect (dialog, "response", G_CALLBACK (on_prompt_response), self);
+			gtk_widget_show (GTK_WIDGET (dialog));
+			
+		/* Block mainloop */
+		} else {
+			response = gtk_dialog_run (GTK_DIALOG (dialog));
+			complete_import_prompt (self, dialog, response);
+			g_object_unref (dialog);
+		}
+	}
+}
+
+/* ---------------------------------------------------------------------------------
+ * PARSING
+ */
+
+static const gchar*
+prepare_auth_primary (CK_OBJECT_CLASS klass)
+{
+	if (klass == CKO_PRIVATE_KEY)
+		return _("Enter password to unlock the private key");
+	else if (klass == CKO_CERTIFICATE)
+		return _("Enter password to unlock the certificate");
+	else 
+		return _("Enter password to unlock");
+}
+
+static gchar*
+prepare_auth_secondary (CK_OBJECT_CLASS klass, const gchar *label)
+{
+	if (label == NULL) {
+		if (klass == CKO_PRIVATE_KEY)
+			return g_strdup (_("In order to import the private key, it must be unlocked"));
+		else if (klass == CKO_CERTIFICATE)
+			return g_strdup (_("In order to import the certificate, it must be unlocked"));
+		else 
+			return g_strdup (_("In order to import the data, it must be unlocked"));
+	} else {
+		if (klass == CKO_PRIVATE_KEY)
+			return g_strdup_printf (_("In order to import the private key '%s', it must be unlocked"), label);
+		else if (klass == CKO_CERTIFICATE)
+			return g_strdup_printf (_("In order to import the certificate '%s', it must be unlocked"), label);
+		else 
+			return g_strdup_printf (_("In order to import '%s', it must be unlocked"), label);
+	}
+}
+
+static void
+on_parser_parsed (GcrParser *parser, GcrImporter *self)
+{
+	GP11Attributes *attrs;
+	
+	g_return_if_fail (GCR_IS_PARSER (parser));
+	g_return_if_fail (GCR_IS_IMPORTER (self));
+	
+	attrs = gcr_parser_get_parsed_attributes (parser);
+	g_return_if_fail (attrs);
+	g_queue_push_tail (&self->pv->queue, gp11_attributes_ref (attrs));
+}
+
+static gboolean
+on_parser_authenticate (GcrParser *parser, gint count, GcrImporter *self)
+{
+	GcrImportDialog *dialog;
+	GP11Attributes *attrs;
+	const gchar *password;
+	gchar *text, *label;
+	GP11Slot *slot;
+	gulong klass;
+	
+	dialog = _gcr_import_dialog_new ();
+	
+	if (self->pv->slot)
+		_gcr_import_dialog_set_selected_slot (dialog, self->pv->slot);
+	
+	/* Figure out the text for the dialog */
+	attrs = gcr_parser_get_parsed_attributes (parser);
+	g_return_val_if_fail (attrs, FALSE);
+	
+	if (!gp11_attributes_find_ulong (attrs, CKA_CLASS, &klass))
+		klass = (gulong)-1;
+	if (!gp11_attributes_find_string (attrs, CKA_LABEL, &label))
+		label = NULL;
+	
+	text = prepare_auth_secondary (klass, label);
+	_gcr_import_dialog_set_primary_text (dialog, prepare_auth_primary (klass));
+	_gcr_import_dialog_set_secondary_text (dialog, text);
+	g_free (label);
+	g_free (text);
+	
+	if (!_gcr_import_dialog_run (dialog, NULL))
+		return FALSE;
+
+	slot = _gcr_import_dialog_get_selected_slot (dialog);
+	gcr_importer_set_slot (self, slot);
+	
+	password = _gcr_import_dialog_get_password (dialog);
+	gcr_parser_add_password (parser, password);
+	
+	g_object_unref (dialog);
+	self->pv->prompted = TRUE;
+	return TRUE;
+}
+
+static void 
+state_parse_buffer (GcrImporter *self, gboolean async)
+{
+	GError *error = NULL;
+	GcrParser *parser;
+	gulong parsed_conn;
+	gulong auth_conn;
+	gboolean ret;
+	
+	g_assert (GCR_IS_IMPORTER (self));
+	g_assert (self->pv->buffer);
+	
+	parser = gcr_importer_get_parser (self);
+	g_object_ref (parser);
+
+	/* Listen in to the parser */
+	parsed_conn = g_signal_connect (parser, "parsed", G_CALLBACK (on_parser_parsed), self);
+	auth_conn = g_signal_connect (parser, "authenticate", G_CALLBACK (on_parser_authenticate), self);
+
+	ret = gcr_parser_parse_data (parser, self->pv->buffer->data, self->pv->buffer->len, &error);
+	
+	/* An optimization to free data early as possible */
+	g_byte_array_free (self->pv->buffer, TRUE);
+	self->pv->buffer = NULL;
+	
+	g_signal_handler_disconnect (parser, parsed_conn);
+	g_signal_handler_disconnect (parser, auth_conn);
+	g_object_unref (parser);
+	
+	if (ret == TRUE) {
+		next_state (self, state_import_prompt);
+	} else {
+		g_propagate_error (&self->pv->error, error);
+		next_state (self, state_failure);
+	}
+}
+
+/* ---------------------------------------------------------------------------------
+ * BUFFER READING
+ */
+
+static void
+complete_read_buffer (GcrImporter *self, gssize count, GError *error)
+{
+	g_assert (GCR_IS_IMPORTER (self));
+	g_assert (self->pv->buffer);
+	
+	/* A failure */
+	if (count == -1) {
+		g_propagate_error (&self->pv->error, error);
+		next_state (self, state_failure);
+	} else {
+	
+		g_return_if_fail (count >= 0 && count <= BLOCK);
+		g_byte_array_set_size (self->pv->buffer, self->pv->buffer->len - (BLOCK - count));
+		
+		/* Finished reading */
+		if (count == 0) {
+			
+			/* Optimization, unref input early */
+			g_object_unref (self->pv->input);
+			self->pv->input = NULL;
+			
+			next_state (self, state_parse_buffer);
+			
+		/* Read the next block */
+		} else {
+			next_state (self, state_read_buffer);
+		}
+	}
+	
+}
+
+static void
+on_read_buffer (GObject *obj, GAsyncResult *res, gpointer user_data)
+{
+	GError *error = NULL;
+	gssize count;
+	
+	count = g_input_stream_read_finish (G_INPUT_STREAM (obj), res, &error);
+	complete_read_buffer (user_data, count, error);
+}
+
+static void 
+state_read_buffer (GcrImporter *self, gboolean async)
+{
+	GError *error = NULL;
+	gssize count;
+	gsize at;
+	
+	g_assert (GCR_IS_IMPORTER (self));
+	g_assert (G_IS_INPUT_STREAM (self->pv->input));
+	
+	if (!self->pv->buffer)
+		self->pv->buffer = g_byte_array_sized_new (BLOCK);
+
+	at = self->pv->buffer->len;
+	g_byte_array_set_size (self->pv->buffer, at + BLOCK);
+	
+	if (async) {
+		g_input_stream_read_async (self->pv->input, self->pv->buffer->data + at, 
+		                           BLOCK, G_PRIORITY_DEFAULT, self->pv->cancel,
+		                           on_read_buffer, self);
+	} else {
+		count = g_input_stream_read (self->pv->input, self->pv->buffer->data + at, 
+		                             BLOCK, self->pv->cancel, &error);
+		complete_read_buffer (self, count, error);
+	}
+}
+
 /* -----------------------------------------------------------------------------
  * OBJECT 
  */
 
-
 static GObject* 
 gcr_importer_constructor (GType type, guint n_props, GObjectConstructParam *props) 
 {
 	GcrImporter *self = GCR_IMPORTER (G_OBJECT_CLASS (gcr_importer_parent_class)->constructor(type, n_props, props));
 	g_return_val_if_fail (self, NULL);	
-
-
 	
 	return G_OBJECT (self);
 }
@@ -60,14 +567,27 @@
 static void
 gcr_importer_init (GcrImporter *self)
 {
-
+	self->pv = G_TYPE_INSTANCE_GET_PRIVATE (self, GCR_TYPE_IMPORTER, GcrImporterPrivate);
+	self->pv->behavior = GCR_IMPORTER_PROMPT_NEEDED;
+	g_queue_init (&self->pv->queue);
 }
 
 static void
 gcr_importer_dispose (GObject *obj)
 {
 	GcrImporter *self = GCR_IMPORTER (obj);
-    
+	
+	cleanup_state_data (self);
+	cleanup_import_data (self);
+	
+	if (self->pv->parser)
+		g_object_unref (self->pv->parser);
+	self->pv->parser = NULL;
+	
+	if (self->pv->slot)
+		g_object_unref (self->pv->slot);
+	self->pv->slot = NULL;
+
 	G_OBJECT_CLASS (gcr_importer_parent_class)->dispose (obj);
 }
 
@@ -75,7 +595,10 @@
 gcr_importer_finalize (GObject *obj)
 {
 	GcrImporter *self = GCR_IMPORTER (obj);
-
+	
+	g_assert (!self->pv->parser);
+	g_assert (!self->pv->slot);
+	
 	G_OBJECT_CLASS (gcr_importer_parent_class)->finalize (obj);
 }
 
@@ -86,7 +609,14 @@
 	GcrImporter *self = GCR_IMPORTER (obj);
 	
 	switch (prop_id) {
-	case PROP_IMPORTER:
+	case PROP_PARSER:
+		gcr_importer_set_parser (self, g_value_get_object (value));
+		break;
+	case PROP_SLOT:
+		gcr_importer_set_slot (self, g_value_get_object (value));
+		break;
+	case PROP_PROMPT_BEHAVIOR:
+		gcr_importer_set_prompt_behavior (self, (GcrImporterPromptBehavior)g_value_get_int (value));
 		break;
 	default:
 		G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
@@ -101,7 +631,14 @@
 	GcrImporter *self = GCR_IMPORTER (obj);
 	
 	switch (prop_id) {
-	case PROP_IMPORTER:
+	case PROP_PARSER:
+		g_value_set_object (value, gcr_importer_get_parser (self));
+		break;
+	case PROP_SLOT:
+		g_value_set_object (value, gcr_importer_get_slot (self));
+		break;
+	case PROP_PROMPT_BEHAVIOR:
+		g_value_set_int (value, gcr_importer_get_prompt_behavior (self));
 		break;
 	default:
 		G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
@@ -120,17 +657,49 @@
 	gobject_class->set_property = gcr_importer_set_property;
 	gobject_class->get_property = gcr_importer_get_property;
     
-	g_object_class_install_property (gobject_class, PROP_IMPORTER,
-	           g_param_spec_pointer ("importer", "Importer", "Importer.", G_PARAM_READWRITE));
-    
-	signals[SIGNAL] = g_signal_new ("signal", GCR_TYPE_IMPORTER, 
-	                                G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GcrImporterClass, signal),
+	g_type_class_add_private (gobject_class, sizeof (GcrImporterPrivate));
+	
+	g_object_class_install_property (gobject_class, PROP_PARSER,
+	           g_param_spec_object ("parser", "Parser", "Parser used to parse imported data",
+	                                GCR_TYPE_PARSER, G_PARAM_READWRITE));
+	
+	g_object_class_install_property (gobject_class, PROP_PARSER,
+	           g_param_spec_object ("slot", "Slot", "PKCS#11 slot to import data into",
+	                                GP11_TYPE_SLOT, G_PARAM_READWRITE));
+	
+	g_object_class_install_property (gobject_class, PROP_PROMPT_BEHAVIOR,
+	           g_param_spec_int ("prompt-behavior", "Prompt Behavior", "Import Prompt Behavior",
+	                             0, G_MAXINT, GCR_IMPORTER_PROMPT_NEEDED, G_PARAM_READWRITE));
+	
+	signals[IMPORTED] = g_signal_new ("imported", GCR_TYPE_IMPORTER, 
+	                                G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GcrImporterClass, imported),
 	                                NULL, NULL, g_cclosure_marshal_VOID__OBJECT, 
-	                                G_TYPE_NONE, 0);
+	                                G_TYPE_NONE, 1, GP11_TYPE_OBJECT);
 	
 	_gcr_initialize ();
 }
 
+static gpointer
+gcr_importer_real_get_user_data (GAsyncResult *base)
+{
+	g_return_val_if_fail (GCR_IS_IMPORTER (base), NULL);
+	return GCR_IMPORTER (base)->pv->user_data;
+}
+
+static GObject* 
+gcr_importer_real_get_source_object (GAsyncResult *base)
+{
+	g_return_val_if_fail (GCR_IS_IMPORTER (base), NULL);
+	return G_OBJECT (base);
+}
+
+static void 
+gcr_importer_async_result (GAsyncResultIface *iface)
+{
+	iface->get_source_object = gcr_importer_real_get_source_object;
+	iface->get_user_data = gcr_importer_real_get_user_data;
+}
+
 /* -----------------------------------------------------------------------------
  * PUBLIC 
  */
@@ -141,73 +710,133 @@
 	return g_object_new (GCR_TYPE_IMPORTER, NULL);
 }
 
-gboolean
-gcr_importer_import_data (GcrImporter *self, const guchar *data, gsize n_data, 
-                          GError *err)
+GcrParser*
+gcr_importer_get_parser (GcrImporter *self)
 {
-	GckParser *parser;
-	gulong parsed_conn;
-	gulong auth_conn;
-	gboolean ret;
+	g_return_val_if_fail (GCR_IS_IMPORTER (self), NULL);
+	if (!self->pv->parser) 
+		self->pv->parser = gcr_parser_new ();
+	return self->pv->parser;
+}
+
+void
+gcr_importer_set_parser (GcrImporter *self, GcrParser *parser)
+{
+	g_return_if_fail (GCR_IS_IMPORTER (self));
+	
+	if (parser)
+		g_object_ref (parser);
+	if (self->pv->parser)
+		g_object_unref (self->pv->parser);
+	self->pv->parser = parser;
+	g_object_notify (G_OBJECT (self), "parser");
+}
+
+GP11Slot*
+gcr_importer_get_slot (GcrImporter *self)
+{
+	g_return_val_if_fail (GCR_IS_IMPORTER (self), NULL);
+	return self->pv->slot;
+}
+
+void 
+gcr_importer_set_slot (GcrImporter *self, GP11Slot *slot)
+{
+	g_return_if_fail (GCR_IS_IMPORTER (self));
 	
+	if (slot)
+		g_object_ref (slot);
+	if (self->pv->slot)
+		g_object_unref (self->pv->slot);
+	self->pv->slot = slot;
+	g_object_notify (G_OBJECT (self), "slot");
+}
+
+GcrImporterPromptBehavior
+gcr_importer_get_prompt_behavior (GcrImporter *self)
+{
+	g_return_val_if_fail (GCR_IS_IMPORTER (self), GCR_IMPORTER_PROMPT_NEEDED);
+	return self->pv->behavior;
+}
+
+void
+gcr_importer_set_prompt_behavior (GcrImporter *self, GcrImporterPromptBehavior behavior)
+{
+	g_return_if_fail (GCR_IMPORTER (self));
+	self->pv->behavior = behavior;
+	g_object_notify (G_OBJECT (self), "prompt-behavior");
+}
+
+gboolean
+gcr_importer_import (GcrImporter *self, GInputStream *input,
+                     GCancellable *cancel, GError **error)
+{
 	g_return_val_if_fail (GCR_IS_IMPORTER (self), FALSE);
-	g_return_val_if_fail (data || !n_data, FALSE);
+	g_return_val_if_fail (G_IS_INPUT_STREAM (input), FALSE);
 	g_return_val_if_fail (!error || !*error, FALSE);
+	g_return_val_if_fail (!self->pv->processing, FALSE);
 	
+	cleanup_import_data (self);
 	
-	xxxx;
-	
-	
-	/* 
-	 * Parse to see if it's something that needs a password
-	 *   if we can't prompt, 
-	 *     return an error
-	 * Possibly prompt, if password needed, with all information necessary
-	 *   
-	 */
-	
-	
-	g_object_ref (self);
-	
-	parser = gcr_importer_get_parser (self);
-	
-	/* Listen in to the parser */
-	g_object_ref (parser);
-	parsed_conn = g_signal_connect (parser, "parsed-item", G_CALLBACK (parser_parsed_item), self);
-	auth_conn = g_signal_connect (parser, "authenticate", G_CALLBACK (parser_authenticate), self);
+	self->pv->input = g_object_ref (input);
+	if (cancel)
+		self->pv->cancel = g_object_ref (cancel);
+	self->pv->processing = TRUE;
+	self->pv->async = FALSE;
 	
-	/* Feed the parser the data */
-	ret = gcr_parser_parse_data (parser, data, n_data, err);
+	next_state (self, state_read_buffer);
 	
-	/* Now we should have all the data ready, check if we should prompt... */
-	/* Import data one by one into module */
+	g_assert (!self->pv->processing);
+	g_assert (!self->pv->input);
+	g_assert (!self->pv->cancel);
 	
-	g_signal_handler_disconnect (parser, parsed_conn);
-	g_signal_handler_disconnect (parser, auth_conn);
-	g_object_unref (parser);
+	if (!self->pv->succeeded) {
+		g_propagate_error (error, self->pv->error);
+		self->pv->error = NULL;
+		return FALSE;
+	}
 	
-	g_object_unref (self);
+	return TRUE;
+}
+
+void
+gcr_importer_import_async (GcrImporter *self, GInputStream *input, GCancellable *cancel,
+                           GAsyncReadyCallback callback, gpointer user_data)
+{
+	g_return_if_fail (GCR_IS_IMPORTER (self));
+	g_return_if_fail (G_IS_INPUT_STREAM (input));
+	g_return_if_fail (!self->pv->processing);
+	
+	cleanup_import_data (self);
+	
+	self->pv->input = g_object_ref (input);
+	if (cancel)
+		self->pv->cancel = g_object_ref (cancel);
+	self->pv->processing = TRUE;
+	self->pv->async = TRUE;
+	self->pv->callback = callback;
+	self->pv->user_data = user_data;
 	
-	return ret;
+	next_state (self, state_read_buffer);
+	g_assert (self->pv->processing);
 }
 
 gboolean
-gcr_importer_import_file (GcrImporter *self, const gchar *filename, 
-                          GError *err)
+gcr_importer_import_finish (GcrImporter *self, GAsyncResult *res, GError **error)
 {
-	gboolean ret;
-	gchar *data;
-	gsize n_data;
-	
 	g_return_val_if_fail (GCR_IS_IMPORTER (self), FALSE);
-	g_return_val_if_fail (filename, FALSE);
+	g_return_val_if_fail (GCR_IMPORTER (res) == self, FALSE);
 	g_return_val_if_fail (!error || !*error, FALSE);
+	g_return_val_if_fail (!self->pv->processing, FALSE);
+
+	g_assert (!self->pv->input);
+	g_assert (!self->pv->cancel);
 	
-	if (!g_file_get_contents (filename, &data, &n_data, err))
+	if (!self->pv->succeeded) {
+		g_propagate_error (error, self->pv->error);
+		self->pv->error = NULL;
 		return FALSE;
+	}
 	
-	ret = gcr_importer_import_data (self, (const guchar*)data, n_data, error);
-	g_free (data);
-	
-	return ret;
+	return TRUE;
 }

Modified: trunk/gcr/gcr-importer.h
==============================================================================
--- trunk/gcr/gcr-importer.h	(original)
+++ trunk/gcr/gcr-importer.h	Wed Jan 21 22:08:17 2009
@@ -22,8 +22,17 @@
 #ifndef __GCR_IMPORTER_H__
 #define __GCR_IMPORTER_H__
 
+#include "gcr.h"
+#include "gcr-parser.h"
+
 #include <glib-object.h>
 
+typedef enum {
+	GCR_IMPORTER_PROMPT_NEEDED,
+	GCR_IMPORTER_PROMPT_ALWAYS,
+	GCR_IMPORTER_PROMPT_NEVER
+} GcrImporterPromptBehavior;
+
 #define GCR_TYPE_IMPORTER               (gcr_importer_get_type ())
 #define GCR_IMPORTER(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GCR_TYPE_IMPORTER, GcrImporter))
 #define GCR_IMPORTER_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), GCR_TYPE_IMPORTER, GcrImporterClass))
@@ -33,49 +42,53 @@
 
 typedef struct _GcrImporter GcrImporter;
 typedef struct _GcrImporterClass GcrImporterClass;
+typedef struct _GcrImporterPrivate GcrImporterPrivate;
 
 struct _GcrImporter {
 	GObject parent;
+	GcrImporterPrivate *pv;
 };
 
 struct _GcrImporterClass {
 	GObjectClass parent_class;
-    
-	/* signals --------------------------------------------------------- */
-    
-	void (*signal) (GcrImporter *self, GkrImportedItem *item);
+	
+	/* signals */
+	
+	void (*imported) (GcrImporter *self, GP11Object *object);
 };
 
-GType               gcr_importer_get_type               (void);
+GType                     gcr_importer_get_type               (void);
 
-GcrImporter*        gcr_importer_new                    (void);
+GcrImporter*              gcr_importer_new                    (void);
 
-GcrImporter*        gcr_importer_new_for_module         (GP11Module *module);
+GcrParser*                gcr_importer_get_parser             (GcrImporter *self);
 
-GcrImporter*        gcr_importer_new_for_module_funcs   (gpointer pkcs11_funcs);
+void                      gcr_importer_set_parser             (GcrImporter *self,
+                                                               GcrParser *parser);
 
-void                gcr_importer_set_slot               (GcrImporter *self,
-                                                         GP11Slot *slot);
+struct _GP11Slot*         gcr_importer_get_slot               (GcrImporter *self);
 
-void                gcr_importer_set_slot_id            (GcrImporter *self,
-                                                         gulong slot_id);
+void                      gcr_importer_set_slot               (GcrImporter *self,
+                                                               struct _GP11Slot *slot);
 
-void                gcr_importer_set_parser             (GcrImporter *self,
-                                                         GcrParser *parser);
+GcrImporterPromptBehavior gcr_importer_get_prompt_behavior    (GcrImporter *self);
 
-void                gcr_importer_set_window             (GcrImporter *self,
-                                                         GtkWindow *window);
+void                      gcr_importer_set_prompt_behavior    (GcrImporter *self,
+                                                               GcrImporterPromptBehavior behavior);
 
-void                gcr_importer_set_prompt_behavior    (GcrImporter *self,
-                                                         GcrImporterPromptBehavior behavior);
+gboolean                  gcr_importer_import                 (GcrImporter *self,
+                                                               GInputStream *input,
+                                                               GCancellable *cancel,
+                                                               GError **error);
 
-gboolean            gcr_importer_import_data            (GcrImporter *self,
-                                                         const guchar *data,
-                                                         gsize n_data,
-                                                         GError *error);
+void                      gcr_importer_import_async           (GcrImporter *self,
+                                                               GInputStream *input,
+                                                               GCancellable *cancel,
+                                                               GAsyncReadyCallback callback,
+                                                               gpointer user_data);
 
-gboolean            gcr_importer_import_file            (GcrImporter *self,
-                                                         const gchar *filename,
-                                                         GError *error);
+gboolean                  gcr_importer_import_finish          (GcrImporter *self,
+                                                               GAsyncResult *res,
+                                                               GError **error);
 
 #endif /* __GCR_IMPORTER_H__ */

Modified: trunk/gcr/gcr-internal.h
==============================================================================
--- trunk/gcr/gcr-internal.h	(original)
+++ trunk/gcr/gcr-internal.h	Wed Jan 21 22:08:17 2009
@@ -1,8 +1,14 @@
 #ifndef GCR_INTERNAL_H_
 #define GCR_INTERNAL_H_
 
+#include "gcr.h"
+
+#include "gp11/gp11.h"
+
 #include <glib.h>
 
-void _gcr_initialize (void);
+void              _gcr_initialize                  (void);
+
+GList*            _gcr_get_pkcs11_modules          (void);
 
 #endif /* GCR_INTERNAL_H_ */

Added: trunk/gcr/gcr-library.c
==============================================================================
--- (empty file)
+++ trunk/gcr/gcr-library.c	Wed Jan 21 22:08:17 2009
@@ -0,0 +1,215 @@
+/* 
+ * gnome-keyring
+ * 
+ * Copyright (C) 2008 Stefan Walter
+ * 
+ * This program is free software; you can redistribute it and/or modify 
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *  
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *  
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.  
+ */
+
+#include "config.h"
+
+#include "gcr.h"
+#include "gcr-types.h"
+#include "gcr-internal.h"
+
+#include "egg/egg-secure-memory.h"
+
+#include <gcrypt.h>
+
+static GList *all_modules = NULL;
+
+GQuark
+gcr_data_error_get_domain (void)
+{
+	static GQuark domain = 0;
+	if (domain == 0)
+		domain = g_quark_from_static_string ("gcr-parser-error");
+	return domain;
+}
+
+/* -----------------------------------------------------------------------------
+ * MEMORY
+ */
+
+static gboolean do_warning = TRUE;
+#define WARNING  "couldn't allocate secure memory to keep passwords " \
+		 "and or keys from being written to the disk"
+		 
+#define ABORTMSG "The GNOME_KEYRING_PARANOID environment variable was set. " \
+                 "Exiting..."
+
+static G_LOCK_DEFINE (memory_lock);
+
+/* 
+ * These are called from egg-secure-memory.c to provide appropriate
+ * locking for memory between threads
+ */ 
+
+void
+egg_memory_lock (void)
+{
+	G_LOCK (memory_lock);
+}
+
+void 
+egg_memory_unlock (void)
+{
+	G_UNLOCK (memory_lock);
+}
+
+void*
+egg_memory_fallback (void *p, unsigned long sz)
+{
+	const gchar *env;
+	
+	/* We were asked to free memory */
+	if (!sz) {
+		g_free (p);
+		return NULL;
+	}
+	
+	/* We were asked to allocate */
+	if (!p) {
+		if (do_warning) {
+			g_message (WARNING);
+			do_warning = FALSE;
+		}
+		
+		env = g_getenv ("GNOME_KEYRING_PARANOID");
+		if (env && *env) 
+			g_error (ABORTMSG);
+			
+		return g_malloc0 (sz);
+	}
+	
+	/* 
+	 * Reallocation is a bit of a gray area, as we can be asked 
+	 * by external libraries (like libgcrypt) to reallocate a 
+	 * non-secure block into secure memory. We cannot satisfy 
+	 * this request (as we don't know the size of the original 
+	 * block) so we just try our best here.
+	 */
+			 
+	return g_realloc (p, sz);
+}
+
+/* ------------------------------------------------------------------------------
+ * GCRYPT HOOKS
+ */
+
+static void
+log_handler (gpointer unused, int unknown, const gchar *msg, va_list va)
+{
+	/* TODO: Figure out additional arguments */
+	g_logv ("gcrypt", G_LOG_LEVEL_MESSAGE, msg, va);
+}
+
+static int 
+no_mem_handler (gpointer unused, size_t sz, unsigned int unknown)
+{
+	/* TODO: Figure out additional arguments */
+	g_error ("couldn't allocate %lu bytes of memory", 
+	         (unsigned long int)sz);
+	return 0;
+}
+
+static void
+fatal_handler (gpointer unused, int unknown, const gchar *msg)
+{
+	/* TODO: Figure out additional arguments */
+	g_log ("gcrypt", G_LOG_LEVEL_ERROR, "%s", msg);
+}
+
+static int
+glib_thread_mutex_init (void **lock)
+{
+	*lock = g_mutex_new ();
+	return 0;
+}
+
+static int 
+glib_thread_mutex_destroy (void **lock)
+{
+	g_mutex_free (*lock);
+	return 0;
+}
+
+static int 
+glib_thread_mutex_lock (void **lock)
+{
+	g_mutex_lock (*lock);
+	return 0;
+}
+
+static int 
+glib_thread_mutex_unlock (void **lock)
+{
+	g_mutex_unlock (*lock);
+	return 0;
+}
+
+static struct gcry_thread_cbs glib_thread_cbs = {
+	GCRY_THREAD_OPTION_USER, NULL,
+	glib_thread_mutex_init, glib_thread_mutex_destroy,
+	glib_thread_mutex_lock, glib_thread_mutex_unlock,
+	NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL 
+};
+
+void
+_gcr_initialize (void)
+{
+	static volatile gsize gcr_initialized = 0;
+	GP11Module *module;
+	GError *error = NULL;
+	unsigned seed;
+
+	if (g_once_init_enter (&gcr_initialized)) {
+		
+		/* Only initialize libgcrypt if it hasn't already been initialized */
+		if (!gcry_control (GCRYCTL_INITIALIZATION_FINISHED_P)) {
+			gcry_control (GCRYCTL_SET_THREAD_CBS, &glib_thread_cbs);
+			gcry_check_version (LIBGCRYPT_VERSION);
+			gcry_set_log_handler (log_handler, NULL);
+			gcry_set_outofcore_handler (no_mem_handler, NULL);
+			gcry_set_fatalerror_handler (fatal_handler, NULL);
+			gcry_set_allocation_handler ((gcry_handler_alloc_t)g_malloc, 
+			                             (gcry_handler_alloc_t)egg_secure_alloc, 
+			                             egg_secure_check, 
+			                             (gcry_handler_realloc_t)egg_secure_realloc, 
+			                             egg_secure_free);
+			gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+		}
+		
+		gcry_create_nonce (&seed, sizeof (seed));
+		srand (seed);
+
+		/* TODO: This needs reworking for multiple modules */
+		module = gp11_module_initialize (PKCS11_MODULE_PATH, NULL, &error);
+		if (module) 
+			all_modules = g_list_prepend (all_modules, module);
+		else 
+			g_warning ("couldn't initialize PKCS#11 module: %s", 
+			           error && error->message ? error->message : "");
+
+		g_once_init_leave (&gcr_initialized, 1);
+	}
+}
+
+GList*
+_gcr_get_pkcs11_modules (void)
+{
+	return all_modules;
+}

Modified: trunk/gcr/gcr-parser.c
==============================================================================
--- trunk/gcr/gcr-parser.c	(original)
+++ trunk/gcr/gcr-parser.c	Wed Jan 21 22:08:17 2009
@@ -263,7 +263,7 @@
 	++state->ask_state;
 	
 	if (!result)
-		return GCR_PARSE_CANCELLED;
+		return GCR_ERROR_CANCELLED;
 	
 	/* Return any passwords added */
 	if (state->seen < self->pv->passwords->len) {
@@ -273,7 +273,7 @@
 		return SUCCESS;
 	}
 	
-	return GCR_PARSE_LOCKED;
+	return GCR_ERROR_LOCKED;
 }
 
 static void
@@ -293,7 +293,7 @@
 static gint
 parse_der_private_key_rsa (GcrParser *self, const guchar *data, gsize n_data)
 {
-	gint res = GCR_PARSE_UNRECOGNIZED;
+	gint res = GCR_ERROR_UNRECOGNIZED;
 	ASN1_TYPE asn = ASN1_TYPE_EMPTY;
 	guint version;
 	
@@ -303,14 +303,14 @@
 	
 	parsed_clear (self, CKO_PRIVATE_KEY);
 	parsed_ulong (self, CKA_KEY_TYPE, CKK_RSA);
-	res = GCR_PARSE_FAILURE;
+	res = GCR_ERROR_FAILURE;
 
 	if (!egg_asn1_read_uint (asn, "version", &version))
 		goto done;
 	
 	/* We only support simple version */
 	if (version != 0) {
-		res = GCR_PARSE_UNRECOGNIZED;
+		res = GCR_ERROR_UNRECOGNIZED;
 		g_message ("unsupported version of RSA key: %u", version);
 		goto done;
 	}
@@ -330,7 +330,7 @@
 	if (asn)
 		asn1_delete_structure (&asn);
 
-	if (res == GCR_PARSE_FAILURE)
+	if (res == GCR_ERROR_FAILURE)
 		g_message ("invalid RSA key");
 	
 	return res;
@@ -343,7 +343,7 @@
 static gint
 parse_der_private_key_dsa (GcrParser *self, const guchar *data, gsize n_data)
 {
-	gint ret = GCR_PARSE_UNRECOGNIZED;
+	gint ret = GCR_ERROR_UNRECOGNIZED;
 	int res;
 	ASN1_TYPE asn;
 
@@ -353,7 +353,7 @@
 	
 	parsed_clear (self, CKO_PRIVATE_KEY);
 	parsed_ulong (self, CKA_KEY_TYPE, CKK_DSA);
-	res = GCR_PARSE_FAILURE;
+	res = GCR_ERROR_FAILURE;
 
 	if (!parsed_asn1_attribute (self, asn, data, n_data, "p", CKA_PRIME) ||
 	    !parsed_asn1_attribute (self, asn, data, n_data, "q", CKA_SUBPRIME) ||
@@ -368,7 +368,7 @@
 	if (asn)
 		asn1_delete_structure (&asn);
 	
-	if (ret == GCR_PARSE_FAILURE) 
+	if (ret == GCR_ERROR_FAILURE) 
 		g_message ("invalid DSA key");
 		
 	return ret;
@@ -378,7 +378,7 @@
 parse_der_private_key_dsa_parts (GcrParser *self, const guchar *keydata, gsize n_keydata,
                                  const guchar *params, gsize n_params)
 {
-	gint ret = GCR_PARSE_UNRECOGNIZED;
+	gint ret = GCR_ERROR_UNRECOGNIZED;
 	int res;
 	ASN1_TYPE asn_params = ASN1_TYPE_EMPTY;
 	ASN1_TYPE asn_key = ASN1_TYPE_EMPTY;
@@ -390,7 +390,7 @@
 	
 	parsed_clear (self, CKO_PRIVATE_KEY);
 	parsed_ulong (self, CKA_KEY_TYPE, CKK_DSA);
-	res = GCR_PARSE_FAILURE;
+	res = GCR_ERROR_FAILURE;
     
 	if (!parsed_asn1_attribute (self, asn_params, params, n_params, "p", CKA_PRIME) ||
 	    !parsed_asn1_attribute (self, asn_params, params, n_params, "q", CKA_SUBPRIME) ||
@@ -407,7 +407,7 @@
 	if (asn_params)
 		asn1_delete_structure (&asn_params);
 	
-	if (ret == GCR_PARSE_FAILURE) 
+	if (ret == GCR_ERROR_FAILURE) 
 		g_message ("invalid DSA key");
 		
 	return ret;	
@@ -423,7 +423,7 @@
 	gint res;
 	
 	res = parse_der_private_key_rsa (self, data, n_data);
-	if (res == GCR_PARSE_UNRECOGNIZED)
+	if (res == GCR_ERROR_UNRECOGNIZED)
 		res = parse_der_private_key_dsa (self, data, n_data);
 		
 	return res;
@@ -445,13 +445,13 @@
 	const guchar *params;
 	gsize n_params;
 	
-	ret = GCR_PARSE_UNRECOGNIZED;
+	ret = GCR_ERROR_UNRECOGNIZED;
 	
 	asn = egg_asn1_decode ("PKIX1.pkcs-8-PrivateKeyInfo", data, n_data);
 	if (!asn)
 		goto done;
 
-	ret = GCR_PARSE_FAILURE;
+	ret = GCR_ERROR_FAILURE;
 	key_type = GP11_INVALID;
 		
 	key_algo = egg_asn1_read_oid (asn, "privateKeyAlgorithm.algorithm");
@@ -463,7 +463,7 @@
   		key_type = CKK_DSA;
   		
   	if (key_type == GP11_INVALID) {
-  		ret = GCR_PARSE_UNRECOGNIZED;
+  		ret = GCR_ERROR_UNRECOGNIZED;
   		goto done;
   	}
 
@@ -487,17 +487,17 @@
 			ret = parse_der_private_key_dsa (self, keydata, n_keydata);
 			
 			/* Otherwise try the two part format that everyone seems to like */
-			if (ret == GCR_PARSE_UNRECOGNIZED && params && n_params)
+			if (ret == GCR_ERROR_UNRECOGNIZED && params && n_params)
 				ret = parse_der_private_key_dsa_parts (self, keydata, n_keydata, 
 				                                       params, n_params);
 			break;
 		default:
 			g_message ("invalid or unsupported key type in PKCS#8 key");
-			ret = GCR_PARSE_UNRECOGNIZED;
+			ret = GCR_ERROR_UNRECOGNIZED;
 			break;
 		};
 		
-	} else if (ret == GCR_PARSE_FAILURE) {
+	} else if (ret == GCR_ERROR_FAILURE) {
 		g_message ("invalid PKCS#8 key");
 	}
 	
@@ -521,13 +521,13 @@
 	const gchar *password;
 	gint l;
 
-	ret = GCR_PARSE_UNRECOGNIZED;
+	ret = GCR_ERROR_UNRECOGNIZED;
 	
 	asn = egg_asn1_decode ("PKIX1.pkcs-8-EncryptedPrivateKeyInfo", data, n_data);
 	if (!asn)
 		goto done;
 
-	ret = GCR_PARSE_FAILURE;
+	ret = GCR_ERROR_FAILURE;
 
 	/* Figure out the type of encryption */
 	scheme = egg_asn1_read_oid (asn, "encryptionAlgorithm.algorithm");
@@ -576,7 +576,7 @@
 		egg_secure_free (crypted);
 		crypted = NULL;
 		
-		if (r != GCR_PARSE_UNRECOGNIZED) {
+		if (r != GCR_ERROR_UNRECOGNIZED) {
 			ret = r;
 			break;
 		}
@@ -600,7 +600,7 @@
 	gint ret;
 	
 	ret = parse_der_pkcs8_plain (self, data, n_data);
-	if (ret == GCR_PARSE_UNRECOGNIZED)
+	if (ret == GCR_ERROR_UNRECOGNIZED)
 		ret = parse_der_pkcs8_encrypted (self, data, n_data);
 	
 	return ret;
@@ -618,7 +618,7 @@
 	
 	asn = egg_asn1_decode ("PKIX1.Certificate", data, n_data);
 	if (asn == NULL)
-		return GCR_PARSE_UNRECOGNIZED;
+		return GCR_ERROR_UNRECOGNIZED;
 
 	parsed_clear (self, CKO_CERTIFICATE);
 	parsed_ulong (self, CKA_CERTIFICATE_TYPE, CKC_X_509);
@@ -651,13 +651,13 @@
 	gsize n_certificate;
 	int i;
 	
-	ret = GCR_PARSE_UNRECOGNIZED;
+	ret = GCR_ERROR_UNRECOGNIZED;
 	
 	asn = egg_asn1_decode ("PKIX1.pkcs-7-SignedData", data, n_data);
 	if (!asn)
 		goto done;
 
-	ret = GCR_PARSE_FAILURE;
+	ret = GCR_ERROR_FAILURE;
 	
 	for (i = 0; TRUE; ++i) {
 			
@@ -694,13 +694,13 @@
 	gsize n_content;
 	GQuark oid;
 	
-	ret = GCR_PARSE_UNRECOGNIZED;
+	ret = GCR_ERROR_UNRECOGNIZED;
 	
 	asn = egg_asn1_decode ("PKIX1.pkcs-7-ContentInfo", data, n_data);
 	if (!asn)
 		goto done;
 
-	ret = GCR_PARSE_FAILURE;
+	ret = GCR_ERROR_FAILURE;
 
 	oid = egg_asn1_read_oid (asn, "contentType");
 	if (!oid)
@@ -736,13 +736,13 @@
 	gsize n_certificate;
 	gint ret;
 
-	ret = GCR_PARSE_UNRECOGNIZED;
+	ret = GCR_ERROR_UNRECOGNIZED;
 	
 	asn = egg_asn1_decode ("PKIX1.pkcs-12-CertBag", data, n_data);
 	if (!asn)
 		goto done;
 		
-	ret = GCR_PARSE_FAILURE;
+	ret = GCR_ERROR_FAILURE;
 	
 	certificate = egg_asn1_read_content (asn, data, n_data, "certValue", &n_certificate);
 	if (!certificate)
@@ -775,13 +775,13 @@
 	const guchar *element;
 	gsize n_element;
 	
-	ret = GCR_PARSE_UNRECOGNIZED;
+	ret = GCR_ERROR_UNRECOGNIZED;
 	
 	asn = egg_asn1_decode ("PKIX1.pkcs-12-SafeContents", data, n_data);
 	if (!asn)
 		goto done;
 		
-	ret = GCR_PARSE_FAILURE;
+	ret = GCR_ERROR_FAILURE;
 	
 	/* Get the number of elements in this bag */
 	res = asn1_number_of_elements (asn, "", &count);
@@ -822,10 +822,10 @@
 								
 		/* TODO: OID_PKCS12_BAG_CRL */
 		} else {
-			r = GCR_PARSE_UNRECOGNIZED;
+			r = GCR_ERROR_UNRECOGNIZED;
 		}
 		 
-		if (r == GCR_PARSE_FAILURE || r == GCR_PARSE_CANCELLED) {
+		if (r == GCR_ERROR_FAILURE || r == GCR_ERROR_CANCELLED) {
 			ret = r;
 			goto done;
 		}
@@ -855,13 +855,13 @@
 	gint ret, r;
 	gint l;
 	
-	ret = GCR_PARSE_UNRECOGNIZED;
+	ret = GCR_ERROR_UNRECOGNIZED;
 	
 	asn = egg_asn1_decode ("PKIX1.pkcs-7-EncryptedData", data, n_data);
 	if (!asn)
 		goto done;
 	
-	ret = GCR_PARSE_FAILURE;
+	ret = GCR_ERROR_FAILURE;
 		
 	/* Check the encryption schema OID */
 	scheme = egg_asn1_read_oid (asn, "encryptedContentInfo.contentEncryptionAlgorithm.algorithm");
@@ -887,7 +887,7 @@
 	        
 		/* Parse the encryption stuff into a cipher. */
 		if (!egg_symkey_read_cipher (scheme, password, -1, params, n_params, &cih)) {
-			ret = GCR_PARSE_FAILURE;
+			ret = GCR_ERROR_FAILURE;
 			goto done;
 		}
 			
@@ -915,7 +915,7 @@
 		egg_secure_free (crypted);
 		crypted = NULL;
 		
-		if (r != GCR_PARSE_UNRECOGNIZED) {
+		if (r != GCR_ERROR_UNRECOGNIZED) {
 			ret = r;
 			break;
 		}
@@ -944,13 +944,13 @@
 	GQuark oid;
 	guint i;
 	
-	ret = GCR_PARSE_UNRECOGNIZED;
+	ret = GCR_ERROR_UNRECOGNIZED;
 	
 	asn = egg_asn1_decode ("PKIX1.pkcs-12-AuthenticatedSafe", data, n_data);
 	if (!asn)
 		goto done;
 		
-	ret = GCR_PARSE_FAILURE;
+	ret = GCR_ERROR_FAILURE;
 	
 	/*
 	 * Inside each PKCS12 safe there are multiple bags. 
@@ -992,10 +992,10 @@
 		/* Hmmmm, not sure what this is */
 		} else {
 			g_warning ("unrecognized type of safe content in pkcs12: %s", g_quark_to_string (oid));
-			r = GCR_PARSE_UNRECOGNIZED;
+			r = GCR_ERROR_UNRECOGNIZED;
 		}
 		
-		if (r == GCR_PARSE_FAILURE || r == GCR_PARSE_CANCELLED) {
+		if (r == GCR_ERROR_FAILURE || r == GCR_ERROR_CANCELLED) {
 			ret = r;
 			goto done;
 		}
@@ -1019,7 +1019,7 @@
 	gsize n_content;
 	GQuark oid;
 	
-	ret = GCR_PARSE_UNRECOGNIZED;
+	ret = GCR_ERROR_UNRECOGNIZED;
 	
 	asn = egg_asn1_decode ("PKIX1.pkcs-12-PFX", data, n_data);
 	if (!asn)
@@ -1091,14 +1091,14 @@
 		format_id = GCR_FORMAT_DER_PKCS12;
 		
 	else
-		return GCR_PARSE_UNRECOGNIZED;
+		return GCR_ERROR_UNRECOGNIZED;
 
 	if (subformat != 0 && subformat != format_id)
-		return GCR_PARSE_UNRECOGNIZED;
+		return GCR_ERROR_UNRECOGNIZED;
 	
 	format = parser_format_lookup (format_id);
 	if (format == NULL)
-		return GCR_PARSE_UNRECOGNIZED;
+		return GCR_ERROR_UNRECOGNIZED;
 	
 	return (format->function) (self, data, n_data);
 }
@@ -1143,7 +1143,7 @@
 	val = g_hash_table_lookup (headers, "DEK-Info");
 	if (!val) {
 		g_message ("missing encryption header");
-		return GCR_PARSE_FAILURE;
+		return GCR_ERROR_FAILURE;
 	}
 	
 	/* Fill in information necessary for prompting */
@@ -1162,7 +1162,7 @@
 		ret = egg_openssl_decrypt_block (val, password, -1, data, n_data, 
 		                                 &decrypted, &n_decrypted);
 		if (!ret)
-			return GCR_PARSE_FAILURE;
+			return GCR_ERROR_FAILURE;
 			
 		g_assert (decrypted);
 		
@@ -1176,11 +1176,11 @@
 		egg_secure_free (decrypted);
 
 		/* Unrecognized is a bad password */
-		if (res != GCR_PARSE_UNRECOGNIZED)
+		if (res != GCR_ERROR_UNRECOGNIZED)
 			return res;		
 	}
 	
-	return GCR_PARSE_FAILURE;
+	return GCR_ERROR_FAILURE;
 }
 
 typedef struct {
@@ -1194,12 +1194,12 @@
                  GHashTable *headers, gpointer user_data)
 {
 	HandlePemArgs *args = (HandlePemArgs*)user_data;
-	gint res = GCR_PARSE_FAILURE;
+	gint res = GCR_ERROR_FAILURE;
 	gboolean encrypted = FALSE;
 	const gchar *val;
 	
 	/* Something already failed to parse */
-	if (args->result == GCR_PARSE_FAILURE)
+	if (args->result == GCR_ERROR_FAILURE)
 		return;
 	
 	/* See if it's encrypted PEM all openssl like*/
@@ -1216,8 +1216,8 @@
 		res = handle_plain_pem (args->parser, type, args->subformat, 
 		                        data, n_data);
 	
-	if (res != GCR_PARSE_UNRECOGNIZED) {
-		if (args->result == GCR_PARSE_UNRECOGNIZED)
+	if (res != GCR_ERROR_UNRECOGNIZED) {
+		if (args->result == GCR_ERROR_UNRECOGNIZED)
 			args->result = res;
 		else if (res > args->result)
 			args->result = res;
@@ -1227,16 +1227,16 @@
 static gint
 handle_pem_format (GcrParser *self, gint subformat, const guchar *data, gsize n_data)
 {
-	HandlePemArgs ctx = { self, GCR_PARSE_UNRECOGNIZED, subformat };
+	HandlePemArgs ctx = { self, GCR_ERROR_UNRECOGNIZED, subformat };
 	guint found;
 	
 	if (n_data == 0)
-		return GCR_PARSE_UNRECOGNIZED;
+		return GCR_ERROR_UNRECOGNIZED;
 	
 	found = egg_openssl_pem_parse (data, n_data, handle_pem_data, &ctx);
 	
 	if (found == 0)
-		return GCR_PARSE_UNRECOGNIZED;
+		return GCR_ERROR_UNRECOGNIZED;
 		
 	return ctx.result;
 }
@@ -1375,7 +1375,7 @@
 	g_assert (GCR_IS_PARSER (args->parser));
 	
 	result = (format->function) (args->parser, args->data, args->n_data);
-	if (result != GCR_PARSE_UNRECOGNIZED) {
+	if (result != GCR_ERROR_UNRECOGNIZED) {
 		args->result = result;
 		return TRUE;
 	}
@@ -1534,15 +1534,6 @@
 	return g_object_new (GCR_TYPE_PARSER, NULL);
 }
 
-GQuark
-gcr_parser_get_error_domain (void)
-{
-	static GQuark domain = 0;
-	if (domain == 0)
-		domain = g_quark_from_static_string ("gcr-parser-error");
-	return domain;
-}
-
 void
 gcr_parser_add_password (GcrParser *self, const gchar *password)
 {
@@ -1554,7 +1545,7 @@
 gcr_parser_parse_data (GcrParser *self, const guchar *data, 
                        gsize n_data, GError **err)
 {
-	ForeachArgs args = { self, data, n_data, GCR_PARSE_UNRECOGNIZED };
+	ForeachArgs args = { self, data, n_data, GCR_ERROR_UNRECOGNIZED };
 	const gchar *message;
 	gint i;
 	
@@ -1578,16 +1569,16 @@
 	switch (args.result) {
 	case SUCCESS:
 		return TRUE;
-	case GCR_PARSE_CANCELLED:
+	case GCR_ERROR_CANCELLED:
 		message = _("The operation was cancelled");
 		break;
-	case GCR_PARSE_UNRECOGNIZED:
+	case GCR_ERROR_UNRECOGNIZED:
 		message = _("Unrecognized or unsupported data.");
 		break;
-	case GCR_PARSE_FAILURE:
+	case GCR_ERROR_FAILURE:
 		message = _("Could not parse invalid or corrupted data.");
 		break;
-	case GCR_PARSE_LOCKED:
+	case GCR_ERROR_LOCKED:
 		message = _("The data is locked");
 		break;
 	default:
@@ -1595,37 +1586,11 @@
 		break;
 	};
 	
-	g_set_error_literal (err, GCR_PARSER_ERROR, args.result, message);
+	g_set_error_literal (err, GCR_DATA_ERROR, args.result, message);
 	return FALSE;
 }
 
 gboolean
-gcr_parser_parse_file (GcrParser *self, const gchar *filename, GError **err)
-{
-	GMappedFile *mapped;
-	gboolean ret;
-	const guchar *data;
-	gsize n_data; 
-	
-	g_return_val_if_fail (GCR_IS_PARSER (self), FALSE);
-	g_return_val_if_fail (filename, FALSE);
-	g_return_val_if_fail (!err || !*err, FALSE);
-	
-	mapped = g_mapped_file_new (filename, FALSE, err);
-	if (mapped == NULL)
-		return FALSE;
-
-	data = (const guchar*)g_mapped_file_get_contents (mapped);
-	n_data = g_mapped_file_get_length (mapped);
-	
-	ret = gcr_parser_parse_data (self, data, n_data, err);
-		
-	g_mapped_file_free (mapped);
-	
-	return ret;
-}
-
-gboolean
 gcr_parser_format_enable (GcrParser *self, gint format_id)
 {
 	ParserFormat *format;

Modified: trunk/gcr/gcr-parser.h
==============================================================================
--- trunk/gcr/gcr-parser.h	(original)
+++ trunk/gcr/gcr-parser.h	Wed Jan 21 22:08:17 2009
@@ -22,12 +22,12 @@
 #ifndef __GCR_PARSER_H__
 #define __GCR_PARSER_H__
 
+#include "gcr.h"
+
 #include <glib-object.h>
 
 #include "gcr-types.h"
 
-#define GCR_PARSER_ERROR              (gcr_parser_get_error_domain ())
-
 #define GCR_TYPE_PARSER               (gcr_parser_get_type ())
 #define GCR_PARSER(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GCR_TYPE_PARSER, GcrParser))
 #define GCR_PARSER_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), GCR_TYPE_PARSER, GcrParserClass))
@@ -56,37 +56,31 @@
 	void     (*parsed) (GcrParser *self);
 };
 
-GType               gcr_parser_get_type               (void);
-
-GQuark 	            gcr_parser_get_error_domain       (void) G_GNUC_CONST;
-
-GcrParser*          gcr_parser_new                    (void);
+GType                    gcr_parser_get_type               (void);
 
-gboolean            gcr_parser_format_enable          (GcrParser *self, 
-                                                       gint format);
+GcrParser*               gcr_parser_new                    (void);
 
-gboolean            gcr_parser_format_disable         (GcrParser *self, 
-                                                       gint format);
+gboolean                 gcr_parser_format_enable          (GcrParser *self, 
+                                                            gint format);
 
-gboolean            gcr_parser_format_supported       (GcrParser *self,
-                                                       gint format);
+gboolean                 gcr_parser_format_disable         (GcrParser *self, 
+                                                            gint format);
 
-gboolean            gcr_parser_parse_data             (GcrParser *self, 
-                                                       const guchar *data, 
-                                                       gsize n_data, 
-                                                       GError **err);
+gboolean                 gcr_parser_format_supported       (GcrParser *self,
+                                                            gint format);
 
-gboolean            gcr_parser_parse_file             (GcrParser *self, 
-                                                       const gchar *filename, 
-                                                       GError **err);
+gboolean                 gcr_parser_parse_data             (GcrParser *self, 
+                                                            const guchar *data, 
+                                                            gsize n_data, 
+                                                            GError **err);
 
-void                gcr_parser_add_password           (GcrParser *self,
-                                                       const gchar *password);
+void                     gcr_parser_add_password           (GcrParser *self,
+                                                            const gchar *password);
 
-const gchar*        gcr_parser_get_parsed_label       (GcrParser *self);
+const gchar*             gcr_parser_get_parsed_label       (GcrParser *self);
 
-const gchar*        gcr_parser_get_parsed_description (GcrParser *self);
+const gchar*             gcr_parser_get_parsed_description (GcrParser *self);
 
-GP11Attributes*     gcr_parser_get_parsed_attributes  (GcrParser *self);
+struct _GP11Attributes*  gcr_parser_get_parsed_attributes  (GcrParser *self);
 
 #endif /* __GCR_PARSER_H__ */

Modified: trunk/gcr/gcr-types.h
==============================================================================
--- trunk/gcr/gcr-types.h	(original)
+++ trunk/gcr/gcr-types.h	Wed Jan 21 22:08:17 2009
@@ -1,11 +1,15 @@
 #ifndef GCRTYPES_H_
 #define GCRTYPES_H_
 
+#define             GCR_DATA_ERROR                    (gcr_data_error_get_domain ())
+
+GQuark 	            gcr_data_error_get_domain         (void) G_GNUC_CONST;
+
 enum {
-	GCR_PARSE_FAILURE = -1,
-	GCR_PARSE_UNRECOGNIZED = 1,
-	GCR_PARSE_CANCELLED = 2,
-	GCR_PARSE_LOCKED = 3
+	GCR_ERROR_FAILURE = -1,
+	GCR_ERROR_UNRECOGNIZED = 1,
+	GCR_ERROR_CANCELLED = 2,
+	GCR_ERROR_LOCKED = 3
 };
 
 enum {
@@ -35,11 +39,8 @@
 	GCR_FORMAT_PEM_PKCS12
 };
 
-#ifndef GP11_H
-
 /* Forward declare some of the GP11 objects */
-typedef struct _GP11Attributes GP11Attributes;
-
-#endif /* GP11_H */
+struct _GP11Attributes;
+struct _GP11Slot;
 
 #endif /* GCRTYPES_H_ */

Added: trunk/gcr/gcr.h
==============================================================================
--- (empty file)
+++ trunk/gcr/gcr.h	Wed Jan 21 22:08:17 2009
@@ -0,0 +1,46 @@
+/* 
+ * gnome-keyring
+ * 
+ * Copyright (C) 2008 Stefan Walter
+ * 
+ * This program is free software; you can redistribute it and/or modify 
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *  
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *  
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.  
+ */
+
+#ifndef __GCR_H__
+#define __GCR_H__
+
+#include <glib.h>
+
+#ifndef GCR_API_SUBJECT_TO_CHANGE
+#error "This API has not yet reached stability." 
+#endif 
+
+struct _GP11Slot;
+
+#ifdef UNIMPLEMENTED
+enum {
+	GCR_INIT_NO_MODULES = 0x01,
+};
+
+void                 gcr_initialize                          (guint flags);
+
+void                 gcr_modules_register_loaded             (gpointer funcs);
+
+gboolean             gcr_modules_register_file               (const gchar *module_path,
+                                                              GError *error);
+#endif /* UNIMPLEMENTED */
+
+#endif /* __GCR_H__ */

Modified: trunk/gcr/template/gcr-xxx.c
==============================================================================
--- trunk/gcr/template/gcr-xxx.c	(original)
+++ trunk/gcr/template/gcr-xxx.c	Wed Jan 21 22:08:17 2009
@@ -21,6 +21,7 @@
 
 #include "config.h"
 
+#include "gcr-internal.h"
 #include "gcr-xxx.h"
 
 enum {
@@ -133,6 +134,8 @@
 	                                G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GcrXxxClass, signal),
 	                                NULL, NULL, g_cclosure_marshal_VOID__OBJECT, 
 	                                G_TYPE_NONE, 0);
+	
+	_gcr_initialize ();
 }
 
 /* -----------------------------------------------------------------------------

Modified: trunk/gcr/template/gcr-xxx.h
==============================================================================
--- trunk/gcr/template/gcr-xxx.h	(original)
+++ trunk/gcr/template/gcr-xxx.h	Wed Jan 21 22:08:17 2009
@@ -22,6 +22,8 @@
 #ifndef __GCR_XXX_H__
 #define __GCR_XXX_H__
 
+#include "gcr.h"
+
 #include <glib-object.h>
 
 #define GCR_TYPE_XXX               (gcr_xxx_get_type ())

Modified: trunk/gcr/tests/Makefile.am
==============================================================================
--- trunk/gcr/tests/Makefile.am	(original)
+++ trunk/gcr/tests/Makefile.am	Wed Jan 21 22:08:17 2009
@@ -8,6 +8,10 @@
 UNIT_LIBS =  \
 	$(top_builddir)/gcr/libgcr.la \
 	$(top_builddir)/egg/libegg.la \
+	$(top_builddir)/egg/libegg-secure-entry.la \
 	$(top_builddir)/gp11/libgp11.la
+	
+UNIT_FLAGS = \
+	-DGCR_API_SUBJECT_TO_CHANGE
 
 include $(top_srcdir)/tests/gtest.make

Modified: trunk/gcr/tests/unit-test-parser.c
==============================================================================
--- trunk/gcr/tests/unit-test-parser.c	(original)
+++ trunk/gcr/tests/unit-test-parser.c	Wed Jan 21 22:08:17 2009
@@ -29,6 +29,8 @@
 
 #include "gcr/gcr-parser.h"
 
+#include "gp11/gp11.h"
+
 #include <glib.h>
 #include <gcrypt.h>
 #include <libtasn1.h>

Modified: trunk/po/POTFILES.skip
==============================================================================
--- trunk/po/POTFILES.skip	(original)
+++ trunk/po/POTFILES.skip	Wed Jan 21 22:08:17 2009
@@ -1,2 +1,2 @@
 daemon/gnome-keyring-daemon.desktop.in
-
+gcr/gcr-import-dialog.ui

Modified: trunk/tool/Makefile.am
==============================================================================
--- trunk/tool/Makefile.am	(original)
+++ trunk/tool/Makefile.am	Wed Jan 21 22:08:17 2009
@@ -2,17 +2,25 @@
 	gnome-keyring
 
 INCLUDES=	\
-	-DPKCS11_MODULE_PATH=\""$(libdir)/gnome-keyring/gnome-keyring-pkcs11.so"\" 	\
-	-DGNOMELOCALEDIR=\""$(datadir)/locale"\"					\
-	-I$(top_srcdir) 								\
-	-I$(top_builddir) 								\
-	$(GOBJECT_CFLAGS) 								\
+	-I$(top_srcdir) \
+	-I$(top_builddir) \
+	$(GTK_CFLAGS) \
+	$(GOBJECT_CFLAGS) \
 	$(GLIB_CFLAGS)
 	
 gnome_keyring_SOURCES = \
 	gkr-tool.c gkr-tool.h \
 	gkr-tool-import.c
+	
+gnome_keyring_CFLAGS = \
+	-DGCR_API_SUBJECT_TO_CHANGE \
+	-DGNOMELOCALEDIR=\""$(datadir)/locale"\"
 
 gnome_keyring_LDADD = \
 	$(top_builddir)/gp11/libgp11.la \
-	$(GLIB_LIBS) $(GTHREAD_LIBS)
+	$(top_builddir)/gcr/libgcr.la \
+	$(top_builddir)/egg/libegg.la \
+	$(GTK_LIBS) \
+	$(GCRYPT_LIBS) \
+	$(LIBTASN1_LIBS) \
+	$(DAEMON_LIBS)

Modified: trunk/tool/gkr-tool-import.c
==============================================================================
--- trunk/tool/gkr-tool-import.c	(original)
+++ trunk/tool/gkr-tool-import.c	Wed Jan 21 22:08:17 2009
@@ -27,7 +27,9 @@
 
 #include "gp11/gp11.h"
 
-#include "pkcs11/pkcs11g.h"
+#include "gcr/gcr-importer.h"
+
+#include "egg/egg-hex.h"
 
 static gchar **import_files = NULL;
 
@@ -37,23 +39,15 @@
 	{ NULL }
 };
 
-static const gulong ATTR_TYPES[] = {
-	CKA_LABEL,
-	CKA_CLASS,
-	CKA_ID
-};
-
-static const char HEXC[] = "0123456789ABCDEF";
-
 static void
-print_object_information (GP11Object *object)
+on_imported (GcrImporter *importer, GP11Object *object)
 {
 	GP11Attributes *attrs;
 	GP11Attribute *id;
 	CK_OBJECT_CLASS klass;
 	const gchar *message;
 	GError *err = NULL;
-	gchar *label;
+	gchar *label, *hex;
 	
 	attrs = gp11_attributes_new_empty (CKA_LABEL, CKA_CLASS, CKA_ID, -1);
 	if (!gp11_object_get_full (object, attrs, NULL, &err)) {
@@ -91,133 +85,23 @@
 	g_print (message, label);
 
 	if (id) {
-		guchar *data = id->value;
-		gsize n_data = id->length;
-		gchar pair[3];
-		
-		g_print ("\tID: ");
-		
-		while(n_data > 0) {
-			pair[0] = HEXC[*(data) >> 4 & 0xf];
-			pair[1] = HEXC[*(data++) & 0xf];
-			pair[2] = 0;
-			n_data--;
-			g_print ("%s", pair);
-		}
-
-		g_print ("\n");
+		hex = egg_hex_encode (id->value, id->length);
+		g_print ("\tID: %s\n", hex);
+		g_free (hex);
 	}
 	
 	gp11_attributes_unref (attrs);
 	g_free (label);
 }
 
-static void
-print_import_information (GP11Session *session, GP11Object *import)
-{
-	CK_OBJECT_HANDLE_PTR handles;
-	CK_ULONG n_handles;
-	gsize length;
-	GList *objects, *l;
-	GP11Slot *slot;
-	GError *err;
-	
-	handles = gp11_object_get_data (import, CKA_GNOME_IMPORT_OBJECTS, &length, &err);
-	if (!handles) {
-		gkr_tool_handle_error (&err, "couldn't find imported objects");
-		return;
-	}
-	
-	n_handles = length / sizeof (CK_OBJECT_HANDLE);
-	
-	slot = gp11_session_get_slot (session);
-	g_return_if_fail (slot);
-
-	objects = gp11_objects_from_handle_array (slot, handles, n_handles);
-	g_free (handles);
-	g_object_unref (slot);
-
-	for (l = objects; l; l = g_list_next (l))
-		print_object_information (GP11_OBJECT (l->data));
-	
-	gp11_list_unref_free (objects);
-}
-
-static int
-import_from_file (GP11Session *session, const gchar *filename)
-{
-	GError *err = NULL;
-	GP11Object *import;
-	GP11Attributes *attrs;
-	gchar *basename;
-	gchar *data;
-	gsize n_data;
-	
-	/* Read in the file data */
-	if (!g_file_get_contents (filename, &data, &n_data, &err)) {
-		gkr_tool_handle_error (&err, NULL);
-		return 1;
-	}
-	
-	/* Setup the attributes on the object */
-	attrs = gp11_attributes_new ();
-	gp11_attributes_add_data (attrs, CKA_VALUE, data, n_data);
-	gp11_attributes_add_boolean (attrs, CKA_TOKEN, FALSE);
-	gp11_attributes_add_ulong (attrs, CKA_CLASS, CKO_GNOME_IMPORT);
-	gp11_attributes_add_boolean (attrs, CKA_GNOME_IMPORT_TOKEN, TRUE);
-	basename = g_path_get_basename (filename);
-	gp11_attributes_add_string (attrs, CKA_GNOME_IMPORT_LABEL, basename);
-	g_free (basename);
-	
-	import = gp11_session_create_object_full (session, attrs, NULL, &err);
-	gp11_attributes_unref (attrs);
-	g_free (data);
-	
-	if (!import) {
-		gkr_tool_handle_error (&err, "couldn't import file: %s", filename);
-		return 1;
-	}
-	
-	if (!gkr_tool_mode_quiet)
-		print_import_information (session, import);
-	
-	g_object_unref (import);
-	return 0;
-}
-
-static GP11Session*
-open_import_session (void)
-{
-	GP11Module *module;
-	GP11Session *session;
-	GList *slots;
-	GError *err = NULL;
-	
-	module = gp11_module_initialize (PKCS11_MODULE_PATH, NULL, &err);
-	if (!module) {
-		gkr_tool_handle_error (&err, NULL);
-		return NULL;
-	}
-	
-	slots = gp11_module_get_slots (module, FALSE);
-	g_return_val_if_fail (slots && slots->data, NULL);
-	
-	session = gp11_slot_open_session(slots->data, CKF_RW_SESSION, &err);
-	gp11_list_unref_free (slots);
-	g_object_unref (module);
-	
-	if (!session) {
-		gkr_tool_handle_error (&err, "couldn't connect to gnome-keyring");
-		return NULL;
-	}
-	
-	return session;
-}
-
 int
 gkr_tool_import (int argc, char *argv[])
 {
-	GP11Session *session;
+	GcrImporter *importer;
+	GError *error = NULL;
+	GInputStream *input;
+	gboolean res;
+	GFile *file;
 	gchar **imp;
 	int ret = 0;
 	
@@ -230,17 +114,31 @@
 		return 2;
 	}
 	
-	/* Open a session */
-	session = open_import_session ();
-	if (!session)
-		return 1;
+	importer = gcr_importer_new ();
+	gcr_importer_set_prompt_behavior (importer, GCR_IMPORTER_PROMPT_NEEDED);
+	
+	if (!gkr_tool_mode_quiet) 
+		g_signal_connect (importer, "imported", G_CALLBACK (on_imported), NULL);
 	
 	for (imp = import_files; *imp; ++imp) {
-		ret = import_from_file (session, *imp);
-		if (ret != 0)
-			break;
+		file = g_file_new_for_commandline_arg (*imp);
+		
+		input = G_INPUT_STREAM (g_file_read (file, NULL, &error));
+		g_object_unref (file);
+		if (!input) {
+			gkr_tool_handle_error (&error, "couldn't read file: %s", *imp);
+			ret = 1;
+		}
+		
+		res = gcr_importer_import (importer, input, NULL, &error);
+		g_object_unref (input);
+		if (res == FALSE) {
+			if (!error || error->code != GCR_ERROR_CANCELLED)
+				gkr_tool_handle_error (&error, "couldn't import file: %s", *imp);
+			ret = 1;
+		}
 	}
 	
-	g_object_unref (session);
+	g_object_unref (importer);
 	return ret;
 }

Modified: trunk/tool/gkr-tool.c
==============================================================================
--- trunk/tool/gkr-tool.c	(original)
+++ trunk/tool/gkr-tool.c	Wed Jan 21 22:08:17 2009
@@ -25,9 +25,8 @@
 
 #include "gkr-tool.h"
 
-#include <glib.h>
 #include <glib/gi18n.h>
-#include <glib-object.h>
+#include <gtk/gtk.h>
 
 #include <locale.h>
 #include <string.h>
@@ -127,6 +126,8 @@
 	bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
 #endif
 
+	gtk_init (&argc, &argv);
+	
 	/* The first argument is the command */
 	if (argc < 2) {
 		print_general_usage ();



[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]