src/editaddress.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2001 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 <gdk/gdkkeysyms.h>
  28 #include <gtk/gtkwindow.h>
  29 #include <gtk/gtksignal.h>
  30 #include <gtk/gtklabel.h>
  31 #include <gtk/gtkvbox.h>
  32 #include <gtk/gtkentry.h>
  33 #include <gtk/gtktable.h>
  34
  35 #include "intl.h"
  36 #include "mgutils.h"
  37 #include "addressbook.h"
  38 #include "addressitem.h"
  39 #include "addritem.h"
  40 #include "addrbook.h"
  41 #include "manage_window.h"
  42 #include "gtkutils.h"
  43 #include "codeconv.h"
  44
  45 #include "prefs_common.h"
  46
  47 /*
  48 static struct _AddressEdit_dlg {
  49         GtkWidget *window;
  50         GtkWidget *name_entry;
  51         GtkWidget *addr_entry;
  52         GtkWidget *rem_entry;
  53         GtkWidget *ok_btn;
  54         GtkWidget *cancel_btn;
  55 } addredit;
  56 */
  57
  58 static struct _PersonEdit_dlg {
  59         GtkWidget *window;
  60         GtkWidget *notebook;
  61         GtkWidget *ok_btn;
  62         GtkWidget *cancel_btn;
  63         GtkWidget *statusbar;
  64         gint status_cid;
  65
  66         // Basic data tab
  67         GtkWidget *entry_name;
  68         GtkWidget *entry_first;
  69         GtkWidget *entry_last;
  70         GtkWidget *entry_nick;
  71
  72         // EMail data tab
  73         GtkWidget *entry_email;
  74         GtkWidget *entry_alias;
  75         GtkWidget *entry_remarks;
  76         GtkWidget *clist_email;
  77
  78         // Attribute data tab
  79         GtkWidget *entry_atname;
  80         GtkWidget *entry_atvalue;
  81         GtkWidget *clist_attrib;
  82
  83         gint rowIndEMail;
  84         gint rowIndAttrib;
  85         gboolean editNew;
  86
  87 } personeditdlg;
  88
  89 typedef enum {
  90         EMAIL_COL_EMAIL   = 0,
  91         EMAIL_COL_ALIAS   = 1,
  92         EMAIL_COL_REMARKS = 2
  93 } PersonEditEMailColumnPos;
  94
  95 typedef enum {
  96         ATTRIB_COL_NAME    = 0,
  97         ATTRIB_COL_VALUE   = 1
  98 } PersonEditAttribColumnPos;
  99
 100 #define EDITPERSON_WIDTH      520
 101 #define EDITPERSON_HEIGHT     340
 102
 103 #define EMAIL_N_COLS          3
 104 #define EMAIL_COL_WIDTH_EMAIL 180
 105 #define EMAIL_COL_WIDTH_ALIAS 80
 106
 107 #define ATTRIB_N_COLS          2
 108 #define ATTRIB_COL_WIDTH_NAME  120
 109 #define ATTRIB_COL_WIDTH_VALUE 180
 110
 111 #define PAGE_BASIC             0
 112 #define PAGE_EMAIL             1
 113 #define PAGE_ATTRIBUTES        2
 114
 115 /*
 116 #define SET_LABEL_AND_ENTRY(str, entry, top) \
 117 { \
 118         label = gtk_label_new(str); \
 119         gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), \
 120                          GTK_FILL, 0, 0, 0); \
 121         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); \
 122  \
 123         entry = gtk_entry_new(); \
 124         gtk_table_attach(GTK_TABLE(table), entry, 1, 2, top, (top + 1), \
 125                          GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0); \
 126 }
 127
 128 static void edit_address_ok(GtkWidget *widget, gboolean *cancelled)
 129 {
 130         *cancelled = FALSE;
 131         gtk_main_quit();
 132 }
 133
 134 static void edit_address_cancel(GtkWidget *widget, gboolean *cancelled)
 135 {
 136         *cancelled = TRUE;
 137         gtk_main_quit();
 138 }
 139
 140 static gint edit_address_delete_event(GtkWidget *widget, GdkEventAny *event,
 141                                       gboolean *cancelled)
 142 {
 143         *cancelled = TRUE;
 144         gtk_main_quit();
 145
 146         return TRUE;
 147 }
 148
 149 static void edit_address_key_pressed(GtkWidget *widget, GdkEventKey *event,
 150                                      gboolean *cancelled)
 151 {
 152         if (event && event->keyval == GDK_Escape) {
 153                 *cancelled = TRUE;
 154                 gtk_main_quit();
 155         }
 156 }
 157
 158 static void addressbook_edit_address_create(gboolean *cancelled)
 159 {
 160         GtkWidget *window;
 161         GtkWidget *vbox;
 162         GtkWidget *table;
 163         GtkWidget *label;
 164         GtkWidget *name_entry;
 165         GtkWidget *addr_entry;
 166         GtkWidget *rem_entry;
 167         GtkWidget *hbbox;
 168         GtkWidget *ok_btn;
 169         GtkWidget *cancel_btn;
 170
 171         debug_print("Creating edit_address window...\n");
 172
 173         window = gtk_window_new(GTK_WINDOW_DIALOG);
 174         gtk_widget_set_usize(window, 400, -1);
 175         //gtk_container_set_border_width(GTK_CONTAINER(window), 8);
 176         gtk_window_set_title(GTK_WINDOW(window), _("Edit address"));
 177         gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
 178         gtk_window_set_modal(GTK_WINDOW(window), TRUE);
 179         gtk_signal_connect(GTK_OBJECT(window), "delete_event",
 180                            GTK_SIGNAL_FUNC(edit_address_delete_event),
 181                            cancelled);
 182         gtk_signal_connect(GTK_OBJECT(window), "key_press_event",
 183                            GTK_SIGNAL_FUNC(edit_address_key_pressed),
 184                            cancelled);
 185
 186         vbox = gtk_vbox_new(FALSE, 8);
 187         gtk_container_add(GTK_CONTAINER(window), vbox);
 188
 189         table = gtk_table_new(3, 2, FALSE);
 190         gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
 191         gtk_table_set_row_spacings(GTK_TABLE(table), 8);
 192         gtk_table_set_col_spacings(GTK_TABLE(table), 8);
 193
 194         SET_LABEL_AND_ENTRY(_("Name"),    name_entry, 0);
 195         SET_LABEL_AND_ENTRY(_("Address"), addr_entry, 1);
 196         SET_LABEL_AND_ENTRY(_("Remarks"), rem_entry,  2);
 197
 198         gtkut_button_set_create(&hbbox, &ok_btn, _("OK"),
 199                                 &cancel_btn, _("Cancel"), NULL, NULL);
 200         gtk_box_pack_end(GTK_BOX(vbox), hbbox, FALSE, FALSE, 0);
 201         gtk_widget_grab_default(ok_btn);
 202
 203         gtk_signal_connect(GTK_OBJECT(ok_btn), "clicked",
 204                            GTK_SIGNAL_FUNC(edit_address_ok), cancelled);
 205         gtk_signal_connect(GTK_OBJECT(cancel_btn), "clicked",
 206                            GTK_SIGNAL_FUNC(edit_address_cancel), cancelled);
 207
 208         gtk_widget_show_all(vbox);
 209
 210         addredit.window     = window;
 211         addredit.name_entry = name_entry;
 212         addredit.addr_entry = addr_entry;
 213         addredit.rem_entry  = rem_entry;
 214         addredit.ok_btn     = ok_btn;
 215         addredit.cancel_btn = cancel_btn;
 216 }
 217
 218 AddressItem *addressbook_edit_address(AddressItem *item)
 219 {
 220         static gboolean cancelled;
 221         const gchar *str;
 222
 223         if (!addredit.window)
 224                 addressbook_edit_address_create(&cancelled);
 225         gtk_widget_grab_focus(addredit.ok_btn);
 226         gtk_widget_grab_focus(addredit.name_entry);
 227         gtk_widget_show(addredit.window);
 228         manage_window_set_transient(GTK_WINDOW(addredit.window));
 229
 230         gtk_entry_set_text(GTK_ENTRY(addredit.name_entry), "");
 231         gtk_entry_set_text(GTK_ENTRY(addredit.addr_entry), "");
 232         gtk_entry_set_text(GTK_ENTRY(addredit.rem_entry),  "");
 233
 234         if (item) {
 235                 if (ADDRESS_OBJECT_NAME(item))
 236                         gtk_entry_set_text(GTK_ENTRY(addredit.name_entry),
 237                                            ADDRESS_OBJECT_NAME(item));
 238                 if (item->address)
 239                         gtk_entry_set_text(GTK_ENTRY(addredit.addr_entry),
 240                                            item->address);
 241                 if (item->remarks)
 242                         gtk_entry_set_text(GTK_ENTRY(addredit.rem_entry),
 243                                            item->remarks);
 244         }
 245
 246         gtk_main();
 247         gtk_widget_hide(addredit.window);
 248         if (cancelled == TRUE) return NULL;
 249
 250         str = gtk_entry_get_text(GTK_ENTRY(addredit.name_entry));
 251         if (*str == '\0') return NULL;
 252
 253         if (!item) {
 254                 item = mgu_create_address();
 255                 ADDRESS_OBJECT_TYPE(item) = ADDR_ITEM;
 256         }
 257
 258         g_free(ADDRESS_OBJECT_NAME(item));
 259         ADDRESS_OBJECT_NAME(item) = g_strdup(str);
 260
 261         str = gtk_entry_get_text(GTK_ENTRY(addredit.addr_entry));
 262         g_free(item->address);
 263         if (*str == '\0')
 264                 item->address = NULL;
 265         else
 266                 item->address = g_strdup(str);
 267
 268         str = gtk_entry_get_text(GTK_ENTRY(addredit.rem_entry));
 269         g_free(item->remarks);
 270         if (*str == '\0')
 271                 item->remarks = NULL;
 272         else
 273                 item->remarks = g_strdup(str);
 274
 275         return item;
 276 }
 277 */
 278
 279 static void edit_person_status_show( gchar *msg ) {
 280         if( personeditdlg.statusbar != NULL ) {
 281                 gtk_statusbar_pop( GTK_STATUSBAR(personeditdlg.statusbar), personeditdlg.status_cid );
 282                 if( msg ) {
 283                         gtk_statusbar_push( GTK_STATUSBAR(personeditdlg.statusbar), personeditdlg.status_cid, msg );
 284                 }
 285         }
 286 }
 287
 288 static void edit_person_ok(GtkWidget *widget, gboolean *cancelled) {
 289         *cancelled = FALSE;
 290         gtk_main_quit();
 291 }
 292
 293 static void edit_person_cancel(GtkWidget *widget, gboolean *cancelled) {
 294         *cancelled = TRUE;
 295         gtk_main_quit();
 296 }
 297
 298 static gint edit_person_delete_event(GtkWidget *widget, GdkEventAny *event, gboolean *cancelled) {
 299         *cancelled = TRUE;
 300         gtk_main_quit();
 301         return TRUE;
 302 }
 303
 304 static void edit_person_key_pressed(GtkWidget *widget, GdkEventKey *event, gboolean *cancelled) {
 305         if (event && event->keyval == GDK_Escape) {
 306                 *cancelled = TRUE;
 307                 gtk_main_quit();
 308         }
 309 }
 310
 311 static gchar *_title_new_ = NULL;
 312 static gchar *_title_edit_ = NULL;
 313
 314 static void edit_person_set_window_title( gint pageNum ) {
 315         gchar *sTitle;
 316
 317         if( _title_new_ == NULL ) {
 318                 _title_new_ = g_strdup( _("Add New Person") );
 319                 _title_edit_ = g_strdup( _("Edit Person Details") );
 320         }
 321
 322         if( pageNum == PAGE_BASIC ) {
 323                 if( personeditdlg.editNew ) {
 324                         gtk_window_set_title( GTK_WINDOW(personeditdlg.window), _title_new_ );
 325                 }
 326                 else {
 327                         gtk_window_set_title( GTK_WINDOW(personeditdlg.window), _title_edit_ );
 328                 }
 329         }
 330         else {
 331                 if( personeditdlg.entry_name == NULL ) {
 332                         sTitle = g_strdup( _title_edit_ );
 333                 }
 334                 else {
 335                         sTitle = g_strdup_printf( "%s - %s", _title_edit_,
 336                                         gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_name), 0, -1 ) );
 337                 }
 338                 gtk_window_set_title( GTK_WINDOW(personeditdlg.window), sTitle );
 339                 g_free( sTitle );
 340         }
 341 }
 342
 343 static void edit_person_email_clear( gpointer data ) {
 344         gtk_entry_set_text( GTK_ENTRY(personeditdlg.entry_email), "" );
 345         gtk_entry_set_text( GTK_ENTRY(personeditdlg.entry_alias), "" );
 346         gtk_entry_set_text( GTK_ENTRY(personeditdlg.entry_remarks), "" );
 347 }
 348
 349 static void edit_person_attrib_clear( gpointer data ) {
 350         gtk_entry_set_text( GTK_ENTRY(personeditdlg.entry_atname), "" );
 351         gtk_entry_set_text( GTK_ENTRY(personeditdlg.entry_atvalue), "" );
 352 }
 353
 354 static void edit_person_switch_page( GtkNotebook *notebook, GtkNotebookPage *page,
 355                                         gint pageNum, gpointer user_data)
 356 {
 357         edit_person_set_window_title( pageNum );
 358         edit_person_status_show( "" );
 359 }
 360
 361 /*
 362 * Load clist with a copy of person's email addresses.
 363 */
 364 void edit_person_load_email( ItemPerson *person ) {
 365         GList *node = person->listEMail;
 366         GtkCList *clist = GTK_CLIST(personeditdlg.clist_email);
 367         gchar *text[ EMAIL_N_COLS ];
 368         while( node ) {
 369                 ItemEMail *emorig = ( ItemEMail * ) node->data;
 370                 ItemEMail *email = addritem_copy_item_email( emorig );
 371                 gint row;
 372                 text[ EMAIL_COL_EMAIL   ] = email->address;
 373                 text[ EMAIL_COL_ALIAS   ] = email->obj.name;
 374                 text[ EMAIL_COL_REMARKS ] = email->remarks;
 375
 376                 row = gtk_clist_append( clist, text );
 377                 gtk_clist_set_row_data( clist, row, email );
 378                 node = g_list_next( node );
 379         }
 380 }
 381
 382 static void edit_person_email_list_selected( GtkCList *clist, gint row, gint column, GdkEvent *event, gpointer data ) {
 383         ItemEMail *email = gtk_clist_get_row_data( clist, row );
 384         if( email ) {
 385                 if( email->address )
 386                         gtk_entry_set_text( GTK_ENTRY(personeditdlg.entry_email), email->address );
 387                 if( ADDRITEM_NAME(email) )
 388                         gtk_entry_set_text( GTK_ENTRY(personeditdlg.entry_alias), ADDRITEM_NAME(email) );
 389                 if( email->remarks )
 390                         gtk_entry_set_text( GTK_ENTRY(personeditdlg.entry_remarks), email->remarks );
 391         }
 392         personeditdlg.rowIndEMail = row;
 393         edit_person_status_show( NULL );
 394 }
 395
 396 static void edit_person_email_move( gint dir ) {
 397         GtkCList *clist = GTK_CLIST(personeditdlg.clist_email);
 398         gint row = personeditdlg.rowIndEMail + dir;
 399         ItemEMail *email = gtk_clist_get_row_data( clist, row );
 400         if( email ) {
 401                 gtk_clist_row_move( clist, personeditdlg.rowIndEMail, row );
 402                 personeditdlg.rowIndEMail = row;
 403         }
 404         edit_person_email_clear( NULL );
 405         edit_person_status_show( NULL );
 406 }
 407
 408 static void edit_person_email_move_up( gpointer data ) {
 409         edit_person_email_move( -1 );
 410 }
 411
 412 static void edit_person_email_move_down( gpointer data ) {
 413         edit_person_email_move( +1 );
 414 }
 415
 416 static void edit_person_email_delete( gpointer data ) {
 417         GtkCList *clist = GTK_CLIST(personeditdlg.clist_email);
 418         gint row = personeditdlg.rowIndEMail;
 419         ItemEMail *email = gtk_clist_get_row_data( clist, row );
 420         edit_person_email_clear( NULL );
 421         if( email ) {
 422                 // Remove list entry
 423                 gtk_clist_remove( clist, row );
 424                 addritem_free_item_email( email );
 425                 email = NULL;
 426         }
 427
 428         // Position hilite bar
 429         email = gtk_clist_get_row_data( clist, row );
 430         if( ! email ) {
 431                 personeditdlg.rowIndEMail = -1 + row;
 432         }
 433         edit_person_status_show( NULL );
 434 }
 435
 436 static ItemEMail *edit_person_email_edit( gboolean *error, ItemEMail *email ) {
 437         ItemEMail *retVal = NULL;
 438         gchar *sEmail, *sAlias, *sRemarks;
 439         *error = TRUE;
 440         sEmail = gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_email), 0, -1 );
 441         sAlias = gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_alias), 0, -1 );
 442         sRemarks = gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_remarks), 0, -1 );
 443         sEmail = mgu_email_check_empty( sEmail );
 444         if( sEmail ) {
 445                 if( email == NULL ) {
 446                         email = addritem_create_item_email();
 447                 }
 448                 addritem_email_set_address( email, sEmail );
 449                 addritem_email_set_alias( email, sAlias );
 450                 addritem_email_set_remarks( email, sRemarks );
 451                 retVal = email;
 452                 *error = FALSE;
 453         }
 454         else {
 455                 edit_person_status_show( _( "An E-Mail address must be supplied." ) );
 456         }
 457         return retVal;
 458 }
 459
 460 static void edit_person_email_modify( gpointer data ) {
 461         gboolean errFlg = FALSE;
 462         GtkCList *clist = GTK_CLIST(personeditdlg.clist_email);
 463         gint row = personeditdlg.rowIndEMail;
 464         ItemEMail *email = gtk_clist_get_row_data( clist, row );
 465         if( email ) {
 466                 edit_person_email_edit( &errFlg, email );
 467                 if( ! errFlg ) {
 468                         gtk_clist_set_text( clist, row, EMAIL_COL_EMAIL, email->address );
 469                         gtk_clist_set_text( clist, row, EMAIL_COL_ALIAS, email->obj.name );
 470                         gtk_clist_set_text( clist, row, EMAIL_COL_REMARKS, email->remarks );
 471                         edit_person_email_clear( NULL );
 472                 }
 473         }
 474 }
 475
 476 static void edit_person_email_add( gpointer data ) {
 477         GtkCList *clist = GTK_CLIST(personeditdlg.clist_email);
 478         gboolean errFlg = FALSE;
 479         ItemEMail *email = NULL;
 480         gint row = personeditdlg.rowIndEMail;
 481         if( gtk_clist_get_row_data( clist, row ) == NULL ) row = 0;
 482
 483         email = edit_person_email_edit( &errFlg, NULL );
 484         if( ! errFlg ) {
 485                 gchar *text[ EMAIL_N_COLS ];
 486                 text[ EMAIL_COL_EMAIL   ] = email->address;
 487                 text[ EMAIL_COL_ALIAS   ] = email->obj.name;
 488                 text[ EMAIL_COL_REMARKS ] = email->remarks;
 489
 490                 row = gtk_clist_insert( clist, 1 + row, text );
 491                 gtk_clist_set_row_data( clist, row, email );
 492                 gtk_clist_select_row( clist, row, 0 );
 493                 edit_person_email_clear( NULL );
 494         }
 495 }
 496
 497 /*
 498 * Load clist with a copy of person's email addresses.
 499 */
 500 void edit_person_load_attrib( ItemPerson *person ) {
 501         GList *node = person->listAttrib;
 502         GtkCList *clist = GTK_CLIST(personeditdlg.clist_attrib);
 503         gchar *text[ ATTRIB_N_COLS ];
 504         while( node ) {
 505                 UserAttribute *atorig = ( UserAttribute * ) node->data;
 506                 UserAttribute *attrib = addritem_copy_attribute( atorig );
 507                 gint row;
 508                 text[ ATTRIB_COL_NAME  ] = attrib->name;
 509                 text[ ATTRIB_COL_VALUE ] = attrib->value;
 510
 511                 row = gtk_clist_append( clist, text );
 512                 gtk_clist_set_row_data( clist, row, attrib );
 513                 node = g_list_next( node );
 514         }
 515 }
 516
 517 static void edit_person_attrib_list_selected( GtkCList *clist, gint row, gint column, GdkEvent *event, gpointer data ) {
 518         UserAttribute *attrib = gtk_clist_get_row_data( clist, row );
 519         if( attrib ) {
 520                 gtk_entry_set_text( GTK_ENTRY(personeditdlg.entry_atname), attrib->name );
 521                 gtk_entry_set_text( GTK_ENTRY(personeditdlg.entry_atvalue), attrib->value );
 522         }
 523         personeditdlg.rowIndAttrib = row;
 524         edit_person_status_show( NULL );
 525 }
 526
 527 static void edit_person_attrib_delete( gpointer data ) {
 528         GtkCList *clist = GTK_CLIST(personeditdlg.clist_attrib);
 529         gint row = personeditdlg.rowIndAttrib;
 530         UserAttribute *attrib = gtk_clist_get_row_data( clist, row );
 531         edit_person_attrib_clear( NULL );
 532         if( attrib ) {
 533                 // Remove list entry
 534                 gtk_clist_remove( clist, row );
 535                 addritem_free_attribute( attrib );
 536                 attrib = NULL;
 537         }
 538
 539         // Position hilite bar
 540         attrib = gtk_clist_get_row_data( clist, row );
 541         if( ! attrib ) {
 542                 personeditdlg.rowIndAttrib = -1 + row;
 543         }
 544         edit_person_status_show( NULL );
 545 }
 546
 547 static UserAttribute *edit_person_attrib_edit( gboolean *error, UserAttribute *attrib ) {
 548         UserAttribute *retVal = NULL;
 549         gchar *sName, *sValue;
 550         *error = TRUE;
 551         sName = gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_atname), 0, -1 );
 552         sValue = gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_atvalue), 0, -1 );
 553         sName = mgu_email_check_empty( sName );
 554         sValue = mgu_email_check_empty( sValue );
 555         if( sName && sValue ) {
 556                 if( attrib == NULL ) {
 557                         attrib = addritem_create_attribute();
 558                 }
 559                 addritem_attrib_set_name( attrib, sName );
 560                 addritem_attrib_set_value( attrib, sValue );
 561                 retVal = attrib;
 562                 *error = FALSE;
 563         }
 564         else {
 565                 edit_person_status_show( _( "A Name and Value must be supplied." ) );
 566         }
 567         return retVal;
 568 }
 569
 570 static void edit_person_attrib_modify( gpointer data ) {
 571         gboolean errFlg = FALSE;
 572         GtkCList *clist = GTK_CLIST(personeditdlg.clist_attrib);
 573         gint row = personeditdlg.rowIndAttrib;
 574         UserAttribute *attrib = gtk_clist_get_row_data( clist, row );
 575         if( attrib ) {
 576                 edit_person_attrib_edit( &errFlg, attrib );
 577                 if( ! errFlg ) {
 578                         gtk_clist_set_text( clist, row, ATTRIB_COL_NAME, attrib->name );
 579                         gtk_clist_set_text( clist, row, ATTRIB_COL_VALUE, attrib->value );
 580                         edit_person_attrib_clear( NULL );
 581                 }
 582         }
 583 }
 584
 585 static void edit_person_attrib_add( gpointer data ) {
 586         GtkCList *clist = GTK_CLIST(personeditdlg.clist_attrib);
 587         gboolean errFlg = FALSE;
 588         UserAttribute *attrib = NULL;
 589         gint row = personeditdlg.rowIndAttrib;
 590         if( gtk_clist_get_row_data( clist, row ) == NULL ) row = 0;
 591
 592         attrib = edit_person_attrib_edit( &errFlg, NULL );
 593         if( ! errFlg ) {
 594                 gchar *text[ EMAIL_N_COLS ];
 595                 text[ ATTRIB_COL_NAME  ] = attrib->name;
 596                 text[ ATTRIB_COL_VALUE ] = attrib->value;
 597
 598                 row = gtk_clist_insert( clist, 1 + row, text );
 599                 gtk_clist_set_row_data( clist, row, attrib );
 600                 gtk_clist_select_row( clist, row, 0 );
 601                 edit_person_attrib_clear( NULL );
 602         }
 603 }
 604
 605 static void addressbook_edit_person_dialog_create( gboolean *cancelled ) {
 606         GtkWidget *window;
 607         GtkWidget *vbox;
 608         GtkWidget *vnbox;
 609         GtkWidget *notebook;
 610         GtkWidget *hbbox;
 611         GtkWidget *ok_btn;
 612         GtkWidget *cancel_btn;
 613         GtkWidget *hsbox;
 614         GtkWidget *statusbar;
 615
 616         window = gtk_window_new(GTK_WINDOW_DIALOG);
 617         gtk_widget_set_usize(window, EDITPERSON_WIDTH, EDITPERSON_HEIGHT );
 618         //gtk_container_set_border_width(GTK_CONTAINER(window), 0);
 619         gtk_window_set_title(GTK_WINDOW(window), _("Edit Person Data"));
 620         gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
 621         gtk_window_set_modal(GTK_WINDOW(window), TRUE);
 622         gtk_signal_connect(GTK_OBJECT(window), "delete_event",
 623                            GTK_SIGNAL_FUNC(edit_person_delete_event),
 624                            cancelled);
 625         gtk_signal_connect(GTK_OBJECT(window), "key_press_event",
 626                            GTK_SIGNAL_FUNC(edit_person_key_pressed),
 627                            cancelled);
 628
 629         vbox = gtk_vbox_new(FALSE, 4);
 630         //gtk_container_set_border_width(GTK_CONTAINER(vbox), BORDER_WIDTH);
 631         gtk_widget_show(vbox);
 632         gtk_container_add(GTK_CONTAINER(window), vbox);
 633
 634         vnbox = gtk_vbox_new(FALSE, 4);
 635         gtk_container_set_border_width(GTK_CONTAINER(vnbox), 4);
 636         gtk_widget_show(vnbox);
 637         gtk_box_pack_start(GTK_BOX(vbox), vnbox, TRUE, TRUE, 0);
 638
 639         // Notebook
 640         notebook = gtk_notebook_new();
 641         gtk_widget_show(notebook);
 642         gtk_box_pack_start(GTK_BOX(vnbox), notebook, TRUE, TRUE, 0);
 643         gtk_container_set_border_width(GTK_CONTAINER(notebook), 6);
 644
 645         // Status line
 646         hsbox = gtk_hbox_new(FALSE, 0);
 647         gtk_box_pack_end(GTK_BOX(vbox), hsbox, FALSE, FALSE, BORDER_WIDTH);
 648         statusbar = gtk_statusbar_new();
 649         gtk_box_pack_start(GTK_BOX(hsbox), statusbar, TRUE, TRUE, BORDER_WIDTH);
 650
 651         // Button panel
 652         gtkut_button_set_create(&hbbox, &ok_btn, _("OK"),
 653                                 &cancel_btn, _("Cancel"), NULL, NULL);
 654         gtk_box_pack_end(GTK_BOX(vnbox), hbbox, FALSE, FALSE, 0);
 655         gtk_widget_grab_default(ok_btn);
 656
 657         gtk_signal_connect(GTK_OBJECT(ok_btn), "clicked",
 658                            GTK_SIGNAL_FUNC(edit_person_ok), cancelled);
 659         gtk_signal_connect(GTK_OBJECT(cancel_btn), "clicked",
 660                            GTK_SIGNAL_FUNC(edit_person_cancel), cancelled);
 661         gtk_signal_connect(GTK_OBJECT(notebook), "switch_page",
 662                            GTK_SIGNAL_FUNC(edit_person_switch_page), NULL );
 663
 664         gtk_widget_show_all(vbox);
 665
 666         personeditdlg.window     = window;
 667         personeditdlg.notebook   = notebook;
 668         personeditdlg.ok_btn     = ok_btn;
 669         personeditdlg.cancel_btn = cancel_btn;
 670         personeditdlg.statusbar  = statusbar;
 671         personeditdlg.status_cid = gtk_statusbar_get_context_id( GTK_STATUSBAR(statusbar), "Edit Person Dialog" );
 672
 673 }
 674
 675 void addressbook_edit_person_page_basic( gint pageNum, gchar *pageLbl ) {
 676         GtkWidget *vbox;
 677         GtkWidget *table;
 678         GtkWidget *label;
 679         GtkWidget *entry_name;
 680         GtkWidget *entry_fn;
 681         GtkWidget *entry_ln;
 682         GtkWidget *entry_nn;
 683         const gchar *locale;
 684         gint top = 0;
 685
 686         vbox = gtk_vbox_new( FALSE, 8 );
 687         gtk_widget_show( vbox );
 688         gtk_container_add( GTK_CONTAINER( personeditdlg.notebook ), vbox );
 689         gtk_container_set_border_width( GTK_CONTAINER (vbox), BORDER_WIDTH );
 690
 691         label = gtk_label_new( pageLbl );
 692         gtk_widget_show( label );
 693         gtk_notebook_set_tab_label(
 694                 GTK_NOTEBOOK( personeditdlg.notebook ),
 695                 gtk_notebook_get_nth_page( GTK_NOTEBOOK( personeditdlg.notebook ), pageNum ), label );
 696
 697         table = gtk_table_new( 4, 3, FALSE);
 698         gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
 699         gtk_container_set_border_width( GTK_CONTAINER(table), 8 );
 700         gtk_table_set_row_spacings(GTK_TABLE(table), 8);
 701         gtk_table_set_col_spacings(GTK_TABLE(table), 8);
 702
 703 #define ATTACH_ROW(text, entry) \
 704 { \
 705         label = gtk_label_new(text); \
 706         gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), \
 707                          GTK_FILL, 0, 0, 0); \
 708         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); \
 709  \
 710         entry = gtk_entry_new(); \
 711         gtk_table_attach(GTK_TABLE(table), entry, 1, 2, top, (top + 1), \
 712                          GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0); \
 713         top++; \
 714 }
 715
 716         ATTACH_ROW(_("Display Name"), entry_name);
 717         locale = conv_get_current_locale();
 718         if (locale &&
 719             (!g_strncasecmp(locale, "ja", 2) ||
 720              !g_strncasecmp(locale, "ko", 2) ||
 721              !g_strncasecmp(locale, "zh", 2))) {
 722                 ATTACH_ROW(_("Last Name"), entry_ln);
 723                 ATTACH_ROW(_("First Name"), entry_fn);
 724         } else {
 725                 ATTACH_ROW(_("First Name"), entry_fn);
 726                 ATTACH_ROW(_("Last Name"), entry_ln);
 727         }
 728         ATTACH_ROW(_("Nick Name"), entry_nn);
 729
 730 #undef ATTACH_ROW
 731
 732         gtk_widget_show_all(vbox);
 733
 734         personeditdlg.entry_name  = entry_name;
 735         personeditdlg.entry_first = entry_fn;
 736         personeditdlg.entry_last  = entry_ln;
 737         personeditdlg.entry_nick  = entry_nn;
 738 }
 739
 740 void addressbook_edit_person_page_email( gint pageNum, gchar *pageLbl ) {
 741         GtkWidget *vbox;
 742         GtkWidget *hbox;
 743         GtkWidget *vboxl;
 744         GtkWidget *vboxb;
 745         GtkWidget *vbuttonbox;
 746         GtkWidget *buttonUp;
 747         GtkWidget *buttonDown;
 748         GtkWidget *buttonDel;
 749         GtkWidget *buttonMod;
 750         GtkWidget *buttonAdd;
 751         GtkWidget *buttonClr;
 752
 753         GtkWidget *table;
 754         GtkWidget *label;
 755         GtkWidget *clist_swin;
 756         GtkWidget *clist;
 757         GtkWidget *entry_email;
 758         GtkWidget *entry_alias;
 759         GtkWidget *entry_remarks;
 760         gint top;
 761
 762         gchar *titles[ EMAIL_N_COLS ] = { _("E-Mail Address"), _("Alias"), _("Remarks") };
 763         gint i;
 764
 765         vbox = gtk_vbox_new( FALSE, 8 );
 766         gtk_widget_show( vbox );
 767         gtk_container_add( GTK_CONTAINER( personeditdlg.notebook ), vbox );
 768         gtk_container_set_border_width( GTK_CONTAINER (vbox), BORDER_WIDTH );
 769
 770         label = gtk_label_new( pageLbl );
 771         gtk_widget_show( label );
 772         gtk_notebook_set_tab_label(
 773                 GTK_NOTEBOOK( personeditdlg.notebook ),
 774                 gtk_notebook_get_nth_page( GTK_NOTEBOOK( personeditdlg.notebook ), pageNum ), label );
 775
 776         // Split into two areas
 777         hbox = gtk_hbox_new( FALSE, 0 );
 778         gtk_container_add( GTK_CONTAINER( vbox ), hbox );
 779
 780         // EMail list
 781         vboxl = gtk_vbox_new( FALSE, 4 );
 782         gtk_container_add( GTK_CONTAINER( hbox ), vboxl );
 783         gtk_container_set_border_width( GTK_CONTAINER(vboxl), 4 );
 784
 785         // Address list
 786         clist_swin = gtk_scrolled_window_new( NULL, NULL );
 787         gtk_container_add( GTK_CONTAINER(vboxl), clist_swin );
 788         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(clist_swin),
 789                                        GTK_POLICY_AUTOMATIC,
 790                                        GTK_POLICY_ALWAYS);
 791
 792         clist = gtk_clist_new_with_titles( EMAIL_N_COLS, titles );
 793         gtk_container_add( GTK_CONTAINER(clist_swin), clist );
 794         gtk_clist_set_selection_mode( GTK_CLIST(clist), GTK_SELECTION_BROWSE );
 795         gtk_clist_set_column_width( GTK_CLIST(clist), EMAIL_COL_EMAIL, EMAIL_COL_WIDTH_EMAIL );
 796         gtk_clist_set_column_width( GTK_CLIST(clist), EMAIL_COL_ALIAS, EMAIL_COL_WIDTH_ALIAS );
 797
 798         for( i = 0; i < EMAIL_N_COLS; i++ )
 799                 GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(clist)->column[i].button, GTK_CAN_FOCUS);
 800
 801         // Data entry area
 802         table = gtk_table_new( 4, 2, FALSE);
 803         gtk_box_pack_start(GTK_BOX(vboxl), table, FALSE, FALSE, 0);
 804         gtk_container_set_border_width( GTK_CONTAINER(table), 4 );
 805         gtk_table_set_row_spacings(GTK_TABLE(table), 4);
 806         gtk_table_set_col_spacings(GTK_TABLE(table), 4);
 807
 808         // First row
 809         top = 0;
 810         label = gtk_label_new(_("E-Mail Address"));
 811         gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0);
 812         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
 813
 814         entry_email = gtk_entry_new();
 815         gtk_table_attach(GTK_TABLE(table), entry_email, 1, 2, top, (top + 1), GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0);
 816
 817         // Next row
 818         ++top;
 819         label = gtk_label_new(_("Alias"));
 820         gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0);
 821         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
 822
 823         entry_alias = gtk_entry_new();
 824         gtk_table_attach(GTK_TABLE(table), entry_alias, 1, 2, top, (top + 1), GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0);
 825
 826         // Next row
 827         ++top;
 828         label = gtk_label_new(_("Remarks"));
 829         gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0);
 830         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
 831
 832         entry_remarks = gtk_entry_new();
 833         gtk_table_attach(GTK_TABLE(table), entry_remarks, 1, 2, top, (top + 1), GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0);
 834
 835         // Button box
 836         vboxb = gtk_vbox_new( FALSE, 4 );
 837         gtk_box_pack_start(GTK_BOX(hbox), vboxb, FALSE, FALSE, 2);
 838
 839         vbuttonbox = gtk_vbutton_box_new();
 840         gtk_button_box_set_layout( GTK_BUTTON_BOX(vbuttonbox), GTK_BUTTONBOX_START );
 841         gtk_button_box_set_spacing( GTK_BUTTON_BOX(vbuttonbox), 8 );
 842         gtk_container_set_border_width( GTK_CONTAINER(vbuttonbox), 4 );
 843         gtk_container_add( GTK_CONTAINER(vboxb), vbuttonbox );
 844
 845         // Buttons
 846         buttonUp = gtk_button_new_with_label( _( "Move Up" ) );
 847         gtk_container_add( GTK_CONTAINER(vbuttonbox), buttonUp );
 848
 849         buttonDown = gtk_button_new_with_label( _( "Move Down" ) );
 850         gtk_container_add( GTK_CONTAINER(vbuttonbox), buttonDown );
 851
 852         buttonDel = gtk_button_new_with_label( _( "Delete" ) );
 853         gtk_container_add( GTK_CONTAINER(vbuttonbox), buttonDel );
 854
 855         buttonMod = gtk_button_new_with_label( _( "Modify" ) );
 856         gtk_container_add( GTK_CONTAINER(vbuttonbox), buttonMod );
 857
 858         buttonAdd = gtk_button_new_with_label( _( "Add" ) );
 859         gtk_container_add( GTK_CONTAINER(vbuttonbox), buttonAdd );
 860
 861         buttonClr = gtk_button_new_with_label( _( "Clear" ) );
 862         gtk_container_add( GTK_CONTAINER(vbuttonbox), buttonClr );
 863
 864         gtk_widget_show_all(vbox);
 865
 866         // Event handlers
 867         gtk_signal_connect( GTK_OBJECT(clist), "select_row",
 868                         GTK_SIGNAL_FUNC( edit_person_email_list_selected), NULL );
 869         gtk_signal_connect( GTK_OBJECT(buttonUp), "clicked",
 870                         GTK_SIGNAL_FUNC( edit_person_email_move_up ), NULL );
 871         gtk_signal_connect( GTK_OBJECT(buttonDown), "clicked",
 872                         GTK_SIGNAL_FUNC( edit_person_email_move_down ), NULL );
 873         gtk_signal_connect( GTK_OBJECT(buttonDel), "clicked",
 874                         GTK_SIGNAL_FUNC( edit_person_email_delete ), NULL );
 875         gtk_signal_connect( GTK_OBJECT(buttonMod), "clicked",
 876                         GTK_SIGNAL_FUNC( edit_person_email_modify ), NULL );
 877         gtk_signal_connect( GTK_OBJECT(buttonAdd), "clicked",
 878                         GTK_SIGNAL_FUNC( edit_person_email_add ), NULL );
 879         gtk_signal_connect( GTK_OBJECT(buttonClr), "clicked",
 880                         GTK_SIGNAL_FUNC( edit_person_email_clear ), NULL );
 881
 882         personeditdlg.clist_email   = clist;
 883         personeditdlg.entry_email   = entry_email;
 884         personeditdlg.entry_alias   = entry_alias;
 885         personeditdlg.entry_remarks = entry_remarks;
 886 }
 887
 888 void addressbook_edit_person_page_attrib( gint pageNum, gchar *pageLbl ) {
 889         GtkWidget *vbox;
 890         GtkWidget *hbox;
 891         GtkWidget *vboxl;
 892         GtkWidget *vboxb;
 893         GtkWidget *vbuttonbox;
 894         GtkWidget *buttonDel;
 895         GtkWidget *buttonMod;
 896         GtkWidget *buttonAdd;
 897         GtkWidget *buttonClr;
 898
 899         GtkWidget *table;
 900         GtkWidget *label;
 901         GtkWidget *clist_swin;
 902         GtkWidget *clist;
 903         GtkWidget *entry_name;
 904         GtkWidget *entry_value;
 905         gint top;
 906
 907         gchar *titles[ ATTRIB_N_COLS ] = { _("Name"), _("Value") };
 908         gint i;
 909
 910         vbox = gtk_vbox_new( FALSE, 8 );
 911         gtk_widget_show( vbox );
 912         gtk_container_add( GTK_CONTAINER( personeditdlg.notebook ), vbox );
 913         gtk_container_set_border_width( GTK_CONTAINER (vbox), BORDER_WIDTH );
 914
 915         label = gtk_label_new( pageLbl );
 916         gtk_widget_show( label );
 917         gtk_notebook_set_tab_label(
 918                 GTK_NOTEBOOK( personeditdlg.notebook ),
 919                 gtk_notebook_get_nth_page( GTK_NOTEBOOK( personeditdlg.notebook ), pageNum ), label );
 920
 921         // Split into two areas
 922         hbox = gtk_hbox_new( FALSE, 0 );
 923         gtk_container_add( GTK_CONTAINER( vbox ), hbox );
 924
 925         // Attribute list
 926         vboxl = gtk_vbox_new( FALSE, 4 );
 927         gtk_container_add( GTK_CONTAINER( hbox ), vboxl );
 928         gtk_container_set_border_width( GTK_CONTAINER(vboxl), 4 );
 929
 930         // Address list
 931         clist_swin = gtk_scrolled_window_new( NULL, NULL );
 932         gtk_container_add( GTK_CONTAINER(vboxl), clist_swin );
 933         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(clist_swin),
 934                                        GTK_POLICY_AUTOMATIC,
 935                                        GTK_POLICY_ALWAYS);
 936
 937         clist = gtk_clist_new_with_titles( ATTRIB_N_COLS, titles );
 938         gtk_container_add( GTK_CONTAINER(clist_swin), clist );
 939         gtk_clist_set_selection_mode( GTK_CLIST(clist), GTK_SELECTION_BROWSE );
 940         gtk_clist_set_column_width( GTK_CLIST(clist), ATTRIB_COL_NAME, ATTRIB_COL_WIDTH_NAME );
 941         gtk_clist_set_column_width( GTK_CLIST(clist), ATTRIB_COL_VALUE, ATTRIB_COL_WIDTH_VALUE );
 942
 943         for( i = 0; i < ATTRIB_N_COLS; i++ )
 944                 GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(clist)->column[i].button, GTK_CAN_FOCUS);
 945
 946         // Data entry area
 947         table = gtk_table_new( 4, 2, FALSE);
 948         gtk_box_pack_start(GTK_BOX(vboxl), table, FALSE, FALSE, 0);
 949         gtk_container_set_border_width( GTK_CONTAINER(table), 4 );
 950         gtk_table_set_row_spacings(GTK_TABLE(table), 4);
 951         gtk_table_set_col_spacings(GTK_TABLE(table), 4);
 952
 953         // First row
 954         top = 0;
 955         label = gtk_label_new(_("Name"));
 956         gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0);
 957         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
 958
 959         entry_name = gtk_entry_new();
 960         gtk_table_attach(GTK_TABLE(table), entry_name, 1, 2, top, (top + 1), GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0);
 961
 962         // Next row
 963         ++top;
 964         label = gtk_label_new(_("Value"));
 965         gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0);
 966         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
 967
 968         entry_value = gtk_entry_new();
 969         gtk_table_attach(GTK_TABLE(table), entry_value, 1, 2, top, (top + 1), GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0);
 970
 971         // Button box
 972         vboxb = gtk_vbox_new( FALSE, 4 );
 973         gtk_box_pack_start(GTK_BOX(hbox), vboxb, FALSE, FALSE, 2);
 974
 975         vbuttonbox = gtk_vbutton_box_new();
 976         gtk_button_box_set_layout( GTK_BUTTON_BOX(vbuttonbox), GTK_BUTTONBOX_START );
 977         gtk_button_box_set_spacing( GTK_BUTTON_BOX(vbuttonbox), 8 );
 978         gtk_container_set_border_width( GTK_CONTAINER(vbuttonbox), 4 );
 979         gtk_container_add( GTK_CONTAINER(vboxb), vbuttonbox );
 980
 981         // Buttons
 982         buttonDel = gtk_button_new_with_label( _( "Delete" ) );
 983         gtk_container_add( GTK_CONTAINER(vbuttonbox), buttonDel );
 984
 985         buttonMod = gtk_button_new_with_label( _( "Modify" ) );
 986         gtk_container_add( GTK_CONTAINER(vbuttonbox), buttonMod );
 987
 988         buttonAdd = gtk_button_new_with_label( _( "Add" ) );
 989         gtk_container_add( GTK_CONTAINER(vbuttonbox), buttonAdd );
 990
 991         buttonClr = gtk_button_new_with_label( _( "Clear" ) );
 992         gtk_container_add( GTK_CONTAINER(vbuttonbox), buttonClr );
 993
 994         gtk_widget_show_all(vbox);
 995
 996         // Event handlers
 997         gtk_signal_connect( GTK_OBJECT(clist), "select_row",
 998                         GTK_SIGNAL_FUNC( edit_person_attrib_list_selected), NULL );
 999         gtk_signal_connect( GTK_OBJECT(buttonDel), "clicked",
1000                         GTK_SIGNAL_FUNC( edit_person_attrib_delete ), NULL );
1001         gtk_signal_connect( GTK_OBJECT(buttonMod), "clicked",
1002                         GTK_SIGNAL_FUNC( edit_person_attrib_modify ), NULL );
1003         gtk_signal_connect( GTK_OBJECT(buttonAdd), "clicked",
1004                         GTK_SIGNAL_FUNC( edit_person_attrib_add ), NULL );
1005         gtk_signal_connect( GTK_OBJECT(buttonClr), "clicked",
1006                         GTK_SIGNAL_FUNC( edit_person_attrib_clear ), NULL );
1007
1008         personeditdlg.clist_attrib  = clist;
1009         personeditdlg.entry_atname  = entry_name;
1010         personeditdlg.entry_atvalue = entry_value;
1011 }
1012
1013 static void addressbook_edit_person_create( gboolean *cancelled ) {
1014         addressbook_edit_person_dialog_create( cancelled );
1015         addressbook_edit_person_page_basic( PAGE_BASIC, _( "Basic Data" ) );
1016         addressbook_edit_person_page_email( PAGE_EMAIL, _( "E-Mail Address" ) );
1017         addressbook_edit_person_page_attrib( PAGE_ATTRIBUTES, _( "User Attributes" ) );
1018         gtk_widget_show_all( personeditdlg.window );
1019 }
1020
1021 /*
1022 * Return list of email items.
1023 */
1024 static GList *edit_person_build_email_list() {
1025         GtkCList *clist = GTK_CLIST(personeditdlg.clist_email);
1026         GList *listEMail = NULL;
1027         ItemEMail *email;
1028         gint row = 0;
1029         while( (email = gtk_clist_get_row_data( clist, row )) ) {
1030                 listEMail = g_list_append( listEMail, email );
1031                 row++;
1032         }
1033         return listEMail;
1034 }
1035
1036 /*
1037 * Return list of attributes.
1038 */
1039 static GList *edit_person_build_attrib_list() {
1040         GtkCList *clist = GTK_CLIST(personeditdlg.clist_attrib);
1041         GList *listAttrib = NULL;
1042         UserAttribute *attrib;
1043         gint row = 0;
1044         while( (attrib = gtk_clist_get_row_data( clist, row )) ) {
1045                 listAttrib = g_list_append( listAttrib, attrib );
1046                 row++;
1047         }
1048         return listAttrib;
1049 }
1050
1051 /*
1052 * Edit person.
1053 * Enter: abf    Address book.
1054 *        parent Parent folder for person (or NULL if adding to root folder). Argument is
1055 *               only required for new objects).
1056 *        person Person to edit, or NULL for a new person object.
1057 *        pgMail If TRUE, E-Mail page will be activated.
1058 * Return: Edited object, or NULL if cancelled.
1059 */
1060 ItemPerson *addressbook_edit_person( AddressBookFile *abf, ItemFolder *parent, ItemPerson *person, gboolean pgMail ) {
1061         static gboolean cancelled;
1062         GList *listEMail = NULL;
1063         GList *listAttrib = NULL;
1064         gchar *cn = NULL;
1065
1066         if (!personeditdlg.window)
1067                 addressbook_edit_person_create(&cancelled);
1068         gtk_widget_grab_focus(personeditdlg.ok_btn);
1069         gtk_widget_grab_focus(personeditdlg.entry_name);
1070         gtk_widget_show(personeditdlg.window);
1071         manage_window_set_transient(GTK_WINDOW(personeditdlg.window));
1072
1073         // Clear all fields
1074         personeditdlg.rowIndEMail = -1;
1075         personeditdlg.rowIndAttrib = -1;
1076         edit_person_status_show( "" );
1077         gtk_clist_clear( GTK_CLIST(personeditdlg.clist_email) );
1078         gtk_clist_clear( GTK_CLIST(personeditdlg.clist_attrib) );
1079         gtk_entry_set_text(GTK_ENTRY(personeditdlg.entry_name), "" );
1080         gtk_entry_set_text(GTK_ENTRY(personeditdlg.entry_first), "" );
1081         gtk_entry_set_text(GTK_ENTRY(personeditdlg.entry_last), "" );
1082         gtk_entry_set_text(GTK_ENTRY(personeditdlg.entry_nick), "" );
1083
1084         personeditdlg.editNew = FALSE;
1085         if( person ) {
1086                 if( ADDRITEM_NAME(person) )
1087                         gtk_entry_set_text(GTK_ENTRY(personeditdlg.entry_name), ADDRITEM_NAME(person) );
1088                 if( person->firstName )
1089                         gtk_entry_set_text(GTK_ENTRY(personeditdlg.entry_first), person->firstName );
1090                 if( person->lastName )
1091                         gtk_entry_set_text(GTK_ENTRY(personeditdlg.entry_last), person->lastName );
1092                 if( person->nickName )
1093                         gtk_entry_set_text(GTK_ENTRY(personeditdlg.entry_nick), person->nickName );
1094                 edit_person_load_email( person );
1095                 edit_person_load_attrib( person );
1096         }
1097         else {
1098                 personeditdlg.editNew = TRUE;
1099         }
1100
1101         // Select appropriate start page
1102         if( pgMail ) {
1103                 gtk_notebook_set_page( GTK_NOTEBOOK(personeditdlg.notebook), PAGE_EMAIL );
1104         }
1105         else {
1106                 gtk_notebook_set_page( GTK_NOTEBOOK(personeditdlg.notebook), PAGE_BASIC );
1107         }
1108
1109         gtk_clist_select_row( GTK_CLIST(personeditdlg.clist_email), 0, 0 );
1110         gtk_clist_select_row( GTK_CLIST(personeditdlg.clist_attrib), 0, 0 );
1111         edit_person_email_clear( NULL );
1112         edit_person_attrib_clear( NULL );
1113
1114         gtk_main();
1115         gtk_widget_hide( personeditdlg.window );
1116
1117         listEMail = edit_person_build_email_list();
1118         listAttrib = edit_person_build_attrib_list();
1119         if( cancelled ) {
1120                 addritem_free_list_email( listEMail );
1121                 gtk_clist_clear( GTK_CLIST(personeditdlg.clist_email) );
1122                 gtk_clist_clear( GTK_CLIST(personeditdlg.clist_attrib) );
1123                 return NULL;
1124         }
1125
1126         cn = g_strdup( gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_name), 0, -1 ) );
1127         if( person ) {
1128                 // Update email/attribute list
1129                 addrbook_update_address_list( abf, person, listEMail );
1130                 addrbook_update_attrib_list( abf, person, listAttrib );
1131         }
1132         else {
1133                 // Create new person and email/attribute list
1134                 if( cn == NULL || *cn == '\0' ) {
1135                         // Wasting our time
1136                         if( listEMail == NULL && listAttrib == NULL ) cancelled = TRUE;
1137                 }
1138                 if( ! cancelled ) {
1139                         person = addrbook_add_address_list( abf, parent, listEMail );
1140                         addrbook_add_attrib_list( abf, person, listAttrib );
1141                 }
1142         }
1143
1144         if( ! cancelled ) {
1145                 // Set person stuff
1146                 addritem_person_set_common_name( person, cn );
1147                 addritem_person_set_first_name( person,
1148                         gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_first), 0, -1 ) );
1149                 addritem_person_set_last_name( person,
1150                         gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_last), 0, -1 ) );
1151                 addritem_person_set_nick_name( person,
1152                         gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_nick), 0, -1 ) );
1153         }
1154         g_free( cn );
1155
1156         listEMail = NULL;
1157
1158         gtk_clist_clear( GTK_CLIST(personeditdlg.clist_email) );
1159         gtk_clist_clear( GTK_CLIST(personeditdlg.clist_attrib) );
1160
1161         return person;
1162 }
1163
1164 /*
1165 * End of Source.
1166 */
1167