src/editaddress.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2009 Hiroyuki Yamamoto and the Claws Mail team
   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 3 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, see <http://www.gnu.org/licenses/>.
  17  *
  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 <glib/gi18n.h>
  28 #include <gdk/gdkkeysyms.h>
  29 #include <gtk/gtk.h>
  30
  31 #include "alertpanel.h"
  32 #include "mgutils.h"
  33 #include "addressbook.h"
  34 #include "addressitem.h"
  35 #include "addritem.h"
  36 #include "addrbook.h"
  37 #include "manage_window.h"
  38 #include "gtkutils.h"
  39 #include "filesel.h"
  40 #include "codeconv.h"
  41 #include "editaddress.h"
  42 #include "editaddress_other_attributes_ldap.h"
  43 #include "prefs_common.h"
  44 #include "menu.h"
  45 #include "combobox.h"
  46
  47 /* transient data */
  48 static struct _PersonEdit_dlg personeditdlg;
  49 static AddressBookFile *current_abf = NULL;
  50 static ItemPerson *current_person = NULL;
  51 static ItemFolder *current_parent_folder = NULL;
  52 static EditAddressPostUpdateCallback edit_person_close_post_update_cb = NULL;
  53
  54 typedef enum {
  55         EMAIL_COL_EMAIL   = 0,
  56         EMAIL_COL_ALIAS   = 1,
  57         EMAIL_COL_REMARKS = 2
  58 } PersonEditEMailColumnPos;
  59
  60 typedef enum {
  61         ATTRIB_COL_NAME    = 0,
  62         ATTRIB_COL_VALUE   = 1
  63 } PersonEditAttribColumnPos;
  64
  65 #define EDITPERSON_WIDTH      520
  66 #define EDITPERSON_HEIGHT     320
  67
  68 #ifndef GENERIC_UMPC
  69 # define EMAIL_N_COLS          3
  70 # define EMAIL_COL_WIDTH_EMAIL 180
  71 # define EMAIL_COL_WIDTH_ALIAS 80
  72 #else
  73 # define EMAIL_N_COLS          1
  74 # define EMAIL_COL_WIDTH_EMAIL 130
  75 # define EMAIL_COL_WIDTH_ALIAS 130
  76 #endif
  77
  78 #ifndef GENERIC_UMPC
  79 # define ATTRIB_N_COLS          2
  80 # define ATTRIB_COL_WIDTH_NAME  240
  81 # define ATTRIB_COL_WIDTH_VALUE 0
  82 #else
  83 # define ATTRIB_N_COLS          2
  84 # define ATTRIB_COL_WIDTH_NAME  120
  85 # define ATTRIB_COL_WIDTH_VALUE 120
  86 #endif
  87
  88 #define PAGE_BASIC             0
  89 #define PAGE_EMAIL             1
  90 #define PAGE_ATTRIBUTES        2
  91
  92 static gboolean addressbook_edit_person_close( gboolean cancelled );
  93 static GList *edit_person_build_email_list();
  94 static GList *edit_person_build_attrib_list();
  95
  96 static gchar* edit_person_get_common_name_from_widgets(void)
  97 {
  98         gchar *cn = NULL; /* cn must be freed by caller */
  99
 100 #ifndef GENERIC_UMPC
 101         {
 102                 cn = gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_name), 0, -1 );
 103                 if ( cn == NULL || *cn == '\0' ) {
 104                         gchar *first = gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_first), 0, -1 );
 105                         gchar *last = gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_last), 0, -1 );
 106                         cn = g_strdup_printf("%s%s%s", first?first:"", (first && last && *first && *last)?" ":"", last?last:"");
 107                         g_free(first);
 108                         g_free(last);
 109                 }
 110                 if ( cn == NULL || *cn == '\0' ) {
 111                         g_free(cn);
 112                         cn = gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_nick), 0, -1 );;
 113                 }
 114         }
 115 #else
 116         {
 117                 gchar *first = gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_first), 0, -1 );
 118                 gchar *last = gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_last), 0, -1 );
 119                 cn = g_strdup_printf("%s%s%s", first?first:"", (first && last && *first && *last)?" ":"", last?last:"");
 120                 g_free(first);
 121                 g_free(last);
 122         }
 123 #endif
 124         if ( cn != NULL )
 125                 g_strstrip(cn);
 126         return cn;
 127 }
 128
 129 static void edit_person_status_show( gchar *msg ) {
 130         if( personeditdlg.statusbar != NULL ) {
 131                 gtk_statusbar_pop( GTK_STATUSBAR(personeditdlg.statusbar), personeditdlg.status_cid );
 132                 if( msg ) {
 133                         gtk_statusbar_push( GTK_STATUSBAR(personeditdlg.statusbar), personeditdlg.status_cid, msg );
 134                 }
 135         }
 136 }
 137
 138 static void edit_person_cancel(GtkWidget *widget, gboolean *cancelled) {
 139         *cancelled = TRUE;
 140         if (prefs_common.addressbook_use_editaddress_dialog)
 141                 gtk_main_quit();
 142         else
 143                 addressbook_edit_person_close( *cancelled );
 144 }
 145
 146 static void edit_person_ok(GtkWidget *widget, gboolean *cancelled) {
 147         GList *listEMail = edit_person_build_email_list();
 148         GList *listAttrib = edit_person_build_attrib_list();
 149         gchar *cn = edit_person_get_common_name_from_widgets();
 150
 151         if( (cn == NULL || *cn == '\0') && listEMail == NULL && listAttrib == NULL ) {
 152                 gint val;
 153
 154                 val = alertpanel( _("Add New Person"),
 155 #ifndef GENERIC_UMPC
 156                                 _("Adding a new person requires at least one of the\n"
 157                                   "following values to be set:\n"
 158                                   " - Display Name\n"
 159                                   " - First Name\n"
 160                                   " - Last Name\n"
 161                                   " - Nickname\n"
 162                                   " - any email address\n"
 163                                   " - any additional attribute\n\n"
 164                                   "Click OK to keep editing this contact.\n"
 165                                   "Click Cancel to close without saving."),
 166 #else
 167                                 _("Adding a new person requires at least one of the\n"
 168                                   "following values to be set:\n"
 169                                   " - First Name\n"
 170                                   " - Last Name\n"
 171                                   " - any email address\n"
 172                                   " - any additional attribute\n\n"
 173                                   "Click OK to keep editing this contact.\n"
 174                                   "Click Cancel to close without saving."),
 175 #endif
 176                                 GTK_STOCK_CANCEL, "+"GTK_STOCK_OK, NULL );
 177                 if( val == G_ALERTDEFAULT ) {
 178                         edit_person_cancel(widget, cancelled);
 179                 }
 180                 g_free( cn );
 181                 return;
 182         }
 183         g_free( cn );
 184
 185         *cancelled = FALSE;
 186         if (prefs_common.addressbook_use_editaddress_dialog)
 187                 gtk_main_quit();
 188         else
 189                 addressbook_edit_person_close( *cancelled );
 190 }
 191
 192 static gint edit_person_delete_event(GtkWidget *widget, GdkEventAny *event, gboolean *cancelled) {
 193         *cancelled = TRUE;
 194         if (prefs_common.addressbook_use_editaddress_dialog)
 195                 gtk_main_quit();
 196         else
 197                 addressbook_edit_person_close( *cancelled );
 198         return TRUE;
 199 }
 200
 201 static gboolean edit_person_key_pressed(GtkWidget *widget, GdkEventKey *event, gboolean *cancelled) {
 202         if (prefs_common.addressbook_use_editaddress_dialog) {
 203         if (event && event->keyval == GDK_Escape) {
 204                 *cancelled = TRUE;
 205                 gtk_main_quit();
 206         }
 207         }
 208         return FALSE;
 209 }
 210
 211 static gchar *_title_new_ = NULL;
 212 static gchar *_title_edit_ = NULL;
 213
 214 static void edit_person_set_widgets_title( gchar *text )
 215 {
 216         gchar *label = NULL;
 217
 218         cm_return_if_fail( text != NULL );
 219
 220         gtk_label_set_text(GTK_LABEL(personeditdlg.title), "");
 221         label = g_markup_printf_escaped("<b>%s</b>", text);
 222         gtk_label_set_markup(GTK_LABEL(personeditdlg.title), label);
 223         g_free(label);
 224 }
 225
 226 static void edit_person_set_window_title( gint pageNum ) {
 227         gchar *sTitle;
 228
 229         if( _title_new_ == NULL ) {
 230                 _title_new_ = g_strdup( _("Add New Person") );
 231                 _title_edit_ = g_strdup( _("Edit Person Details") );
 232         }
 233
 234         if( pageNum == PAGE_BASIC ) {
 235                 if( personeditdlg.editNew ) {
 236                         if (prefs_common.addressbook_use_editaddress_dialog)
 237                                 gtk_window_set_title( GTK_WINDOW(personeditdlg.container), _title_new_ );
 238                         else
 239                                 edit_person_set_widgets_title( _title_new_ );
 240                 }
 241                 else {
 242                         if (prefs_common.addressbook_use_editaddress_dialog)
 243                                 gtk_window_set_title( GTK_WINDOW(personeditdlg.container), _title_edit_ );
 244                         else
 245                                 edit_person_set_widgets_title( _title_edit_ );
 246                 }
 247         }
 248         else {
 249                 if( personeditdlg.entry_name == NULL ) {
 250                         sTitle = g_strdup( _title_edit_ );
 251                 }
 252                 else {
 253                         gchar *name;
 254                         name = gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_name), 0, -1 );
 255                         g_strstrip(name);
 256                         if ( *name != '\0' )
 257                                 sTitle = g_strdup_printf( "%s - %s", _title_edit_, name );
 258                         else
 259                                 sTitle = g_strdup( _title_edit_ );
 260                         g_free( name );
 261                 }
 262                 if (prefs_common.addressbook_use_editaddress_dialog)
 263                         gtk_window_set_title( GTK_WINDOW(personeditdlg.container), sTitle );
 264                 else
 265                         edit_person_set_widgets_title( sTitle );
 266                 g_free( sTitle );
 267         }
 268 }
 269
 270 static void edit_person_email_clear( gpointer data ) {
 271         gtk_entry_set_text( GTK_ENTRY(personeditdlg.entry_email), "" );
 272         gtk_entry_set_text( GTK_ENTRY(personeditdlg.entry_alias), "" );
 273         gtk_entry_set_text( GTK_ENTRY(personeditdlg.entry_remarks), "" );
 274 }
 275
 276 static void edit_person_attrib_clear( gpointer data ) {
 277         if (!personeditdlg.ldap) {
 278                 gtk_entry_set_text( GTK_ENTRY(gtk_bin_get_child(GTK_BIN((personeditdlg.entry_atname)))), "" );
 279                 gtk_entry_set_text( GTK_ENTRY(personeditdlg.entry_atvalue), "" );
 280         }
 281 }
 282
 283 static void edit_person_switch_page( GtkNotebook *notebook, GtkNotebookPage *page,
 284                                         gint pageNum, gpointer user_data)
 285 {
 286         edit_person_set_window_title( pageNum );
 287         edit_person_status_show( "" );
 288 }
 289
 290 /*
 291 * Load clist with a copy of person's email addresses.
 292 */
 293 static void edit_person_load_email( ItemPerson *person ) {
 294         GList *node = person->listEMail;
 295         GtkCMCList *clist = GTK_CMCLIST(personeditdlg.clist_email);
 296         gchar *text[ EMAIL_N_COLS ];
 297         while( node ) {
 298                 ItemEMail *emorig = ( ItemEMail * ) node->data;
 299                 ItemEMail *email = addritem_copyfull_item_email( emorig );
 300                 gint row;
 301                 text[ EMAIL_COL_EMAIL   ] = email->address;
 302 #ifndef GENERIC_UMPC
 303                 text[ EMAIL_COL_ALIAS   ] = email->obj.name;
 304                 text[ EMAIL_COL_REMARKS ] = email->remarks;
 305 #endif
 306                 row = gtk_cmclist_append( clist, text );
 307                 gtk_cmclist_set_row_data( clist, row, email );
 308                 node = g_list_next( node );
 309         }
 310 }
 311
 312 static void edit_person_email_list_selected( GtkCMCList *clist, gint row, gint column, GdkEvent *event, gpointer data ) {
 313         ItemEMail *email = gtk_cmclist_get_row_data( clist, row );
 314         if( email ) {
 315                 if( email->address )
 316                         gtk_entry_set_text( GTK_ENTRY(personeditdlg.entry_email), email->address );
 317                 if( ADDRITEM_NAME(email) )
 318                         gtk_entry_set_text( GTK_ENTRY(personeditdlg.entry_alias), ADDRITEM_NAME(email) );
 319                 if( email->remarks )
 320                         gtk_entry_set_text( GTK_ENTRY(personeditdlg.entry_remarks), email->remarks );
 321                 if (!personeditdlg.read_only) {
 322                         gtk_widget_set_sensitive(personeditdlg.email_del, TRUE);
 323                         gtk_widget_set_sensitive(personeditdlg.email_up, row > 0);
 324                         gtk_widget_set_sensitive(personeditdlg.email_down, gtk_cmclist_get_row_data(clist, row + 1) != NULL);
 325                 }
 326         } else {
 327                 gtk_widget_set_sensitive(personeditdlg.email_del, FALSE);
 328                 gtk_widget_set_sensitive(personeditdlg.email_up, FALSE);
 329                 gtk_widget_set_sensitive(personeditdlg.email_down, FALSE);
 330         }
 331         personeditdlg.rowIndEMail = row;
 332         edit_person_status_show( NULL );
 333 }
 334
 335 static void edit_person_email_move( gint dir ) {
 336         GtkCMCList *clist = GTK_CMCLIST(personeditdlg.clist_email);
 337         gint row = personeditdlg.rowIndEMail + dir;
 338         ItemEMail *email = gtk_cmclist_get_row_data( clist, row );
 339         if( email ) {
 340                 gtk_cmclist_row_move( clist, personeditdlg.rowIndEMail, row );
 341                 personeditdlg.rowIndEMail = row;
 342                 if (!personeditdlg.read_only) {
 343                         gtk_widget_set_sensitive(personeditdlg.email_up, row > 0);
 344                         gtk_widget_set_sensitive(personeditdlg.email_down, gtk_cmclist_get_row_data(clist, row + 1) != NULL);
 345                 }
 346         } else {
 347                 gtk_widget_set_sensitive(personeditdlg.email_up, FALSE);
 348                 gtk_widget_set_sensitive(personeditdlg.email_down, FALSE);
 349         }
 350         edit_person_email_clear( NULL );
 351         edit_person_status_show( NULL );
 352 }
 353
 354 static void edit_person_email_move_up( gpointer data ) {
 355         edit_person_email_move( -1 );
 356 }
 357
 358 static void edit_person_email_move_down( gpointer data ) {
 359         edit_person_email_move( +1 );
 360 }
 361
 362 static void edit_person_email_delete( gpointer data ) {
 363         GtkCMCList *clist = GTK_CMCLIST(personeditdlg.clist_email);
 364         gint row = personeditdlg.rowIndEMail;
 365         ItemEMail *email = gtk_cmclist_get_row_data( clist, row );
 366         edit_person_email_clear( NULL );
 367         if( email ) {
 368                 /* Remove list entry */
 369                 gtk_cmclist_remove( clist, row );
 370                 addritem_free_item_email( email );
 371                 email = NULL;
 372         }
 373
 374         /* Position hilite bar */
 375         email = gtk_cmclist_get_row_data( clist, row );
 376         if( ! email ) {
 377                 personeditdlg.rowIndEMail = -1 + row;
 378         }
 379         if (!personeditdlg.read_only) {
 380                 gtk_widget_set_sensitive(personeditdlg.email_del, gtk_cmclist_get_row_data(clist, 0) != NULL);
 381                 gtk_widget_set_sensitive(personeditdlg.email_up, gtk_cmclist_get_row_data(clist, personeditdlg.rowIndEMail + 1) != NULL);
 382                 gtk_widget_set_sensitive(personeditdlg.email_down, gtk_cmclist_get_row_data(clist, personeditdlg.rowIndEMail - 1) != NULL);
 383         }
 384         edit_person_status_show( NULL );
 385 }
 386
 387 static ItemEMail *edit_person_email_edit( gboolean *error, ItemEMail *email ) {
 388         ItemEMail *retVal = NULL;
 389         gchar *sEmail, *sAlias, *sRemarks, *sEmail_;
 390
 391         *error = TRUE;
 392         sEmail_ = gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_email), 0, -1 );
 393         sAlias = gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_alias), 0, -1 );
 394         sRemarks = gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_remarks), 0, -1 );
 395         sEmail = mgu_email_check_empty( sEmail_ );
 396         g_free( sEmail_ );
 397
 398         if( sEmail ) {
 399                 if( email == NULL ) {
 400                         email = addritem_create_item_email();
 401                 }
 402                 addritem_email_set_address( email, sEmail );
 403                 addritem_email_set_alias( email, sAlias );
 404                 addritem_email_set_remarks( email, sRemarks );
 405                 retVal = email;
 406                 *error = FALSE;
 407         }
 408         else {
 409                 edit_person_status_show( _( "An Email address must be supplied." ) );
 410         }
 411
 412         g_free( sEmail );
 413         g_free( sAlias );
 414         g_free( sRemarks );
 415
 416         return retVal;
 417 }
 418
 419 static void edit_person_email_modify( gpointer data ) {
 420         gboolean errFlg = FALSE;
 421         GtkCMCList *clist = GTK_CMCLIST(personeditdlg.clist_email);
 422         gint row = personeditdlg.rowIndEMail;
 423         ItemEMail *email = gtk_cmclist_get_row_data( clist, row );
 424         if( email ) {
 425                 edit_person_email_edit( &errFlg, email );
 426                 if( ! errFlg ) {
 427                         gtk_cmclist_set_text( clist, row, EMAIL_COL_EMAIL, email->address );
 428                         gtk_cmclist_set_text( clist, row, EMAIL_COL_ALIAS, email->obj.name );
 429                         gtk_cmclist_set_text( clist, row, EMAIL_COL_REMARKS, email->remarks );
 430                         edit_person_email_clear( NULL );
 431                 }
 432         }
 433 }
 434
 435 static void edit_person_email_add( gpointer data ) {
 436         GtkCMCList *clist = GTK_CMCLIST(personeditdlg.clist_email);
 437         gboolean errFlg = FALSE;
 438         ItemEMail *email = NULL;
 439         gint row = personeditdlg.rowIndEMail;
 440         if( gtk_cmclist_get_row_data( clist, row ) == NULL ) row = 0;
 441
 442         email = edit_person_email_edit( &errFlg, NULL );
 443         if( ! errFlg ) {
 444                 gchar *text[ EMAIL_N_COLS ];
 445                 text[ EMAIL_COL_EMAIL   ] = email->address;
 446 #ifndef GENERIC_UMPC
 447                 text[ EMAIL_COL_ALIAS   ] = email->obj.name;
 448                 text[ EMAIL_COL_REMARKS ] = email->remarks;
 449 #endif
 450                 row = gtk_cmclist_insert( clist, 1 + row, text );
 451                 gtk_cmclist_set_row_data( clist, row, email );
 452                 gtk_cmclist_select_row( clist, row, 0 );
 453                 edit_person_email_clear( NULL );
 454         }
 455 }
 456
 457 /*
 458 * Comparison using cell contents (text in first column). Used for sort
 459 * address index widget.
 460 */
 461 static gint edit_person_attrib_compare_func(
 462         GtkCMCList *clist, gconstpointer ptr1, gconstpointer ptr2 )
 463 {
 464         GtkCMCell *cell1 = ((GtkCMCListRow *)ptr1)->cell;
 465         GtkCMCell *cell2 = ((GtkCMCListRow *)ptr2)->cell;
 466         gchar *name1 = NULL, *name2 = NULL;
 467
 468         if( cell1 ) name1 = cell1->u.text;
 469         if( cell2 ) name2 = cell2->u.text;
 470         if( ! name1 ) return ( name2 != NULL );
 471         if( ! name2 ) return -1;
 472         return g_utf8_collate( name1, name2 );
 473 }
 474
 475 static gboolean list_find_attribute(const gchar *attr)
 476 {
 477         GtkCMCList *clist = GTK_CMCLIST(personeditdlg.clist_attrib);
 478         UserAttribute *attrib;
 479         gint row = 0;
 480         while( (attrib = gtk_cmclist_get_row_data( clist, row )) ) {
 481                 if (!g_ascii_strcasecmp(attrib->name, attr)) {
 482                         gtk_cmclist_select_row(clist, row, 0);
 483                         return TRUE;
 484                 }
 485                 row++;
 486         }
 487         return FALSE;
 488 }
 489
 490 static gboolean list_find_email(const gchar *addr)
 491 {
 492         GtkCMCList *clist = GTK_CMCLIST(personeditdlg.clist_email);
 493         ItemEMail *email;
 494         gint row = 0;
 495         while( (email = gtk_cmclist_get_row_data( clist, row )) ) {
 496                 if (!g_ascii_strcasecmp(email->address, addr)) {
 497                         gtk_cmclist_select_row(clist, row, 0);
 498                         return TRUE;
 499                 }
 500                 row++;
 501         }
 502         return FALSE;
 503 }
 504
 505 /*
 506 * Load clist with a copy of person's email addresses.
 507 */
 508 static void edit_person_load_attrib( ItemPerson *person ) {
 509         GList *node = person->listAttrib;
 510         GtkCMCList *clist = GTK_CMCLIST(personeditdlg.clist_attrib);
 511         gchar *text[ ATTRIB_N_COLS ];
 512         while( node ) {
 513                 UserAttribute *atorig = ( UserAttribute * ) node->data;
 514                 UserAttribute *attrib = addritem_copy_attribute( atorig );
 515                 gint row;
 516                 debug_print("name: %s value: %s\n", attrib->name, attrib->value);
 517                 text[ ATTRIB_COL_NAME  ] = attrib->name;
 518                 text[ ATTRIB_COL_VALUE ] = attrib->value;
 519
 520                 row = gtk_cmclist_append( clist, text );
 521                 gtk_cmclist_set_row_data( clist, row, attrib );
 522                 node = g_list_next( node );
 523         }
 524 }
 525
 526 static void edit_person_attrib_list_selected( GtkCMCList *clist, gint row, gint column, GdkEvent *event, gpointer data ) {
 527         UserAttribute *attrib = gtk_cmclist_get_row_data( clist, row );
 528         if( attrib && !personeditdlg.read_only && !personeditdlg.ldap ) {
 529                 gtk_entry_set_text( GTK_ENTRY(gtk_bin_get_child(GTK_BIN((personeditdlg.entry_atname))) ), attrib->name );
 530                 gtk_entry_set_text( GTK_ENTRY(personeditdlg.entry_atvalue), attrib->value );
 531                 gtk_widget_set_sensitive(personeditdlg.attrib_del, TRUE);
 532         } else {
 533                 gtk_widget_set_sensitive(personeditdlg.attrib_del, FALSE);
 534         }
 535         personeditdlg.rowIndAttrib = row;
 536         edit_person_status_show( NULL );
 537 }
 538
 539 static void edit_person_attrib_delete( gpointer data ) {
 540         GtkCMCList *clist = GTK_CMCLIST(personeditdlg.clist_attrib);
 541         gint row = personeditdlg.rowIndAttrib;
 542         UserAttribute *attrib = gtk_cmclist_get_row_data( clist, row );
 543         edit_person_attrib_clear( NULL );
 544         if( attrib ) {
 545                 /* Remove list entry */
 546                 gtk_cmclist_remove( clist, row );
 547                 addritem_free_attribute( attrib );
 548                 attrib = NULL;
 549         }
 550
 551         /* Position hilite bar */
 552         attrib = gtk_cmclist_get_row_data( clist, row );
 553         if( ! attrib ) {
 554                 personeditdlg.rowIndAttrib = -1 + row;
 555         }
 556
 557         if (!personeditdlg.read_only && !personeditdlg.ldap)
 558                 gtk_widget_set_sensitive(personeditdlg.attrib_del, gtk_cmclist_get_row_data(clist, 0) != NULL);
 559
 560         edit_person_status_show( NULL );
 561 }
 562
 563 static UserAttribute *edit_person_attrib_edit( gboolean *error, UserAttribute *attrib ) {
 564         UserAttribute *retVal = NULL;
 565         gchar *sName, *sValue, *sName_, *sValue_;
 566
 567         *error = TRUE;
 568         sName_ = gtk_editable_get_chars( GTK_EDITABLE(gtk_bin_get_child(GTK_BIN((personeditdlg.entry_atname)))), 0, -1 );
 569         sValue_ = gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_atvalue), 0, -1 );
 570         sName = mgu_email_check_empty( sName_ );
 571         sValue = mgu_email_check_empty( sValue_ );
 572         g_free( sName_ );
 573         g_free( sValue_ );
 574
 575         if( sName && sValue ) {
 576                 if( attrib == NULL ) {
 577                         attrib = addritem_create_attribute();
 578                 }
 579                 addritem_attrib_set_name( attrib, sName );
 580                 addritem_attrib_set_value( attrib, sValue );
 581                 retVal = attrib;
 582                 *error = FALSE;
 583         }
 584         else {
 585                 edit_person_status_show( _( "A Name and Value must be supplied." ) );
 586         }
 587
 588         g_free( sName );
 589         g_free( sValue );
 590
 591         return retVal;
 592 }
 593
 594 static void edit_person_attrib_modify( gpointer data ) {
 595         gboolean errFlg = FALSE;
 596         GtkCMCList *clist = GTK_CMCLIST(personeditdlg.clist_attrib);
 597         gint row = personeditdlg.rowIndAttrib;
 598         UserAttribute *attrib = gtk_cmclist_get_row_data( clist, row );
 599         if( attrib ) {
 600                 edit_person_attrib_edit( &errFlg, attrib );
 601                 if( ! errFlg ) {
 602                         gtk_cmclist_set_text( clist, row, ATTRIB_COL_NAME, attrib->name );
 603                         gtk_cmclist_set_text( clist, row, ATTRIB_COL_VALUE, attrib->value );
 604                         edit_person_attrib_clear( NULL );
 605                 }
 606         }
 607 }
 608
 609 static void edit_person_attrib_add( gpointer data ) {
 610         GtkCMCList *clist = GTK_CMCLIST(personeditdlg.clist_attrib);
 611         gboolean errFlg = FALSE;
 612         UserAttribute *attrib = NULL;
 613         gint row = personeditdlg.rowIndAttrib;
 614         if( gtk_cmclist_get_row_data( clist, row ) == NULL ) row = 0;
 615
 616         attrib = edit_person_attrib_edit( &errFlg, NULL );
 617         if( ! errFlg ) {
 618                 gchar *text[ ATTRIB_N_COLS ];
 619                 text[ ATTRIB_COL_NAME  ] = attrib->name;
 620                 text[ ATTRIB_COL_VALUE ] = attrib->value;
 621
 622                 row = gtk_cmclist_insert( clist, 1 + row, text );
 623                 gtk_cmclist_set_row_data( clist, row, attrib );
 624                 gtk_cmclist_select_row( clist, row, 0 );
 625                 edit_person_attrib_clear( NULL );
 626         }
 627 }
 628
 629 /*!
 630  *\brief        Save Gtk object size to prefs dataset
 631  */
 632 static void edit_person_size_allocate_cb(GtkWidget *widget,
 633                                          GtkAllocation *allocation)
 634 {
 635         cm_return_if_fail(allocation != NULL);
 636
 637         prefs_common.addressbookeditpersonwin_width = allocation->width;
 638         prefs_common.addressbookeditpersonwin_height = allocation->height;
 639 }
 640
 641 /* build edit person widgets, return a pointer to the main container of the widgetset (a vbox) */
 642 static GtkWidget* addressbook_edit_person_widgets_create( GtkWidget* container, gboolean *cancelled )
 643 {
 644         GtkWidget *vbox;
 645         GtkWidget *vnbox;
 646         GtkWidget *notebook;
 647         GtkWidget *hbbox;
 648         GtkWidget *ok_btn;
 649         GtkWidget *cancel_btn;
 650
 651         vbox = gtk_vbox_new(FALSE, 4);
 652          gtk_container_set_border_width(GTK_CONTAINER(vbox), BORDER_WIDTH);
 653         gtk_widget_show(vbox);
 654         gtk_container_add(GTK_CONTAINER(container), vbox);
 655
 656         vnbox = gtk_vbox_new(FALSE, 4);
 657         gtk_container_set_border_width(GTK_CONTAINER(vnbox), 4);
 658         gtk_widget_show(vnbox);
 659         gtk_box_pack_start(GTK_BOX(vbox), vnbox, TRUE, TRUE, 0);
 660
 661         /* Notebook */
 662         notebook = gtk_notebook_new();
 663         gtk_widget_show(notebook);
 664         gtk_box_pack_start(GTK_BOX(vnbox), notebook, TRUE, TRUE, 0);
 665         gtk_container_set_border_width(GTK_CONTAINER(notebook), 6);
 666
 667         /* Button panel */
 668         if (prefs_common.addressbook_use_editaddress_dialog)
 669         gtkut_stock_button_set_create(&hbbox, &cancel_btn, GTK_STOCK_CANCEL,
 670                                       &ok_btn, GTK_STOCK_OK,
 671                                       NULL, NULL);
 672         else
 673                 gtkut_stock_with_text_button_set_create(&hbbox,
 674                                           &cancel_btn, GTK_STOCK_CANCEL, _("Discard"),
 675                                       &ok_btn, GTK_STOCK_OK, _("Apply"),
 676                                       NULL, NULL, NULL);
 677         gtk_box_pack_end(GTK_BOX(vnbox), hbbox, FALSE, FALSE, 0);
 678         gtk_widget_grab_default(ok_btn);
 679
 680         g_signal_connect(G_OBJECT(ok_btn), "clicked",
 681                          G_CALLBACK(edit_person_ok), cancelled);
 682         g_signal_connect(G_OBJECT(cancel_btn), "clicked",
 683                          G_CALLBACK(edit_person_cancel), cancelled);
 684         g_signal_connect(G_OBJECT(notebook), "switch_page",
 685                          G_CALLBACK(edit_person_switch_page), NULL );
 686
 687         gtk_widget_show_all(vbox);
 688
 689         personeditdlg.notebook   = notebook;
 690         personeditdlg.ok_btn     = ok_btn;
 691         personeditdlg.cancel_btn = cancel_btn;
 692
 693         return vbox;
 694 }
 695
 696 static void addressbook_edit_person_dialog_create( gboolean *cancelled ) {
 697         GtkWidget *window;
 698         GtkWidget *hsbox;
 699         GtkWidget *vbox;
 700         GtkWidget *statusbar;
 701         static GdkGeometry geometry;
 702
 703         window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "editaddress");
 704         /* gtk_container_set_border_width(GTK_CONTAINER(window), 0); */
 705         gtk_window_set_title(GTK_WINDOW(window), _("Edit Person Data"));
 706         gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
 707         gtk_window_set_modal(GTK_WINDOW(window), TRUE);
 708         g_signal_connect(G_OBJECT(window), "delete_event",
 709                          G_CALLBACK(edit_person_delete_event),
 710                          cancelled);
 711         g_signal_connect(G_OBJECT(window), "size_allocate",
 712                          G_CALLBACK(edit_person_size_allocate_cb),
 713                         cancelled);
 714         g_signal_connect(G_OBJECT(window), "key_press_event",
 715                          G_CALLBACK(edit_person_key_pressed),
 716                          cancelled);
 717
 718         vbox = addressbook_edit_person_widgets_create(window, cancelled);
 719
 720         /* Status line */
 721         hsbox = gtk_hbox_new(FALSE, 0);
 722         gtk_box_pack_end(GTK_BOX(vbox), hsbox, FALSE, FALSE, BORDER_WIDTH);
 723         statusbar = gtk_statusbar_new();
 724         gtk_box_pack_start(GTK_BOX(hsbox), statusbar, TRUE, TRUE, BORDER_WIDTH);
 725
 726         if (!geometry.min_height) {
 727                 geometry.min_width = EDITPERSON_WIDTH;
 728                 geometry.min_height = EDITPERSON_HEIGHT;
 729         }
 730
 731         gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL, &geometry,
 732                                       GDK_HINT_MIN_SIZE);
 733         gtk_widget_set_size_request(window, prefs_common.addressbookeditpersonwin_width,
 734                                     prefs_common.addressbookeditpersonwin_height);
 735
 736         personeditdlg.container  = window;
 737         personeditdlg.statusbar  = statusbar;
 738         personeditdlg.status_cid = gtk_statusbar_get_context_id( GTK_STATUSBAR(statusbar), "Edit Person Dialog" );
 739
 740 }
 741
 742 /* parent must be a box */
 743 static void addressbook_edit_person_widgetset_create( GtkWidget *parent, gboolean *cancelled )
 744 {
 745         GtkWidget *vbox;
 746         GtkWidget *label;
 747
 748         if ( parent == NULL )
 749                 g_warning("addressbook_edit_person_widgetset_create: parent is NULL");
 750
 751         vbox = gtk_vbox_new(FALSE, 0);
 752         gtk_box_pack_end(GTK_BOX(parent), vbox, TRUE, TRUE, 0);
 753
 754         label = gtk_label_new(_("Edit Person Data"));
 755         gtk_label_set_justify( GTK_LABEL(label), GTK_JUSTIFY_CENTER);
 756         gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
 757
 758         addressbook_edit_person_widgets_create(vbox, cancelled);
 759
 760         gtk_widget_set_size_request(vbox, EDITPERSON_WIDTH, EDITPERSON_HEIGHT);
 761
 762         personeditdlg.container = vbox;
 763         personeditdlg.title = label;
 764         personeditdlg.statusbar  = NULL;
 765         personeditdlg.status_cid = 0;
 766 }
 767
 768 void addressbook_edit_person_widgetset_hide( void )
 769 {
 770         if ( personeditdlg.container )
 771                 gtk_widget_hide( personeditdlg.container );
 772 }
 773
 774 static void addressbook_edit_person_set_picture(void)
 775 {
 776         GError *error = NULL;
 777         gchar *filename;
 778         int width, height, scalewidth, scaleheight;
 779
 780         if (personeditdlg.ldap)
 781                 return;
 782
 783         if ( (filename = filesel_select_file_open(_("Choose a picture"), NULL)) ) {
 784                 GdkPixbuf *pixbuf = NULL;
 785                 gdk_pixbuf_get_file_info(filename, &width, &height);
 786
 787                 if ( width > 128 || height > 128 ) {
 788                         if (width > height) {
 789                                 scaleheight = (height * 128) / width;
 790                                 scalewidth = 128;
 791                         }
 792                         else {
 793                                 scalewidth = (width * 128) / height;
 794                                 scaleheight = 128;
 795                         }
 796                         pixbuf = gdk_pixbuf_new_from_file_at_scale(filename,
 797                                         scalewidth, scaleheight, TRUE, &error);
 798                 } else {
 799                         pixbuf = gdk_pixbuf_new_from_file(filename, &error);
 800                 }
 801                 if (error) {
 802                         alertpanel_error(_("Failed to import image: \n%s"),
 803                                         error->message);
 804                         g_error_free(error);
 805                         error = NULL;
 806                         /* keep the previous picture if any */
 807                         g_free(filename);
 808                         if (pixbuf)
 809                                 g_object_unref(pixbuf);
 810                         return;
 811                 }
 812                 personeditdlg.picture_set = TRUE;
 813                 cm_menu_set_sensitive("EditAddressPopup/UnsetPicture", personeditdlg.picture_set);
 814                 g_free(filename);
 815                 gtk_image_set_from_pixbuf(GTK_IMAGE(personeditdlg.image), pixbuf);
 816                 g_object_unref(pixbuf);
 817         }
 818 }
 819
 820 static void addressbook_edit_person_clear_picture(void)
 821 {
 822         GdkPixbuf *pixbuf;
 823
 824         stock_pixbuf_gdk(NULL, STOCK_PIXMAP_ANONYMOUS, &pixbuf);
 825         personeditdlg.picture_set = FALSE;
 826         cm_menu_set_sensitive("EditAddressPopup/UnsetPicture", personeditdlg.picture_set);
 827         gtk_image_set_from_pixbuf(GTK_IMAGE(personeditdlg.image), pixbuf);
 828 }
 829
 830 static void addressbook_edit_person_set_picture_menu_cb (GtkAction *action, gpointer data)
 831 {
 832         addressbook_edit_person_set_picture();
 833 }
 834
 835 static void addressbook_edit_person_unset_picture_menu_cb (GtkAction *action, gpointer data)
 836 {
 837         addressbook_edit_person_clear_picture();
 838 }
 839
 840 static GtkWidget *editaddr_popup_menu = NULL;
 841 static GtkActionEntry editaddr_popup_entries[] =
 842 {
 843         {"EditAddressPopup",                    NULL, "EditAddressPopup" },
 844         {"EditAddressPopup/SetPicture",         NULL, N_("_Set picture"), NULL, NULL, G_CALLBACK(addressbook_edit_person_set_picture_menu_cb) },
 845         {"EditAddressPopup/UnsetPicture",       NULL, N_("_Unset picture"), NULL, NULL, G_CALLBACK(addressbook_edit_person_unset_picture_menu_cb) },
 846 };
 847
 848 static void addressbook_edit_person_set_picture_cb(GtkWidget *widget,
 849                 GdkEventButton *event, gpointer data)
 850 {
 851         if (event->button == 1) {
 852                 addressbook_edit_person_set_picture();
 853         } else {
 854                 gtk_menu_popup(GTK_MENU(editaddr_popup_menu),
 855                                NULL, NULL, NULL, NULL,
 856                                event->button, event->time);
 857         }
 858 }
 859
 860 static gboolean addressbook_edit_person_picture_popup_menu(GtkWidget *widget, gpointer data)
 861 {
 862         GdkEventButton event;
 863
 864         event.button = 3;
 865         event.time = gtk_get_current_event_time();
 866
 867         addressbook_edit_person_set_picture_cb(NULL, &event, data);
 868
 869         return TRUE;
 870 }
 871
 872 static void addressbook_edit_person_page_basic( gint pageNum, gchar *pageLbl ) {
 873         GtkWidget *vbox;
 874         GtkWidget *hbox;
 875         GtkWidget *table;
 876         GtkWidget *label;
 877         GtkWidget *ebox_picture;
 878         GtkWidget *frame_picture;
 879         GtkWidget *entry_name;
 880         GtkWidget *entry_fn;
 881         GtkWidget *entry_ln;
 882         GtkWidget *entry_nn;
 883         const gchar *locale;
 884         gint top = 0;
 885         GtkActionGroup *action_group;
 886
 887         vbox = gtk_vbox_new( FALSE, 20 );
 888         hbox = gtk_hbox_new( FALSE, 8 );
 889
 890         gtk_widget_show( vbox );
 891
 892         if (!editaddr_popup_menu) {
 893                 action_group = cm_menu_create_action_group("EditAddressPopup", editaddr_popup_entries,
 894                         G_N_ELEMENTS(editaddr_popup_entries), (gpointer)NULL);
 895                 MENUITEM_ADDUI("/Menus", "EditAddressPopup", "EditAddressPopup", GTK_UI_MANAGER_MENU)
 896                 MENUITEM_ADDUI("/Menus/EditAddressPopup", "SetPicture", "EditAddressPopup/SetPicture", GTK_UI_MANAGER_MENUITEM)
 897                 MENUITEM_ADDUI("/Menus/EditAddressPopup", "UnsetPicture", "EditAddressPopup/UnsetPicture", GTK_UI_MANAGER_MENUITEM)
 898
 899                 editaddr_popup_menu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(
 900                         gtk_ui_manager_get_widget(gtkut_ui_manager(), "/Menus/EditAddressPopup")) );
 901         }
 902         /* User's picture */
 903         ebox_picture = gtk_event_box_new();
 904         frame_picture = gtk_frame_new(_("Photo"));
 905
 906         /* Room for a photo */
 907         personeditdlg.image = gtk_image_new();
 908         addressbook_edit_person_clear_picture();
 909
 910         gtk_container_add(GTK_CONTAINER(ebox_picture), personeditdlg.image);
 911         gtk_container_add(GTK_CONTAINER(frame_picture), ebox_picture);
 912         gtk_container_add(GTK_CONTAINER( personeditdlg.notebook ), hbox );
 913         gtk_container_set_border_width( GTK_CONTAINER (vbox), BORDER_WIDTH );
 914         gtk_container_set_border_width( GTK_CONTAINER (hbox), BORDER_WIDTH );
 915
 916         label = gtk_label_new_with_mnemonic( pageLbl );
 917         gtk_widget_show( label );
 918
 919         gtk_box_pack_start(GTK_BOX(hbox), frame_picture, TRUE, TRUE, 0);
 920
 921         gtk_notebook_set_tab_label(
 922                 GTK_NOTEBOOK( personeditdlg.notebook ),
 923                 gtk_notebook_get_nth_page( GTK_NOTEBOOK( personeditdlg.notebook ), pageNum ), label );
 924
 925 #ifndef MAEMO
 926         g_signal_connect(G_OBJECT(ebox_picture), "popup-menu",
 927                          G_CALLBACK(addressbook_edit_person_picture_popup_menu), NULL);
 928 #else
 929         gtk_widget_tap_and_hold_setup(GTK_WIDGET(ebox_picture), NULL, NULL,
 930                         GTK_TAP_AND_HOLD_NONE | GTK_TAP_AND_HOLD_NO_INTERNALS);
 931         g_signal_connect(G_OBJECT(ebox_picture), "tap-and-hold",
 932                          G_CALLBACK(addressbook_edit_person_picture_popup_menu), NULL);
 933 #endif
 934         g_signal_connect(G_OBJECT(ebox_picture), "button_press_event",
 935                         G_CALLBACK(addressbook_edit_person_set_picture_cb), NULL);
 936
 937         table = gtk_table_new( 3, 3, FALSE);
 938
 939 #define ATTACH_ROW(text, entry) \
 940 { \
 941         label = gtk_label_new(text); \
 942         gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), \
 943                          GTK_FILL, 0, 0, 0); \
 944         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); \
 945  \
 946         entry = gtk_entry_new(); \
 947         gtk_table_attach(GTK_TABLE(table), entry, 1, 2, top, (top + 1), \
 948                          GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0); \
 949         top++; \
 950 }
 951
 952 #define ATTACH_HIDDEN_ROW(text, entry) \
 953 { \
 954         entry = gtk_entry_new(); \
 955 }
 956
 957 #ifndef GENERIC_UMPC
 958         ATTACH_ROW(_("Display Name"), entry_name);
 959 #else
 960         ATTACH_HIDDEN_ROW(_("Display Name"), entry_name);
 961 #endif
 962         locale = conv_get_current_locale();
 963         if (locale &&
 964             (!g_ascii_strncasecmp(locale, "ja", 2) ||
 965              !g_ascii_strncasecmp(locale, "ko", 2) ||
 966              !g_ascii_strncasecmp(locale, "zh", 2))) {
 967                 ATTACH_ROW(_("Last Name"), entry_ln);
 968                 ATTACH_ROW(_("First Name"), entry_fn);
 969         } else {
 970                 ATTACH_ROW(_("First Name"), entry_fn);
 971                 ATTACH_ROW(_("Last Name"), entry_ln);
 972         }
 973 #ifndef GENERIC_UMPC
 974         ATTACH_ROW(_("Nickname"), entry_nn);
 975 #else
 976         ATTACH_HIDDEN_ROW(_("Nickname"), entry_nn);
 977 #endif
 978
 979 #undef ATTACH_ROW
 980 #undef ATTACH_HIDDEN_ROW
 981         gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 0);
 982         gtk_box_pack_end(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
 983         gtk_container_set_border_width( GTK_CONTAINER(table), 8 );
 984         gtk_table_set_row_spacings(GTK_TABLE(table), 15);
 985         gtk_table_set_col_spacings(GTK_TABLE(table), 8);
 986
 987         gtk_widget_show_all(vbox);
 988         personeditdlg.entry_name  = entry_name;
 989         personeditdlg.entry_first = entry_fn;
 990         personeditdlg.entry_last  = entry_ln;
 991         personeditdlg.entry_nick  = entry_nn;
 992 }
 993
 994 static gboolean email_adding = FALSE, email_saving = FALSE;
 995
 996 static void edit_person_entry_email_changed (GtkWidget *entry, gpointer data)
 997 {
 998         gboolean non_empty = gtk_cmclist_get_row_data(GTK_CMCLIST(personeditdlg.clist_email), 0) != NULL;
 999
1000         if (personeditdlg.read_only)
1001                 return;
1002
1003         if (gtk_entry_get_text(GTK_ENTRY(personeditdlg.entry_email)) == NULL
1004         ||  strlen(gtk_entry_get_text(GTK_ENTRY(personeditdlg.entry_email))) == 0) {
1005                 gtk_widget_set_sensitive(personeditdlg.email_add,FALSE);
1006                 gtk_widget_set_sensitive(personeditdlg.email_mod,FALSE);
1007                 email_adding = FALSE;
1008                 email_saving = FALSE;
1009         } else if (list_find_email(gtk_entry_get_text(GTK_ENTRY(personeditdlg.entry_email)))) {
1010                 gtk_widget_set_sensitive(personeditdlg.email_add,FALSE);
1011                 gtk_widget_set_sensitive(personeditdlg.email_mod,non_empty);
1012                 email_adding = FALSE;
1013                 email_saving = non_empty;
1014         } else {
1015                 gtk_widget_set_sensitive(personeditdlg.email_add,TRUE);
1016                 gtk_widget_set_sensitive(personeditdlg.email_mod,non_empty);
1017                 email_adding = TRUE;
1018                 email_saving = non_empty;
1019         }
1020 }
1021
1022 static gboolean edit_person_entry_email_pressed(GtkWidget *widget, GdkEventKey *event, gpointer data)
1023 {
1024         if (event && event->keyval == GDK_Return) {
1025                 if (email_saving)
1026                         edit_person_email_modify(NULL);
1027                 else if (email_adding)
1028                         edit_person_email_add(NULL);
1029         }
1030         return FALSE;
1031 }
1032
1033
1034 static void addressbook_edit_person_page_email( gint pageNum, gchar *pageLbl ) {
1035         GtkWidget *vbox;
1036         GtkWidget *hbox;
1037         GtkWidget *vboxl;
1038         GtkWidget *vboxb;
1039         GtkWidget *vbuttonbox;
1040         GtkWidget *buttonUp;
1041         GtkWidget *buttonDown;
1042         GtkWidget *buttonDel;
1043         GtkWidget *buttonMod;
1044         GtkWidget *buttonAdd;
1045
1046         GtkWidget *table;
1047         GtkWidget *label;
1048         GtkWidget *clist_swin;
1049         GtkWidget *clist;
1050         GtkWidget *entry_email;
1051         GtkWidget *entry_alias;
1052         GtkWidget *entry_remarks;
1053         gint top;
1054
1055         gchar *titles[ EMAIL_N_COLS ];
1056         gint i;
1057
1058         titles[ EMAIL_COL_EMAIL   ] = _("Email Address");
1059 #ifndef GENERIC_UMPC
1060         titles[ EMAIL_COL_ALIAS   ] = _("Alias");
1061         titles[ EMAIL_COL_REMARKS ] = _("Remarks");
1062 #endif
1063         vbox = gtk_vbox_new( FALSE, 8 );
1064         gtk_widget_show( vbox );
1065         gtk_container_add( GTK_CONTAINER( personeditdlg.notebook ), vbox );
1066         gtk_container_set_border_width( GTK_CONTAINER (vbox), BORDER_WIDTH );
1067
1068         label = gtk_label_new_with_mnemonic( pageLbl );
1069         gtk_widget_show( label );
1070         gtk_notebook_set_tab_label(
1071                 GTK_NOTEBOOK( personeditdlg.notebook ),
1072                 gtk_notebook_get_nth_page( GTK_NOTEBOOK( personeditdlg.notebook ), pageNum ), label );
1073
1074         /* Split into two areas */
1075         hbox = gtk_hbox_new( FALSE, 0 );
1076         gtk_container_add( GTK_CONTAINER( vbox ), hbox );
1077
1078         /* Address list */
1079         vboxl = gtk_vbox_new( FALSE, 4 );
1080         gtk_container_add( GTK_CONTAINER( hbox ), vboxl );
1081         gtk_container_set_border_width( GTK_CONTAINER(vboxl), 4 );
1082
1083         clist_swin = gtk_scrolled_window_new( NULL, NULL );
1084         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(clist_swin),
1085                                        GTK_POLICY_AUTOMATIC,
1086                                        GTK_POLICY_AUTOMATIC);
1087
1088         clist = gtk_cmclist_new_with_titles( EMAIL_N_COLS, titles );
1089
1090         gtk_container_add( GTK_CONTAINER(clist_swin), clist );
1091         gtk_cmclist_set_selection_mode( GTK_CMCLIST(clist), GTK_SELECTION_BROWSE );
1092         gtk_cmclist_set_column_width( GTK_CMCLIST(clist), EMAIL_COL_EMAIL, EMAIL_COL_WIDTH_EMAIL );
1093         gtk_cmclist_set_column_width( GTK_CMCLIST(clist), EMAIL_COL_ALIAS, EMAIL_COL_WIDTH_ALIAS );
1094
1095         for( i = 0; i < EMAIL_N_COLS; i++ )
1096                 GTK_WIDGET_UNSET_FLAGS(GTK_CMCLIST(clist)->column[i].button, GTK_CAN_FOCUS);
1097
1098         /* Data entry area */
1099         table = gtk_table_new( 4, 2, FALSE);
1100
1101 #ifndef GENERIC_UMPC
1102         gtk_container_add( GTK_CONTAINER(vboxl), clist_swin );
1103         gtk_box_pack_start(GTK_BOX(vboxl), table, FALSE, FALSE, 0);
1104 #else
1105         gtk_box_pack_start(GTK_BOX(vboxl), table, FALSE, FALSE, 0);
1106         gtk_container_add( GTK_CONTAINER(vboxl), clist_swin );
1107         gtk_cmclist_column_titles_hide(GTK_CMCLIST(clist));
1108 #endif
1109         gtk_container_set_border_width( GTK_CONTAINER(table), 4 );
1110         gtk_table_set_row_spacings(GTK_TABLE(table), 4);
1111         gtk_table_set_col_spacings(GTK_TABLE(table), 4);
1112
1113         entry_email = gtk_entry_new();
1114         entry_alias = gtk_entry_new();
1115         entry_remarks = gtk_entry_new();
1116
1117         /* First row */
1118         top = 0;
1119         label = gtk_label_new(_("Email Address"));
1120         gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0);
1121         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
1122
1123         gtk_table_attach(GTK_TABLE(table), entry_email, 1, 2, top, (top + 1), GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0);
1124
1125 #ifndef GENERIC_UMPC
1126         /* Next row */
1127         ++top;
1128         label = gtk_label_new(_("Alias"));
1129         gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0);
1130         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
1131
1132         gtk_table_attach(GTK_TABLE(table), entry_alias, 1, 2, top, (top + 1), GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0);
1133
1134         /* Next row */
1135         ++top;
1136         label = gtk_label_new(_("Remarks"));
1137         gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0);
1138         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
1139
1140         gtk_table_attach(GTK_TABLE(table), entry_remarks, 1, 2, top, (top + 1), GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0);
1141 #endif
1142
1143         /* Button box */
1144         vboxb = gtk_vbox_new( FALSE, 4 );
1145         gtk_box_pack_start(GTK_BOX(hbox), vboxb, FALSE, FALSE, 2);
1146
1147         vbuttonbox = gtk_vbutton_box_new();
1148         gtk_button_box_set_layout( GTK_BUTTON_BOX(vbuttonbox), GTK_BUTTONBOX_START );
1149         gtk_box_set_spacing( GTK_BOX(vbuttonbox), 8 );
1150         gtk_container_set_border_width( GTK_CONTAINER(vbuttonbox), 4 );
1151         gtk_container_add( GTK_CONTAINER(vboxb), vbuttonbox );
1152
1153         /* Buttons */
1154         buttonUp = gtk_button_new_from_stock(GTK_STOCK_GO_UP);
1155         buttonDown = gtk_button_new_from_stock(GTK_STOCK_GO_DOWN);
1156         buttonDel = gtk_button_new_from_stock(GTK_STOCK_DELETE);
1157         buttonMod = gtk_button_new_from_stock(GTK_STOCK_SAVE);
1158         buttonAdd = gtk_button_new_from_stock(GTK_STOCK_ADD);
1159
1160
1161 #ifndef GENERIC_UMPC
1162         gtk_container_add( GTK_CONTAINER(vbuttonbox), buttonUp );
1163
1164         gtk_container_add( GTK_CONTAINER(vbuttonbox), buttonDown );
1165 #endif
1166         gtk_container_add( GTK_CONTAINER(vbuttonbox), buttonDel );
1167
1168         gtk_container_add( GTK_CONTAINER(vbuttonbox), buttonMod );
1169
1170         gtk_container_add( GTK_CONTAINER(vbuttonbox), buttonAdd );
1171
1172         gtk_widget_show_all(vbox);
1173
1174         /* Event handlers */
1175         g_signal_connect( G_OBJECT(clist), "select_row",
1176                           G_CALLBACK( edit_person_email_list_selected), NULL );
1177         g_signal_connect( G_OBJECT(buttonUp), "clicked",
1178                           G_CALLBACK( edit_person_email_move_up ), NULL );
1179         g_signal_connect( G_OBJECT(buttonDown), "clicked",
1180                           G_CALLBACK( edit_person_email_move_down ), NULL );
1181         g_signal_connect( G_OBJECT(buttonDel), "clicked",
1182                           G_CALLBACK( edit_person_email_delete ), NULL );
1183         g_signal_connect( G_OBJECT(buttonMod), "clicked",
1184                           G_CALLBACK( edit_person_email_modify ), NULL );
1185         g_signal_connect( G_OBJECT(buttonAdd), "clicked",
1186                           G_CALLBACK( edit_person_email_add ), NULL );
1187         g_signal_connect(G_OBJECT(entry_email), "changed",
1188                          G_CALLBACK(edit_person_entry_email_changed), NULL);
1189         g_signal_connect(G_OBJECT(entry_email), "key_press_event",
1190                          G_CALLBACK(edit_person_entry_email_pressed), NULL);
1191         g_signal_connect(G_OBJECT(entry_alias), "key_press_event",
1192                          G_CALLBACK(edit_person_entry_email_pressed), NULL);
1193         g_signal_connect(G_OBJECT(entry_remarks), "key_press_event",
1194                          G_CALLBACK(edit_person_entry_email_pressed), NULL);
1195
1196         personeditdlg.clist_email   = clist;
1197         personeditdlg.entry_email   = entry_email;
1198         personeditdlg.entry_alias   = entry_alias;
1199         personeditdlg.entry_remarks = entry_remarks;
1200         personeditdlg.email_up = buttonUp;
1201         personeditdlg.email_down = buttonDown;
1202         personeditdlg.email_del = buttonDel;
1203         personeditdlg.email_mod = buttonMod;
1204         personeditdlg.email_add = buttonAdd;
1205 }
1206
1207 static gboolean attrib_adding = FALSE, attrib_saving = FALSE;
1208
1209 static void edit_person_entry_att_changed (GtkWidget *entry, gpointer data)
1210 {
1211         gboolean non_empty = gtk_cmclist_get_row_data(GTK_CMCLIST(personeditdlg.clist_attrib), 0) != NULL;
1212         const gchar *atname;
1213
1214         if (personeditdlg.read_only || personeditdlg.ldap)
1215                 return;
1216
1217         atname = gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN((personeditdlg.entry_atname)))));
1218         if ( atname == NULL
1219         ||  strlen(atname) == 0) {
1220                 gtk_widget_set_sensitive(personeditdlg.attrib_add,FALSE);
1221                 gtk_widget_set_sensitive(personeditdlg.attrib_mod,FALSE);
1222                 attrib_adding = FALSE;
1223                 attrib_saving = FALSE;
1224         } else if (list_find_attribute(atname)) {
1225                 gtk_widget_set_sensitive(personeditdlg.attrib_add,FALSE);
1226                 gtk_widget_set_sensitive(personeditdlg.attrib_mod,non_empty);
1227                 attrib_adding = FALSE;
1228                 attrib_saving = non_empty;
1229         } else {
1230                 gtk_widget_set_sensitive(personeditdlg.attrib_add,TRUE);
1231                 gtk_widget_set_sensitive(personeditdlg.attrib_mod,non_empty);
1232                 attrib_adding = TRUE;
1233                 attrib_saving = non_empty;
1234         }
1235 }
1236
1237 static gboolean edit_person_entry_att_pressed(GtkWidget *widget, GdkEventKey *event, gpointer data)
1238 {
1239         if (event && event->keyval == GDK_Return) {
1240                 if (attrib_saving)
1241                         edit_person_attrib_modify(NULL);
1242                 else if (attrib_adding)
1243                         edit_person_attrib_add(NULL);
1244         }
1245         return FALSE;
1246 }
1247
1248 static void addressbook_edit_person_page_attrib( gint pageNum, gchar *pageLbl ) {
1249         GtkWidget *vbox;
1250         GtkWidget *hbox;
1251         GtkWidget *vboxl;
1252         GtkWidget *vboxb;
1253         GtkWidget *vbuttonbox;
1254         GtkWidget *buttonDel;
1255         GtkWidget *buttonMod;
1256         GtkWidget *buttonAdd;
1257
1258         GtkWidget *table;
1259         GtkWidget *label;
1260         GtkWidget *clist_swin;
1261         GtkWidget *clist;
1262         GtkWidget *entry_name;
1263         GtkWidget *entry_value;
1264         gint top;
1265
1266         gchar *titles[ ATTRIB_N_COLS ];
1267         gint i;
1268
1269         titles[ ATTRIB_COL_NAME  ] = _("Name");
1270         titles[ ATTRIB_COL_VALUE ] = _("Value");
1271
1272         vbox = gtk_vbox_new( FALSE, 8 );
1273         gtk_widget_show( vbox );
1274         gtk_container_add( GTK_CONTAINER( personeditdlg.notebook ), vbox );
1275         gtk_container_set_border_width( GTK_CONTAINER (vbox), BORDER_WIDTH );
1276
1277         label = gtk_label_new_with_mnemonic( pageLbl );
1278         gtk_widget_show( label );
1279         gtk_notebook_set_tab_label(
1280                 GTK_NOTEBOOK( personeditdlg.notebook ),
1281                 gtk_notebook_get_nth_page( GTK_NOTEBOOK( personeditdlg.notebook ), pageNum ), label );
1282
1283         /* Split into two areas */
1284         hbox = gtk_hbox_new( FALSE, 0 );
1285         gtk_container_add( GTK_CONTAINER( vbox ), hbox );
1286
1287         /* Attribute list */
1288         vboxl = gtk_vbox_new( FALSE, 4 );
1289         gtk_container_add( GTK_CONTAINER( hbox ), vboxl );
1290         gtk_container_set_border_width( GTK_CONTAINER(vboxl), 4 );
1291
1292         clist_swin = gtk_scrolled_window_new( NULL, NULL );
1293         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(clist_swin),
1294                                        GTK_POLICY_AUTOMATIC,
1295                                        GTK_POLICY_AUTOMATIC);
1296
1297         clist = gtk_cmclist_new_with_titles( ATTRIB_N_COLS, titles );
1298         gtk_container_add( GTK_CONTAINER(clist_swin), clist );
1299         gtk_cmclist_set_selection_mode( GTK_CMCLIST(clist), GTK_SELECTION_BROWSE );
1300         gtk_cmclist_set_compare_func( GTK_CMCLIST(clist), edit_person_attrib_compare_func );
1301         gtk_cmclist_set_auto_sort( GTK_CMCLIST(clist), TRUE );
1302         gtk_cmclist_set_column_width( GTK_CMCLIST(clist), ATTRIB_COL_NAME, ATTRIB_COL_WIDTH_NAME );
1303         gtk_cmclist_set_column_width( GTK_CMCLIST(clist), ATTRIB_COL_VALUE, ATTRIB_COL_WIDTH_VALUE );
1304
1305         for( i = 0; i < ATTRIB_N_COLS; i++ )
1306                 GTK_WIDGET_UNSET_FLAGS(GTK_CMCLIST(clist)->column[i].button, GTK_CAN_FOCUS);
1307
1308         /* Data entry area */
1309 #ifndef GENERIC_UMPC
1310         table = gtk_table_new( 4, 2, FALSE);
1311         gtk_container_add( GTK_CONTAINER(vboxl), clist_swin );
1312         gtk_box_pack_start(GTK_BOX(vboxl), table, FALSE, FALSE, 0);
1313 #else
1314         table = gtk_table_new( 2, 4, FALSE);
1315         gtk_box_pack_start(GTK_BOX(vboxl), table, FALSE, FALSE, 0);
1316         gtk_container_add( GTK_CONTAINER(vboxl), clist_swin );
1317         gtk_cmclist_column_titles_hide(GTK_CMCLIST(clist));
1318 #endif
1319         gtk_container_set_border_width( GTK_CONTAINER(table), 4 );
1320         gtk_table_set_row_spacings(GTK_TABLE(table), 4);
1321         gtk_table_set_col_spacings(GTK_TABLE(table), 4);
1322
1323         /* First row */
1324         top = 0;
1325 #ifndef GENERIC_UMPC
1326         label = gtk_label_new(_("Name"));
1327         gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0);
1328         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
1329
1330         entry_name = gtk_combo_box_entry_new_text ();
1331         gtk_table_attach(GTK_TABLE(table), entry_name, 1, 2, top, (top + 1), GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0);
1332
1333         /* Next row */
1334         ++top;
1335         label = gtk_label_new(_("Value"));
1336         gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0);
1337         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
1338
1339         entry_value = gtk_entry_new();
1340         gtk_table_attach(GTK_TABLE(table), entry_value, 1, 2, top, (top + 1), GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0);
1341 #else
1342         label = gtk_label_new(_("Name"));
1343         gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1, GTK_FILL, 0, 0, 0);
1344         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
1345
1346         entry_name = gtk_combo_box_entry_new_text ();
1347         gtk_table_attach(GTK_TABLE(table), entry_name, 1, 2, 0, 1, GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0);
1348
1349         /* Next row */
1350         ++top;
1351         label = gtk_label_new(_("Value"));
1352         gtk_table_attach(GTK_TABLE(table), label, 2, 3, 0, 1, GTK_FILL, 0, 0, 0);
1353         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
1354
1355         entry_value = gtk_entry_new();
1356         gtk_table_attach(GTK_TABLE(table), entry_value, 3, 4, 0, 1, GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0);
1357 #endif
1358         gtk_combo_box_set_active(GTK_COMBO_BOX(entry_name), -1);
1359         if (prefs_common.addressbook_custom_attributes)
1360                 combobox_set_popdown_strings(GTK_COMBO_BOX(entry_name),
1361                                 prefs_common.addressbook_custom_attributes);
1362
1363         /* Button box */
1364         vboxb = gtk_vbox_new( FALSE, 4 );
1365         gtk_box_pack_start(GTK_BOX(hbox), vboxb, FALSE, FALSE, 2);
1366
1367         vbuttonbox = gtk_vbutton_box_new();
1368         gtk_button_box_set_layout( GTK_BUTTON_BOX(vbuttonbox), GTK_BUTTONBOX_START );
1369         gtk_box_set_spacing( GTK_BOX(vbuttonbox), 8 );
1370         gtk_container_set_border_width( GTK_CONTAINER(vbuttonbox), 4 );
1371         gtk_container_add( GTK_CONTAINER(vboxb), vbuttonbox );
1372
1373         /* Buttons */
1374         buttonDel = gtk_button_new_from_stock(GTK_STOCK_DELETE);
1375         gtk_container_add( GTK_CONTAINER(vbuttonbox), buttonDel );
1376
1377         buttonMod = gtk_button_new_from_stock(GTK_STOCK_SAVE);
1378         gtk_container_add( GTK_CONTAINER(vbuttonbox), buttonMod );
1379
1380         buttonAdd = gtk_button_new_from_stock(GTK_STOCK_ADD);
1381         gtk_container_add( GTK_CONTAINER(vbuttonbox), buttonAdd );
1382
1383         gtk_widget_set_sensitive(buttonDel,FALSE);
1384         gtk_widget_set_sensitive(buttonMod,FALSE);
1385         gtk_widget_set_sensitive(buttonAdd,FALSE);
1386
1387         gtk_widget_show_all(vbox);
1388
1389         /* Event handlers */
1390         g_signal_connect( G_OBJECT(clist), "select_row",
1391                           G_CALLBACK( edit_person_attrib_list_selected), NULL );
1392         g_signal_connect( G_OBJECT(buttonDel), "clicked",
1393                           G_CALLBACK( edit_person_attrib_delete ), NULL );
1394         g_signal_connect( G_OBJECT(buttonMod), "clicked",
1395                           G_CALLBACK( edit_person_attrib_modify ), NULL );
1396         g_signal_connect( G_OBJECT(buttonAdd), "clicked",
1397                           G_CALLBACK( edit_person_attrib_add ), NULL );
1398         g_signal_connect(G_OBJECT(entry_name), "changed",
1399                          G_CALLBACK(edit_person_entry_att_changed), NULL);
1400         g_signal_connect(G_OBJECT(entry_name), "key_press_event",
1401                          G_CALLBACK(edit_person_entry_att_pressed), NULL);
1402         g_signal_connect(G_OBJECT(entry_value), "key_press_event",
1403                          G_CALLBACK(edit_person_entry_att_pressed), NULL);
1404
1405         personeditdlg.clist_attrib  = clist;
1406         personeditdlg.entry_atname  = entry_name;
1407         personeditdlg.entry_atvalue = entry_value;
1408         personeditdlg.attrib_add = buttonAdd;
1409         personeditdlg.attrib_del = buttonDel;
1410         personeditdlg.attrib_mod = buttonMod;
1411 }
1412
1413 static void addressbook_edit_person_create( GtkWidget *parent, gboolean *cancelled ) {
1414         if (prefs_common.addressbook_use_editaddress_dialog)
1415                 addressbook_edit_person_dialog_create( cancelled );
1416         else
1417                 addressbook_edit_person_widgetset_create( parent, cancelled );
1418         addressbook_edit_person_page_basic( PAGE_BASIC, _( "_User Data" ) );
1419         addressbook_edit_person_page_email( PAGE_EMAIL, _( "_Email Addresses" ) );
1420 #ifdef USE_LDAP
1421         if (personeditdlg.ldap)
1422                 addressbook_edit_person_page_attrib_ldap(&personeditdlg, PAGE_ATTRIBUTES, _("O_ther Attributes"));
1423         else
1424 #endif
1425                 addressbook_edit_person_page_attrib( PAGE_ATTRIBUTES, _( "O_ther Attributes" ) );
1426         gtk_widget_show_all( personeditdlg.container );
1427 }
1428
1429 /*
1430 * Return list of email items.
1431 */
1432 static GList *edit_person_build_email_list() {
1433         GtkCMCList *clist = GTK_CMCLIST(personeditdlg.clist_email);
1434         GList *listEMail = NULL;
1435         ItemEMail *email;
1436         gint row = 0;
1437         while( (email = gtk_cmclist_get_row_data( clist, row )) ) {
1438                 listEMail = g_list_append( listEMail, email );
1439                 row++;
1440         }
1441         return listEMail;
1442 }
1443
1444 /*
1445 * Return list of attributes.
1446 */
1447 static GList *edit_person_build_attrib_list() {
1448         GtkCMCList *clist = GTK_CMCLIST(personeditdlg.clist_attrib);
1449         GList *listAttrib = NULL;
1450         UserAttribute *attrib;
1451         gint row = 0;
1452         while( (attrib = gtk_cmclist_get_row_data( clist, row )) ) {
1453                 listAttrib = g_list_append( listAttrib, attrib );
1454                 row++;
1455         }
1456         return listAttrib;
1457 }
1458
1459 static void update_sensitivity(void)
1460 {
1461         gtk_widget_set_sensitive(personeditdlg.entry_name,    !personeditdlg.read_only);
1462         gtk_widget_set_sensitive(personeditdlg.entry_first,   !personeditdlg.read_only);
1463         gtk_widget_set_sensitive(personeditdlg.entry_last,    !personeditdlg.read_only);
1464         gtk_widget_set_sensitive(personeditdlg.entry_nick,    !personeditdlg.read_only && !personeditdlg.ldap);
1465         gtk_widget_set_sensitive(personeditdlg.entry_email,   !personeditdlg.read_only);
1466         gtk_widget_set_sensitive(personeditdlg.entry_alias,   !personeditdlg.read_only && !personeditdlg.ldap);
1467         gtk_widget_set_sensitive(personeditdlg.entry_remarks, !personeditdlg.read_only && !personeditdlg.ldap);
1468         gtk_widget_set_sensitive(personeditdlg.email_up,      !personeditdlg.read_only);
1469         gtk_widget_set_sensitive(personeditdlg.email_down,    !personeditdlg.read_only);
1470         gtk_widget_set_sensitive(personeditdlg.email_del,     !personeditdlg.read_only);
1471         gtk_widget_set_sensitive(personeditdlg.email_mod,     !personeditdlg.read_only);
1472         gtk_widget_set_sensitive(personeditdlg.email_add,     !personeditdlg.read_only);
1473         gtk_widget_set_sensitive(personeditdlg.entry_atname,  !personeditdlg.read_only);
1474         gtk_widget_set_sensitive(personeditdlg.entry_atvalue, !personeditdlg.read_only);
1475         gtk_widget_set_sensitive(personeditdlg.attrib_add,    !personeditdlg.read_only);
1476         gtk_widget_set_sensitive(personeditdlg.attrib_del,    !personeditdlg.read_only);
1477         gtk_widget_set_sensitive(personeditdlg.attrib_mod,    !personeditdlg.read_only);
1478 }
1479
1480 static void addressbook_edit_person_flush_transient( void )
1481 {
1482         ItemPerson *person = current_person;
1483         EditAddressPostUpdateCallback callback = edit_person_close_post_update_cb;
1484
1485         /* reset transient data */
1486         current_abf = NULL;
1487         current_person = NULL;
1488         current_parent_folder = NULL;
1489         edit_person_close_post_update_cb = NULL;
1490
1491         /* post action to perform on addressbook side */
1492         if (callback)
1493                 callback( person );
1494 }
1495
1496 void addressbook_edit_person_invalidate( AddressBookFile *abf, ItemFolder *parent_folder,
1497                                                                                  ItemPerson *person )
1498 {
1499         if (current_abf == NULL &&
1500                 current_person == NULL &&
1501                 current_parent_folder == NULL)
1502                 /* edit address form is already hidden */
1503                 return;
1504
1505         /* unconditional invalidation or invalidating the currently edited item */
1506         if ( ( abf == NULL && person == NULL && parent_folder == NULL )
1507                 || (current_abf == abf ||
1508                         current_person == person ||
1509                         current_parent_folder == parent_folder))
1510                 addressbook_edit_person_close( TRUE );
1511 }
1512
1513 static gboolean addressbook_edit_person_close( gboolean cancelled )
1514 {
1515         GList *listEMail = NULL;
1516         GList *listAttrib = NULL;
1517         GError *error = NULL;
1518
1519         listEMail = edit_person_build_email_list();
1520         listAttrib = edit_person_build_attrib_list();
1521         if( cancelled ) {
1522                 addritem_free_list_email( listEMail );
1523                 addritem_free_list_attribute( listAttrib );
1524                 gtk_cmclist_clear( GTK_CMCLIST(personeditdlg.clist_email) );
1525                 gtk_cmclist_clear( GTK_CMCLIST(personeditdlg.clist_attrib) );
1526
1527                 if (!prefs_common.addressbook_use_editaddress_dialog)
1528                         gtk_widget_hide( personeditdlg.container );
1529
1530                 /* no callback, as we're discarding the form */
1531                 edit_person_close_post_update_cb = NULL;
1532                 addressbook_edit_person_flush_transient();
1533                 current_person = NULL;
1534
1535                 /* set focus to the address list (this is done by the post_update_cb usually) */
1536                 addressbook_address_list_set_focus();
1537                 return FALSE;
1538         }
1539
1540         if( current_person && current_abf ) {
1541                 /* Update email/attribute list for existing current_person */
1542                 addrbook_update_address_list( current_abf, current_person, listEMail );
1543                 addrbook_update_attrib_list( current_abf, current_person, listAttrib );
1544         }
1545         else {
1546                 /* Create new current_person and email/attribute list */
1547                 if( ! cancelled && current_abf ) {
1548                         current_person = addrbook_add_address_list( current_abf, current_parent_folder, listEMail );
1549                         addrbook_add_attrib_list( current_abf, current_person, listAttrib );
1550                 }
1551         }
1552         listEMail = NULL;
1553         listAttrib = NULL;
1554
1555         if( ! cancelled ) {
1556                 /* Set current_person stuff */
1557
1558                 gchar *name;
1559                 gchar *cn = edit_person_get_common_name_from_widgets();
1560
1561                 addritem_person_set_common_name( current_person, cn );
1562                 g_free( cn );
1563
1564                 if (personeditdlg.picture_set) {
1565                         GdkPixbuf * pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(personeditdlg.image));
1566
1567                         if (!current_person->picture)
1568                                 name = g_strconcat( get_rc_dir(), G_DIR_SEPARATOR_S, ADDRBOOK_DIR, G_DIR_SEPARATOR_S,
1569                                                 ADDRITEM_ID(current_person), ".png", NULL );
1570                         else
1571                                 name = g_strconcat( get_rc_dir(), G_DIR_SEPARATOR_S, ADDRBOOK_DIR, G_DIR_SEPARATOR_S,
1572                                                 current_person->picture, ".png", NULL );
1573
1574                         gdk_pixbuf_save(pixbuf, name, "png", &error, NULL);
1575                         if (error) {
1576                                 alertpanel_error(_("Failed to save image: \n%s"),
1577                                                 error->message);
1578                                 g_error_free(error);
1579                         } else {
1580                                 debug_print("saved picture to %s\n", name);
1581                         }
1582                         if (!current_person->picture)
1583                                 addritem_person_set_picture( current_person, ADDRITEM_ID(current_person) ) ;
1584                         g_free( name );
1585                 } else {
1586                         if (!current_person->picture)
1587                                 name = g_strconcat( get_rc_dir(), G_DIR_SEPARATOR_S, ADDRBOOK_DIR, G_DIR_SEPARATOR_S,
1588                                                 ADDRITEM_ID(current_person), ".png", NULL );
1589                         else
1590                                 name = g_strconcat( get_rc_dir(), G_DIR_SEPARATOR_S, ADDRBOOK_DIR, G_DIR_SEPARATOR_S,
1591                                                 current_person->picture, ".png", NULL );
1592                         claws_unlink(name);
1593                         g_free(name);
1594                 }
1595                 name = gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_first), 0, -1 );
1596                 addritem_person_set_first_name( current_person, name );
1597                 g_free( name );
1598                 name = gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_last), 0, -1 );
1599                 addritem_person_set_last_name( current_person, name );
1600                 g_free( name );
1601                 name = gtk_editable_get_chars( GTK_EDITABLE(personeditdlg.entry_nick), 0, -1 );
1602                 addritem_person_set_nick_name( current_person, name );
1603                 g_free( name );
1604         }
1605
1606         gtk_cmclist_clear( GTK_CMCLIST(personeditdlg.clist_email) );
1607         gtk_cmclist_clear( GTK_CMCLIST(personeditdlg.clist_attrib) );
1608
1609         if (!prefs_common.addressbook_use_editaddress_dialog)
1610                 gtk_widget_hide( personeditdlg.container );
1611
1612         addressbook_edit_person_flush_transient();
1613
1614         return TRUE;
1615 }
1616
1617 /*
1618 * Edit person.
1619 * Enter: abf    Address book.
1620 *        parent Parent folder for person (or NULL if adding to root folder). Argument is
1621 *               only required for new objects).
1622 *        person Person to edit, or NULL for a new person object.
1623 *        pgMail If TRUE, E-Mail page will be activated.
1624 * Return: Edited object, or NULL if cancelled.*/
1625 ItemPerson *addressbook_edit_person( AddressBookFile *abf, ItemFolder *parent_folder, ItemPerson *person,
1626                                                                          gboolean pgMail, GtkWidget *parent_container,
1627                                                                          void (*post_update_cb) (ItemPerson *person),
1628                                                                          gboolean get_focus) {
1629         static gboolean cancelled;
1630         GError *error = NULL;
1631         GdkPixbuf *pixbuf = NULL;
1632         /* set transient data */
1633         current_abf = abf;
1634         current_person = person;
1635         current_parent_folder = parent_folder;
1636         edit_person_close_post_update_cb = post_update_cb;
1637         personeditdlg.ldap = (abf && abf->type == ADBOOKTYPE_LDAP)? TRUE : FALSE;
1638
1639         if( personeditdlg.container ) {
1640                 gtk_widget_destroy(personeditdlg.container);
1641                 personeditdlg.container = NULL;
1642         }
1643         addressbook_edit_person_create(parent_container, &cancelled);
1644
1645         /* typically, get focus when dialog mode is enabled, or when editing a new address */
1646         if( get_focus ) {
1647                 gtk_widget_grab_focus(personeditdlg.ok_btn);
1648                 gtk_widget_grab_focus(personeditdlg.entry_name);
1649         }
1650
1651         personeditdlg.read_only = (current_abf == NULL);
1652         update_sensitivity();
1653
1654         gtk_widget_show(personeditdlg.container);
1655         if (prefs_common.addressbook_use_editaddress_dialog)
1656                 manage_window_set_transient(GTK_WINDOW(personeditdlg.container));
1657         else
1658                 if (get_focus)
1659                         addressbook_address_list_disable_some_actions();
1660
1661         /* Clear all fields */
1662         personeditdlg.rowIndEMail = -1;
1663         personeditdlg.rowIndAttrib = -1;
1664         edit_person_status_show( "" );
1665         gtk_cmclist_clear( GTK_CMCLIST(personeditdlg.clist_email) );
1666         gtk_cmclist_clear( GTK_CMCLIST(personeditdlg.clist_attrib) );
1667         gtk_entry_set_text(GTK_ENTRY(personeditdlg.entry_name), "" );
1668         gtk_entry_set_text(GTK_ENTRY(personeditdlg.entry_first), "" );
1669         gtk_entry_set_text(GTK_ENTRY(personeditdlg.entry_last), "" );
1670         gtk_entry_set_text(GTK_ENTRY(personeditdlg.entry_nick), "" );
1671
1672         personeditdlg.editNew = FALSE;
1673         if( current_person ) {
1674                 gchar *filename = NULL;
1675
1676                 if( ADDRITEM_NAME(current_person) )
1677                         gtk_entry_set_text(GTK_ENTRY(personeditdlg.entry_name), ADDRITEM_NAME(person) );
1678
1679                 cm_menu_set_sensitive("EditAddressPopup/SetPicture", !personeditdlg.ldap);
1680                 cm_menu_set_sensitive("EditAddressPopup/UnsetPicture", !personeditdlg.ldap);
1681                 if( current_person->picture ) {
1682                         filename = g_strconcat( get_rc_dir(), G_DIR_SEPARATOR_S, ADDRBOOK_DIR, G_DIR_SEPARATOR_S,
1683                                                         current_person->picture, ".png", NULL );
1684                         if (is_file_exist(filename)) {
1685                                 pixbuf = gdk_pixbuf_new_from_file(filename, &error);
1686                                 if (error) {
1687                                         debug_print("Failed to import image: \n%s",
1688                                                         error->message);
1689                                         g_error_free(error);
1690                                         goto no_img;
1691                                 }
1692                                 personeditdlg.picture_set = TRUE;
1693                                 cm_menu_set_sensitive("EditAddressPopup/UnsetPicture", !personeditdlg.ldap && personeditdlg.picture_set);
1694                         } else {
1695                                 goto no_img;
1696                         }
1697                         gtk_image_set_from_pixbuf(GTK_IMAGE(personeditdlg.image), pixbuf);
1698                 } else {
1699 no_img:
1700                         addressbook_edit_person_clear_picture();
1701                 }
1702
1703                 g_free(filename);
1704                 if (pixbuf) {
1705                         g_object_unref(pixbuf);
1706                         pixbuf = NULL;
1707                 }
1708
1709                 if( current_person->firstName )
1710                         gtk_entry_set_text(GTK_ENTRY(personeditdlg.entry_first), current_person->firstName );
1711                 if( current_person->lastName )
1712                         gtk_entry_set_text(GTK_ENTRY(personeditdlg.entry_last), current_person->lastName );
1713                 if( current_person->nickName )
1714                         gtk_entry_set_text(GTK_ENTRY(personeditdlg.entry_nick), current_person->nickName );
1715                 edit_person_load_email( current_person );
1716                 edit_person_load_attrib( current_person );
1717                 gtk_entry_set_text(GTK_ENTRY(personeditdlg.entry_atvalue), "");
1718         }
1719         else {
1720                 personeditdlg.editNew = TRUE;
1721         }
1722
1723         /* Select appropriate start page */
1724         if( pgMail ) {
1725                 gtk_notebook_set_current_page( GTK_NOTEBOOK(personeditdlg.notebook), PAGE_EMAIL );
1726         }
1727         else {
1728                 gtk_notebook_set_current_page( GTK_NOTEBOOK(personeditdlg.notebook), PAGE_BASIC );
1729         }
1730
1731         gtk_cmclist_select_row( GTK_CMCLIST(personeditdlg.clist_email), 0, 0 );
1732         gtk_cmclist_select_row( GTK_CMCLIST(personeditdlg.clist_attrib), 0, 0 );
1733         edit_person_email_clear( NULL );
1734         if (current_person)
1735                 edit_person_email_list_selected(GTK_CMCLIST(personeditdlg.clist_email), 0, 0, NULL, NULL);
1736
1737         edit_person_attrib_clear( NULL );
1738
1739         if (prefs_common.addressbook_use_editaddress_dialog) {
1740                 gtk_main();
1741                 gtk_widget_hide( personeditdlg.container );
1742
1743                 if (!addressbook_edit_person_close( cancelled )) {
1744                         return NULL;
1745                 }
1746         }
1747
1748         return person;
1749 }
1750
1751 void addressbook_edit_reload_attr_list( void )
1752 {
1753         if (personeditdlg.entry_atname) {
1754                 combobox_unset_popdown_strings(GTK_COMBO_BOX(personeditdlg.entry_atname));
1755                 if (prefs_common.addressbook_custom_attributes)
1756                         combobox_set_popdown_strings(GTK_COMBO_BOX(personeditdlg.entry_atname),
1757                                         prefs_common.addressbook_custom_attributes);
1758         }
1759 }
1760
1761 /*
1762 * End of Source.
1763 */
1764