src/moonshot-window.c

   1 /* moonshot-window.c generated by valac 0.10.4, the Vala compiler
   2  * generated from moonshot-window.vala, do not modify */
   3
   4
   5 #include <glib.h>
   6 #include <glib-object.h>
   7 #include <gtk/gtk.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <gdk-pixbuf/gdk-pixdata.h>
  11 #include <gdk/gdk.h>
  12 #include <glib/gi18n-lib.h>
  13 #include <pango/pango.h>
  14 #include <float.h>
  15 #include <math.h>
  16 #include <stdio.h>
  17 #include <atk/atk.h>
  18 #include <dbus/dbus-glib-lowlevel.h>
  19 #include <dbus/dbus-glib.h>
  20 #include <dbus/dbus.h>
  21 #include <config.h>
  22
  23
  24 #define TYPE_MAIN_WINDOW (main_window_get_type ())
  25 #define MAIN_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MAIN_WINDOW, MainWindow))
  26 #define MAIN_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MAIN_WINDOW, MainWindowClass))
  27 #define IS_MAIN_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MAIN_WINDOW))
  28 #define IS_MAIN_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MAIN_WINDOW))
  29 #define MAIN_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MAIN_WINDOW, MainWindowClass))
  30
  31 typedef struct _MainWindow MainWindow;
  32 typedef struct _MainWindowClass MainWindowClass;
  33 typedef struct _MainWindowPrivate MainWindowPrivate;
  34
  35 #define TYPE_IDENTITIES_MANAGER (identities_manager_get_type ())
  36 #define IDENTITIES_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_IDENTITIES_MANAGER, IdentitiesManager))
  37 #define IDENTITIES_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_IDENTITIES_MANAGER, IdentitiesManagerClass))
  38 #define IS_IDENTITIES_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_IDENTITIES_MANAGER))
  39 #define IS_IDENTITIES_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_IDENTITIES_MANAGER))
  40 #define IDENTITIES_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_IDENTITIES_MANAGER, IdentitiesManagerClass))
  41
  42 typedef struct _IdentitiesManager IdentitiesManager;
  43 typedef struct _IdentitiesManagerClass IdentitiesManagerClass;
  44
  45 #define TYPE_IDENTITY_REQUEST (identity_request_get_type ())
  46 #define IDENTITY_REQUEST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_IDENTITY_REQUEST, IdentityRequest))
  47 #define IDENTITY_REQUEST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_IDENTITY_REQUEST, IdentityRequestClass))
  48 #define IS_IDENTITY_REQUEST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_IDENTITY_REQUEST))
  49 #define IS_IDENTITY_REQUEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_IDENTITY_REQUEST))
  50 #define IDENTITY_REQUEST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_IDENTITY_REQUEST, IdentityRequestClass))
  51
  52 typedef struct _IdentityRequest IdentityRequest;
  53 typedef struct _IdentityRequestClass IdentityRequestClass;
  54
  55 #define TYPE_CUSTOM_VBOX (custom_vbox_get_type ())
  56 #define CUSTOM_VBOX(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CUSTOM_VBOX, CustomVBox))
  57 #define CUSTOM_VBOX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CUSTOM_VBOX, CustomVBoxClass))
  58 #define IS_CUSTOM_VBOX(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CUSTOM_VBOX))
  59 #define IS_CUSTOM_VBOX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CUSTOM_VBOX))
  60 #define CUSTOM_VBOX_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CUSTOM_VBOX, CustomVBoxClass))
  61
  62 typedef struct _CustomVBox CustomVBox;
  63 typedef struct _CustomVBoxClass CustomVBoxClass;
  64
  65 #define TYPE_ID_CARD (id_card_get_type ())
  66 #define ID_CARD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_ID_CARD, IdCard))
  67 #define ID_CARD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_ID_CARD, IdCardClass))
  68 #define IS_ID_CARD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_ID_CARD))
  69 #define IS_ID_CARD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_ID_CARD))
  70 #define ID_CARD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_ID_CARD, IdCardClass))
  71
  72 typedef struct _IdCard IdCard;
  73 typedef struct _IdCardClass IdCardClass;
  74
  75 #define TYPE_MOONSHOT_SERVER (moonshot_server_get_type ())
  76 #define MOONSHOT_SERVER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MOONSHOT_SERVER, MoonshotServer))
  77 #define MOONSHOT_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MOONSHOT_SERVER, MoonshotServerClass))
  78 #define IS_MOONSHOT_SERVER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MOONSHOT_SERVER))
  79 #define IS_MOONSHOT_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MOONSHOT_SERVER))
  80 #define MOONSHOT_SERVER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MOONSHOT_SERVER, MoonshotServerClass))
  81
  82 typedef struct _MoonshotServer MoonshotServer;
  83 typedef struct _MoonshotServerClass MoonshotServerClass;
  84
  85 #define MAIN_WINDOW_TYPE_COLUMNS (main_window_columns_get_type ())
  86 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
  87 #define __g_slist_free_g_object_unref0(var) ((var == NULL) ? NULL : (var = (_g_slist_free_g_object_unref (var), NULL)))
  88 #define _g_queue_free0(var) ((var == NULL) ? NULL : (var = (g_queue_free (var), NULL)))
  89 #define _g_hash_table_unref0(var) ((var == NULL) ? NULL : (var = (g_hash_table_unref (var), NULL)))
  90 #define _g_free0(var) (var = (g_free (var), NULL))
  91 typedef struct _IdentitiesManagerPrivate IdentitiesManagerPrivate;
  92
  93 #define TYPE_ID_CARD_WIDGET (id_card_widget_get_type ())
  94 #define ID_CARD_WIDGET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_ID_CARD_WIDGET, IdCardWidget))
  95 #define ID_CARD_WIDGET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_ID_CARD_WIDGET, IdCardWidgetClass))
  96 #define IS_ID_CARD_WIDGET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_ID_CARD_WIDGET))
  97 #define IS_ID_CARD_WIDGET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_ID_CARD_WIDGET))
  98 #define ID_CARD_WIDGET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_ID_CARD_WIDGET, IdCardWidgetClass))
  99
 100 typedef struct _IdCardWidget IdCardWidget;
 101 typedef struct _IdCardWidgetClass IdCardWidgetClass;
 102 #define _g_list_free0(var) ((var == NULL) ? NULL : (var = (g_list_free (var), NULL)))
 103
 104 #define TYPE_ADD_IDENTITY_DIALOG (add_identity_dialog_get_type ())
 105 #define ADD_IDENTITY_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_ADD_IDENTITY_DIALOG, AddIdentityDialog))
 106 #define ADD_IDENTITY_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_ADD_IDENTITY_DIALOG, AddIdentityDialogClass))
 107 #define IS_ADD_IDENTITY_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_ADD_IDENTITY_DIALOG))
 108 #define IS_ADD_IDENTITY_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_ADD_IDENTITY_DIALOG))
 109 #define ADD_IDENTITY_DIALOG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_ADD_IDENTITY_DIALOG, AddIdentityDialogClass))
 110
 111 typedef struct _AddIdentityDialog AddIdentityDialog;
 112 typedef struct _AddIdentityDialogClass AddIdentityDialogClass;
 113 typedef struct _IdentityRequestPrivate IdentityRequestPrivate;
 114 #define __g_slist_free_g_free0(var) ((var == NULL) ? NULL : (var = (_g_slist_free_g_free (var), NULL)))
 115
 116 #define TYPE_RULE (rule_get_type ())
 117 typedef struct _Rule Rule;
 118 typedef struct _Block4Data Block4Data;
 119 #define _g_pattern_spec_free0(var) ((var == NULL) ? NULL : (var = (g_pattern_spec_free (var), NULL)))
 120
 121 #define TYPE_ADD_PASSWORD_DIALOG (add_password_dialog_get_type ())
 122 #define ADD_PASSWORD_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_ADD_PASSWORD_DIALOG, AddPasswordDialog))
 123 #define ADD_PASSWORD_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_ADD_PASSWORD_DIALOG, AddPasswordDialogClass))
 124 #define IS_ADD_PASSWORD_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_ADD_PASSWORD_DIALOG))
 125 #define IS_ADD_PASSWORD_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_ADD_PASSWORD_DIALOG))
 126 #define ADD_PASSWORD_DIALOG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_ADD_PASSWORD_DIALOG, AddPasswordDialogClass))
 127
 128 typedef struct _AddPasswordDialog AddPasswordDialog;
 129 typedef struct _AddPasswordDialogClass AddPasswordDialogClass;
 130 #define _pango_font_description_free0(var) ((var == NULL) ? NULL : (var = (pango_font_description_free (var), NULL)))
 131 #define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
 132 #define _dbus_g_connection_unref0(var) ((var == NULL) ? NULL : (var = (dbus_g_connection_unref (var), NULL)))
 133 typedef struct _DBusObjectVTable _DBusObjectVTable;
 134
 135 struct _MainWindow {
 136         GtkWindow parent_instance;
 137         MainWindowPrivate * priv;
 138         IdentitiesManager* identities_manager;
 139         GQueue* request_queue;
 140 };
 141
 142 struct _MainWindowClass {
 143         GtkWindowClass parent_class;
 144 };
 145
 146 struct _MainWindowPrivate {
 147         GtkUIManager* ui_manager;
 148         GtkEntry* search_entry;
 149         GtkVBox* vbox_right;
 150         CustomVBox* custom_vbox;
 151         GtkVBox* services_internal_vbox;
 152         GtkEntry* username_entry;
 153         GtkEntry* password_entry;
 154         GtkListStore* listmodel;
 155         GtkTreeModelFilter* filter;
 156         GSList* candidates;
 157         MoonshotServer* ipc_server;
 158         IdCard* default_id_card;
 159         GHashTable* service_button_map;
 160 };
 161
 162 typedef enum  {
 163         MAIN_WINDOW_COLUMNS_IDCARD_COL,
 164         MAIN_WINDOW_COLUMNS_LOGO_COL,
 165         MAIN_WINDOW_COLUMNS_ISSUER_COL,
 166         MAIN_WINDOW_COLUMNS_USERNAME_COL,
 167         MAIN_WINDOW_COLUMNS_PASSWORD_COL,
 168         MAIN_WINDOW_COLUMNS_N_COLUMNS
 169 } MainWindowColumns;
 170
 171 struct _IdentitiesManager {
 172         GObject parent_instance;
 173         IdentitiesManagerPrivate * priv;
 174         GSList* id_card_list;
 175 };
 176
 177 struct _IdentitiesManagerClass {
 178         GObjectClass parent_class;
 179 };
 180
 181 struct _IdentityRequest {
 182         GObject parent_instance;
 183         IdentityRequestPrivate * priv;
 184         IdCard* id_card;
 185         gboolean complete;
 186         gboolean select_default;
 187         char* nai;
 188         char* password;
 189         char* service;
 190 };
 191
 192 struct _IdentityRequestClass {
 193         GObjectClass parent_class;
 194 };
 195
 196 struct _Rule {
 197         char* pattern;
 198         char* always_confirm;
 199 };
 200
 201 struct _Block4Data {
 202         int _ref_count_;
 203         MainWindow * self;
 204         IdCard* identity;
 205 };
 206
 207 struct _DBusObjectVTable {
 208         void (*register_object) (DBusConnection*, const char*, void*);
 209 };
 210
 211
 212 static gpointer main_window_parent_class = NULL;
 213
 214 GType main_window_get_type (void) G_GNUC_CONST;
 215 GType identities_manager_get_type (void) G_GNUC_CONST;
 216 GType identity_request_get_type (void) G_GNUC_CONST;
 217 GType custom_vbox_get_type (void) G_GNUC_CONST;
 218 GType id_card_get_type (void) G_GNUC_CONST;
 219 GType moonshot_server_get_type (void) G_GNUC_CONST;
 220 #define MAIN_WINDOW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_MAIN_WINDOW, MainWindowPrivate))
 221 enum  {
 222         MAIN_WINDOW_DUMMY_PROPERTY
 223 };
 224 static GType main_window_columns_get_type (void) G_GNUC_UNUSED;
 225 static void _g_slist_free_g_object_unref (GSList* self);
 226 #define MAIN_WINDOW_WINDOW_WIDTH 400
 227 #define MAIN_WINDOW_WINDOW_HEIGHT 500
 228 #define MAIN_WINDOW_layout "\n" \
 229 "<menubar name='MenuBar'>\n" \
 230 "        <menu name='FileMenu' action='FileMenuAction'>\n" \
 231 "            <menuitem name='AddIdCard' action='AddIdCardAction' />\n" \
 232 "            <separator />\n" \
 233 "            <menuitem name='Quit' action='QuitAction' />\n" \
 234 "        </menu>\n" \
 235 "\n" \
 236 "        <menu name='HelpMenu' action='HelpMenuAction'>\n" \
 237 "             <menuitem name='About' action='AboutAction' />\n" \
 238 "        </menu>\n" \
 239 "</menubar>\n"
 240 MainWindow* main_window_new (void);
 241 MainWindow* main_window_construct (GType object_type);
 242 static void main_window_build_ui (MainWindow* self);
 243 static void main_window_setup_identities_list (MainWindow* self);
 244 static void main_window_load_id_cards (MainWindow* self);
 245 static void main_window_connect_signals (MainWindow* self);
 246 static void main_window_init_ipc_server (MainWindow* self);
 247 void main_window_add_candidate (MainWindow* self, IdCard* idcard);
 248 static gboolean main_window_visible_func (MainWindow* self, GtkTreeModel* model, GtkTreeIter* iter);
 249 const char* id_card_get_issuer (IdCard* self);
 250 const char* id_card_get_display_name (IdCard* self);
 251 char** id_card_get_services (IdCard* self, int* result_length1);
 252 static gboolean _main_window_visible_func_gtk_tree_model_filter_visible_func (GtkTreeModel* model, GtkTreeIter* iter, gpointer self);
 253 static void main_window_search_entry_icon_press_cb (MainWindow* self, GtkEntryIconPosition pos, GdkEvent* event);
 254 static void main_window_search_entry_text_changed_cb (MainWindow* self);
 255 static void main_window_redraw_id_card_widgets (MainWindow* self);
 256 static gboolean main_window_search_entry_key_press_event_cb (MainWindow* self, GdkEventKey* e);
 257 IdentitiesManager* identities_manager_new (void);
 258 IdentitiesManager* identities_manager_construct (GType object_type);
 259 static void main_window_add_id_card_data (MainWindow* self, IdCard* id_card);
 260 static void main_window_add_id_card_widget (MainWindow* self, IdCard* id_card);
 261 GType id_card_widget_get_type (void) G_GNUC_CONST;
 262 static void main_window_fill_details (MainWindow* self, IdCardWidget* id_card_widget);
 263 IdCard* id_card_widget_get_id_card (IdCardWidget* self);
 264 const char* id_card_get_username (IdCard* self);
 265 const char* id_card_get_password (IdCard* self);
 266 static void main_window_fill_services_vbox (MainWindow* self, IdCard* id_card);
 267 void identities_manager_store_id_cards (IdentitiesManager* self);
 268 static void main_window_show_details (MainWindow* self, IdCard* id_card);
 269 static void main_window_details_identity_cb (MainWindow* self, IdCardWidget* id_card_widget);
 270 GType add_identity_dialog_get_type (void) G_GNUC_CONST;
 271 static IdCard* main_window_get_id_card_data (MainWindow* self, AddIdentityDialog* dialog);
 272 IdCard* id_card_new (void);
 273 IdCard* id_card_construct (GType object_type);
 274 const char* add_identity_dialog_get_display_name (AddIdentityDialog* self);
 275 void id_card_set_display_name (IdCard* self, const char* value);
 276 const char* add_identity_dialog_get_issuer (AddIdentityDialog* self);
 277 void id_card_set_issuer (IdCard* self, const char* value);
 278 const char* add_identity_dialog_get_username (AddIdentityDialog* self);
 279 void id_card_set_username (IdCard* self, const char* value);
 280 const char* add_identity_dialog_get_password (AddIdentityDialog* self);
 281 void id_card_set_password (IdCard* self, const char* value);
 282 void id_card_set_services (IdCard* self, char** value, int value_length1);
 283 GdkPixbuf* find_icon (const char* name, gint size);
 284 static void main_window_remove_id_card_data (MainWindow* self, IdCard* id_card);
 285 IdCardWidget* id_card_widget_new (IdCard* id_card);
 286 IdCardWidget* id_card_widget_construct (GType object_type, IdCard* id_card);
 287 void custom_vbox_add_id_card_widget (CustomVBox* self, IdCardWidget* id_card_widget);
 288 static void _main_window_details_identity_cb_id_card_widget_details_id (IdCardWidget* _sender, gpointer self);
 289 static void main_window_remove_identity_cb (MainWindow* self, IdCardWidget* id_card_widget);
 290 static void _main_window_remove_identity_cb_id_card_widget_remove_id (IdCardWidget* _sender, gpointer self);
 291 static void _lambda2_ (IdCardWidget* w, MainWindow* self);
 292 void main_window_send_identity_cb (MainWindow* self, IdCard* identity);
 293 static void __lambda2__id_card_widget_send_id (IdCardWidget* _sender, gpointer self);
 294 void custom_vbox_receive_expanded_event (CustomVBox* self, IdCardWidget* id_card_widget);
 295 static void _custom_vbox_receive_expanded_event_id_card_widget_expanded (IdCardWidget* _sender, gpointer self);
 296 static void _main_window_fill_details_id_card_widget_expanded (IdCardWidget* _sender, gpointer self);
 297 gboolean main_window_display_name_is_valid (MainWindow* self, const char* name, char** candidate);
 298 void main_window_insert_id_card (MainWindow* self, IdCard* id_card);
 299 gboolean main_window_add_identity (MainWindow* self, IdCard* id_card);
 300 static void main_window_add_identity_manual_cb (MainWindow* self);
 301 AddIdentityDialog* add_identity_dialog_new (void);
 302 AddIdentityDialog* add_identity_dialog_construct (GType object_type);
 303 static void main_window_remove_id_card_widget (MainWindow* self, IdCardWidget* id_card_widget);
 304 void custom_vbox_remove_id_card_widget (CustomVBox* self, IdCardWidget* id_card_widget);
 305 static void main_window_remove_identity (MainWindow* self, IdCardWidget* id_card_widget);
 306 void main_window_select_identity (MainWindow* self, IdentityRequest* request);
 307 IdCardWidget* custom_vbox_get_current_idcard (CustomVBox* self);
 308 GtkButton* id_card_widget_get_send_button (IdCardWidget* self);
 309 const char* id_card_get_nai (IdCard* self);
 310 static void _g_slist_free_g_free (GSList* self);
 311 GType rule_get_type (void) G_GNUC_CONST;
 312 Rule* rule_dup (const Rule* self);
 313 void rule_free (Rule* self);
 314 void rule_copy (const Rule* self, Rule* dest);
 315 void rule_destroy (Rule* self);
 316 Rule* id_card_get_rules (IdCard* self, int* result_length1);
 317 static gboolean main_window_match_service_pattern (MainWindow* self, const char* service, const char* pattern);
 318 static gboolean _lambda3_ (Block4Data* _data4_);
 319 static gboolean __lambda3__gsource_func (gpointer self);
 320 static Block4Data* block4_data_ref (Block4Data* _data4_);
 321 static void block4_data_unref (Block4Data* _data4_);
 322 AddPasswordDialog* add_password_dialog_new (void);
 323 AddPasswordDialog* add_password_dialog_construct (GType object_type);
 324 GType add_password_dialog_get_type (void) G_GNUC_CONST;
 325 const char* add_password_dialog_get_password (AddPasswordDialog* self);
 326 gboolean add_password_dialog_get_remember (AddPasswordDialog* self);
 327 void identity_request_return_identity (IdentityRequest* self, IdCard* id_card);
 328 static void main_window_label_make_bold (MainWindow* self, GtkLabel* label);
 329 static void _lambda1_ (GtkButton* remove_button, MainWindow* self);
 330 void id_card_widget_update_id_card_label (IdCardWidget* self);
 331 static void __lambda1__gtk_button_clicked (GtkButton* _sender, gpointer self);
 332 static void main_window_on_about_action (MainWindow* self);
 333 static GtkActionEntry* main_window_create_actions (MainWindow* self, int* result_length1);
 334 static void _vala_array_add1 (GtkActionEntry** array, int* length, int* size, const GtkActionEntry* value);
 335 static void _main_window_add_identity_manual_cb_gtk_action_callback (GtkAction* action, gpointer self);
 336 static void _vala_array_add2 (GtkActionEntry** array, int* length, int* size, const GtkActionEntry* value);
 337 static void _gtk_main_quit_gtk_action_callback (GtkAction* action, gpointer self);
 338 static void _vala_array_add3 (GtkActionEntry** array, int* length, int* size, const GtkActionEntry* value);
 339 static void _vala_array_add4 (GtkActionEntry** array, int* length, int* size, const GtkActionEntry* value);
 340 static void _main_window_on_about_action_gtk_action_callback (GtkAction* action, gpointer self);
 341 static void _vala_array_add5 (GtkActionEntry** array, int* length, int* size, const GtkActionEntry* value);
 342 static void main_window_create_ui_manager (MainWindow* self);
 343 static void main_window_set_atk_name_description (MainWindow* self, GtkWidget* widget, const char* name, const char* description);
 344 GdkPixbuf* find_icon_sized (const char* name, GtkIconSize icon_size);
 345 static void _main_window_search_entry_icon_press_cb_gtk_entry_icon_press (GtkEntry* _sender, GtkEntryIconPosition p0, GdkEvent* p1, gpointer self);
 346 static void _main_window_search_entry_text_changed_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
 347 static gboolean _main_window_search_entry_key_press_event_cb_gtk_widget_key_press_event (GtkWidget* _sender, GdkEventKey* event, gpointer self);
 348 CustomVBox* custom_vbox_new (MainWindow* window, gboolean homogeneous, gint spacing);
 349 CustomVBox* custom_vbox_construct (GType object_type, MainWindow* window, gboolean homogeneous, gint spacing);
 350 static void _gtk_main_quit_gtk_object_destroy (GtkObject* _sender, gpointer self);
 351 static guint _dynamic_request_name0 (DBusGProxy* self, const char* param1, guint param2, GError** error);
 352 MoonshotServer* moonshot_server_new (GtkWindow* window);
 353 MoonshotServer* moonshot_server_construct (GType object_type, GtkWindow* window);
 354 static void _vala_dbus_register_object (DBusConnection* connection, const char* path, void* object);
 355 static void _vala_dbus_unregister_object (gpointer connection, GObject* object);
 356 gint main_window_main (char** args, int args_length1);
 357 static void main_window_finalize (GObject* obj);
 358 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
 359 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
 360 static gint _vala_array_length (gpointer array);
 361 static int _vala_strcmp0 (const char * str1, const char * str2);
 362
 363
 364
 365 static GType main_window_columns_get_type (void) {
 366         static volatile gsize main_window_columns_type_id__volatile = 0;
 367         if (g_once_init_enter (&main_window_columns_type_id__volatile)) {
 368                 static const GEnumValue values[] = {{MAIN_WINDOW_COLUMNS_IDCARD_COL, "MAIN_WINDOW_COLUMNS_IDCARD_COL", "idcard-col"}, {MAIN_WINDOW_COLUMNS_LOGO_COL, "MAIN_WINDOW_COLUMNS_LOGO_COL", "logo-col"}, {MAIN_WINDOW_COLUMNS_ISSUER_COL, "MAIN_WINDOW_COLUMNS_ISSUER_COL", "issuer-col"}, {MAIN_WINDOW_COLUMNS_USERNAME_COL, "MAIN_WINDOW_COLUMNS_USERNAME_COL", "username-col"}, {MAIN_WINDOW_COLUMNS_PASSWORD_COL, "MAIN_WINDOW_COLUMNS_PASSWORD_COL", "password-col"}, {MAIN_WINDOW_COLUMNS_N_COLUMNS, "MAIN_WINDOW_COLUMNS_N_COLUMNS", "n-columns"}, {0, NULL, NULL}};
 369                 GType main_window_columns_type_id;
 370                 main_window_columns_type_id = g_enum_register_static ("MainWindowColumns", values);
 371                 g_once_init_leave (&main_window_columns_type_id__volatile, main_window_columns_type_id);
 372         }
 373         return main_window_columns_type_id__volatile;
 374 }
 375
 376
 377 static void _g_slist_free_g_object_unref (GSList* self) {
 378         g_slist_foreach (self, (GFunc) g_object_unref, NULL);
 379         g_slist_free (self);
 380 }
 381
 382
 383 MainWindow* main_window_construct (GType object_type) {
 384         MainWindow * self;
 385         GQueue* _tmp0_;
 386         GHashTable* _tmp1_;
 387         self = g_object_newv (object_type, 0, NULL);
 388         self->request_queue = (_tmp0_ = g_queue_new (), _g_queue_free0 (self->request_queue), _tmp0_);
 389         self->priv->service_button_map = (_tmp1_ = g_hash_table_new_full (g_direct_hash, g_direct_equal, g_object_unref, g_free), _g_hash_table_unref0 (self->priv->service_button_map), _tmp1_);
 390         gtk_window_set_title ((GtkWindow*) self, "Moonshoot");
 391         gtk_window_set_position ((GtkWindow*) self, GTK_WIN_POS_CENTER);
 392         gtk_window_set_default_size ((GtkWindow*) self, MAIN_WINDOW_WINDOW_WIDTH, MAIN_WINDOW_WINDOW_HEIGHT);
 393         main_window_build_ui (self);
 394         main_window_setup_identities_list (self);
 395         main_window_load_id_cards (self);
 396         main_window_connect_signals (self);
 397         main_window_init_ipc_server (self);
 398         return self;
 399 }
 400
 401
 402 MainWindow* main_window_new (void) {
 403         return main_window_construct (TYPE_MAIN_WINDOW);
 404 }
 405
 406
 407 static gpointer _g_object_ref0 (gpointer self) {
 408         return self ? g_object_ref (self) : NULL;
 409 }
 410
 411
 412 void main_window_add_candidate (MainWindow* self, IdCard* idcard) {
 413         g_return_if_fail (self != NULL);
 414         g_return_if_fail (idcard != NULL);
 415         self->priv->candidates = g_slist_append (self->priv->candidates, _g_object_ref0 (idcard));
 416 }
 417
 418
 419 static gboolean string_contains (const char* self, const char* needle) {
 420         gboolean result = FALSE;
 421         g_return_val_if_fail (self != NULL, FALSE);
 422         g_return_val_if_fail (needle != NULL, FALSE);
 423         result = strstr (self, needle) != NULL;
 424         return result;
 425 }
 426
 427
 428 static gboolean main_window_visible_func (MainWindow* self, GtkTreeModel* model, GtkTreeIter* iter) {
 429         gboolean result = FALSE;
 430         IdCard* id_card;
 431         char* entry_text;
 432         gboolean _tmp0_ = FALSE;
 433         g_return_val_if_fail (self != NULL, FALSE);
 434         g_return_val_if_fail (model != NULL, FALSE);
 435         id_card = NULL;
 436         gtk_tree_model_get (model, iter, MAIN_WINDOW_COLUMNS_IDCARD_COL, &id_card, -1);
 437         if (id_card == NULL) {
 438                 result = FALSE;
 439                 _g_object_unref0 (id_card);
 440                 return result;
 441         }
 442         if (self->priv->candidates != NULL) {
 443                 gboolean is_candidate;
 444                 is_candidate = FALSE;
 445                 {
 446                         GSList* candidate_collection;
 447                         GSList* candidate_it;
 448                         candidate_collection = self->priv->candidates;
 449                         for (candidate_it = candidate_collection; candidate_it != NULL; candidate_it = candidate_it->next) {
 450                                 IdCard* candidate;
 451                                 candidate = _g_object_ref0 ((IdCard*) candidate_it->data);
 452                                 {
 453                                         if (candidate == id_card) {
 454                                                 is_candidate = TRUE;
 455                                         }
 456                                         _g_object_unref0 (candidate);
 457                                 }
 458                         }
 459                 }
 460                 if (!is_candidate) {
 461                         result = FALSE;
 462                         _g_object_unref0 (id_card);
 463                         return result;
 464                 }
 465         }
 466         entry_text = g_strdup (gtk_entry_get_text (self->priv->search_entry));
 467         if (entry_text == NULL) {
 468                 _tmp0_ = TRUE;
 469         } else {
 470                 _tmp0_ = _vala_strcmp0 (entry_text, "") == 0;
 471         }
 472         if (_tmp0_) {
 473                 result = TRUE;
 474                 _g_free0 (entry_text);
 475                 _g_object_unref0 (id_card);
 476                 return result;
 477         }
 478         {
 479                 char** _tmp1_;
 480                 char** search_text_collection;
 481                 int search_text_collection_length1;
 482                 int search_text_it;
 483                 search_text_collection = _tmp1_ = g_strsplit (entry_text, " ", 0);
 484                 search_text_collection_length1 = _vala_array_length (_tmp1_);
 485                 for (search_text_it = 0; search_text_it < _vala_array_length (_tmp1_); search_text_it = search_text_it + 1) {
 486                         char* search_text;
 487                         search_text = g_strdup (search_text_collection[search_text_it]);
 488                         {
 489                                 char* search_text_casefold;
 490                                 gint _tmp2_;
 491                                 if (_vala_strcmp0 (search_text, "") == 0) {
 492                                         _g_free0 (search_text);
 493                                         continue;
 494                                 }
 495                                 search_text_casefold = g_utf8_casefold (search_text, -1);
 496                                 if (id_card_get_issuer (id_card) != NULL) {
 497                                         char* issuer_casefold;
 498                                         issuer_casefold = g_strdup (id_card_get_issuer (id_card));
 499                                         if (string_contains (issuer_casefold, search_text_casefold)) {
 500                                                 result = TRUE;
 501                                                 _g_free0 (issuer_casefold);
 502                                                 _g_free0 (search_text_casefold);
 503                                                 _g_free0 (search_text);
 504                                                 search_text_collection = (_vala_array_free (search_text_collection, search_text_collection_length1, (GDestroyNotify) g_free), NULL);
 505                                                 _g_free0 (entry_text);
 506                                                 _g_object_unref0 (id_card);
 507                                                 return result;
 508                                         }
 509                                         _g_free0 (issuer_casefold);
 510                                 }
 511                                 if (id_card_get_display_name (id_card) != NULL) {
 512                                         char* display_name_casefold;
 513                                         display_name_casefold = g_utf8_casefold (id_card_get_display_name (id_card), -1);
 514                                         if (string_contains (display_name_casefold, search_text_casefold)) {
 515                                                 result = TRUE;
 516                                                 _g_free0 (display_name_casefold);
 517                                                 _g_free0 (search_text_casefold);
 518                                                 _g_free0 (search_text);
 519                                                 search_text_collection = (_vala_array_free (search_text_collection, search_text_collection_length1, (GDestroyNotify) g_free), NULL);
 520                                                 _g_free0 (entry_text);
 521                                                 _g_object_unref0 (id_card);
 522                                                 return result;
 523                                         }
 524                                         _g_free0 (display_name_casefold);
 525                                 }
 526                                 if (_tmp2_ > 0) {
 527                                         {
 528                                                 gint _tmp3_;
 529                                                 char** service_collection;
 530                                                 int service_collection_length1;
 531                                                 int service_it;
 532                                                 service_collection = id_card_get_services (id_card, &_tmp3_);
 533                                                 service_collection_length1 = _tmp3_;
 534                                                 for (service_it = 0; service_it < _tmp3_; service_it = service_it + 1) {
 535                                                         char* service;
 536                                                         service = g_strdup (service_collection[service_it]);
 537                                                         {
 538                                                                 char* service_casefold;
 539                                                                 service_casefold = g_utf8_casefold (service, -1);
 540                                                                 if (string_contains (service_casefold, search_text_casefold)) {
 541                                                                         result = TRUE;
 542                                                                         _g_free0 (service_casefold);
 543                                                                         _g_free0 (service);
 544                                                                         _g_free0 (search_text_casefold);
 545                                                                         _g_free0 (search_text);
 546                                                                         search_text_collection = (_vala_array_free (search_text_collection, search_text_collection_length1, (GDestroyNotify) g_free), NULL);
 547                                                                         _g_free0 (entry_text);
 548                                                                         _g_object_unref0 (id_card);
 549                                                                         return result;
 550                                                                 }
 551                                                                 _g_free0 (service_casefold);
 552                                                                 _g_free0 (service);
 553                                                         }
 554                                                 }
 555                                         }
 556                                 }
 557                                 _g_free0 (search_text_casefold);
 558                                 _g_free0 (search_text);
 559                         }
 560                 }
 561                 search_text_collection = (_vala_array_free (search_text_collection, search_text_collection_length1, (GDestroyNotify) g_free), NULL);
 562         }
 563         result = FALSE;
 564         _g_free0 (entry_text);
 565         _g_object_unref0 (id_card);
 566         return result;
 567 }
 568
 569
 570 static gboolean _main_window_visible_func_gtk_tree_model_filter_visible_func (GtkTreeModel* model, GtkTreeIter* iter, gpointer self) {
 571         gboolean result;
 572         result = main_window_visible_func (self, model, iter);
 573         return result;
 574 }
 575
 576
 577 static void main_window_setup_identities_list (MainWindow* self) {
 578         GtkListStore* _tmp0_;
 579         GtkTreeModelFilter* _tmp1_;
 580         g_return_if_fail (self != NULL);
 581         self->priv->listmodel = (_tmp0_ = gtk_list_store_new ((gint) MAIN_WINDOW_COLUMNS_N_COLUMNS, TYPE_ID_CARD, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING), _g_object_unref0 (self->priv->listmodel), _tmp0_);
 582         self->priv->filter = (_tmp1_ = (GtkTreeModelFilter*) gtk_tree_model_filter_new ((GtkTreeModel*) self->priv->listmodel, NULL), _g_object_unref0 (self->priv->filter), _tmp1_);
 583         gtk_tree_model_filter_set_visible_func (self->priv->filter, _main_window_visible_func_gtk_tree_model_filter_visible_func, g_object_ref (self), g_object_unref);
 584 }
 585
 586
 587 static void main_window_search_entry_icon_press_cb (MainWindow* self, GtkEntryIconPosition pos, GdkEvent* event) {
 588         g_return_if_fail (self != NULL);
 589         g_return_if_fail (event != NULL);
 590         if (pos == GTK_ENTRY_ICON_PRIMARY) {
 591                 g_print ("Search entry icon pressed\n");
 592         } else {
 593                 gtk_entry_set_text (self->priv->search_entry, "");
 594         }
 595 }
 596
 597
 598 static void main_window_search_entry_text_changed_cb (MainWindow* self) {
 599         gboolean has_text;
 600         g_return_if_fail (self != NULL);
 601         gtk_tree_model_filter_refilter (self->priv->filter);
 602         main_window_redraw_id_card_widgets (self);
 603         has_text = gtk_entry_get_text_length (self->priv->search_entry) > 0;
 604         gtk_entry_set_icon_sensitive (self->priv->search_entry, GTK_ENTRY_ICON_PRIMARY, has_text);
 605         gtk_entry_set_icon_sensitive (self->priv->search_entry, GTK_ENTRY_ICON_SECONDARY, has_text);
 606         gtk_widget_set_visible ((GtkWidget*) self->priv->vbox_right, FALSE);
 607 }
 608
 609
 610 static gboolean main_window_search_entry_key_press_event_cb (MainWindow* self, GdkEventKey* e) {
 611         gboolean result = FALSE;
 612         g_return_val_if_fail (self != NULL, FALSE);
 613         if (_vala_strcmp0 (gdk_keyval_name ((*e).keyval), "Escape") == 0) {
 614                 gtk_entry_set_text (self->priv->search_entry, "");
 615         }
 616         result = FALSE;
 617         return result;
 618 }
 619
 620
 621 static void main_window_load_id_cards (MainWindow* self) {
 622         IdentitiesManager* _tmp0_;
 623         IdCard* _tmp1_;
 624         g_return_if_fail (self != NULL);
 625         self->identities_manager = (_tmp0_ = identities_manager_new (), _g_object_unref0 (self->identities_manager), _tmp0_);
 626         if (self->identities_manager->id_card_list == NULL) {
 627                 return;
 628         }
 629         {
 630                 GSList* id_card_collection;
 631                 GSList* id_card_it;
 632                 id_card_collection = self->identities_manager->id_card_list;
 633                 for (id_card_it = id_card_collection; id_card_it != NULL; id_card_it = id_card_it->next) {
 634                         IdCard* id_card;
 635                         id_card = _g_object_ref0 ((IdCard*) id_card_it->data);
 636                         {
 637                                 main_window_add_id_card_data (self, id_card);
 638                                 main_window_add_id_card_widget (self, id_card);
 639                                 _g_object_unref0 (id_card);
 640                         }
 641                 }
 642         }
 643         self->priv->default_id_card = (_tmp1_ = _g_object_ref0 ((IdCard*) self->identities_manager->id_card_list->data), _g_object_unref0 (self->priv->default_id_card), _tmp1_);
 644 }
 645
 646
 647 static void main_window_fill_details (MainWindow* self, IdCardWidget* id_card_widget) {
 648         IdCard* id_card;
 649         char* _tmp0_;
 650         GList* children;
 651         g_return_if_fail (self != NULL);
 652         g_return_if_fail (id_card_widget != NULL);
 653         id_card = _g_object_ref0 (id_card_widget_get_id_card (id_card_widget));
 654         gtk_entry_set_text (self->priv->username_entry, id_card_get_username (id_card));
 655         _tmp0_ = g_strdup (id_card_get_password (id_card));
 656         if (_tmp0_ == NULL) {
 657                 char* _tmp1_;
 658                 _tmp0_ = (_tmp1_ = g_strdup (""), _g_free0 (_tmp0_), _tmp1_);
 659         }
 660         gtk_entry_set_text (self->priv->password_entry, _tmp0_);
 661         children = gtk_container_get_children ((GtkContainer*) self->priv->services_internal_vbox);
 662         {
 663                 GList* hbox_collection;
 664                 GList* hbox_it;
 665                 hbox_collection = children;
 666                 for (hbox_it = hbox_collection; hbox_it != NULL; hbox_it = hbox_it->next) {
 667                         GtkWidget* hbox;
 668                         hbox = (GtkWidget*) hbox_it->data;
 669                         {
 670                                 gtk_object_destroy ((GtkObject*) hbox);
 671                         }
 672                 }
 673         }
 674         main_window_fill_services_vbox (self, id_card_widget_get_id_card (id_card_widget));
 675         identities_manager_store_id_cards (self->identities_manager);
 676         _g_list_free0 (children);
 677         _g_free0 (_tmp0_);
 678         _g_object_unref0 (id_card);
 679 }
 680
 681
 682 static void main_window_show_details (MainWindow* self, IdCard* id_card) {
 683         g_return_if_fail (self != NULL);
 684         g_return_if_fail (id_card != NULL);
 685         gtk_widget_set_visible ((GtkWidget*) self->priv->vbox_right, !gtk_widget_get_visible ((GtkWidget*) self->priv->vbox_right));
 686         if (gtk_widget_get_visible ((GtkWidget*) self->priv->vbox_right) == FALSE) {
 687                 gtk_window_resize ((GtkWindow*) self, MAIN_WINDOW_WINDOW_WIDTH, MAIN_WINDOW_WINDOW_HEIGHT);
 688         }
 689 }
 690
 691
 692 static void main_window_details_identity_cb (MainWindow* self, IdCardWidget* id_card_widget) {
 693         g_return_if_fail (self != NULL);
 694         g_return_if_fail (id_card_widget != NULL);
 695         main_window_fill_details (self, id_card_widget);
 696         main_window_show_details (self, id_card_widget_get_id_card (id_card_widget));
 697 }
 698
 699
 700 static IdCard* main_window_get_id_card_data (MainWindow* self, AddIdentityDialog* dialog) {
 701         IdCard* result = NULL;
 702         IdCard* id_card;
 703         char** _tmp0_ = NULL;
 704         char** _tmp1_;
 705         gint _tmp1__length1;
 706         char** _tmp2_;
 707         g_return_val_if_fail (self != NULL, NULL);
 708         g_return_val_if_fail (dialog != NULL, NULL);
 709         id_card = id_card_new ();
 710         id_card_set_display_name (id_card, add_identity_dialog_get_display_name (dialog));
 711         id_card_set_issuer (id_card, add_identity_dialog_get_issuer (dialog));
 712         if (_vala_strcmp0 (id_card_get_issuer (id_card), "") == 0) {
 713                 id_card_set_issuer (id_card, "Issuer");
 714         }
 715         id_card_set_username (id_card, add_identity_dialog_get_username (dialog));
 716         id_card_set_password (id_card, add_identity_dialog_get_password (dialog));
 717         _tmp2_ = (_tmp1_ = (_tmp0_ = g_new0 (char*, 0 + 1), _tmp0_), _tmp1__length1 = 0, _tmp1_);
 718         id_card_set_services (id_card, _tmp2_, 0);
 719         _tmp1_ = (_vala_array_free (_tmp1_, _tmp1__length1, (GDestroyNotify) g_free), NULL);
 720         g_object_set_data_full ((GObject*) id_card, "pixbuf", find_icon ("avatar-default", 48), g_object_unref);
 721         result = id_card;
 722         return result;
 723 }
 724
 725
 726 static void main_window_add_id_card_data (MainWindow* self, IdCard* id_card) {
 727         GtkTreeIter iter = {0};
 728         GdkPixbuf* pixbuf;
 729         GdkPixbuf* _tmp0_;
 730         g_return_if_fail (self != NULL);
 731         g_return_if_fail (id_card != NULL);
 732         pixbuf = NULL;
 733         gtk_list_store_append (self->priv->listmodel, &iter);
 734         pixbuf = (_tmp0_ = _g_object_ref0 ((GdkPixbuf*) g_object_get_data ((GObject*) id_card, "pixbuf")), _g_object_unref0 (pixbuf), _tmp0_);
 735         gtk_list_store_set (self->priv->listmodel, &iter, MAIN_WINDOW_COLUMNS_IDCARD_COL, id_card, MAIN_WINDOW_COLUMNS_LOGO_COL, pixbuf, MAIN_WINDOW_COLUMNS_ISSUER_COL, id_card_get_issuer (id_card), MAIN_WINDOW_COLUMNS_USERNAME_COL, id_card_get_username (id_card), MAIN_WINDOW_COLUMNS_PASSWORD_COL, id_card_get_password (id_card), -1);
 736         _g_object_unref0 (pixbuf);
 737 }
 738
 739
 740 static void main_window_remove_id_card_data (MainWindow* self, IdCard* id_card) {
 741         GtkTreeIter iter = {0};
 742         char* issuer;
 743         g_return_if_fail (self != NULL);
 744         g_return_if_fail (id_card != NULL);
 745         issuer = NULL;
 746         if (gtk_tree_model_get_iter_first ((GtkTreeModel*) self->priv->listmodel, &iter)) {
 747                 {
 748                         gboolean _tmp0_;
 749                         _tmp0_ = TRUE;
 750                         while (TRUE) {
 751                                 if (!_tmp0_) {
 752                                         if (!gtk_tree_model_iter_next ((GtkTreeModel*) self->priv->listmodel, &iter)) {
 753                                                 break;
 754                                         }
 755                                 }
 756                                 _tmp0_ = FALSE;
 757                                 gtk_tree_model_get ((GtkTreeModel*) self->priv->listmodel, &iter, MAIN_WINDOW_COLUMNS_ISSUER_COL, &issuer, -1);
 758                                 if (_vala_strcmp0 (id_card_get_issuer (id_card), issuer) == 0) {
 759                                         gtk_list_store_remove (self->priv->listmodel, &iter);
 760                                         break;
 761                                 }
 762                         }
 763                 }
 764         }
 765         _g_free0 (issuer);
 766 }
 767
 768
 769 static void _main_window_details_identity_cb_id_card_widget_details_id (IdCardWidget* _sender, gpointer self) {
 770         main_window_details_identity_cb (self, _sender);
 771 }
 772
 773
 774 static void _main_window_remove_identity_cb_id_card_widget_remove_id (IdCardWidget* _sender, gpointer self) {
 775         main_window_remove_identity_cb (self, _sender);
 776 }
 777
 778
 779 static void _lambda2_ (IdCardWidget* w, MainWindow* self) {
 780         g_return_if_fail (w != NULL);
 781         main_window_send_identity_cb (self, id_card_widget_get_id_card (w));
 782 }
 783
 784
 785 static void __lambda2__id_card_widget_send_id (IdCardWidget* _sender, gpointer self) {
 786         _lambda2_ (_sender, self);
 787 }
 788
 789
 790 static void _custom_vbox_receive_expanded_event_id_card_widget_expanded (IdCardWidget* _sender, gpointer self) {
 791         custom_vbox_receive_expanded_event (self, _sender);
 792 }
 793
 794
 795 static void _main_window_fill_details_id_card_widget_expanded (IdCardWidget* _sender, gpointer self) {
 796         main_window_fill_details (self, _sender);
 797 }
 798
 799
 800 static void main_window_add_id_card_widget (MainWindow* self, IdCard* id_card) {
 801         IdCardWidget* id_card_widget;
 802         g_return_if_fail (self != NULL);
 803         g_return_if_fail (id_card != NULL);
 804         id_card_widget = g_object_ref_sink (id_card_widget_new (id_card));
 805         custom_vbox_add_id_card_widget (self->priv->custom_vbox, id_card_widget);
 806         g_signal_connect_object (id_card_widget, "details-id", (GCallback) _main_window_details_identity_cb_id_card_widget_details_id, self, 0);
 807         g_signal_connect_object (id_card_widget, "remove-id", (GCallback) _main_window_remove_identity_cb_id_card_widget_remove_id, self, 0);
 808         g_signal_connect_object (id_card_widget, "send-id", (GCallback) __lambda2__id_card_widget_send_id, self, 0);
 809         g_signal_connect_object (id_card_widget, "expanded", (GCallback) _custom_vbox_receive_expanded_event_id_card_widget_expanded, self->priv->custom_vbox, 0);
 810         g_signal_connect_object (id_card_widget, "expanded", (GCallback) _main_window_fill_details_id_card_widget_expanded, self, 0);
 811         _g_object_unref0 (id_card_widget);
 812 }
 813
 814
 815 gboolean main_window_display_name_is_valid (MainWindow* self, const char* name, char** candidate) {
 816         gboolean result = FALSE;
 817         g_return_val_if_fail (self != NULL, FALSE);
 818         g_return_val_if_fail (name != NULL, FALSE);
 819         if (candidate != NULL) {
 820                 *candidate = NULL;
 821         }
 822         {
 823                 GSList* id_card_collection;
 824                 GSList* id_card_it;
 825                 id_card_collection = self->identities_manager->id_card_list;
 826                 for (id_card_it = id_card_collection; id_card_it != NULL; id_card_it = id_card_it->next) {
 827                         IdCard* id_card;
 828                         id_card = _g_object_ref0 ((IdCard*) id_card_it->data);
 829                         {
 830                                 if (_vala_strcmp0 (id_card_get_display_name (id_card), name) == 0) {
 831                                         if ((candidate) != NULL) {
 832                                                 {
 833                                                         gint i;
 834                                                         i = 0;
 835                                                         {
 836                                                                 gboolean _tmp0_;
 837                                                                 _tmp0_ = TRUE;
 838                                                                 while (TRUE) {
 839                                                                         char* tmp;
 840                                                                         if (!_tmp0_) {
 841                                                                                 i++;
 842                                                                         }
 843                                                                         _tmp0_ = FALSE;
 844                                                                         if (!(i < 1000)) {
 845                                                                                 break;
 846                                                                         }
 847                                                                         tmp = g_strdup_printf ("%s %d", name, i);
 848                                                                         if (main_window_display_name_is_valid (self, tmp, NULL)) {
 849                                                                                 char* _tmp1_;
 850                                                                                 *candidate = (_tmp1_ = g_strdup (tmp), _g_free0 (*candidate), _tmp1_);
 851                                                                                 _g_free0 (tmp);
 852                                                                                 break;
 853                                                                         }
 854                                                                         _g_free0 (tmp);
 855                                                                 }
 856                                                         }
 857                                                 }
 858                                         }
 859                                         result = FALSE;
 860                                         _g_object_unref0 (id_card);
 861                                         return result;
 862                                 }
 863                                 _g_object_unref0 (id_card);
 864                         }
 865                 }
 866         }
 867         result = TRUE;
 868         return result;
 869 }
 870
 871
 872 void main_window_insert_id_card (MainWindow* self, IdCard* id_card) {
 873         char* candidate;
 874         char* _tmp0_ = NULL;
 875         gboolean _tmp1_;
 876         char* _tmp2_;
 877         g_return_if_fail (self != NULL);
 878         g_return_if_fail (id_card != NULL);
 879         candidate = NULL;
 880         if (!(_tmp1_ = main_window_display_name_is_valid (self, id_card_get_display_name (id_card), &_tmp0_), candidate = (_tmp2_ = _tmp0_, _g_free0 (candidate), _tmp2_), _tmp1_)) {
 881                 id_card_set_display_name (id_card, candidate);
 882         }
 883         self->identities_manager->id_card_list = g_slist_prepend (self->identities_manager->id_card_list, _g_object_ref0 (id_card));
 884         identities_manager_store_id_cards (self->identities_manager);
 885         main_window_add_id_card_data (self, id_card);
 886         main_window_add_id_card_widget (self, id_card);
 887         _g_free0 (candidate);
 888 }
 889
 890
 891 gboolean main_window_add_identity (MainWindow* self, IdCard* id_card) {
 892         gboolean result = FALSE;
 893         GtkMessageDialog* dialog;
 894         gint ret;
 895         g_return_val_if_fail (self != NULL, FALSE);
 896         g_return_val_if_fail (id_card != NULL, FALSE);
 897         dialog = g_object_ref_sink ((GtkMessageDialog*) gtk_message_dialog_new ((GtkWindow*) self, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, _ ("Would you like to add '%s' ID Card to the ID Card Organizer?"), id_card_get_display_name (id_card)));
 898         gtk_widget_show_all ((GtkWidget*) dialog);
 899         ret = gtk_dialog_run ((GtkDialog*) dialog);
 900         gtk_widget_hide ((GtkWidget*) dialog);
 901         if (ret == GTK_RESPONSE_YES) {
 902                 g_object_set_data_full ((GObject*) id_card, "pixbuf", find_icon ("avatar-default", 48), g_object_unref);
 903                 main_window_insert_id_card (self, id_card);
 904                 result = TRUE;
 905                 _g_object_unref0 (dialog);
 906                 return result;
 907         }
 908         result = FALSE;
 909         _g_object_unref0 (dialog);
 910         return result;
 911 }
 912
 913
 914 static void main_window_add_identity_manual_cb (MainWindow* self) {
 915         AddIdentityDialog* dialog;
 916         gint _result_;
 917         g_return_if_fail (self != NULL);
 918         dialog = g_object_ref_sink (add_identity_dialog_new ());
 919         _result_ = gtk_dialog_run ((GtkDialog*) dialog);
 920         switch (_result_) {
 921                 case GTK_RESPONSE_OK:
 922                 {
 923                         IdCard* _tmp0_;
 924                         main_window_insert_id_card (self, _tmp0_ = main_window_get_id_card_data (self, dialog));
 925                         _g_object_unref0 (_tmp0_);
 926                         break;
 927                 }
 928                 default:
 929                 {
 930                         break;
 931                 }
 932         }
 933         gtk_object_destroy ((GtkObject*) dialog);
 934         _g_object_unref0 (dialog);
 935 }
 936
 937
 938 static void main_window_remove_id_card_widget (MainWindow* self, IdCardWidget* id_card_widget) {
 939         g_return_if_fail (self != NULL);
 940         g_return_if_fail (id_card_widget != NULL);
 941         main_window_remove_id_card_data (self, id_card_widget_get_id_card (id_card_widget));
 942         custom_vbox_remove_id_card_widget (self->priv->custom_vbox, id_card_widget);
 943 }
 944
 945
 946 static void main_window_remove_identity (MainWindow* self, IdCardWidget* id_card_widget) {
 947         IdCard* id_card;
 948         g_return_if_fail (self != NULL);
 949         g_return_if_fail (id_card_widget != NULL);
 950         id_card = _g_object_ref0 (id_card_widget_get_id_card (id_card_widget));
 951         self->identities_manager->id_card_list = g_slist_remove (self->identities_manager->id_card_list, id_card);
 952         identities_manager_store_id_cards (self->identities_manager);
 953         main_window_remove_id_card_widget (self, id_card_widget);
 954         _g_object_unref0 (id_card);
 955 }
 956
 957
 958 static void main_window_redraw_id_card_widgets (MainWindow* self) {
 959         GtkTreeIter iter = {0};
 960         IdCard* id_card;
 961         GList* children;
 962         g_return_if_fail (self != NULL);
 963         id_card = NULL;
 964         children = gtk_container_get_children ((GtkContainer*) self->priv->custom_vbox);
 965         {
 966                 GList* id_card_widget_collection;
 967                 GList* id_card_widget_it;
 968                 id_card_widget_collection = children;
 969                 for (id_card_widget_it = id_card_widget_collection; id_card_widget_it != NULL; id_card_widget_it = id_card_widget_it->next) {
 970                         GtkWidget* id_card_widget;
 971                         id_card_widget = (GtkWidget*) id_card_widget_it->data;
 972                         {
 973                                 gtk_object_destroy ((GtkObject*) id_card_widget);
 974                         }
 975                 }
 976         }
 977         if (gtk_tree_model_get_iter_first ((GtkTreeModel*) self->priv->filter, &iter)) {
 978                 {
 979                         gboolean _tmp0_;
 980                         _tmp0_ = TRUE;
 981                         while (TRUE) {
 982                                 if (!_tmp0_) {
 983                                         if (!gtk_tree_model_iter_next ((GtkTreeModel*) self->priv->filter, &iter)) {
 984                                                 break;
 985                                         }
 986                                 }
 987                                 _tmp0_ = FALSE;
 988                                 gtk_tree_model_get ((GtkTreeModel*) self->priv->filter, &iter, MAIN_WINDOW_COLUMNS_IDCARD_COL, &id_card, -1);
 989                                 main_window_add_id_card_widget (self, id_card);
 990                         }
 991                 }
 992         }
 993         _g_list_free0 (children);
 994         _g_object_unref0 (id_card);
 995 }
 996
 997
 998 static void main_window_remove_identity_cb (MainWindow* self, IdCardWidget* id_card_widget) {
 999         IdCard* id_card;
1000         GtkMessageDialog* dialog;
1001         gint _result_;
1002         g_return_if_fail (self != NULL);
1003         g_return_if_fail (id_card_widget != NULL);
1004         id_card = _g_object_ref0 (id_card_widget_get_id_card (id_card_widget));
1005         dialog = g_object_ref_sink ((GtkMessageDialog*) gtk_message_dialog_new (NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_YES_NO, _ ("Are you sure you want to delete %s ID Card?"), id_card_get_issuer (id_card)));
1006         _result_ = gtk_dialog_run ((GtkDialog*) dialog);
1007         switch (_result_) {
1008                 case GTK_RESPONSE_YES:
1009                 {
1010                         main_window_remove_identity (self, id_card_widget);
1011                         break;
1012                 }
1013                 default:
1014                 {
1015                         break;
1016                 }
1017         }
1018         gtk_object_destroy ((GtkObject*) dialog);
1019         _g_object_unref0 (dialog);
1020         _g_object_unref0 (id_card);
1021 }
1022
1023
1024 static void _g_slist_free_g_free (GSList* self) {
1025         g_slist_foreach (self, (GFunc) g_free, NULL);
1026         g_slist_free (self);
1027 }
1028
1029
1030 static gboolean _lambda3_ (Block4Data* _data4_) {
1031         MainWindow * self;
1032         gboolean result = FALSE;
1033         self = _data4_->self;
1034         main_window_send_identity_cb (self, _data4_->identity);
1035         result = FALSE;
1036         return result;
1037 }
1038
1039
1040 static gboolean __lambda3__gsource_func (gpointer self) {
1041         gboolean result;
1042         result = _lambda3_ (self);
1043         return result;
1044 }
1045
1046
1047 static Block4Data* block4_data_ref (Block4Data* _data4_) {
1048         g_atomic_int_inc (&_data4_->_ref_count_);
1049         return _data4_;
1050 }
1051
1052
1053 static void block4_data_unref (Block4Data* _data4_) {
1054         if (g_atomic_int_dec_and_test (&_data4_->_ref_count_)) {
1055                 _g_object_unref0 (_data4_->self);
1056                 _g_object_unref0 (_data4_->identity);
1057                 g_slice_free (Block4Data, _data4_);
1058         }
1059 }
1060
1061
1062 void main_window_select_identity (MainWindow* self, IdentityRequest* request) {
1063         Block4Data* _data4_;
1064         gboolean _tmp0_ = FALSE;
1065         g_return_if_fail (self != NULL);
1066         g_return_if_fail (request != NULL);
1067         _data4_ = g_slice_new0 (Block4Data);
1068         _data4_->_ref_count_ = 1;
1069         _data4_->self = g_object_ref (self);
1070         _data4_->identity = NULL;
1071         g_queue_push_tail (self->request_queue, _g_object_ref0 (request));
1072         if (custom_vbox_get_current_idcard (self->priv->custom_vbox) != NULL) {
1073                 _tmp0_ = id_card_widget_get_send_button (custom_vbox_get_current_idcard (self->priv->custom_vbox)) != NULL;
1074         } else {
1075                 _tmp0_ = FALSE;
1076         }
1077         if (_tmp0_) {
1078                 gtk_widget_set_sensitive ((GtkWidget*) id_card_widget_get_send_button (custom_vbox_get_current_idcard (self->priv->custom_vbox)), TRUE);
1079         }
1080         if (request->select_default) {
1081                 IdCard* _tmp1_;
1082                 _data4_->identity = (_tmp1_ = _g_object_ref0 (self->priv->default_id_card), _g_object_unref0 (_data4_->identity), _tmp1_);
1083         }
1084         if (_data4_->identity == NULL) {
1085                 gboolean _tmp2_ = FALSE;
1086                 gboolean has_nai;
1087                 gboolean _tmp3_ = FALSE;
1088                 gboolean has_srv;
1089                 gboolean confirm;
1090                 IdCard* nai_provided;
1091                 gboolean _tmp7_ = FALSE;
1092                 if (request->nai != NULL) {
1093                         _tmp2_ = _vala_strcmp0 (request->nai, "") != 0;
1094                 } else {
1095                         _tmp2_ = FALSE;
1096                 }
1097                 has_nai = _tmp2_;
1098                 if (request->service != NULL) {
1099                         _tmp3_ = _vala_strcmp0 (request->service, "") != 0;
1100                 } else {
1101                         _tmp3_ = FALSE;
1102                 }
1103                 has_srv = _tmp3_;
1104                 confirm = FALSE;
1105                 nai_provided = NULL;
1106                 {
1107                         GSList* id_collection;
1108                         GSList* id_it;
1109                         id_collection = self->identities_manager->id_card_list;
1110                         for (id_it = id_collection; id_it != NULL; id_it = id_it->next) {
1111                                 IdCard* id;
1112                                 id = _g_object_ref0 ((IdCard*) id_it->data);
1113                                 {
1114                                         gboolean _tmp4_ = FALSE;
1115                                         if (has_nai) {
1116                                                 _tmp4_ = _vala_strcmp0 (request->nai, id_card_get_nai (id)) == 0;
1117                                         } else {
1118                                                 _tmp4_ = FALSE;
1119                                         }
1120                                         if (_tmp4_) {
1121                                                 IdCard* _tmp5_;
1122                                                 nai_provided = (_tmp5_ = _g_object_ref0 (id), _g_object_unref0 (nai_provided), _tmp5_);
1123                                                 main_window_add_candidate (self, id);
1124                                                 _g_object_unref0 (id);
1125                                                 continue;
1126                                         }
1127                                         if (has_srv) {
1128                                                 {
1129                                                         gint _tmp6_;
1130                                                         char** srv_collection;
1131                                                         int srv_collection_length1;
1132                                                         int srv_it;
1133                                                         srv_collection = id_card_get_services (id, &_tmp6_);
1134                                                         srv_collection_length1 = _tmp6_;
1135                                                         for (srv_it = 0; srv_it < _tmp6_; srv_it = srv_it + 1) {
1136                                                                 char* srv;
1137                                                                 srv = g_strdup (srv_collection[srv_it]);
1138                                                                 {
1139                                                                         if (_vala_strcmp0 (request->service, srv) == 0) {
1140                                                                                 main_window_add_candidate (self, id);
1141                                                                                 _g_free0 (srv);
1142                                                                                 continue;
1143                                                                         }
1144                                                                         _g_free0 (srv);
1145                                                                 }
1146                                                         }
1147                                                 }
1148                                         }
1149                                         _g_object_unref0 (id);
1150                                 }
1151                         }
1152                 }
1153                 if (has_srv) {
1154                         _tmp7_ = g_slist_length (self->priv->candidates) > 1;
1155                 } else {
1156                         _tmp7_ = FALSE;
1157                 }
1158                 if (_tmp7_) {
1159                         {
1160                                 GSList* id_collection;
1161                                 GSList* id_it;
1162                                 id_collection = self->priv->candidates;
1163                                 for (id_it = id_collection; id_it != NULL; id_it = id_it->next) {
1164                                         IdCard* id;
1165                                         id = _g_object_ref0 ((IdCard*) id_it->data);
1166                                         {
1167                                                 gint i;
1168                                                 GSList* services_list;
1169                                                 gboolean has_service;
1170                                                 gint services_length1;
1171                                                 gint _services_size_;
1172                                                 char** _tmp13_;
1173                                                 gint _tmp12_;
1174                                                 char** services;
1175                                                 char** _tmp15_;
1176                                                 i = 0;
1177                                                 services_list = NULL;
1178                                                 has_service = FALSE;
1179                                                 {
1180                                                         gint _tmp8_;
1181                                                         char** srv_collection;
1182                                                         int srv_collection_length1;
1183                                                         int srv_it;
1184                                                         srv_collection = id_card_get_services (id, &_tmp8_);
1185                                                         srv_collection_length1 = _tmp8_;
1186                                                         for (srv_it = 0; srv_it < _tmp8_; srv_it = srv_it + 1) {
1187                                                                 char* srv;
1188                                                                 srv = g_strdup (srv_collection[srv_it]);
1189                                                                 {
1190                                                                         if (_vala_strcmp0 (srv, request->service) == 0) {
1191                                                                                 has_service = TRUE;
1192                                                                                 _g_free0 (srv);
1193                                                                                 continue;
1194                                                                         }
1195                                                                         services_list = g_slist_append (services_list, g_strdup (srv));
1196                                                                         _g_free0 (srv);
1197                                                                 }
1198                                                         }
1199                                                 }
1200                                                 if (!has_service) {
1201                                                         __g_slist_free_g_free0 (services_list);
1202                                                         _g_object_unref0 (id);
1203                                                         continue;
1204                                                 }
1205                                                 if (g_slist_length (services_list) == 0) {
1206                                                         char** _tmp9_ = NULL;
1207                                                         char** _tmp10_;
1208                                                         gint _tmp10__length1;
1209                                                         char** _tmp11_;
1210                                                         _tmp11_ = (_tmp10_ = (_tmp9_ = g_new0 (char*, 0 + 1), _tmp9_), _tmp10__length1 = 0, _tmp10_);
1211                                                         id_card_set_services (id, _tmp11_, 0);
1212                                                         _tmp10_ = (_vala_array_free (_tmp10_, _tmp10__length1, (GDestroyNotify) g_free), NULL);
1213                                                         __g_slist_free_g_free0 (services_list);
1214                                                         _g_object_unref0 (id);
1215                                                         continue;
1216                                                 }
1217                                                 services = (_tmp13_ = g_new0 (char*, (_tmp12_ = g_slist_length (services_list)) + 1), services_length1 = _tmp12_, _services_size_ = services_length1, _tmp13_);
1218                                                 {
1219                                                         GSList* srv_collection;
1220                                                         GSList* srv_it;
1221                                                         srv_collection = services_list;
1222                                                         for (srv_it = srv_collection; srv_it != NULL; srv_it = srv_it->next) {
1223                                                                 char* srv;
1224                                                                 srv = g_strdup ((const char*) srv_it->data);
1225                                                                 {
1226                                                                         char* _tmp14_;
1227                                                                         services[i] = (_tmp14_ = g_strdup (srv), _g_free0 (services[i]), _tmp14_);
1228                                                                         i++;
1229                                                                         _g_free0 (srv);
1230                                                                 }
1231                                                         }
1232                                                 }
1233                                                 _tmp15_ = services;
1234                                                 id_card_set_services (id, _tmp15_, services_length1);
1235                                                 services = (_vala_array_free (services, services_length1, (GDestroyNotify) g_free), NULL);
1236                                                 __g_slist_free_g_free0 (services_list);
1237                                                 _g_object_unref0 (id);
1238                                         }
1239                                 }
1240                         }
1241                 }
1242                 identities_manager_store_id_cards (self->identities_manager);
1243                 if (g_slist_length (self->priv->candidates) == 0) {
1244                         {
1245                                 GSList* id_collection;
1246                                 GSList* id_it;
1247                                 id_collection = self->identities_manager->id_card_list;
1248                                 for (id_it = id_collection; id_it != NULL; id_it = id_it->next) {
1249                                         IdCard* id;
1250                                         id = _g_object_ref0 ((IdCard*) id_it->data);
1251                                         {
1252                                                 {
1253                                                         gint _tmp16_;
1254                                                         Rule* rule_collection;
1255                                                         int rule_collection_length1;
1256                                                         int rule_it;
1257                                                         rule_collection = id_card_get_rules (id, &_tmp16_);
1258                                                         rule_collection_length1 = _tmp16_;
1259                                                         for (rule_it = 0; rule_it < _tmp16_; rule_it = rule_it + 1) {
1260                                                                 Rule _tmp17_ = {0};
1261                                                                 Rule rule;
1262                                                                 rule = (rule_copy (&rule_collection[rule_it], &_tmp17_), _tmp17_);
1263                                                                 {
1264                                                                         if (!main_window_match_service_pattern (self, request->service, rule.pattern)) {
1265                                                                                 rule_destroy (&rule);
1266                                                                                 continue;
1267                                                                         }
1268                                                                         self->priv->candidates = g_slist_append (self->priv->candidates, _g_object_ref0 (id));
1269                                                                         if (_vala_strcmp0 (rule.always_confirm, "true") == 0) {
1270                                                                                 confirm = TRUE;
1271                                                                         }
1272                                                                         rule_destroy (&rule);
1273                                                                 }
1274                                                         }
1275                                                 }
1276                                                 _g_object_unref0 (id);
1277                                         }
1278                                 }
1279                         }
1280                 }
1281                 if (g_slist_length (self->priv->candidates) > 1) {
1282                         gboolean _tmp18_ = FALSE;
1283                         if (has_nai) {
1284                                 _tmp18_ = nai_provided != NULL;
1285                         } else {
1286                                 _tmp18_ = FALSE;
1287                         }
1288                         if (_tmp18_) {
1289                                 IdCard* _tmp19_;
1290                                 _data4_->identity = (_tmp19_ = _g_object_ref0 (nai_provided), _g_object_unref0 (_data4_->identity), _tmp19_);
1291                                 confirm = FALSE;
1292                         } else {
1293                                 confirm = TRUE;
1294                         }
1295                 } else {
1296                         IdCard* _tmp20_;
1297                         _data4_->identity = (_tmp20_ = _g_object_ref0 ((IdCard*) g_slist_nth_data (self->priv->candidates, (guint) 0)), _g_object_unref0 (_data4_->identity), _tmp20_);
1298                 }
1299                 if (confirm) {
1300                         gtk_tree_model_filter_refilter (self->priv->filter);
1301                         main_window_redraw_id_card_widgets (self);
1302                         gtk_widget_show ((GtkWidget*) self);
1303                         _g_object_unref0 (nai_provided);
1304                         block4_data_unref (_data4_);
1305                         return;
1306                 }
1307                 _g_object_unref0 (nai_provided);
1308         }
1309         g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, __lambda3__gsource_func, block4_data_ref (_data4_), block4_data_unref);
1310         block4_data_unref (_data4_);
1311         return;
1312 }
1313
1314
1315 static gboolean main_window_match_service_pattern (MainWindow* self, const char* service, const char* pattern) {
1316         gboolean result = FALSE;
1317         GPatternSpec* pspec;
1318         g_return_val_if_fail (self != NULL, FALSE);
1319         g_return_val_if_fail (service != NULL, FALSE);
1320         g_return_val_if_fail (pattern != NULL, FALSE);
1321         pspec = g_pattern_spec_new (pattern);
1322         result = g_pattern_match_string (pspec, service);
1323         _g_pattern_spec_free0 (pspec);
1324         return result;
1325 }
1326
1327
1328 void main_window_send_identity_cb (MainWindow* self, IdCard* identity) {
1329         IdentityRequest* request;
1330         gboolean reset_password;
1331         gboolean _tmp0_ = FALSE;
1332         GSList* _tmp12_;
1333         g_return_if_fail (self != NULL);
1334         g_return_if_fail (identity != NULL);
1335         g_return_if_fail (self->request_queue->length > 0);
1336         request = (IdentityRequest*) g_queue_pop_head (self->request_queue);
1337         reset_password = FALSE;
1338         if (request->service != NULL) {
1339                 _tmp0_ = _vala_strcmp0 (request->service, "") != 0;
1340         } else {
1341                 _tmp0_ = FALSE;
1342         }
1343         if (_tmp0_) {
1344                 gint services_length1;
1345                 gint _services_size_;
1346                 char** _tmp2_;
1347                 gint _tmp1_;
1348                 char** services;
1349                 gint _tmp7_;
1350                 gint _tmp8_;
1351                 char* _tmp9_;
1352                 char** _tmp10_;
1353                 services = (_tmp2_ = g_new0 (char*, (_tmp1_ + 1) + 1), services_length1 = _tmp1_ + 1, _services_size_ = services_length1, _tmp2_);
1354                 {
1355                         gint i;
1356                         i = 0;
1357                         {
1358                                 gboolean _tmp3_;
1359                                 _tmp3_ = TRUE;
1360                                 while (TRUE) {
1361                                         gint _tmp4_;
1362                                         gint _tmp5_;
1363                                         char* _tmp6_;
1364                                         if (!_tmp3_) {
1365                                                 i++;
1366                                         }
1367                                         _tmp3_ = FALSE;
1368                                         if (!(i < _tmp4_)) {
1369                                                 break;
1370                                         }
1371                                         services[i] = (_tmp6_ = g_strdup (id_card_get_services (identity, &_tmp5_)[i]), _g_free0 (services[i]), _tmp6_);
1372                                 }
1373                         }
1374                 }
1375                 services[_tmp7_] = (_tmp9_ = g_strdup (request->service), _g_free0 (services[_tmp7_]), _tmp9_);
1376                 _tmp10_ = services;
1377                 id_card_set_services (identity, _tmp10_, services_length1);
1378                 identities_manager_store_id_cards (self->identities_manager);
1379                 services = (_vala_array_free (services, services_length1, (GDestroyNotify) g_free), NULL);
1380         }
1381         if (id_card_get_password (identity) == NULL) {
1382                 AddPasswordDialog* dialog;
1383                 gint _result_;
1384                 dialog = g_object_ref_sink (add_password_dialog_new ());
1385                 _result_ = gtk_dialog_run ((GtkDialog*) dialog);
1386                 switch (_result_) {
1387                         case GTK_RESPONSE_OK:
1388                         {
1389                                 id_card_set_password (identity, add_password_dialog_get_password (dialog));
1390                                 reset_password = !add_password_dialog_get_remember (dialog);
1391                                 break;
1392                         }
1393                         default:
1394                         {
1395                                 identity = NULL;
1396                                 break;
1397                         }
1398                 }
1399                 gtk_object_destroy ((GtkObject*) dialog);
1400                 _g_object_unref0 (dialog);
1401         }
1402         if (g_queue_is_empty (self->request_queue)) {
1403                 gtk_widget_hide ((GtkWidget*) self);
1404         }
1405         if (identity != NULL) {
1406                 IdCard* _tmp11_;
1407                 self->priv->default_id_card = (_tmp11_ = _g_object_ref0 (identity), _g_object_unref0 (self->priv->default_id_card), _tmp11_);
1408         }
1409         identity_request_return_identity (request, identity);
1410         if (reset_password) {
1411                 id_card_set_password (identity, NULL);
1412         }
1413         self->priv->candidates = (_tmp12_ = NULL, __g_slist_free_g_object_unref0 (self->priv->candidates), _tmp12_);
1414         _g_object_unref0 (request);
1415 }
1416
1417
1418 static void main_window_label_make_bold (MainWindow* self, GtkLabel* label) {
1419         PangoFontDescription* font_desc;
1420         g_return_if_fail (self != NULL);
1421         g_return_if_fail (label != NULL);
1422         font_desc = pango_font_description_new ();
1423         pango_font_description_set_weight (font_desc, PANGO_WEIGHT_BOLD);
1424         gtk_widget_modify_font ((GtkWidget*) label, font_desc);
1425         _pango_font_description_free0 (font_desc);
1426 }
1427
1428
1429 static void _lambda1_ (GtkButton* remove_button, MainWindow* self) {
1430         GtkMessageDialog* dialog;
1431         gint ret;
1432         g_return_if_fail (remove_button != NULL);
1433         dialog = g_object_ref_sink ((GtkMessageDialog*) gtk_message_dialog_new ((GtkWindow*) self, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, _ ("Are you sure you want to stop '%s' ID Card to use %s?"), id_card_get_display_name (id_card_widget_get_id_card (custom_vbox_get_current_idcard (self->priv->custom_vbox)))));
1434         ret = gtk_dialog_run ((GtkDialog*) dialog);
1435         gtk_widget_hide ((GtkWidget*) dialog);
1436         if (ret == GTK_RESPONSE_YES) {
1437                 IdCard* idcard;
1438                 char* candidate;
1439                 GSList* services;
1440                 gint _tmp1_;
1441                 char** _tmp2_;
1442                 gint _tmp2__length1;
1443                 char** _tmp3_;
1444                 GList* children;
1445                 idcard = _g_object_ref0 (id_card_widget_get_id_card (custom_vbox_get_current_idcard (self->priv->custom_vbox)));
1446                 candidate = g_strdup ((const char*) g_hash_table_lookup (self->priv->service_button_map, remove_button));
1447                 services = NULL;
1448                 {
1449                         gint _tmp0_;
1450                         char** srv_collection;
1451                         int srv_collection_length1;
1452                         int srv_it;
1453                         srv_collection = id_card_get_services (idcard, &_tmp0_);
1454                         srv_collection_length1 = _tmp0_;
1455                         for (srv_it = 0; srv_it < _tmp0_; srv_it = srv_it + 1) {
1456                                 char* srv;
1457                                 srv = g_strdup (srv_collection[srv_it]);
1458                                 {
1459                                         if (_vala_strcmp0 (srv, candidate) == 0) {
1460                                                 _g_free0 (srv);
1461                                                 continue;
1462                                         }
1463                                         services = g_slist_append (services, g_strdup (srv));
1464                                         _g_free0 (srv);
1465                                 }
1466                         }
1467                 }
1468                 _tmp3_ = (_tmp2_ = g_new0 (char*, (_tmp1_ = g_slist_length (services)) + 1), _tmp2__length1 = _tmp1_, _tmp2_);
1469                 id_card_set_services (idcard, _tmp3_, _tmp1_);
1470                 _tmp2_ = (_vala_array_free (_tmp2_, _tmp2__length1, (GDestroyNotify) g_free), NULL);
1471                 {
1472                         gint j;
1473                         j = 0;
1474                         {
1475                                 gboolean _tmp4_;
1476                                 _tmp4_ = TRUE;
1477                                 while (TRUE) {
1478                                         gint _tmp5_;
1479                                         gint _tmp6_;
1480                                         gint _tmp7_;
1481                                         char* *_tmp8_;
1482                                         char* _tmp9_;
1483                                         if (!_tmp4_) {
1484                                                 j++;
1485                                         }
1486                                         _tmp4_ = FALSE;
1487                                         if (!(j < _tmp5_)) {
1488                                                 break;
1489                                         }
1490                                         _tmp8_ = &id_card_get_services (idcard, &_tmp7_)[j];
1491                                         (*_tmp8_) = (_tmp9_ = g_strdup ((const char*) g_slist_nth_data (services, (guint) j)), _g_free0 ((*_tmp8_)), _tmp9_);
1492                                 }
1493                         }
1494                 }
1495                 children = gtk_container_get_children ((GtkContainer*) self->priv->services_internal_vbox);
1496                 {
1497                         GList* hbox_collection;
1498                         GList* hbox_it;
1499                         hbox_collection = children;
1500                         for (hbox_it = hbox_collection; hbox_it != NULL; hbox_it = hbox_it->next) {
1501                                 GtkWidget* hbox;
1502                                 hbox = (GtkWidget*) hbox_it->data;
1503                                 {
1504                                         gtk_object_destroy ((GtkObject*) hbox);
1505                                 }
1506                         }
1507                 }
1508                 main_window_fill_services_vbox (self, idcard);
1509                 id_card_widget_update_id_card_label (custom_vbox_get_current_idcard (self->priv->custom_vbox));
1510                 _g_list_free0 (children);
1511                 __g_slist_free_g_free0 (services);
1512                 _g_free0 (candidate);
1513                 _g_object_unref0 (idcard);
1514         }
1515         _g_object_unref0 (dialog);
1516 }
1517
1518
1519 static void __lambda1__gtk_button_clicked (GtkButton* _sender, gpointer self) {
1520         _lambda1_ (_sender, self);
1521 }
1522
1523
1524 static void main_window_fill_services_vbox (MainWindow* self, IdCard* id_card) {
1525         gint i;
1526         gint _tmp0_;
1527         gint n_columns;
1528         GtkTable* services_table;
1529         g_return_if_fail (self != NULL);
1530         g_return_if_fail (id_card != NULL);
1531         i = 0;
1532         n_columns = _tmp0_;
1533         services_table = g_object_ref_sink ((GtkTable*) gtk_table_new ((guint) n_columns, (guint) 2, FALSE));
1534         gtk_table_set_col_spacings (services_table, (guint) 10);
1535         gtk_table_set_row_spacings (services_table, (guint) 10);
1536         gtk_container_add ((GtkContainer*) self->priv->services_internal_vbox, (GtkWidget*) services_table);
1537         g_hash_table_remove_all (self->priv->service_button_map);
1538         {
1539                 gint _tmp1_;
1540                 char** service_collection;
1541                 int service_collection_length1;
1542                 int service_it;
1543                 service_collection = id_card_get_services (id_card, &_tmp1_);
1544                 service_collection_length1 = _tmp1_;
1545                 for (service_it = 0; service_it < _tmp1_; service_it = service_it + 1) {
1546                         char* service;
1547                         service = g_strdup (service_collection[service_it]);
1548                         {
1549                                 GtkLabel* label;
1550                                 GtkButton* remove_button;
1551                                 label = g_object_ref_sink ((GtkLabel*) gtk_label_new (service));
1552                                 gtk_misc_set_alignment ((GtkMisc*) label, (float) 0, (float) 0.5);
1553                                 remove_button = g_object_ref_sink ((GtkButton*) gtk_button_new_from_stock (GTK_STOCK_REMOVE));
1554                                 g_hash_table_insert (self->priv->service_button_map, _g_object_ref0 (remove_button), g_strdup (service));
1555                                 g_signal_connect_object (remove_button, "clicked", (GCallback) __lambda1__gtk_button_clicked, self, 0);
1556                                 gtk_table_attach_defaults (services_table, (GtkWidget*) label, (guint) 0, (guint) 1, (guint) i, (guint) (i + 1));
1557                                 gtk_table_attach_defaults (services_table, (GtkWidget*) remove_button, (guint) 1, (guint) 2, (guint) i, (guint) (i + 1));
1558                                 i++;
1559                                 _g_object_unref0 (remove_button);
1560                                 _g_object_unref0 (label);
1561                                 _g_free0 (service);
1562                         }
1563                 }
1564         }
1565         gtk_widget_show_all ((GtkWidget*) self->priv->services_internal_vbox);
1566         _g_object_unref0 (services_table);
1567 }
1568
1569
1570 static void main_window_on_about_action (MainWindow* self) {
1571         gint authors_length1;
1572         gint _authors_size_;
1573         char** _tmp1_;
1574         char** _tmp0_ = NULL;
1575         char** authors;
1576         char* copyright;
1577         char* license;
1578         g_return_if_fail (self != NULL);
1579         authors = (_tmp1_ = (_tmp0_ = g_new0 (char*, 4 + 1), _tmp0_[0] = g_strdup ("Javier Jardón <jjardon@codethink.co.uk>"), _tmp0_[1] = g_strdup ("Sam Thursfield <samthursfield@codethink.co.uk>"), _tmp0_[2] = g_strdup ("Alberto Ruiz <alberto.ruiz@codethink.co.uk>"), _tmp0_[3] = NULL, _tmp0_), authors_length1 = 4, _authors_size_ = authors_length1, _tmp1_);
1580         copyright = g_strdup ("Copyright 2011 JANET");
1581         license = g_strdup ("\n" \
1582 "Copyright (c) 2011, JANET(UK)\n" \
1583 "All rights reserved.\n" \
1584 "\n" \
1585 "Redistribution and use in source and binary forms, with or without\n" \
1586 "modification, are permitted provided that the following conditions\n" \
1587 "are met:\n" \
1588 "\n" \
1589 "1. Redistributions of source code must retain the above copyright\n" \
1590 "   notice, this list of conditions and the following disclaimer.\n" \
1591 "\n" \
1592 "2. Redistributions in binary form must reproduce the above copyright\n" \
1593 "   notice, this list of conditions and the following disclaimer in the" \
1594 "\n" \
1595 "   documentation and/or other materials provided with the distribution" \
1596 ".\n" \
1597 "\n" \
1598 "3. Neither the name of JANET(UK) nor the names of its contributors\n" \
1599 "   may be used to endorse or promote products derived from this softwa" \
1600 "re\n" \
1601 "   without specific prior written permission.\n" \
1602 "\n" \
1603 "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \\" \
1604 "\"AS IS\\\"\n" \
1605 "AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, " \
1606 "THE\n" \
1607 "IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PUR" \
1608 "POSE\n" \
1609 "ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS" \
1610 " BE LIABLE\n" \
1611 "FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUEN" \
1612 "TIAL\n" \
1613 "DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOOD" \
1614 "S\n" \
1615 "OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n" \
1616 "HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ST" \
1617 "RICT\n" \
1618 "LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY " \
1619 "WAY\n" \
1620 "OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF" \
1621 "\n" \
1622 "SUCH DAMAGE.\n");
1623         gtk_show_about_dialog ((GtkWindow*) self, "comments", _ ("Moonshot project UI"), "copyright", copyright, "website", "http://www.project-moonshot.org/", "license", license, "website-label", _ ("Visit the Moonshot project web site"), "authors", authors, "translator-credits", _ ("translator-credits"), NULL, NULL);
1624         _g_free0 (license);
1625         _g_free0 (copyright);
1626         authors = (_vala_array_free (authors, authors_length1, (GDestroyNotify) g_free), NULL);
1627 }
1628
1629
1630 static void _vala_array_add1 (GtkActionEntry** array, int* length, int* size, const GtkActionEntry* value) {
1631         if ((*length) == (*size)) {
1632                 *size = (*size) ? (2 * (*size)) : 4;
1633                 *array = g_renew (GtkActionEntry, *array, *size);
1634         }
1635         (*array)[(*length)++] = *value;
1636 }
1637
1638
1639 static void _main_window_add_identity_manual_cb_gtk_action_callback (GtkAction* action, gpointer self) {
1640         main_window_add_identity_manual_cb (self);
1641 }
1642
1643
1644 static void _vala_array_add2 (GtkActionEntry** array, int* length, int* size, const GtkActionEntry* value) {
1645         if ((*length) == (*size)) {
1646                 *size = (*size) ? (2 * (*size)) : 4;
1647                 *array = g_renew (GtkActionEntry, *array, *size);
1648         }
1649         (*array)[(*length)++] = *value;
1650 }
1651
1652
1653 static void _gtk_main_quit_gtk_action_callback (GtkAction* action, gpointer self) {
1654         gtk_main_quit ();
1655 }
1656
1657
1658 static void _vala_array_add3 (GtkActionEntry** array, int* length, int* size, const GtkActionEntry* value) {
1659         if ((*length) == (*size)) {
1660                 *size = (*size) ? (2 * (*size)) : 4;
1661                 *array = g_renew (GtkActionEntry, *array, *size);
1662         }
1663         (*array)[(*length)++] = *value;
1664 }
1665
1666
1667 static void _vala_array_add4 (GtkActionEntry** array, int* length, int* size, const GtkActionEntry* value) {
1668         if ((*length) == (*size)) {
1669                 *size = (*size) ? (2 * (*size)) : 4;
1670                 *array = g_renew (GtkActionEntry, *array, *size);
1671         }
1672         (*array)[(*length)++] = *value;
1673 }
1674
1675
1676 static void _main_window_on_about_action_gtk_action_callback (GtkAction* action, gpointer self) {
1677         main_window_on_about_action (self);
1678 }
1679
1680
1681 static void _vala_array_add5 (GtkActionEntry** array, int* length, int* size, const GtkActionEntry* value) {
1682         if ((*length) == (*size)) {
1683                 *size = (*size) ? (2 * (*size)) : 4;
1684                 *array = g_renew (GtkActionEntry, *array, *size);
1685         }
1686         (*array)[(*length)++] = *value;
1687 }
1688
1689
1690 static GtkActionEntry* main_window_create_actions (MainWindow* self, int* result_length1) {
1691         GtkActionEntry* result = NULL;
1692         gint actions_length1;
1693         gint _actions_size_;
1694         GtkActionEntry* _tmp0_;
1695         GtkActionEntry* actions;
1696         GtkActionEntry _tmp1_ = {0};
1697         GtkActionEntry filemenu;
1698         GtkActionEntry _tmp2_ = {0};
1699         GtkActionEntry add;
1700         GtkActionEntry _tmp3_ = {0};
1701         GtkActionEntry quit;
1702         GtkActionEntry _tmp4_ = {0};
1703         GtkActionEntry helpmenu;
1704         GtkActionEntry _tmp5_ = {0};
1705         GtkActionEntry about;
1706         GtkActionEntry* _tmp6_;
1707         g_return_val_if_fail (self != NULL, NULL);
1708         actions = (_tmp0_ = g_new0 (GtkActionEntry, 0), actions_length1 = 0, _actions_size_ = actions_length1, _tmp0_);
1709         filemenu = (_tmp1_.name = "FileMenuAction", _tmp1_.stock_id = NULL, _tmp1_.label = N_ ("_File"), _tmp1_.accelerator = NULL, _tmp1_.tooltip = NULL, _tmp1_.callback = (GCallback) NULL, _tmp1_);
1710         _vala_array_add1 (&actions, &actions_length1, &_actions_size_, &filemenu);
1711         add = (_tmp2_.name = "AddIdCardAction", _tmp2_.stock_id = GTK_STOCK_ADD, _tmp2_.label = N_ ("Add ID Card"), _tmp2_.accelerator = NULL, _tmp2_.tooltip = N_ ("Add a new ID Card"), _tmp2_.callback = (GCallback) _main_window_add_identity_manual_cb_gtk_action_callback, _tmp2_);
1712         _vala_array_add2 (&actions, &actions_length1, &_actions_size_, &add);
1713         quit = (_tmp3_.name = "QuitAction", _tmp3_.stock_id = GTK_STOCK_QUIT, _tmp3_.label = N_ ("Quit"), _tmp3_.accelerator = "<control>Q", _tmp3_.tooltip = N_ ("Quit the application"), _tmp3_.callback = (GCallback) _gtk_main_quit_gtk_action_callback, _tmp3_);
1714         _vala_array_add3 (&actions, &actions_length1, &_actions_size_, &quit);
1715         helpmenu = (_tmp4_.name = "HelpMenuAction", _tmp4_.stock_id = NULL, _tmp4_.label = N_ ("_Help"), _tmp4_.accelerator = NULL, _tmp4_.tooltip = NULL, _tmp4_.callback = (GCallback) NULL, _tmp4_);
1716         _vala_array_add4 (&actions, &actions_length1, &_actions_size_, &helpmenu);
1717         about = (_tmp5_.name = "AboutAction", _tmp5_.stock_id = GTK_STOCK_ABOUT, _tmp5_.label = N_ ("About"), _tmp5_.accelerator = NULL, _tmp5_.tooltip = N_ ("About this application"), _tmp5_.callback = (GCallback) _main_window_on_about_action_gtk_action_callback, _tmp5_);
1718         _vala_array_add5 (&actions, &actions_length1, &_actions_size_, &about);
1719         result = (_tmp6_ = actions, *result_length1 = actions_length1, _tmp6_);
1720         return result;
1721         actions = (g_free (actions), NULL);
1722 }
1723
1724
1725 static void main_window_create_ui_manager (MainWindow* self) {
1726         GtkActionGroup* action_group;
1727         gint _tmp0_;
1728         GtkActionEntry* _tmp1_;
1729         gint _tmp1__length1;
1730         GtkActionEntry* _tmp2_;
1731         GError * _inner_error_ = NULL;
1732         g_return_if_fail (self != NULL);
1733         action_group = gtk_action_group_new ("GeneralActionGroup");
1734         _tmp2_ = (_tmp1_ = main_window_create_actions (self, &_tmp0_), _tmp1__length1 = _tmp0_, _tmp1_);
1735         gtk_action_group_add_actions (action_group, _tmp2_, _tmp0_, self);
1736         _tmp1_ = (g_free (_tmp1_), NULL);
1737         gtk_ui_manager_insert_action_group (self->priv->ui_manager, action_group, 0);
1738         {
1739                 gtk_ui_manager_add_ui_from_string (self->priv->ui_manager, MAIN_WINDOW_layout, (gssize) (-1), &_inner_error_);
1740                 if (_inner_error_ != NULL) {
1741                         goto __catch3_g_error;
1742                 }
1743         }
1744         goto __finally3;
1745         __catch3_g_error:
1746         {
1747                 GError * e;
1748                 e = _inner_error_;
1749                 _inner_error_ = NULL;
1750                 {
1751                         fprintf (stderr, "%s\n", e->message);
1752                         _g_error_free0 (e);
1753                 }
1754         }
1755         __finally3:
1756         if (_inner_error_ != NULL) {
1757                 _g_object_unref0 (action_group);
1758                 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
1759                 g_clear_error (&_inner_error_);
1760                 return;
1761         }
1762         gtk_ui_manager_ensure_update (self->priv->ui_manager);
1763         _g_object_unref0 (action_group);
1764 }
1765
1766
1767 static void _main_window_search_entry_icon_press_cb_gtk_entry_icon_press (GtkEntry* _sender, GtkEntryIconPosition p0, GdkEvent* p1, gpointer self) {
1768         main_window_search_entry_icon_press_cb (self, p0, p1);
1769 }
1770
1771
1772 static void _main_window_search_entry_text_changed_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
1773         main_window_search_entry_text_changed_cb (self);
1774 }
1775
1776
1777 static gboolean _main_window_search_entry_key_press_event_cb_gtk_widget_key_press_event (GtkWidget* _sender, GdkEventKey* event, gpointer self) {
1778         gboolean result;
1779         result = main_window_search_entry_key_press_event_cb (self, event);
1780         return result;
1781 }
1782
1783
1784 static void main_window_build_ui (MainWindow* self) {
1785         GtkEntry* _tmp0_;
1786         GdkPixbuf* _tmp1_;
1787         GdkPixbuf* _tmp2_;
1788         CustomVBox* _tmp3_;
1789         GtkViewport* viewport;
1790         GtkScrolledWindow* scroll;
1791         GtkVBox* vbox_left;
1792         GtkLabel* login_vbox_title;
1793         GtkLabel* username_label;
1794         GtkEntry* _tmp4_;
1795         GtkLabel* password_label;
1796         GtkEntry* _tmp5_;
1797         GtkCheckButton* remember_checkbutton;
1798         GtkTable* login_table;
1799         GtkAlignment* login_vbox_alignment;
1800         GtkVBox* login_vbox;
1801         GtkLabel* services_vbox_title;
1802         GtkAlignment* services_vbox_alignment;
1803         GtkVBox* _tmp6_;
1804         GtkVBox* services_vbox;
1805         GtkVBox* _tmp7_;
1806         GtkHBox* hbox;
1807         GtkVBox* main_vbox;
1808         GtkWidget* menubar;
1809         g_return_if_fail (self != NULL);
1810         main_window_create_ui_manager (self);
1811         self->priv->search_entry = (_tmp0_ = g_object_ref_sink ((GtkEntry*) gtk_entry_new ()), _g_object_unref0 (self->priv->search_entry), _tmp0_);
1812         main_window_set_atk_name_description (self, (GtkWidget*) self->priv->search_entry, _ ("Search entry"), _ ("Search for a specific ID Card"));
1813         gtk_entry_set_icon_from_pixbuf (self->priv->search_entry, GTK_ENTRY_ICON_PRIMARY, _tmp1_ = find_icon_sized ("edit-find-symbolic", GTK_ICON_SIZE_MENU));
1814         _g_object_unref0 (_tmp1_);
1815         gtk_entry_set_icon_tooltip_text (self->priv->search_entry, GTK_ENTRY_ICON_PRIMARY, _ ("Search identity or service"));
1816         gtk_entry_set_icon_sensitive (self->priv->search_entry, GTK_ENTRY_ICON_PRIMARY, FALSE);
1817         gtk_entry_set_icon_from_pixbuf (self->priv->search_entry, GTK_ENTRY_ICON_SECONDARY, _tmp2_ = find_icon_sized ("edit-clear-symbolic", GTK_ICON_SIZE_MENU));
1818         _g_object_unref0 (_tmp2_);
1819         gtk_entry_set_icon_tooltip_text (self->priv->search_entry, GTK_ENTRY_ICON_SECONDARY, _ ("Clear the current search"));
1820         gtk_entry_set_icon_sensitive (self->priv->search_entry, GTK_ENTRY_ICON_SECONDARY, FALSE);
1821         g_signal_connect_object (self->priv->search_entry, "icon-press", (GCallback) _main_window_search_entry_icon_press_cb_gtk_entry_icon_press, self, 0);
1822         g_signal_connect_object ((GObject*) self->priv->search_entry, "notify::text", (GCallback) _main_window_search_entry_text_changed_cb_g_object_notify, self, 0);
1823         g_signal_connect_object ((GtkWidget*) self->priv->search_entry, "key-press-event", (GCallback) _main_window_search_entry_key_press_event_cb_gtk_widget_key_press_event, self, 0);
1824         self->priv->custom_vbox = (_tmp3_ = g_object_ref_sink (custom_vbox_new (self, FALSE, 6)), _g_object_unref0 (self->priv->custom_vbox), _tmp3_);
1825         viewport = g_object_ref_sink ((GtkViewport*) gtk_viewport_new (NULL, NULL));
1826         gtk_container_set_border_width ((GtkContainer*) viewport, (guint) 6);
1827         gtk_viewport_set_shadow_type (viewport, GTK_SHADOW_NONE);
1828         gtk_container_add ((GtkContainer*) viewport, (GtkWidget*) self->priv->custom_vbox);
1829         scroll = g_object_ref_sink ((GtkScrolledWindow*) gtk_scrolled_window_new (NULL, NULL));
1830         gtk_scrolled_window_set_policy (scroll, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
1831         gtk_scrolled_window_set_shadow_type (scroll, GTK_SHADOW_IN);
1832         gtk_scrolled_window_add_with_viewport (scroll, (GtkWidget*) viewport);
1833         vbox_left = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 0));
1834         gtk_box_pack_start ((GtkBox*) vbox_left, (GtkWidget*) self->priv->search_entry, FALSE, FALSE, (guint) 6);
1835         gtk_box_pack_start ((GtkBox*) vbox_left, (GtkWidget*) scroll, TRUE, TRUE, (guint) 0);
1836         gtk_widget_set_size_request ((GtkWidget*) vbox_left, MAIN_WINDOW_WINDOW_WIDTH, 0);
1837         login_vbox_title = g_object_ref_sink ((GtkLabel*) gtk_label_new (_ ("Login: ")));
1838         main_window_label_make_bold (self, login_vbox_title);
1839         gtk_misc_set_alignment ((GtkMisc*) login_vbox_title, (float) 0, (float) 0.5);
1840         username_label = g_object_ref_sink ((GtkLabel*) gtk_label_new (_ ("Username:")));
1841         gtk_misc_set_alignment ((GtkMisc*) username_label, (float) 1, (float) 0.5);
1842         self->priv->username_entry = (_tmp4_ = g_object_ref_sink ((GtkEntry*) gtk_entry_new ()), _g_object_unref0 (self->priv->username_entry), _tmp4_);
1843         password_label = g_object_ref_sink ((GtkLabel*) gtk_label_new (_ ("Password:")));
1844         gtk_misc_set_alignment ((GtkMisc*) password_label, (float) 1, (float) 0.5);
1845         self->priv->password_entry = (_tmp5_ = g_object_ref_sink ((GtkEntry*) gtk_entry_new ()), _g_object_unref0 (self->priv->password_entry), _tmp5_);
1846         gtk_entry_set_invisible_char (self->priv->password_entry, (gunichar) '*');
1847         gtk_entry_set_visibility (self->priv->password_entry, FALSE);
1848         remember_checkbutton = g_object_ref_sink ((GtkCheckButton*) gtk_check_button_new_with_label (_ ("Remember password")));
1849         login_table = g_object_ref_sink ((GtkTable*) gtk_table_new ((guint) 3, (guint) 3, FALSE));
1850         gtk_table_set_col_spacings (login_table, (guint) 10);
1851         gtk_table_set_row_spacings (login_table, (guint) 10);
1852         gtk_table_attach_defaults (login_table, (GtkWidget*) username_label, (guint) 0, (guint) 1, (guint) 0, (guint) 1);
1853         gtk_table_attach_defaults (login_table, (GtkWidget*) self->priv->username_entry, (guint) 1, (guint) 2, (guint) 0, (guint) 1);
1854         gtk_table_attach_defaults (login_table, (GtkWidget*) password_label, (guint) 0, (guint) 1, (guint) 1, (guint) 2);
1855         gtk_table_attach_defaults (login_table, (GtkWidget*) self->priv->password_entry, (guint) 1, (guint) 2, (guint) 1, (guint) 2);
1856         gtk_table_attach_defaults (login_table, (GtkWidget*) remember_checkbutton, (guint) 1, (guint) 2, (guint) 2, (guint) 3);
1857         login_vbox_alignment = g_object_ref_sink ((GtkAlignment*) gtk_alignment_new ((float) 0, (float) 0, (float) 0, (float) 0));
1858         gtk_alignment_set_padding (login_vbox_alignment, (guint) 0, (guint) 0, (guint) 12, (guint) 0);
1859         gtk_container_add ((GtkContainer*) login_vbox_alignment, (GtkWidget*) login_table);
1860         login_vbox = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 6));
1861         gtk_box_pack_start ((GtkBox*) login_vbox, (GtkWidget*) login_vbox_title, FALSE, TRUE, (guint) 0);
1862         gtk_box_pack_start ((GtkBox*) login_vbox, (GtkWidget*) login_vbox_alignment, FALSE, TRUE, (guint) 0);
1863         services_vbox_title = g_object_ref_sink ((GtkLabel*) gtk_label_new (_ ("Services:")));
1864         main_window_label_make_bold (self, services_vbox_title);
1865         gtk_misc_set_alignment ((GtkMisc*) services_vbox_title, (float) 0, (float) 0.5);
1866         services_vbox_alignment = g_object_ref_sink ((GtkAlignment*) gtk_alignment_new ((float) 0, (float) 0, (float) 0, (float) 0));
1867         gtk_alignment_set_padding (services_vbox_alignment, (guint) 0, (guint) 0, (guint) 12, (guint) 0);
1868         self->priv->services_internal_vbox = (_tmp6_ = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (TRUE, 6)), _g_object_unref0 (self->priv->services_internal_vbox), _tmp6_);
1869         gtk_container_add ((GtkContainer*) services_vbox_alignment, (GtkWidget*) self->priv->services_internal_vbox);
1870         services_vbox = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 6));
1871         gtk_box_pack_start ((GtkBox*) services_vbox, (GtkWidget*) services_vbox_title, FALSE, TRUE, (guint) 0);
1872         gtk_box_pack_start ((GtkBox*) services_vbox, (GtkWidget*) services_vbox_alignment, FALSE, TRUE, (guint) 0);
1873         self->priv->vbox_right = (_tmp7_ = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 18)), _g_object_unref0 (self->priv->vbox_right), _tmp7_);
1874         gtk_box_pack_start ((GtkBox*) self->priv->vbox_right, (GtkWidget*) login_vbox, FALSE, TRUE, (guint) 0);
1875         gtk_box_pack_start ((GtkBox*) self->priv->vbox_right, (GtkWidget*) services_vbox, FALSE, TRUE, (guint) 0);
1876         hbox = g_object_ref_sink ((GtkHBox*) gtk_hbox_new (FALSE, 12));
1877         gtk_box_pack_start ((GtkBox*) hbox, (GtkWidget*) vbox_left, TRUE, TRUE, (guint) 0);
1878         gtk_box_pack_start ((GtkBox*) hbox, (GtkWidget*) self->priv->vbox_right, FALSE, FALSE, (guint) 0);
1879         main_vbox = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 0));
1880         gtk_container_set_border_width ((GtkContainer*) main_vbox, (guint) 12);
1881         menubar = _g_object_ref0 (gtk_ui_manager_get_widget (self->priv->ui_manager, "/MenuBar"));
1882         gtk_box_pack_start ((GtkBox*) main_vbox, menubar, FALSE, FALSE, (guint) 0);
1883         gtk_box_pack_start ((GtkBox*) main_vbox, (GtkWidget*) hbox, TRUE, TRUE, (guint) 0);
1884         gtk_container_add ((GtkContainer*) self, (GtkWidget*) main_vbox);
1885         gtk_widget_show_all ((GtkWidget*) main_vbox);
1886         gtk_widget_hide ((GtkWidget*) self->priv->vbox_right);
1887         _g_object_unref0 (menubar);
1888         _g_object_unref0 (main_vbox);
1889         _g_object_unref0 (hbox);
1890         _g_object_unref0 (services_vbox);
1891         _g_object_unref0 (services_vbox_alignment);
1892         _g_object_unref0 (services_vbox_title);
1893         _g_object_unref0 (login_vbox);
1894         _g_object_unref0 (login_vbox_alignment);
1895         _g_object_unref0 (login_table);
1896         _g_object_unref0 (remember_checkbutton);
1897         _g_object_unref0 (password_label);
1898         _g_object_unref0 (username_label);
1899         _g_object_unref0 (login_vbox_title);
1900         _g_object_unref0 (vbox_left);
1901         _g_object_unref0 (scroll);
1902         _g_object_unref0 (viewport);
1903 }
1904
1905
1906 static void main_window_set_atk_name_description (MainWindow* self, GtkWidget* widget, const char* name, const char* description) {
1907         AtkObject* atk_widget;
1908         g_return_if_fail (self != NULL);
1909         g_return_if_fail (widget != NULL);
1910         g_return_if_fail (name != NULL);
1911         g_return_if_fail (description != NULL);
1912         atk_widget = _g_object_ref0 (gtk_widget_get_accessible (widget));
1913         atk_object_set_name (atk_widget, name);
1914         atk_object_set_description (atk_widget, description);
1915         _g_object_unref0 (atk_widget);
1916 }
1917
1918
1919 static void _gtk_main_quit_gtk_object_destroy (GtkObject* _sender, gpointer self) {
1920         gtk_main_quit ();
1921 }
1922
1923
1924 static void main_window_connect_signals (MainWindow* self) {
1925         g_return_if_fail (self != NULL);
1926         g_signal_connect ((GtkObject*) self, "destroy", (GCallback) _gtk_main_quit_gtk_object_destroy, NULL);
1927 }
1928
1929
1930 static guint _dynamic_request_name0 (DBusGProxy* self, const char* param1, guint param2, GError** error) {
1931         guint result;
1932         dbus_g_proxy_call (self, "RequestName", error, G_TYPE_STRING, param1, G_TYPE_UINT, param2, G_TYPE_INVALID, G_TYPE_UINT, &result, G_TYPE_INVALID);
1933         if (*error) {
1934                 return 0U;
1935         }
1936         return result;
1937 }
1938
1939
1940 static void _vala_dbus_register_object (DBusConnection* connection, const char* path, void* object) {
1941         const _DBusObjectVTable * vtable;
1942         vtable = g_type_get_qdata (G_TYPE_FROM_INSTANCE (object), g_quark_from_static_string ("DBusObjectVTable"));
1943         if (vtable) {
1944                 vtable->register_object (connection, path, object);
1945         } else {
1946                 g_warning ("Object does not implement any D-Bus interface");
1947         }
1948 }
1949
1950
1951 static void _vala_dbus_unregister_object (gpointer connection, GObject* object) {
1952         char* path;
1953         path = g_object_steal_data ((GObject*) object, "dbus_object_path");
1954         dbus_connection_unregister_object_path (connection, path);
1955         g_free (path);
1956 }
1957
1958
1959 static void main_window_init_ipc_server (MainWindow* self) {
1960         GError * _inner_error_ = NULL;
1961         g_return_if_fail (self != NULL);
1962         {
1963                 DBusGConnection* conn;
1964                 DBusGProxy* bus;
1965                 guint reply;
1966                 MoonshotServer* _tmp0_;
1967                 conn = dbus_g_bus_get (DBUS_BUS_SESSION, &_inner_error_);
1968                 if (_inner_error_ != NULL) {
1969                         if (_inner_error_->domain == DBUS_GERROR) {
1970                                 goto __catch4_dbus_gerror;
1971                         }
1972                         g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
1973                         g_clear_error (&_inner_error_);
1974                         return;
1975                 }
1976                 bus = dbus_g_proxy_new_for_name (conn, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus");
1977                 reply = _dynamic_request_name0 (bus, "org.janet.Moonshot", (guint) 0, &_inner_error_);
1978                 if (_inner_error_ != NULL) {
1979                         _g_object_unref0 (bus);
1980                         _dbus_g_connection_unref0 (conn);
1981                         if (_inner_error_->domain == DBUS_GERROR) {
1982                                 goto __catch4_dbus_gerror;
1983                         }
1984                         goto __finally4;
1985                 }
1986                 g_assert (reply == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER);
1987                 self->priv->ipc_server = (_tmp0_ = moonshot_server_new ((GtkWindow*) self), _g_object_unref0 (self->priv->ipc_server), _tmp0_);
1988                 _vala_dbus_register_object (dbus_g_connection_get_connection (conn), "/org/janet/moonshot", (GObject*) self->priv->ipc_server);
1989                 _g_object_unref0 (bus);
1990                 _dbus_g_connection_unref0 (conn);
1991         }
1992         goto __finally4;
1993         __catch4_dbus_gerror:
1994         {
1995                 GError * e;
1996                 e = _inner_error_;
1997                 _inner_error_ = NULL;
1998                 {
1999                         fprintf (stderr, "%s\n", e->message);
2000                         _g_error_free0 (e);
2001                 }
2002         }
2003         __finally4:
2004         if (_inner_error_ != NULL) {
2005                 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
2006                 g_clear_error (&_inner_error_);
2007                 return;
2008         }
2009 }
2010
2011
2012 gint main_window_main (char** args, int args_length1) {
2013         gint result = 0;
2014         MainWindow* window;
2015         gtk_init (&args_length1, &args);
2016         bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
2017         bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
2018         textdomain (GETTEXT_PACKAGE);
2019         window = g_object_ref_sink (main_window_new ());
2020         gtk_widget_show ((GtkWidget*) window);
2021         gtk_main ();
2022         result = 0;
2023         _g_object_unref0 (window);
2024         return result;
2025 }
2026
2027
2028 int main (int argc, char ** argv) {
2029         g_type_init ();
2030         return main_window_main (argv, argc);
2031 }
2032
2033
2034 static void main_window_class_init (MainWindowClass * klass) {
2035         main_window_parent_class = g_type_class_peek_parent (klass);
2036         g_type_class_add_private (klass, sizeof (MainWindowPrivate));
2037         G_OBJECT_CLASS (klass)->finalize = main_window_finalize;
2038 }
2039
2040
2041 static void main_window_instance_init (MainWindow * self) {
2042         self->priv = MAIN_WINDOW_GET_PRIVATE (self);
2043         self->priv->ui_manager = gtk_ui_manager_new ();
2044 }
2045
2046
2047 static void main_window_finalize (GObject* obj) {
2048         MainWindow * self;
2049         self = MAIN_WINDOW (obj);
2050         _g_object_unref0 (self->priv->ui_manager);
2051         _g_object_unref0 (self->priv->search_entry);
2052         _g_object_unref0 (self->priv->vbox_right);
2053         _g_object_unref0 (self->priv->custom_vbox);
2054         _g_object_unref0 (self->priv->services_internal_vbox);
2055         _g_object_unref0 (self->priv->username_entry);
2056         _g_object_unref0 (self->priv->password_entry);
2057         _g_object_unref0 (self->priv->listmodel);
2058         _g_object_unref0 (self->priv->filter);
2059         _g_object_unref0 (self->identities_manager);
2060         __g_slist_free_g_object_unref0 (self->priv->candidates);
2061         _g_object_unref0 (self->priv->ipc_server);
2062         _g_object_unref0 (self->priv->default_id_card);
2063         _g_queue_free0 (self->request_queue);
2064         _g_hash_table_unref0 (self->priv->service_button_map);
2065         G_OBJECT_CLASS (main_window_parent_class)->finalize (obj);
2066 }
2067
2068
2069 GType main_window_get_type (void) {
2070         static volatile gsize main_window_type_id__volatile = 0;
2071         if (g_once_init_enter (&main_window_type_id__volatile)) {
2072                 static const GTypeInfo g_define_type_info = { sizeof (MainWindowClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) main_window_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (MainWindow), 0, (GInstanceInitFunc) main_window_instance_init, NULL };
2073                 GType main_window_type_id;
2074                 main_window_type_id = g_type_register_static (GTK_TYPE_WINDOW, "MainWindow", &g_define_type_info, 0);
2075                 g_once_init_leave (&main_window_type_id__volatile, main_window_type_id);
2076         }
2077         return main_window_type_id__volatile;
2078 }
2079
2080
2081 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
2082         if ((array != NULL) && (destroy_func != NULL)) {
2083                 int i;
2084                 for (i = 0; i < array_length; i = i + 1) {
2085                         if (((gpointer*) array)[i] != NULL) {
2086                                 destroy_func (((gpointer*) array)[i]);
2087                         }
2088                 }
2089         }
2090 }
2091
2092
2093 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
2094         _vala_array_destroy (array, array_length, destroy_func);
2095         g_free (array);
2096 }
2097
2098
2099 static gint _vala_array_length (gpointer array) {
2100         int length;
2101         length = 0;
2102         if (array) {
2103                 while (((gpointer*) array)[length]) {
2104                         length++;
2105                 }
2106         }
2107         return length;
2108 }
2109
2110
2111 static int _vala_strcmp0 (const char * str1, const char * str2) {
2112         if (str1 == NULL) {
2113                 return -(str1 != str2);
2114         }
2115         if (str2 == NULL) {
2116                 return str1 != str2;
2117         }
2118         return strcmp (str1, str2);
2119 }
2120
2121
2122
2123