src/account.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999,2000 Hiroyuki Yamamoto
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #endif
  23
  24 #include "defs.h"
  25
  26 #include <glib.h>
  27 #include <gtk/gtk.h>
  28 #include <gdk/gdkkeysyms.h>
  29 #include <stdio.h>
  30 #include <errno.h>
  31
  32 #include "intl.h"
  33 #include "main.h"
  34 #include "mainwindow.h"
  35 #include "folderview.h"
  36 #include "folder.h"
  37 #include "account.h"
  38 #include "prefs.h"
  39 #include "prefs_account.h"
  40 #include "compose.h"
  41 #include "manage_window.h"
  42 #include "inc.h"
  43 #include "gtkutils.h"
  44 #include "utils.h"
  45 #include "alertpanel.h"
  46
  47 typedef enum
  48 {
  49         COL_DEFAULT     = 0,
  50         COL_NAME        = 1,
  51         COL_PROTOCOL    = 2,
  52         COL_SERVER      = 3
  53 } EditAccountColumnPos;
  54
  55 # define N_EDIT_ACCOUNT_COLS    4
  56
  57 #define PREFSBUFSIZE            1024
  58
  59 PrefsAccount *cur_account;
  60
  61 static GList *account_list = NULL;
  62
  63 static struct EditAccount {
  64         GtkWidget *window;
  65         GtkWidget *clist;
  66         GtkWidget *close_btn;
  67 } edit_account;
  68
  69 static void account_edit_create         (void);
  70
  71 static void account_edit_prefs          (void);
  72 static void account_delete              (void);
  73
  74 static void account_up                  (void);
  75 static void account_down                (void);
  76
  77 static void account_set_default         (void);
  78
  79 static void account_edit_close          (void);
  80 static gint account_delete_event        (GtkWidget      *widget,
  81                                          GdkEventAny    *event,
  82                                          gpointer        data);
  83 static void account_key_pressed         (GtkWidget      *widget,
  84                                          GdkEventKey    *event,
  85                                          gpointer        data);
  86
  87 static gint account_clist_set_row       (PrefsAccount   *ac_prefs,
  88                                          gint            row);
  89 static void account_clist_set           (void);
  90
  91 static void account_list_set            (void);
  92
  93 void account_read_config_all(void)
  94 {
  95         GSList *ac_label_list = NULL, *cur;
  96         gchar *rcpath;
  97         FILE *fp;
  98         gchar buf[PREFSBUFSIZE];
  99         PrefsAccount *ac_prefs;
 100
 101         debug_print(_("Reading all config for each account...\n"));
 102
 103         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, ACCOUNT_RC, NULL);
 104         if ((fp = fopen(rcpath, "r")) == NULL) {
 105                 if (ENOENT != errno) FILE_OP_ERROR(rcpath, "fopen");
 106                 g_free(rcpath);
 107                 return;
 108         }
 109         g_free(rcpath);
 110
 111         while (fgets(buf, sizeof(buf), fp) != NULL) {
 112                 if (!strncmp(buf, "[Account: ", 10)) {
 113                         strretchomp(buf);
 114                         memmove(buf, buf + 1, strlen(buf));
 115                         buf[strlen(buf) - 1] = '\0';
 116                         debug_print(_("Found label: %s\n"), buf);
 117                         ac_label_list = g_slist_append(ac_label_list,
 118                                                        g_strdup(buf));
 119                 }
 120         }
 121         fclose(fp);
 122
 123         /* read config data from file */
 124         cur_account = NULL;
 125         for (cur = ac_label_list; cur != NULL; cur = cur->next) {
 126                 ac_prefs = g_new0(PrefsAccount, 1);
 127                 prefs_account_read_config(ac_prefs, (gchar *)cur->data);
 128                 account_list = g_list_append(account_list, ac_prefs);
 129                 if (ac_prefs->is_default)
 130                         cur_account = ac_prefs;
 131         }
 132         /* if default is not set, assume first account as default */
 133         if (!cur_account && account_list) {
 134                 ac_prefs = (PrefsAccount *)account_list->data;
 135                 account_set_as_default(ac_prefs);
 136                 cur_account = ac_prefs;
 137         }
 138
 139         account_set_menu();
 140         main_window_reflect_prefs_all();
 141
 142         while (ac_label_list) {
 143                 g_free(ac_label_list->data);
 144                 ac_label_list = g_slist_remove(ac_label_list,
 145                                                ac_label_list->data);
 146         }
 147 }
 148
 149 void account_save_config_all(void)
 150 {
 151         prefs_account_save_config_all(account_list);
 152 }
 153
 154 PrefsAccount *account_find_from_smtp_server(const gchar *address,
 155                                             const gchar *smtp_server)
 156 {
 157         GList *cur;
 158         PrefsAccount *ac;
 159
 160         for (cur = account_list; cur != NULL; cur = cur->next) {
 161                 ac = (PrefsAccount *)cur->data;
 162                 if (!strcmp2(address, ac->address) &&
 163                     !strcmp2(smtp_server, ac->smtp_server))
 164                         return ac;
 165         }
 166
 167         return NULL;
 168 }
 169
 170 /**
 171  * account_find_mail_from_address:
 172  * @address: Email address string.
 173  *
 174  * Find a mail (not news) account with the specified email address.
 175  *
 176  * Return value: The found account, or NULL if not found.
 177  **/
 178 PrefsAccount *account_find_mail_from_address(const gchar *address)
 179 {
 180         GList *cur;
 181         PrefsAccount *ac;
 182
 183         for (cur = account_list; cur != NULL; cur = cur->next) {
 184                 ac = (PrefsAccount *)cur->data;
 185                 if (ac->protocol != A_NNTP &&
 186                     !strcmp2(address, ac->address))
 187                         return ac;
 188         }
 189
 190         return NULL;
 191 }
 192
 193 PrefsAccount *account_find_from_id(gint id)
 194 {
 195         GList *cur;
 196         PrefsAccount *ac;
 197
 198         for (cur = account_list; cur != NULL; cur = cur->next) {
 199                 ac = (PrefsAccount *)cur->data;
 200                 if (id == ac->account_id)
 201                         return ac;
 202         }
 203
 204         return NULL;
 205 }
 206
 207 void account_set_menu(void)
 208 {
 209         main_window_set_account_menu(account_list);
 210 }
 211
 212 void account_foreach(AccountFunc func, gpointer user_data)
 213 {
 214         GList *cur;
 215
 216         for (cur = account_list; cur != NULL; cur = cur->next)
 217                 if (func((PrefsAccount *)cur->data, user_data) != 0)
 218                         return;
 219 }
 220
 221 GList *account_get_list(void)
 222 {
 223         return account_list;
 224 }
 225
 226 void account_edit_open(void)
 227 {
 228         inc_autocheck_timer_remove();
 229
 230         if (compose_get_compose_list()) {
 231                 alertpanel_notice(_("Some composing windows are open.\n"
 232                                     "Please close all the composing windows before editing the accounts."));
 233                 inc_autocheck_timer_set();
 234                 return;
 235         }
 236
 237         debug_print(_("Opening account edit window...\n"));
 238
 239         if (!edit_account.window)
 240                 account_edit_create();
 241
 242         account_clist_set();
 243
 244         manage_window_set_transient(GTK_WINDOW(edit_account.window));
 245         gtk_widget_grab_focus(edit_account.close_btn);
 246         gtk_widget_show(edit_account.window);
 247
 248         manage_window_focus_in(edit_account.window, NULL, NULL);
 249 }
 250
 251 void account_add(void)
 252 {
 253         PrefsAccount *ac_prefs;
 254
 255         ac_prefs = prefs_account_open(NULL);
 256         inc_autocheck_timer_remove();
 257
 258         if (!ac_prefs) return;
 259
 260         account_list = g_list_append(account_list, ac_prefs);
 261
 262         if (ac_prefs->is_default)
 263                 account_set_as_default(ac_prefs);
 264
 265         account_clist_set();
 266
 267         if (ac_prefs->protocol == A_IMAP4 || ac_prefs->protocol == A_NNTP) {
 268                 Folder *folder;
 269
 270                 if (ac_prefs->protocol == A_IMAP4) {
 271                         folder = folder_new(F_IMAP, ac_prefs->account_name,
 272                                             ac_prefs->recv_server);
 273                 } else {
 274                         folder = folder_new(F_NEWS, ac_prefs->account_name,
 275                                             ac_prefs->nntp_server);
 276                 }
 277                 folder->account = ac_prefs;
 278                 ac_prefs->folder = REMOTE_FOLDER(folder);
 279                 folder_add(folder);
 280                 folderview_update_all();
 281         }
 282 }
 283
 284 void account_set_as_default(PrefsAccount *ac_prefs)
 285 {
 286         PrefsAccount *ap;
 287         GList *cur;
 288
 289         for (cur = account_list; cur != NULL; cur = cur->next) {
 290                 ap = (PrefsAccount *)cur->data;
 291                 if (ap->is_default)
 292                         ap->is_default = FALSE;
 293         }
 294
 295         ac_prefs->is_default = TRUE;
 296 }
 297
 298 PrefsAccount *account_get_default(void)
 299 {
 300         PrefsAccount *ap;
 301         GList *cur;
 302
 303         for (cur = account_list; cur != NULL; cur = cur->next) {
 304                 ap = (PrefsAccount *)cur->data;
 305                 if (ap->is_default)
 306                         return ap;
 307         }
 308
 309         return NULL;
 310 }
 311
 312 void account_set_missing_folder(void)
 313 {
 314         PrefsAccount *ap;
 315         GList *cur;
 316
 317         for (cur = account_list; cur != NULL; cur = cur->next) {
 318                 ap = (PrefsAccount *)cur->data;
 319                 if ((ap->protocol == A_IMAP4 || ap->protocol == A_NNTP) &&
 320                     !ap->folder) {
 321                         Folder *folder;
 322
 323                         if (ap->protocol == A_IMAP4) {
 324                                 folder = folder_new(F_IMAP, ap->account_name,
 325                                                     ap->recv_server);
 326                         } else {
 327                                 folder = folder_new(F_NEWS, ap->account_name,
 328                                                     ap->nntp_server);
 329                         }
 330                         folder->account = ap;
 331                         ap->folder = REMOTE_FOLDER(folder);
 332                         folder_add(folder);
 333                 }
 334         }
 335 }
 336
 337 void account_destroy(PrefsAccount *ac_prefs)
 338 {
 339         g_return_if_fail(ac_prefs != NULL);
 340
 341         prefs_account_free(ac_prefs);
 342         account_list = g_list_remove(account_list, ac_prefs);
 343
 344         if (cur_account == ac_prefs) cur_account = NULL;
 345         if (!cur_account && account_list) {
 346                 cur_account = account_get_default();
 347                 if (!cur_account) {
 348                         ac_prefs = (PrefsAccount *)account_list->data;
 349                         account_set_as_default(ac_prefs);
 350                         cur_account = ac_prefs;
 351                 }
 352         }
 353 }
 354
 355
 356 static void account_edit_create(void)
 357 {
 358         GtkWidget *window;
 359         GtkWidget *vbox;
 360         GtkWidget *hbox;
 361         GtkWidget *scrolledwin;
 362         GtkWidget *clist;
 363         gchar *titles[N_EDIT_ACCOUNT_COLS];
 364         gint i;
 365
 366         GtkWidget *vbox2;
 367         GtkWidget *add_btn;
 368         GtkWidget *edit_btn;
 369         GtkWidget *del_btn;
 370         GtkWidget *up_btn;
 371         GtkWidget *down_btn;
 372
 373         GtkWidget *default_btn;
 374
 375         GtkWidget *hbbox;
 376         GtkWidget *close_btn;
 377
 378         debug_print(_("Creating account edit window...\n"));
 379
 380         window = gtk_window_new (GTK_WINDOW_DIALOG);
 381         gtk_widget_set_usize (window, 500, 320);
 382         gtk_container_set_border_width (GTK_CONTAINER (window), 8);
 383         gtk_window_set_title (GTK_WINDOW (window), _("Edit accounts"));
 384         gtk_window_set_modal (GTK_WINDOW (window), TRUE);
 385         gtk_signal_connect (GTK_OBJECT (window), "delete_event",
 386                             GTK_SIGNAL_FUNC (account_delete_event), NULL);
 387         gtk_signal_connect (GTK_OBJECT (window), "key_press_event",
 388                             GTK_SIGNAL_FUNC (account_key_pressed), NULL);
 389         gtk_signal_connect (GTK_OBJECT (window), "focus_in_event",
 390                             GTK_SIGNAL_FUNC (manage_window_focus_in), NULL);
 391         gtk_signal_connect (GTK_OBJECT (window), "focus_out_event",
 392                             GTK_SIGNAL_FUNC (manage_window_focus_out), NULL);
 393
 394         vbox = gtk_vbox_new (FALSE, 12);
 395         gtk_widget_show (vbox);
 396         gtk_container_add (GTK_CONTAINER (window), vbox);
 397
 398         hbox = gtk_hbox_new (FALSE, 8);
 399         gtk_widget_show (hbox);
 400         gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
 401         gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
 402
 403         scrolledwin = gtk_scrolled_window_new (NULL, NULL);
 404         gtk_widget_show (scrolledwin);
 405         gtk_box_pack_start (GTK_BOX (hbox), scrolledwin, TRUE, TRUE, 0);
 406         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwin),
 407                                         GTK_POLICY_AUTOMATIC,
 408                                         GTK_POLICY_AUTOMATIC);
 409
 410         titles[COL_DEFAULT]  = "";
 411         titles[COL_NAME]     = _("Name");
 412         titles[COL_PROTOCOL] = _("Protocol");
 413         titles[COL_SERVER]   = _("Server");
 414
 415         clist = gtk_clist_new_with_titles (N_EDIT_ACCOUNT_COLS, titles);
 416         gtk_widget_show (clist);
 417         gtk_container_add (GTK_CONTAINER (scrolledwin), clist);
 418         gtk_clist_set_column_width (GTK_CLIST(clist), COL_DEFAULT , 16);
 419         gtk_clist_set_column_width (GTK_CLIST(clist), COL_NAME    , 100);
 420         gtk_clist_set_column_width (GTK_CLIST(clist), COL_PROTOCOL, 70);
 421         gtk_clist_set_column_width (GTK_CLIST(clist), COL_SERVER  , 100);
 422         gtk_clist_set_selection_mode (GTK_CLIST(clist), GTK_SELECTION_BROWSE);
 423
 424         for (i = 0; i < N_EDIT_ACCOUNT_COLS; i++)
 425                 GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(clist)->column[i].button,
 426                                        GTK_CAN_FOCUS);
 427
 428         vbox2 = gtk_vbox_new (FALSE, 0);
 429         gtk_widget_show (vbox2);
 430         gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 0);
 431
 432         add_btn = gtk_button_new_with_label (_("Add"));
 433         gtk_widget_show (add_btn);
 434         gtk_box_pack_start (GTK_BOX (vbox2), add_btn, FALSE, FALSE, 4);
 435         gtk_signal_connect (GTK_OBJECT(add_btn), "clicked",
 436                             GTK_SIGNAL_FUNC (account_add), NULL);
 437
 438         edit_btn = gtk_button_new_with_label (_("Edit"));
 439         gtk_widget_show (edit_btn);
 440         gtk_box_pack_start (GTK_BOX (vbox2), edit_btn, FALSE, FALSE, 4);
 441         gtk_signal_connect (GTK_OBJECT(edit_btn), "clicked",
 442                             GTK_SIGNAL_FUNC (account_edit_prefs), NULL);
 443
 444         del_btn = gtk_button_new_with_label (_(" Delete "));
 445         gtk_widget_show (del_btn);
 446         gtk_box_pack_start (GTK_BOX (vbox2), del_btn, FALSE, FALSE, 4);
 447         gtk_signal_connect (GTK_OBJECT(del_btn), "clicked",
 448                             GTK_SIGNAL_FUNC (account_delete), NULL);
 449
 450         down_btn = gtk_button_new_with_label (_("Down"));
 451         gtk_widget_show (down_btn);
 452         gtk_box_pack_end (GTK_BOX (vbox2), down_btn, FALSE, FALSE, 4);
 453         gtk_signal_connect (GTK_OBJECT(down_btn), "clicked",
 454                             GTK_SIGNAL_FUNC (account_down), NULL);
 455
 456         up_btn = gtk_button_new_with_label (_("Up"));
 457         gtk_widget_show (up_btn);
 458         gtk_box_pack_end (GTK_BOX (vbox2), up_btn, FALSE, FALSE, 4);
 459         gtk_signal_connect (GTK_OBJECT(up_btn), "clicked",
 460                             GTK_SIGNAL_FUNC (account_up), NULL);
 461
 462         hbox = gtk_hbox_new (FALSE, 8);
 463         gtk_widget_show (hbox);
 464         gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 465
 466         vbox2 = gtk_vbox_new(FALSE, 0);
 467         gtk_widget_show (vbox2);
 468         gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 0);
 469
 470         default_btn = gtk_button_new_with_label (_(" Set as usually used account "));
 471         gtk_widget_show (default_btn);
 472         gtk_box_pack_start (GTK_BOX (vbox2), default_btn, TRUE, FALSE, 0);
 473         gtk_signal_connect (GTK_OBJECT(default_btn), "clicked",
 474                             GTK_SIGNAL_FUNC (account_set_default), NULL);
 475
 476         gtkut_button_set_create(&hbbox, &close_btn, _("Close"),
 477                                 NULL, NULL, NULL, NULL);
 478         gtk_widget_show(hbbox);
 479         gtk_box_pack_end (GTK_BOX (hbox), hbbox, FALSE, FALSE, 0);
 480         gtk_widget_grab_default (close_btn);
 481
 482         gtk_signal_connect (GTK_OBJECT (close_btn), "clicked",
 483                             GTK_SIGNAL_FUNC (account_edit_close),
 484                             NULL);
 485
 486         edit_account.window    = window;
 487         edit_account.clist     = clist;
 488         edit_account.close_btn = close_btn;
 489 }
 490
 491 static void account_edit_prefs(void)
 492 {
 493         GtkCList *clist = GTK_CLIST(edit_account.clist);
 494         PrefsAccount *ac_prefs;
 495         gint row;
 496         gboolean prev_default;
 497         gchar *ac_name;
 498
 499         if (!clist->selection) return;
 500
 501         row = GPOINTER_TO_INT(clist->selection->data);
 502         ac_prefs = gtk_clist_get_row_data(clist, row);
 503         prev_default = ac_prefs->is_default;
 504         Xstrdup_a(ac_name, ac_prefs->account_name, return);
 505
 506         prefs_account_open(ac_prefs);
 507         inc_autocheck_timer_remove();
 508
 509         if (!prev_default && ac_prefs->is_default)
 510                 account_set_as_default(ac_prefs);
 511
 512         if ((ac_prefs->protocol == A_IMAP4 || ac_prefs->protocol == A_NNTP) &&
 513             ac_prefs->folder && strcmp(ac_name, ac_prefs->account_name) != 0) {
 514                 folder_set_name(FOLDER(ac_prefs->folder),
 515                                 ac_prefs->account_name);
 516                 folderview_update_all();
 517         }
 518
 519         account_clist_set();
 520 }
 521
 522 static void account_delete(void)
 523 {
 524         GtkCList *clist = GTK_CLIST(edit_account.clist);
 525         PrefsAccount *ac_prefs;
 526         gint row;
 527
 528         if (!clist->selection) return;
 529
 530         if (alertpanel(_("Delete account"),
 531                        _("Do you really want to delete this account?"),
 532                        _("Yes"), _("+No"), NULL) != G_ALERTDEFAULT)
 533                 return;
 534
 535         row = GPOINTER_TO_INT(clist->selection->data);
 536         ac_prefs = gtk_clist_get_row_data(clist, row);
 537         if (ac_prefs->folder) {
 538                 folder_destroy(FOLDER(ac_prefs->folder));
 539                 folderview_update_all();
 540         }
 541         account_destroy(ac_prefs);
 542         account_clist_set();
 543 }
 544
 545 static void account_up(void)
 546 {
 547         GtkCList *clist = GTK_CLIST(edit_account.clist);
 548         gint row;
 549
 550         if (!clist->selection) return;
 551
 552         row = GPOINTER_TO_INT(clist->selection->data);
 553         if (row > 0) {
 554                 gtk_clist_row_move(clist, row, row - 1);
 555                 account_list_set();
 556         }
 557 }
 558
 559 static void account_down(void)
 560 {
 561         GtkCList *clist = GTK_CLIST(edit_account.clist);
 562         gint row;
 563
 564         if (!clist->selection) return;
 565
 566         row = GPOINTER_TO_INT(clist->selection->data);
 567         if (row < clist->rows - 1) {
 568                 gtk_clist_row_move(clist, row, row + 1);
 569                 account_list_set();
 570         }
 571 }
 572
 573 static void account_set_default(void)
 574 {
 575         GtkCList *clist = GTK_CLIST(edit_account.clist);
 576         gint row;
 577         PrefsAccount *ac_prefs;
 578
 579         if (!clist->selection) return;
 580
 581         row = GPOINTER_TO_INT(clist->selection->data);
 582         ac_prefs = gtk_clist_get_row_data(clist, row);
 583         account_set_as_default(ac_prefs);
 584         account_clist_set();
 585
 586         cur_account = ac_prefs;
 587         account_set_menu();
 588         main_window_reflect_prefs_all();
 589 }
 590
 591 static void account_edit_close(void)
 592 {
 593         account_list_set();
 594         account_save_config_all();
 595
 596         if (!cur_account && account_list) {
 597                 PrefsAccount *ac_prefs = (PrefsAccount *)account_list->data;
 598                 account_set_as_default(ac_prefs);
 599                 cur_account = ac_prefs;
 600         }
 601
 602         account_set_menu();
 603         main_window_reflect_prefs_all();
 604
 605         gtk_widget_hide(edit_account.window);
 606
 607         inc_autocheck_timer_set();
 608 }
 609
 610 static gint account_delete_event(GtkWidget *widget, GdkEventAny *event,
 611                                  gpointer data)
 612 {
 613         account_edit_close();
 614         return TRUE;
 615 }
 616
 617 static void account_key_pressed(GtkWidget *widget, GdkEventKey *event,
 618                                 gpointer data)
 619 {
 620         if (event && event->keyval == GDK_Escape)
 621                 account_edit_close();
 622 }
 623
 624 /* set one CList row or add new row */
 625 static gint account_clist_set_row(PrefsAccount *ac_prefs, gint row)
 626 {
 627         GtkCList *clist = GTK_CLIST(edit_account.clist);
 628         gchar *text[N_EDIT_ACCOUNT_COLS];
 629
 630         text[COL_DEFAULT] = ac_prefs->is_default ? "*" : "";
 631         text[COL_NAME] = ac_prefs->account_name;
 632         text[COL_PROTOCOL] = ac_prefs->protocol == A_POP3  ? "POP3"  :
 633                              ac_prefs->protocol == A_APOP  ? "APOP"  :
 634                              ac_prefs->protocol == A_IMAP4 ? "IMAP4" :
 635                              ac_prefs->protocol == A_LOCAL ? "Local" :
 636                              ac_prefs->protocol == A_NNTP  ? "NNTP"  :  "";
 637         text[COL_SERVER] = ac_prefs->protocol == A_NNTP
 638                 ? ac_prefs->nntp_server : ac_prefs->recv_server;
 639
 640         if (row < 0)
 641                 row = gtk_clist_append(clist, text);
 642         else {
 643                 gtk_clist_set_text(clist, row, COL_DEFAULT, text[COL_DEFAULT]);
 644                 gtk_clist_set_text(clist, row, COL_NAME, text[COL_NAME]);
 645                 gtk_clist_set_text(clist, row, COL_PROTOCOL, text[COL_PROTOCOL]);
 646                 gtk_clist_set_text(clist, row, COL_SERVER, text[COL_SERVER]);
 647         }
 648
 649         gtk_clist_set_row_data(clist, row, ac_prefs);
 650
 651         return row;
 652 }
 653
 654 /* set CList from account list */
 655 static void account_clist_set(void)
 656 {
 657         GtkCList *clist = GTK_CLIST(edit_account.clist);
 658         GList *cur;
 659         gint prev_row;
 660
 661         if (clist->selection)
 662                 prev_row = GPOINTER_TO_INT(clist->selection->data);
 663         else
 664                 prev_row = -1;
 665
 666         gtk_clist_freeze(clist);
 667         gtk_clist_clear(clist);
 668
 669         for (cur = account_list; cur != NULL; cur = cur->next) {
 670                 gint row;
 671
 672                 row = account_clist_set_row((PrefsAccount *)cur->data, -1);
 673                 if ((PrefsAccount *)cur->data == cur_account)
 674                         gtk_clist_select_row(clist, row, -1);
 675         }
 676
 677         if (prev_row >= 0)
 678                 gtk_clist_select_row(clist, prev_row, -1);
 679
 680         gtk_clist_thaw(clist);
 681 }
 682
 683 /* set account list from CList */
 684 static void account_list_set(void)
 685 {
 686         GtkCList *clist = GTK_CLIST(edit_account.clist);
 687         gint row;
 688         PrefsAccount *ac_prefs;
 689
 690         while (account_list)
 691                 account_list = g_list_remove(account_list, account_list->data);
 692
 693         for (row = 0; (ac_prefs = gtk_clist_get_row_data(clist, row)) != NULL;
 694              row++)
 695                 account_list = g_list_append(account_list, ac_prefs);
 696 }