* adjusted indentation on modest-ui-wizard.c modest-identity-mgr.h and modest-main.c

* changed some flags on modest.glade
* added some serious functionality to modest-ui-account-setup.c (identities)
  (yet the edit dialog does not work properly)

pmo-trunk-r281

diff --git a/src/gtk-glade/modest-ui-account-setup.c b/src/gtk-glade/modest-ui-account-setup.c
index 7e8a2e7..6066363 100644 (file)
--- a/src/gtk-glade/modest-ui-account-setup.c
+++ b/src/gtk-glade/modest-ui-account-setup.c
@@ -20,6 +20,7 @@
 enum {
        IDENTITY_NAME,
        IDENTITY_ADDRESS,
+       IDENTITY_VIA,
        IDENTITY_COLUMNS
 };
 
@@ -29,6 +30,360 @@ enum {
        ACCOUNT_COLUMNS
 };
 
+typedef struct _CallbackData CallbackData;
+
+struct _CallbackData {
+       GtkWidget       *id_tree_view;
+       GtkWidget       *acc_tree_view;
+       ModestUI        *modest_ui;
+       GladeXML        *glade_xml;
+};
+
+static void
+identity_setup_dialog (ModestUI *, GtkListStore *, gchar *);
+
+static void
+missing_notification(GtkWindow *, gchar *);
+
+/* CALLBACKS */
+
+static void
+edit_action(GtkWidget *button,
+           gpointer userdata)
+{
+       CallbackData *cb_data;
+       GtkListStore *acc_liststore;
+       GtkTreeModel *id_liststore;
+       GtkTreeSelection *selection;
+       GtkTreeIter selected_iter;
+       gchar *identity_name;
+
+       cb_data = (CallbackData *) userdata;
+       selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(cb_data->id_tree_view));
+
+       gtk_tree_selection_get_selected(selection,
+                                       &id_liststore,
+                                       &selected_iter);
+       gtk_tree_model_get(GTK_TREE_MODEL(id_liststore),
+                          &selected_iter,
+                          ACCOUNT_NAME, &identity_name,
+                          -1);
+       acc_liststore=GTK_LIST_STORE(gtk_tree_view_get_model (GTK_TREE_VIEW(cb_data->acc_tree_view)));
+
+       identity_setup_dialog (cb_data->modest_ui, acc_liststore, identity_name);
+       g_free(identity_name);
+}
+
+static void
+create_action(GtkWidget *button,
+             gpointer userdata)
+{
+       CallbackData *cb_data;
+       GtkListStore *acc_liststore;
+
+       cb_data = (CallbackData *) userdata;
+
+       acc_liststore=GTK_LIST_STORE(gtk_tree_view_get_model (GTK_TREE_VIEW(cb_data->acc_tree_view)));
+
+       identity_setup_dialog(cb_data->modest_ui, acc_liststore, NULL);
+}
+
+static void
+delete_action(GtkWidget *button,
+             gpointer userdata)
+{
+       CallbackData *cb_data;
+       GtkTreeSelection *selection;
+       GtkTreeIter selected_iter;
+       GtkTreeModel *id_liststore;
+       gchar *identity_name;
+       GtkWidget *confirmation_dialog;
+       GtkWidget *confirmation_message;
+       gint result;
+
+       cb_data = (CallbackData *) userdata;
+       selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(cb_data->id_tree_view));
+
+       gtk_tree_selection_get_selected(selection,
+                                       &id_liststore,
+                                       &selected_iter);
+       gtk_tree_model_get(GTK_TREE_MODEL(id_liststore),
+                          &selected_iter,
+                          ACCOUNT_NAME, &identity_name,
+                          -1);
+
+       confirmation_dialog = gtk_dialog_new_with_buttons ("Confirm removal of identity",
+                                                          GTK_WINDOW(gtk_widget_get_toplevel(button)),
+                                                          GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
+                                                          GTK_STOCK_OK,
+                                                          GTK_RESPONSE_OK,
+                                                          GTK_STOCK_CANCEL,
+                                                          GTK_RESPONSE_CANCEL,
+                                                          NULL);
+
+       gchar *messy = g_strdup_printf("Remove selected identity '%s'?", identity_name);
+       confirmation_message = gtk_label_new_with_mnemonic (messy);
+
+       gtk_container_add(GTK_CONTAINER(confirmation_dialog),
+                         confirmation_message);
+
+       gtk_widget_show_all(confirmation_dialog);
+
+       result=gtk_dialog_run(GTK_DIALOG(confirmation_dialog));
+       if (result==GTK_RESPONSE_OK)
+       {
+               modest_identity_mgr_remove_identity(MODEST_UI_GET_PRIVATE(cb_data->modest_ui)->modest_id_mgr,
+                                                   identity_name,
+                                                   NULL);
+       }
+       gtk_widget_destroy(confirmation_dialog);
+       g_free(identity_name);
+       g_free(messy);
+
+}
+
+static void
+activate_buttons_on_identity(GtkTreeView *tree_view,
+                            gpointer user_data)
+{
+       GtkWidget *button;
+       GladeXML *glade_xml;
+
+       glade_xml=(GladeXML *) user_data;
+
+       button = glade_xml_get_widget(GLADE_XML(glade_xml), "IdentityEditButton");
+       gtk_widget_set_sensitive(GTK_WIDGET(button), TRUE);
+       button = glade_xml_get_widget(GLADE_XML(glade_xml), "IdentityDeleteButton");
+       gtk_widget_set_sensitive(GTK_WIDGET(button), TRUE);
+}
+
+static void
+use_sig_toggled(GtkToggleButton *button,
+               gpointer userdata) {
+
+       GtkWidget *awidget;
+       GladeXML *glade_xml = (GladeXML *) userdata;
+
+       awidget=glade_xml_get_widget(glade_xml, "ISSignatureTextView");
+       gtk_widget_set_sensitive(awidget, gtk_toggle_button_get_active(button));
+}
+
+/* METHODS */
+
+static void
+missing_notification(GtkWindow *parent, gchar *info_message) {
+       GtkWidget *DenyDialog;
+
+       DenyDialog=gtk_message_dialog_new(parent,
+                                         GTK_DIALOG_MODAL,
+                                         GTK_MESSAGE_INFO,
+                                         GTK_BUTTONS_OK,
+                                         "%s",
+                                         info_message);
+
+       gtk_dialog_run(GTK_DIALOG(DenyDialog));
+
+       gtk_widget_destroy(DenyDialog);
+}
+
+static gboolean
+add_identity(GladeXML *glade_xml, ModestUI *modest_ui, GtkListStore *accounts_model)
+{
+       gchar *reply_to;
+       GtkTextBuffer *sigbuff;
+       gchar *signature;
+       GtkTextIter start_iter;
+       GtkTextIter end_iter;
+       GtkTreeIter transport_iter;
+       ModestUIPrivate *priv;
+       gchar *transport;
+       gint retval;
+
+       priv = MODEST_UI_GET_PRIVATE(MODEST_UI(modest_ui));
+
+       reply_to = g_strdup_printf("%s", gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(glade_xml, "ISReplyToEntry"))));
+
+       if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(glade_xml, "ISUseSignatureCheckButton"))))
+       {
+               sigbuff = gtk_text_view_get_buffer(GTK_TEXT_VIEW(glade_xml_get_widget(glade_xml, "ISSignatureTextView")));
+               gtk_text_buffer_get_bounds(sigbuff,
+                                          &start_iter,
+                                          &end_iter);
+               signature = gtk_text_buffer_get_text(sigbuff,
+                                                    &start_iter,
+                                                    &end_iter,
+                                                    FALSE);
+       }
+       else
+               signature = NULL;
+
+       if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(glade_xml_get_widget(glade_xml, "ISOutServerComboBox")), &transport_iter)) {
+               gtk_tree_model_get(GTK_TREE_MODEL(accounts_model),
+                                  &transport_iter,
+                                  ACCOUNT_NAME, &transport,
+                                  -1);
+       }
+       else {
+               missing_notification(NULL, "Please select an outgoing server!");
+               return FALSE;
+       }
+
+       if (modest_identity_mgr_add_identity (priv->modest_id_mgr,
+                                             gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(glade_xml, "ISIdentityEntry"))),
+                                             gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(glade_xml, "ISNameEntry"))),
+                                             gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(glade_xml, "ISEMailAddress"))),
+                                             reply_to,
+                                             signature,
+                                             gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(glade_xml, "ISUseSignatureCheckButton"))),
+                                             transport,
+                                             FALSE ))
+               retval=TRUE;
+       else
+               retval=FALSE;
+       g_free(transport);
+       return retval;
+}
+
+static void
+identity_setup_dialog (ModestUI *modest_ui, GtkListStore *accounts_model, gchar *identity)
+{
+
+       GladeXML *glade_xml;
+       GtkWidget *id_dialog;
+       GtkWidget *outgoing_server;
+       GtkWidget *awidget;
+       GtkCellRenderer *renderer;
+       ModestIdentityMgr *id_mgr;
+       GtkTextBuffer *sigbuff;
+       gchar *tmptext;
+       gint account_added_successfully;
+       gint result;
+
+       glade_xml = glade_xml_new(MODEST_GLADE, "IdentitySetupDialog", NULL);
+       id_dialog = glade_xml_get_widget(glade_xml, "IdentitySetupDialog");
+
+       outgoing_server = glade_xml_get_widget(glade_xml, "ISOutServerComboBox");
+       gtk_combo_box_set_model(GTK_COMBO_BOX(outgoing_server), GTK_TREE_MODEL(accounts_model));
+       renderer = gtk_cell_renderer_text_new ();
+       gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (outgoing_server), renderer, TRUE);
+       gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (outgoing_server), renderer,
+                                       "text", 0,
+                                       NULL);
+       awidget=glade_xml_get_widget(glade_xml, "ISUseSignatureCheckButton");
+       g_signal_connect(awidget,
+                        "toggled",
+                        G_CALLBACK(use_sig_toggled),
+                        glade_xml);
+
+       if (identity!=NULL) {
+               id_mgr = MODEST_UI_GET_PRIVATE(modest_ui)->modest_id_mgr;
+
+               awidget=glade_xml_get_widget(glade_xml, "ISIdentityEntry");
+               gtk_widget_set_sensitive(awidget, FALSE);
+               gtk_entry_set_text(GTK_ENTRY(awidget), identity);
+               tmptext = modest_identity_mgr_get_identity_string(id_mgr,
+                                                                 identity,
+                                                                 MODEST_IDENTITY_EMAIL,
+                                                                 NULL);
+               awidget=glade_xml_get_widget(glade_xml, "ISEMailAddress");
+               gtk_entry_set_text(GTK_ENTRY(awidget), tmptext);
+               g_free(tmptext);
+
+               if (modest_identity_mgr_get_identity_bool(id_mgr,
+                                                         identity,
+                                                         MODEST_IDENTITY_USE_SIGNATURE,
+                                                         NULL)) {
+                       awidget=glade_xml_get_widget(glade_xml, "ISUseSignatureCheckButton");
+                       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(awidget), TRUE);
+                       awidget=glade_xml_get_widget(glade_xml, "ISSignatureTextView");
+                       gtk_widget_set_sensitive(awidget, TRUE);
+               }
+
+               sigbuff=gtk_text_buffer_new(NULL);
+               tmptext = modest_identity_mgr_get_identity_string(id_mgr,
+                                                                 identity,
+                                                                 MODEST_IDENTITY_SIGNATURE,
+                                                                 NULL),
+               gtk_text_buffer_set_text(sigbuff, tmptext, -1);
+               gtk_text_view_set_buffer(GTK_TEXT_VIEW(glade_xml_get_widget(glade_xml, "ISSignatureTextView")),
+                                                      sigbuff);
+               g_object_unref(sigbuff);
+               g_free(tmptext);
+
+               tmptext = modest_identity_mgr_get_identity_string(id_mgr,
+                                                                 identity,
+                                                                 MODEST_IDENTITY_EMAIL,
+                                                                 NULL);
+               awidget=glade_xml_get_widget(glade_xml, "ISEMailAddress");
+               gtk_entry_set_text(GTK_ENTRY(awidget), tmptext);
+               g_free(tmptext);
+
+               tmptext = modest_identity_mgr_get_identity_string(id_mgr,
+                                                                 identity,
+                                                                 MODEST_IDENTITY_REALNAME,
+                                                                 NULL);
+               awidget=glade_xml_get_widget(glade_xml, "ISNameEntry");
+               gtk_entry_set_text(GTK_ENTRY(awidget), tmptext);
+               g_free(tmptext);
+
+               tmptext = modest_identity_mgr_get_identity_string(id_mgr,
+                                                                 identity,
+                                                                 MODEST_IDENTITY_REALNAME,
+                                                                 NULL);
+               awidget=glade_xml_get_widget(glade_xml, "ISNameEntry");
+               gtk_entry_set_text(GTK_ENTRY(awidget), tmptext);
+
+               g_free(tmptext);
+
+               tmptext = modest_identity_mgr_get_identity_string(id_mgr,
+                                                                 identity,
+                                                                 MODEST_IDENTITY_REPLYTO,
+                                                                 NULL);
+               awidget=glade_xml_get_widget(glade_xml, "ISReplyToEntry");
+               gtk_entry_set_text(GTK_ENTRY(awidget), tmptext);
+
+               g_free(tmptext);
+       }
+
+       gtk_widget_show_all(id_dialog);
+
+       do {
+               result=gtk_dialog_run(GTK_DIALOG(id_dialog));
+
+               switch (result) {
+               case GTK_RESPONSE_OK:
+                       account_added_successfully = add_identity(glade_xml, modest_ui, accounts_model);
+                       break;
+               default:
+                       account_added_successfully = FALSE;
+                       break;
+               }
+       } while(result!=GTK_RESPONSE_DELETE_EVENT && result!=GTK_RESPONSE_CANCEL && account_added_successfully!=TRUE);
+
+       gtk_widget_destroy(id_dialog);
+       g_object_unref(glade_xml);
+}
+
+
+static CallbackData *
+setup_callback_data(GtkWidget *id_tree_view,
+                   GtkWidget *acc_tree_view,
+                   ModestUI *modest_ui)
+{
+       CallbackData *self;
+       self = g_malloc(sizeof(CallbackData));
+       self->modest_ui=modest_ui;
+       self->id_tree_view=id_tree_view;
+       self->acc_tree_view=acc_tree_view;
+       return self;
+}
+
+static void
+free_callback_data(CallbackData *data)
+{
+       g_free(data);
+}
+
 static GtkTreeModel *
 create_identities_model(ModestIdentityMgr *id_mgr) {
 
@@ -36,24 +391,31 @@ create_identities_model(ModestIdentityMgr *id_mgr) {
        GSList *id_names_list_iter;
        GtkListStore *id_list_store;
        GtkTreeIter id_list_store_iter;
-       gchar *tmptext;
+       gchar *tmptext1;
+       gchar *tmptext2;
 
        id_names_list = modest_identity_mgr_identity_names(id_mgr, NULL);
-       id_list_store = gtk_list_store_new(IDENTITY_COLUMNS, G_TYPE_STRING, G_TYPE_STRING);
+       id_list_store = gtk_list_store_new(IDENTITY_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
 
        for (id_names_list_iter=id_names_list;
             id_names_list_iter!=NULL;
             id_names_list_iter=g_slist_next(id_names_list_iter)) {
                gtk_list_store_append(id_list_store, &id_list_store_iter);
-               tmptext=modest_identity_mgr_get_identity_string(id_mgr,
-                                                               id_names_list_iter->data,
-                                                               "email",
-                                                               NULL);
+               tmptext1=modest_identity_mgr_get_identity_string(id_mgr,
+                                                                id_names_list_iter->data,
+                                                                MODEST_IDENTITY_EMAIL,
+                                                                NULL);
+               tmptext2=modest_identity_mgr_get_identity_string(id_mgr,
+                                                                id_names_list_iter->data,
+                                                                MODEST_IDENTITY_ID_VIA,
+                                                                NULL);
                gtk_list_store_set(id_list_store, &id_list_store_iter,
                                   IDENTITY_NAME, id_names_list_iter->data,
-                                  IDENTITY_ADDRESS, tmptext,
+                                  IDENTITY_ADDRESS, tmptext1,
+                                  IDENTITY_VIA, tmptext2,
                                   -1);
-               g_free(tmptext);
+               g_free(tmptext1);
+               g_free(tmptext2);
        }
 
        g_slist_free(id_names_list);
@@ -83,14 +445,13 @@ create_accounts_model(ModestAccountMgr *acc_mgr) {
                gtk_list_store_append(acc_list_store, &acc_list_store_iter);
                tmptext=modest_account_mgr_get_server_account_string(acc_mgr,
                                                                     acc_names_list_iter->data,
-                                                                    "hostname",
+                                                                    MODEST_ACCOUNT_HOSTNAME,
                                                                     NULL);
                gtk_list_store_set(acc_list_store, &acc_list_store_iter,
                                   ACCOUNT_NAME, acc_names_list_iter->data,
                                   ACCOUNT_HOST, tmptext,
                                   -1);
                g_free(tmptext);
-               g_message("Debug");
        }
 
        g_slist_free(acc_names_list);
@@ -108,26 +469,33 @@ accounts_and_identities_dialog (gpointer user_data)
        GtkWidget *accounts_tree_view;
        GtkTreeModel *identities_model;
        GtkTreeModel *accounts_model;
+       ModestUI *modest_ui;
        ModestUIPrivate *priv;
        gint retval;
        GtkCellRenderer *renderer;
        GtkTreeViewColumn *column;
+       CallbackData *cb_data;
+       GtkWidget *abutton;
 
-        g_return_if_fail(MODEST_IS_UI(user_data));
-       priv = MODEST_UI_GET_PRIVATE(MODEST_UI(user_data));
+       g_return_if_fail(MODEST_IS_UI(user_data));
+       modest_ui = (ModestUI *) user_data;
+       priv = MODEST_UI_GET_PRIVATE(modest_ui);
 
        glade_xml = glade_xml_new(MODEST_GLADE, "IdentitiesAndAccountsDialog", NULL);
        main_dialog = glade_xml_get_widget(glade_xml, "IdentitiesAndAccountsDialog");
 
+       /* Accounts */
        accounts_tree_view = glade_xml_get_widget(glade_xml, "AccountsTreeview");
        accounts_model=create_accounts_model(priv->modest_acc_mgr);
        gtk_tree_view_set_model(GTK_TREE_VIEW(accounts_tree_view), accounts_model);
+       /* Account -> Accountname */
        renderer = gtk_cell_renderer_text_new ();
        column = gtk_tree_view_column_new_with_attributes ("Account",
                                                           renderer,
                                                           "text", ACCOUNT_NAME,
                                                           NULL);
        gtk_tree_view_append_column (GTK_TREE_VIEW(accounts_tree_view), column);
+       /* Account -> Hostname */
        renderer = gtk_cell_renderer_text_new ();
        column = gtk_tree_view_column_new_with_attributes ("Hostname",
                                                           renderer,
@@ -135,15 +503,20 @@ accounts_and_identities_dialog (gpointer user_data)
                                                           NULL);
        gtk_tree_view_append_column (GTK_TREE_VIEW(accounts_tree_view), column);
 
+       /* Identities */
        identities_tree_view = glade_xml_get_widget(glade_xml, "IdentitiesTreeview");
        identities_model=create_identities_model(priv->modest_id_mgr);
        gtk_tree_view_set_model(GTK_TREE_VIEW(identities_tree_view), identities_model);
+
+       /* Identities -> Identityname */
        renderer = gtk_cell_renderer_text_new ();
        column = gtk_tree_view_column_new_with_attributes ("Identity",
                                                           renderer,
                                                           "text", IDENTITY_NAME,
                                                           NULL);
        gtk_tree_view_append_column (GTK_TREE_VIEW(identities_tree_view), column);
+
+       /* Identities -> E-mail address */
        renderer = gtk_cell_renderer_text_new ();
        column = gtk_tree_view_column_new_with_attributes ("E-mail address",
                                                           renderer,
@@ -151,20 +524,51 @@ accounts_and_identities_dialog (gpointer user_data)
                                                           NULL);
        gtk_tree_view_append_column (GTK_TREE_VIEW(identities_tree_view), column);
 
+       /* Identities -> Relay */
+       renderer = gtk_cell_renderer_text_new ();
+       column = gtk_tree_view_column_new_with_attributes ("Transport",
+                                                          renderer,
+                                                          "text", IDENTITY_VIA,
+                                                          NULL);
+       gtk_tree_view_append_column (GTK_TREE_VIEW(identities_tree_view), column);
+
+       cb_data=setup_callback_data(identities_tree_view, accounts_tree_view, modest_ui);
+
+       abutton=glade_xml_get_widget(glade_xml, "IdentityCreateButton");
+       g_signal_connect(abutton,
+                        "clicked",
+                        G_CALLBACK(create_action),
+                        cb_data);
+       abutton=glade_xml_get_widget(glade_xml, "IdentityEditButton");
+       g_signal_connect(abutton,
+                        "clicked",
+                        G_CALLBACK(edit_action),
+                        cb_data);
+       abutton=glade_xml_get_widget(glade_xml, "IdentityDeleteButton");
+       g_signal_connect(abutton,
+                        "clicked",
+                        G_CALLBACK(delete_action),
+                        cb_data);
+
+       /* FIXME: the edit/delete buttons are sensitive by default
+        * but we have no selection by default.
+        */
+
+       activate_buttons_on_identity(NULL, glade_xml);
+
        gtk_widget_show_all(GTK_WIDGET(main_dialog));
 
-       while (TRUE) {
-               retval=gtk_dialog_run(GTK_DIALOG(main_dialog));
-               if (retval==GTK_RESPONSE_CANCEL)
-                       break;
-       }
+       retval=gtk_dialog_run(GTK_DIALOG(main_dialog));
 
        gtk_widget_destroy(GTK_WIDGET(main_dialog));
+       g_object_unref(accounts_model);
+       g_object_unref(identities_model);
+       free_callback_data(cb_data);
        g_object_unref(glade_xml);
 }
 
 void account_settings (GtkWidget *widget,
-                       gpointer user_data)
+                      gpointer user_data)
 {
        accounts_and_identities_dialog (MODEST_UI(user_data));
 }

diff --git a/src/gtk-glade/modest-ui-wizard.c b/src/gtk-glade/modest-ui-wizard.c
index b323495..3edf494 100644 (file)
--- a/src/gtk-glade/modest-ui-wizard.c
+++ b/src/gtk-glade/modest-ui-wizard.c
@@ -211,15 +211,15 @@ void wizard_account_dialog(ModestUI *modest_ui)
 {
        GladeXML *glade_xml;
        GtkWidget *dialog;
-        ModestUIPrivate *priv;
-        GtkWidget *finish_button;
-        GtkWidget *back_button;
-        GtkWidget *next_button;
-        GtkWidget *cancel_button;
+       ModestUIPrivate *priv;
+       GtkWidget *finish_button;
+       GtkWidget *back_button;
+       GtkWidget *next_button;
+       GtkWidget *cancel_button;
        GtkWidget *notebook;
        GtkWidget *use_incoming_button;
-        gint cp;
-        gint result;
+       gint cp;
+       gint result;
        gboolean account_added_successfully=FALSE;
 
        g_return_if_fail(MODEST_IS_UI(modest_ui));
@@ -227,15 +227,15 @@ void wizard_account_dialog(ModestUI *modest_ui)
 
        glade_xml = glade_xml_new(MODEST_GLADE, "account_wizard", NULL);
 
-        dialog = glade_xml_get_widget(glade_xml, "account_wizard");
+       dialog = glade_xml_get_widget(glade_xml, "account_wizard");
 
-        gtk_widget_show_all(dialog);
+       gtk_widget_show_all(dialog);
 
-        finish_button=glade_xml_get_widget(glade_xml, "AWFinishButton");
-        back_button=glade_xml_get_widget(glade_xml, "AWBackButton");
-        next_button=glade_xml_get_widget(glade_xml, "AWNextButton");
-        cancel_button=glade_xml_get_widget(glade_xml, "AWCancelButton");
-        notebook=glade_xml_get_widget(glade_xml, "AWNotebook");
+       finish_button=glade_xml_get_widget(glade_xml, "AWFinishButton");
+       back_button=glade_xml_get_widget(glade_xml, "AWBackButton");
+       next_button=glade_xml_get_widget(glade_xml, "AWNextButton");
+       cancel_button=glade_xml_get_widget(glade_xml, "AWCancelButton");
+       notebook=glade_xml_get_widget(glade_xml, "AWNotebook");
 
        gtk_widget_set_sensitive(finish_button, FALSE);
 
@@ -248,37 +248,37 @@ void wizard_account_dialog(ModestUI *modest_ui)
        /* First page not used currently. It's reserved for the account preset. */
        gtk_notebook_set_current_page (GTK_NOTEBOOK(notebook), 1);
 
-        do {
-                cp=gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
-                switch (cp) {
-                case 1:
-                        gtk_widget_set_sensitive(back_button, FALSE);
-                        break;
-                case 2:
-                        gtk_widget_set_sensitive(back_button, TRUE);
-                        break;
-                case 3:
-                        gtk_widget_set_sensitive(finish_button, FALSE);
-                        gtk_widget_set_sensitive(next_button, TRUE);
-                        break;
-                case 4:
-                        gtk_widget_set_sensitive(finish_button, TRUE);
-                        gtk_widget_set_sensitive(next_button, FALSE);
-                        break;
-                default:
-                        g_error("I'm on page %d of notebook AWNotebook, which shouldn't have happened. Pulling emergency breaks.", cp);
-                        break;
-                }
+       do {
+               cp=gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
+               switch (cp) {
+               case 1:
+                       gtk_widget_set_sensitive(back_button, FALSE);
+                       break;
+               case 2:
+                       gtk_widget_set_sensitive(back_button, TRUE);
+                       break;
+               case 3:
+                       gtk_widget_set_sensitive(finish_button, FALSE);
+                       gtk_widget_set_sensitive(next_button, TRUE);
+                       break;
+               case 4:
+                       gtk_widget_set_sensitive(finish_button, TRUE);
+                       gtk_widget_set_sensitive(next_button, FALSE);
+                       break;
+               default:
+                       g_error("I'm on page %d of notebook AWNotebook, which shouldn't have happened. Pulling emergency breaks.", cp);
+                       break;
+               }
 
-                result=gtk_dialog_run(GTK_DIALOG(dialog));
+               result=gtk_dialog_run(GTK_DIALOG(dialog));
 
-                switch (result) {
-                case 1:
-                        if (advance_sanity_check(glade_xml, cp)==TRUE)
-                                gtk_notebook_next_page(GTK_NOTEBOOK(notebook));
-                        break;
-                case 2:
-                        gtk_notebook_prev_page(GTK_NOTEBOOK(notebook));
+               switch (result) {
+               case 1:
+                       if (advance_sanity_check(glade_xml, cp)==TRUE)
+                               gtk_notebook_next_page(GTK_NOTEBOOK(notebook));
+                       break;
+               case 2:
+                       gtk_notebook_prev_page(GTK_NOTEBOOK(notebook));
                        break;
                case GTK_RESPONSE_ACCEPT:
                        account_added_successfully=wizard_account_add(glade_xml, modest_ui);

diff --git a/src/gtk-glade/modest.glade b/src/gtk-glade/modest.glade
index a2c2b71..0ecc50e 100644 (file)
--- a/src/gtk-glade/modest.glade
+++ b/src/gtk-glade/modest.glade
@@ -3694,10 +3694,9 @@ Tap 'Advanced' to edit the advanced e-mail settings.</property>
          <child>
            <widget class="GtkScrolledWindow" id="scrolledwindow11">
              <property name="visible">True</property>
-             <property name="sensitive">False</property>
              <property name="can_focus">True</property>
-             <property name="hscrollbar_policy">GTK_POLICY_ALWAYS</property>
-             <property name="vscrollbar_policy">GTK_POLICY_ALWAYS</property>
+             <property name="hscrollbar_policy">GTK_POLICY_AUTOMATIC</property>
+             <property name="vscrollbar_policy">GTK_POLICY_AUTOMATIC</property>
              <property name="shadow_type">GTK_SHADOW_IN</property>
              <property name="window_placement">GTK_CORNER_TOP_LEFT</property>
 

diff --git a/src/modest-identity-mgr.h b/src/modest-identity-mgr.h
index 459a7ad..307e8b9 100644 (file)
--- a/src/modest-identity-mgr.h
+++ b/src/modest-identity-mgr.h
@@ -69,14 +69,14 @@ GObject * modest_identity_mgr_new (ModestConf * modest_conf);
  * Returns: TRUE if  succeeded, FALSE otherwise,
  */
 gboolean modest_identity_mgr_add_identity (ModestIdentityMgr * self,
-                                           const gchar * name,
-                                           const gchar * realname,
-                                           const gchar * email,
-                                           const gchar * replyto,
-                                           const gchar * signature,
-                                           const gboolean use_signature,
-                                           const gchar * id_via,
-                                           const gboolean use_id_via);
+                                          const gchar * name,
+                                          const gchar * realname,
+                                          const gchar * email,
+                                          const gchar * replyto,
+                                          const gchar * signature,
+                                          const gboolean use_signature,
+                                          const gchar * id_via,
+                                          const gboolean use_id_via);
 
 
 /**

diff --git a/src/modest-main.c b/src/modest-main.c
index bba5bcb..0804f1c 100644 (file)
--- a/src/modest-main.c
+++ b/src/modest-main.c
@@ -191,8 +191,8 @@ install_test_account (ModestConf *conf)
                }
        }
        if (!modest_identity_mgr_add_identity (id_mgr,
-                                               MODEST_IDENTITY_DEFAULT_IDENTITY,
-                                               "Default User",
+                                              MODEST_IDENTITY_DEFAULT_IDENTITY,
+                                              "Default User",
                                               "user@localhost",
                                               "", "", FALSE, NULL, FALSE ))
                g_warning ("failed to add test identity");