2 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3 * Copyright (C) 1999-2002 Hiroyuki Yamamoto
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.
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.
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.
27 #include <gdk/gdkkeysyms.h>
28 #include <gtk/gtkwindow.h>
29 #include <gtk/gtksignal.h>
30 #include <gtk/gtkvbox.h>
31 #include <gtk/gtkscrolledwindow.h>
32 #include <gtk/gtkhpaned.h>
33 #include <gtk/gtkhbox.h>
34 #include <gtk/gtklabel.h>
35 #include <gtk/gtkentry.h>
36 #include <gtk/gtkctree.h>
37 #include <gtk/gtkclist.h>
38 #include <gtk/gtktable.h>
39 #include <gtk/gtkhbbox.h>
40 #include <gtk/gtkbutton.h>
41 #include <gtk/gtkmenu.h>
42 #include <gtk/gtkmenuitem.h>
43 #include <gtk/gtkitemfactory.h>
49 #include "addressbook.h"
50 #include "manage_window.h"
51 #include "prefs_common.h"
52 #include "alertpanel.h"
53 #include "inputdialog.h"
55 #include "stock_pixmap.h"
63 #include "addr_compl.h"
66 #include "addressitem.h"
68 #include "addrcache.h"
70 #include "addrindex.h"
71 #include "addressadd.h"
73 #include "editvcard.h"
74 #include "editgroup.h"
75 #include "editaddress.h"
78 #include "importldif.h"
80 #include "importmutt.h"
84 #include "editjpilot.h"
92 #define ADDRESSBOOK_LDAP_BUSYMSG "Busy"
95 #include "addrselect.h"
99 #include "pixmaps/dir-close.xpm"
100 #include "pixmaps/dir-open.xpm"
101 #include "pixmaps/group.xpm"
102 #include "pixmaps/interface.xpm"
103 #include "pixmaps/book.xpm"
104 #include "pixmaps/address.xpm"
105 #include "pixmaps/vcard.xpm"
106 #include "pixmaps/jpilot.xpm"
107 #include "pixmaps/category.xpm"
108 #include "pixmaps/ldap.xpm"
116 } AddressBookColumnPos;
119 #define COL_NAME_WIDTH 164
120 #define COL_ADDRESS_WIDTH 156
122 #define COL_FOLDER_WIDTH 170
123 #define ADDRESSBOOK_WIDTH 640
124 #define ADDRESSBOOK_HEIGHT 360
126 #define ADDRESSBOOK_MSGBUF_SIZE 2048
128 static GdkPixmap *folderxpm;
129 static GdkBitmap *folderxpmmask;
130 static GdkPixmap *folderopenxpm;
131 static GdkBitmap *folderopenxpmmask;
132 static GdkPixmap *groupxpm;
133 static GdkBitmap *groupxpmmask;
134 static GdkPixmap *interfacexpm;
135 static GdkBitmap *interfacexpmmask;
136 static GdkPixmap *bookxpm;
137 static GdkBitmap *bookxpmmask;
138 static GdkPixmap *addressxpm;
139 static GdkBitmap *addressxpmmask;
140 static GdkPixmap *vcardxpm;
141 static GdkBitmap *vcardxpmmask;
142 static GdkPixmap *jpilotxpm;
143 static GdkBitmap *jpilotxpmmask;
144 static GdkPixmap *categoryxpm;
145 static GdkBitmap *categoryxpmmask;
146 static GdkPixmap *ldapxpm;
147 static GdkBitmap *ldapxpmmask;
150 static gchar addressbook_msgbuf[ ADDRESSBOOK_MSGBUF_SIZE ];
152 /* Address list selection */
153 static AddrSelectList *_addressSelect_ = NULL;
154 static AddressClipboard *_clipBoard_ = NULL;
156 /* Address index file and interfaces */
157 static AddressIndex *_addressIndex_ = NULL;
158 static GList *_addressInterfaceList_ = NULL;
159 static GList *_addressIFaceSelection_ = NULL;
160 #define ADDRESSBOOK_IFACE_SELECTION "1/y,3/y,4/y,2/n"
162 static AddressBook_win addrbook;
164 static GHashTable *_addressBookTypeHash_ = NULL;
165 static GList *_addressBookTypeList_ = NULL;
167 static void addressbook_create (void);
168 static gint addressbook_close (void);
169 static void addressbook_button_set_sensitive (void);
171 /* callback functions */
172 static void addressbook_del_clicked (GtkButton *button,
174 static void addressbook_reg_clicked (GtkButton *button,
176 static void addressbook_to_clicked (GtkButton *button,
178 static void addressbook_lup_clicked (GtkButton *button,
181 static void addressbook_tree_selected (GtkCTree *ctree,
185 static void addressbook_list_selected (GtkCList *clist,
190 static void addressbook_list_row_selected (GtkCTree *clist,
194 static void addressbook_list_row_unselected (GtkCTree *clist,
198 static void addressbook_person_expand_node (GtkCTree *ctree,
201 static void addressbook_person_collapse_node (GtkCTree *ctree,
204 static void addressbook_entry_gotfocus (GtkWidget *widget);
207 static void addressbook_entry_changed (GtkWidget *widget);
210 static void addressbook_list_button_pressed (GtkWidget *widget,
211 GdkEventButton *event,
213 static void addressbook_list_button_released (GtkWidget *widget,
214 GdkEventButton *event,
216 static void addressbook_tree_button_pressed (GtkWidget *ctree,
217 GdkEventButton *event,
219 static void addressbook_tree_button_released (GtkWidget *ctree,
220 GdkEventButton *event,
222 static void addressbook_popup_close (GtkMenuShell *menu_shell,
225 static void addressbook_new_folder_cb (gpointer data,
228 static void addressbook_new_group_cb (gpointer data,
231 static void addressbook_treenode_edit_cb (gpointer data,
234 static void addressbook_treenode_delete_cb (gpointer data,
238 static void addressbook_change_node_name (GtkCTreeNode *node,
241 static void addressbook_new_address_cb (gpointer data,
244 static void addressbook_edit_address_cb (gpointer data,
247 static void addressbook_delete_address_cb (gpointer data,
251 static void close_cb (gpointer data,
254 static void addressbook_file_save_cb (gpointer data,
258 /* Data source edit stuff */
259 static void addressbook_new_book_cb (gpointer data,
262 static void addressbook_new_vcard_cb (gpointer data,
267 static void addressbook_new_jpilot_cb (gpointer data,
273 static void addressbook_new_ldap_cb (gpointer data,
278 static void addressbook_set_clist (AddressObject *obj);
280 static void addressbook_load_tree (void);
281 void addressbook_read_file (void);
283 static GtkCTreeNode *addressbook_add_object (GtkCTreeNode *node,
285 static void addressbook_treenode_remove_item ( void );
287 static AddressDataSource *addressbook_find_datasource
288 (GtkCTreeNode *node );
290 static AddressBookFile *addressbook_get_book_file(void);
292 static GtkCTreeNode *addressbook_node_add_folder
294 AddressDataSource *ds,
295 ItemFolder *itemFolder,
296 AddressObjectType otype);
297 static GtkCTreeNode *addressbook_node_add_group (GtkCTreeNode *node,
298 AddressDataSource *ds,
299 ItemGroup *itemGroup);
300 static void addressbook_tree_remove_children (GtkCTree *ctree,
301 GtkCTreeNode *parent);
302 static void addressbook_move_nodes_up (GtkCTree *ctree,
304 static GtkCTreeNode *addressbook_find_group_node (GtkCTreeNode *parent,
306 static GtkCTreeNode *addressbook_find_folder_node( GtkCTreeNode *parent,
307 ItemFolder *folder );
309 static void addressbook_delete_object (AddressObject *obj);
311 static void key_pressed (GtkWidget *widget,
314 static gint addressbook_treenode_compare_func (GtkCList *clist,
317 static gint addressbook_list_compare_func (GtkCList *clist,
322 static void addressbook_ldap_show_message (SyldapServer *server);
325 /* LUT's and IF stuff */
326 static void addressbook_free_treenode ( gpointer data );
327 AddressTypeControlItem *addrbookctl_lookup (gint ot);
328 AddressTypeControlItem *addrbookctl_lookup_iface(AddressIfType ifType);
330 void addrbookctl_build_map (GtkWidget *window);
331 void addrbookctl_build_iflist (void);
332 AdapterInterface *addrbookctl_find_interface (AddressIfType ifType);
333 void addrbookctl_build_ifselect (void);
335 static void addrbookctl_free_interface (AdapterInterface *adapter);
336 static void addrbookctl_free_datasource (AdapterDSource *adapter);
337 static void addrbookctl_free_folder (AdapterFolder *adapter);
338 static void addrbookctl_free_group (AdapterGroup *adapter);
340 static void addressbook_list_select_clear ( void );
341 static void addressbook_list_select_add ( AddrItemObject *aio,
342 AddressDataSource *ds );
343 static void addressbook_list_select_remove ( AddrItemObject *aio );
345 static void addressbook_import_ldif_cb ( void );
346 static void addressbook_import_mutt_cb ( void );
347 static void addressbook_clip_cut_cb ( void );
348 static void addressbook_clip_copy_cb ( void );
349 static void addressbook_clip_paste_cb ( void );
350 static void addressbook_clip_paste_address_cb ( void );
351 static void addressbook_treenode_cut_cb ( void );
352 static void addressbook_treenode_copy_cb ( void );
353 static void addressbook_treenode_paste_cb ( void );
355 static GtkItemFactoryEntry addressbook_entries[] =
357 {N_("/_File"), NULL, NULL, 0, "<Branch>"},
358 {N_("/_File/New _Book"), "<alt>B", addressbook_new_book_cb, 0, NULL},
359 {N_("/_File/New _vCard"), "<alt>D", addressbook_new_vcard_cb, 0, NULL},
361 {N_("/_File/New _JPilot"), "<alt>J", addressbook_new_jpilot_cb, 0, NULL},
364 {N_("/_File/New _Server"), "<alt>S", addressbook_new_ldap_cb, 0, NULL},
366 {N_("/_File/---"), NULL, NULL, 0, "<Separator>"},
367 {N_("/_File/_Edit"), NULL, addressbook_treenode_edit_cb, 0, NULL},
368 {N_("/_File/_Delete"), NULL, addressbook_treenode_delete_cb, 0, NULL},
369 {N_("/_File/---"), NULL, NULL, 0, "<Separator>"},
370 {N_("/_File/_Save"), "<alt>S", addressbook_file_save_cb, 0, NULL},
371 {N_("/_File/_Close"), "<alt>W", close_cb, 0, NULL},
372 {N_("/_Edit"), NULL, NULL, 0, "<Branch>"},
373 {N_("/_Edit/C_ut"), "<ctl>X", addressbook_clip_cut_cb, 0, NULL},
374 {N_("/_Edit/_Copy"), "<ctl>C", addressbook_clip_copy_cb, 0, NULL},
375 {N_("/_Edit/_Paste"), "<ctl>V", addressbook_clip_paste_cb, 0, NULL},
376 {N_("/_Edit/---"), NULL, NULL, 0, "<Separator>"},
377 {N_("/_Edit/Pa_ste Address"), NULL, addressbook_clip_paste_address_cb, 0, NULL},
378 {N_("/_Address"), NULL, NULL, 0, "<Branch>"},
379 {N_("/_Address/New _Address"), "<alt>N", addressbook_new_address_cb, 0, NULL},
380 {N_("/_Address/New _Group"), "<alt>G", addressbook_new_group_cb, 0, NULL},
381 {N_("/_Address/New _Folder"), "<alt>R", addressbook_new_folder_cb, 0, NULL},
382 {N_("/_Address/---"), NULL, NULL, 0, "<Separator>"},
383 {N_("/_Address/_Edit"), "<alt>Return", addressbook_edit_address_cb, 0, NULL},
384 {N_("/_Address/_Delete"), NULL, addressbook_delete_address_cb, 0, NULL},
385 {N_("/_Tools/---"), NULL, NULL, 0, "<Separator>"},
386 {N_("/_Tools/Import _LDIF file"), NULL, addressbook_import_ldif_cb, 0, NULL},
387 {N_("/_Tools/Import M_utt file"), NULL, addressbook_import_mutt_cb, 0, NULL},
388 {N_("/_Help"), NULL, NULL, 0, "<LastBranch>"},
389 {N_("/_Help/_About"), NULL, about_show, 0, NULL}
392 /* New options to be added. */
394 {N_("/_Tools"), NULL, NULL, 0, "<Branch>"},
395 {N_("/_Tools/Import _Mozilla"), NULL, NULL, 0, NULL},
396 {N_("/_Tools/Import _vCard"), NULL, NULL, 0, NULL},
397 {N_("/_Tools/---"), NULL, NULL, 0, "<Separator>"},
398 {N_("/_Tools/Export _LDIF file"), NULL, NULL, 0, NULL},
399 {N_("/_Tools/Export v_Card"), NULL, NULL, 0, NULL},
402 static GtkItemFactoryEntry addressbook_tree_popup_entries[] =
404 {N_("/New _Address"), NULL, addressbook_new_address_cb, 0, NULL},
405 {N_("/New _Group"), NULL, addressbook_new_group_cb, 0, NULL},
406 {N_("/New _Folder"), NULL, addressbook_new_folder_cb, 0, NULL},
407 {N_("/---"), NULL, NULL, 0, "<Separator>"},
408 {N_("/_Edit"), NULL, addressbook_treenode_edit_cb, 0, NULL},
409 {N_("/_Delete"), NULL, addressbook_treenode_delete_cb, 0, NULL},
410 {N_("/---"), NULL, NULL, 0, "<Separator>"},
411 {N_("/C_ut"), NULL, addressbook_treenode_cut_cb, 0, NULL},
412 {N_("/_Copy"), NULL, addressbook_treenode_copy_cb, 0, NULL},
413 {N_("/_Paste"), NULL, addressbook_treenode_paste_cb, 0, NULL}
416 static GtkItemFactoryEntry addressbook_list_popup_entries[] =
418 {N_("/New _Address"), NULL, addressbook_new_address_cb, 0, NULL},
419 {N_("/New _Group"), NULL, addressbook_new_group_cb, 0, NULL},
420 {N_("/New _Folder"), NULL, addressbook_new_folder_cb, 0, NULL},
421 {N_("/---"), NULL, NULL, 0, "<Separator>"},
422 {N_("/_Edit"), NULL, addressbook_edit_address_cb, 0, NULL},
423 {N_("/_Delete"), NULL, addressbook_delete_address_cb, 0, NULL},
424 {N_("/---"), NULL, NULL, 0, "<Separator>"},
425 {N_("/C_ut"), NULL, addressbook_clip_cut_cb, 0, NULL},
426 {N_("/_Copy"), NULL, addressbook_clip_copy_cb, 0, NULL},
427 {N_("/_Paste"), NULL, addressbook_clip_paste_cb, 0, NULL},
428 {N_("/---"), NULL, NULL, 0, "<Separator>"},
429 {N_("/Pa_ste Address"), NULL, addressbook_clip_paste_address_cb, 0, NULL}
432 void addressbook_open(Compose *target)
434 /* Initialize all static members */
435 if( _clipBoard_ == NULL ) {
436 _clipBoard_ = addrclip_create();
438 if( _addressIndex_ != NULL ) {
439 addrclip_set_index( _clipBoard_, _addressIndex_ );
441 if( _addressSelect_ == NULL ) {
442 _addressSelect_ = addrselect_list_create();
444 if (!addrbook.window) {
445 addressbook_read_file();
446 addressbook_create();
447 addressbook_load_tree();
448 gtk_ctree_select(GTK_CTREE(addrbook.ctree),
449 GTK_CTREE_NODE(GTK_CLIST(addrbook.ctree)->row_list));
451 gtk_widget_hide(addrbook.window);
453 gtk_widget_show_all(addrbook.window);
455 addressbook_set_target_compose(target);
458 void addressbook_set_target_compose(Compose *target)
460 addrbook.target_compose = target;
462 addressbook_button_set_sensitive();
465 Compose *addressbook_get_target_compose(void)
467 return addrbook.target_compose;
470 void addressbook_refresh(void)
472 if (addrbook.window) {
473 if (addrbook.treeSelected) {
474 gtk_ctree_select(GTK_CTREE(addrbook.ctree),
475 addrbook.treeSelected);
478 addressbook_export_to_file();
482 * Create the address book widgets. The address book contains two CTree widgets: the
483 * address index tree on the left and the address list on the right.
485 * The address index tree displays a hierarchy of interfaces and groups. Each node in
486 * this tree is linked to an address Adapter. Adapters have been created for interfaces,
487 * data sources and folder objects.
489 * The address list displays group, person and email objects. These items are linked
490 * directly to ItemGroup, ItemPerson and ItemEMail objects inside the address book data
493 * In the tradition of MVC architecture, the data stores have been separated from the
494 * GUI components. The addrindex.c file provides the interface to all data stores.
496 static void addressbook_create(void)
502 GtkWidget *ctree_swin;
504 GtkWidget *clist_vbox;
505 GtkWidget *clist_swin;
511 GtkWidget *statusbar;
520 GtkWidget *tree_popup;
521 GtkWidget *list_popup;
522 GtkItemFactory *tree_factory;
523 GtkItemFactory *list_factory;
524 GtkItemFactory *menu_factory;
528 gchar *titles[N_COLS] = {_("Name"), _("E-Mail address"), _("Remarks")};
532 debug_print("Creating addressbook window...\n");
534 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
535 gtk_window_set_title(GTK_WINDOW(window), _("Address book"));
536 gtk_widget_set_usize(window, ADDRESSBOOK_WIDTH, ADDRESSBOOK_HEIGHT);
537 gtk_window_set_policy(GTK_WINDOW(window), TRUE, TRUE, TRUE);
538 gtk_window_set_wmclass(GTK_WINDOW(window), "addressbook", "Sylpheed");
539 gtk_widget_realize(window);
541 gtk_signal_connect(GTK_OBJECT(window), "delete_event",
542 GTK_SIGNAL_FUNC(addressbook_close), NULL);
543 gtk_signal_connect(GTK_OBJECT(window), "key_press_event",
544 GTK_SIGNAL_FUNC(key_pressed), NULL);
545 gtk_signal_connect(GTK_OBJECT(window), "focus_in_event",
546 GTK_SIGNAL_FUNC(manage_window_focus_in), NULL);
547 gtk_signal_connect(GTK_OBJECT(window), "focus_out_event",
548 GTK_SIGNAL_FUNC(manage_window_focus_out), NULL);
550 vbox = gtk_vbox_new(FALSE, 0);
551 gtk_container_add(GTK_CONTAINER(window), vbox);
553 n_entries = sizeof(addressbook_entries) /
554 sizeof(addressbook_entries[0]);
555 menubar = menubar_create(window, addressbook_entries, n_entries,
556 "<AddressBook>", NULL);
557 gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, TRUE, 0);
558 menu_factory = gtk_item_factory_from_widget(menubar);
560 vbox2 = gtk_vbox_new(FALSE, 4);
561 gtk_container_set_border_width(GTK_CONTAINER(vbox2), BORDER_WIDTH);
562 gtk_box_pack_start(GTK_BOX(vbox), vbox2, TRUE, TRUE, 0);
564 ctree_swin = gtk_scrolled_window_new(NULL, NULL);
565 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ctree_swin),
566 GTK_POLICY_AUTOMATIC,
568 gtk_widget_set_usize(ctree_swin, COL_FOLDER_WIDTH + 40, -1);
571 ctree = gtk_ctree_new(1, 0);
572 gtk_container_add(GTK_CONTAINER(ctree_swin), ctree);
573 gtk_clist_set_selection_mode(GTK_CLIST(ctree), GTK_SELECTION_BROWSE);
574 gtk_clist_set_column_width(GTK_CLIST(ctree), 0, COL_FOLDER_WIDTH);
575 gtk_ctree_set_line_style(GTK_CTREE(ctree), GTK_CTREE_LINES_DOTTED);
576 gtk_ctree_set_expander_style(GTK_CTREE(ctree),
577 GTK_CTREE_EXPANDER_SQUARE);
578 gtk_ctree_set_indent(GTK_CTREE(ctree), CTREE_INDENT);
579 gtk_clist_set_compare_func(GTK_CLIST(ctree),
580 addressbook_treenode_compare_func);
582 gtk_signal_connect(GTK_OBJECT(ctree), "tree_select_row",
583 GTK_SIGNAL_FUNC(addressbook_tree_selected), NULL);
584 gtk_signal_connect(GTK_OBJECT(ctree), "button_press_event",
585 GTK_SIGNAL_FUNC(addressbook_tree_button_pressed),
587 gtk_signal_connect(GTK_OBJECT(ctree), "button_release_event",
588 GTK_SIGNAL_FUNC(addressbook_tree_button_released),
591 clist_vbox = gtk_vbox_new(FALSE, 4);
593 clist_swin = gtk_scrolled_window_new(NULL, NULL);
594 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(clist_swin),
595 GTK_POLICY_AUTOMATIC,
597 gtk_box_pack_start(GTK_BOX(clist_vbox), clist_swin, TRUE, TRUE, 0);
600 clist = gtk_ctree_new_with_titles(N_COLS, 0, titles);
601 gtk_container_add(GTK_CONTAINER(clist_swin), clist);
602 gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_EXTENDED);
603 gtk_ctree_set_line_style(GTK_CTREE(clist), GTK_CTREE_LINES_NONE);
604 gtk_ctree_set_expander_style(GTK_CTREE(clist), GTK_CTREE_EXPANDER_SQUARE);
605 gtk_ctree_set_indent(GTK_CTREE(clist), CTREE_INDENT);
606 gtk_clist_set_column_width(GTK_CLIST(clist), COL_NAME,
608 gtk_clist_set_column_width(GTK_CLIST(clist), COL_ADDRESS,
610 gtk_clist_set_compare_func(GTK_CLIST(clist),
611 addressbook_list_compare_func);
613 for (i = 0; i < N_COLS; i++)
614 GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(clist)->column[i].button,
617 gtk_signal_connect(GTK_OBJECT(clist), "tree_select_row",
618 GTK_SIGNAL_FUNC(addressbook_list_row_selected), NULL);
619 gtk_signal_connect(GTK_OBJECT(clist), "tree_unselect_row",
620 GTK_SIGNAL_FUNC(addressbook_list_row_unselected), NULL);
621 gtk_signal_connect(GTK_OBJECT(clist), "button_press_event",
622 GTK_SIGNAL_FUNC(addressbook_list_button_pressed),
624 gtk_signal_connect(GTK_OBJECT(clist), "button_release_event",
625 GTK_SIGNAL_FUNC(addressbook_list_button_released),
627 gtk_signal_connect(GTK_OBJECT(clist), "select_row",
628 GTK_SIGNAL_FUNC(addressbook_list_selected), NULL);
629 gtk_signal_connect(GTK_OBJECT(clist), "tree_expand",
630 GTK_SIGNAL_FUNC(addressbook_person_expand_node), NULL );
631 gtk_signal_connect(GTK_OBJECT(clist), "tree_collapse",
632 GTK_SIGNAL_FUNC(addressbook_person_collapse_node), NULL );
634 hbox = gtk_hbox_new(FALSE, 4);
635 gtk_box_pack_start(GTK_BOX(clist_vbox), hbox, FALSE, FALSE, 0);
637 label = gtk_label_new(_("Name:"));
638 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
640 entry = gtk_entry_new();
641 gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0);
643 address_completion_register_entry(GTK_ENTRY(entry));
644 gtk_signal_connect(GTK_OBJECT(entry), "focus_in_event",
645 GTK_SIGNAL_FUNC(addressbook_entry_gotfocus), NULL);
648 gtk_signal_connect(GTK_OBJECT(entry), "changed",
649 GTK_SIGNAL_FUNC(addressbook_entry_changed), NULL);
652 paned = gtk_hpaned_new();
653 gtk_box_pack_start(GTK_BOX(vbox2), paned, TRUE, TRUE, 0);
654 gtk_paned_add1(GTK_PANED(paned), ctree_swin);
655 gtk_paned_add2(GTK_PANED(paned), clist_vbox);
658 hsbox = gtk_hbox_new(FALSE, 0);
659 gtk_box_pack_end(GTK_BOX(vbox), hsbox, FALSE, FALSE, BORDER_WIDTH);
660 statusbar = gtk_statusbar_new();
661 gtk_box_pack_start(GTK_BOX(hsbox), statusbar, TRUE, TRUE, BORDER_WIDTH);
664 hbbox = gtk_hbutton_box_new();
665 gtk_button_box_set_layout(GTK_BUTTON_BOX(hbbox), GTK_BUTTONBOX_END);
666 gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbbox), 2);
667 gtk_box_pack_end(GTK_BOX(vbox), hbbox, FALSE, FALSE, 0);
669 del_btn = gtk_button_new_with_label(_("Delete"));
670 GTK_WIDGET_SET_FLAGS(del_btn, GTK_CAN_DEFAULT);
671 gtk_box_pack_start(GTK_BOX(hbbox), del_btn, TRUE, TRUE, 0);
672 reg_btn = gtk_button_new_with_label(_("Add"));
673 GTK_WIDGET_SET_FLAGS(reg_btn, GTK_CAN_DEFAULT);
674 gtk_box_pack_start(GTK_BOX(hbbox), reg_btn, TRUE, TRUE, 0);
675 lup_btn = gtk_button_new_with_label(_("Lookup"));
676 GTK_WIDGET_SET_FLAGS(lup_btn, GTK_CAN_DEFAULT);
677 gtk_box_pack_start(GTK_BOX(hbbox), lup_btn, TRUE, TRUE, 0);
679 gtk_signal_connect(GTK_OBJECT(del_btn), "clicked",
680 GTK_SIGNAL_FUNC(addressbook_del_clicked), NULL);
681 gtk_signal_connect(GTK_OBJECT(reg_btn), "clicked",
682 GTK_SIGNAL_FUNC(addressbook_reg_clicked), NULL);
683 gtk_signal_connect(GTK_OBJECT(lup_btn), "clicked",
684 GTK_SIGNAL_FUNC(addressbook_lup_clicked), NULL);
686 to_btn = gtk_button_new_with_label
687 (prefs_common.trans_hdr ? _("To:") : "To:");
688 GTK_WIDGET_SET_FLAGS(to_btn, GTK_CAN_DEFAULT);
689 gtk_box_pack_start(GTK_BOX(hbbox), to_btn, TRUE, TRUE, 0);
690 cc_btn = gtk_button_new_with_label
691 (prefs_common.trans_hdr ? _("Cc:") : "Cc:");
692 GTK_WIDGET_SET_FLAGS(cc_btn, GTK_CAN_DEFAULT);
693 gtk_box_pack_start(GTK_BOX(hbbox), cc_btn, TRUE, TRUE, 0);
694 bcc_btn = gtk_button_new_with_label
695 (prefs_common.trans_hdr ? _("Bcc:") : "Bcc:");
696 GTK_WIDGET_SET_FLAGS(bcc_btn, GTK_CAN_DEFAULT);
697 gtk_box_pack_start(GTK_BOX(hbbox), bcc_btn, TRUE, TRUE, 0);
699 gtk_signal_connect(GTK_OBJECT(to_btn), "clicked",
700 GTK_SIGNAL_FUNC(addressbook_to_clicked),
701 GINT_TO_POINTER(COMPOSE_TO));
702 gtk_signal_connect(GTK_OBJECT(cc_btn), "clicked",
703 GTK_SIGNAL_FUNC(addressbook_to_clicked),
704 GINT_TO_POINTER(COMPOSE_CC));
705 gtk_signal_connect(GTK_OBJECT(bcc_btn), "clicked",
706 GTK_SIGNAL_FUNC(addressbook_to_clicked),
707 GINT_TO_POINTER(COMPOSE_BCC));
709 /* Build icons for interface */
710 stock_pixmap_gdk( window, STOCK_PIXMAP_INTERFACE,
711 &interfacexpm, &interfacexpmmask );
713 /* Build control tables */
714 addrbookctl_build_map(window);
715 addrbookctl_build_iflist();
716 addrbookctl_build_ifselect();
718 /* Add each interface into the tree as a root level folder */
719 nodeIf = _addressInterfaceList_;
721 AdapterInterface *adapter = nodeIf->data;
722 AddressInterface *iface = adapter->interface;
723 nodeIf = g_list_next(nodeIf);
725 if(iface->useInterface) {
726 AddressTypeControlItem *atci = adapter->atci;
727 text = atci->displayName;
729 gtk_ctree_insert_node( GTK_CTREE(ctree),
730 NULL, NULL, &text, FOLDER_SPACING,
731 interfacexpm, interfacexpmmask,
732 interfacexpm, interfacexpmmask,
734 menu_set_sensitive( menu_factory, atci->menuCommand, adapter->haveLibrary );
735 gtk_ctree_node_set_row_data_full(
736 GTK_CTREE(ctree), adapter->treeNode, adapter,
737 addressbook_free_treenode );
742 n_entries = sizeof(addressbook_tree_popup_entries) /
743 sizeof(addressbook_tree_popup_entries[0]);
744 tree_popup = menu_create_items(addressbook_tree_popup_entries,
746 "<AddressBookTree>", &tree_factory,
748 gtk_signal_connect(GTK_OBJECT(tree_popup), "selection_done",
749 GTK_SIGNAL_FUNC(addressbook_popup_close), NULL);
750 n_entries = sizeof(addressbook_list_popup_entries) /
751 sizeof(addressbook_list_popup_entries[0]);
752 list_popup = menu_create_items(addressbook_list_popup_entries,
754 "<AddressBookList>", &list_factory,
757 addrbook.window = window;
758 addrbook.menubar = menubar;
759 addrbook.ctree = ctree;
760 addrbook.clist = clist;
761 addrbook.entry = entry;
762 addrbook.statusbar = statusbar;
763 addrbook.status_cid = gtk_statusbar_get_context_id(
764 GTK_STATUSBAR(statusbar), "Addressbook Window" );
766 addrbook.del_btn = del_btn;
767 addrbook.reg_btn = reg_btn;
768 addrbook.lup_btn = lup_btn;
769 addrbook.to_btn = to_btn;
770 addrbook.cc_btn = cc_btn;
771 addrbook.bcc_btn = bcc_btn;
773 addrbook.tree_popup = tree_popup;
774 addrbook.list_popup = list_popup;
775 addrbook.tree_factory = tree_factory;
776 addrbook.list_factory = list_factory;
777 addrbook.menu_factory = menu_factory;
779 addrbook.listSelected = NULL;
780 address_completion_start(window);
781 gtk_widget_show_all(window);
785 static gint addressbook_close(void)
787 gtk_widget_hide(addrbook.window);
788 addressbook_export_to_file();
792 static void addressbook_status_show( gchar *msg ) {
793 if( addrbook.statusbar != NULL ) {
795 GTK_STATUSBAR(addrbook.statusbar),
796 addrbook.status_cid );
799 GTK_STATUSBAR(addrbook.statusbar),
800 addrbook.status_cid, msg );
805 static void addressbook_ds_status_message( AddressDataSource *ds, gchar *msg ) {
806 *addressbook_msgbuf = '\0';
810 name = addrindex_ds_get_name( ds );
811 sprintf( addressbook_msgbuf, "%s: %s", name, msg );
814 sprintf( addressbook_msgbuf, "%s", msg );
816 addressbook_status_show( addressbook_msgbuf );
819 static void addressbook_ds_show_message( AddressDataSource *ds ) {
822 *addressbook_msgbuf = '\0';
824 name = addrindex_ds_get_name( ds );
825 retVal = addrindex_ds_get_status_code( ds );
826 if( retVal == MGU_SUCCESS ) {
827 sprintf( addressbook_msgbuf, "%s", name );
830 sprintf( addressbook_msgbuf, "%s: %s", name,
831 mgu_error2string( retVal ) );
834 addressbook_status_show( addressbook_msgbuf );
837 static void addressbook_button_set_sensitive(void)
839 gboolean to_sens = FALSE;
840 gboolean cc_sens = FALSE;
841 gboolean bcc_sens = FALSE;
843 if (!addrbook.window) return;
845 if (addrbook.target_compose) {
849 if (addrbook.target_compose->use_bcc)
854 gtk_widget_set_sensitive(addrbook.to_btn, to_sens);
855 gtk_widget_set_sensitive(addrbook.cc_btn, cc_sens);
856 gtk_widget_set_sensitive(addrbook.bcc_btn, bcc_sens);
860 * Delete one or more objects from address list.
862 static void addressbook_del_clicked(GtkButton *button, gpointer data)
864 GtkCTree *clist = GTK_CTREE(addrbook.clist);
865 GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
867 AdapterDSource *ads = NULL;
868 GtkCTreeNode *nodeList;
871 AddressBookFile *abf = NULL;
872 AddressDataSource *ds = NULL;
873 AddressInterface *iface;
875 AddrSelectItem *item;
878 pobj = gtk_ctree_node_get_row_data(ctree, addrbook.opened );
879 g_return_if_fail(pobj != NULL);
881 /* Test whether anything selected for deletion */
882 nodeList = addrbook.listSelected;
883 aio = gtk_ctree_node_get_row_data( clist, nodeList );
884 if( aio == NULL) return;
885 ds = addressbook_find_datasource( addrbook.treeSelected );
886 if( ds == NULL ) return;
888 /* Test for read only */
889 iface = ds->interface;
890 if( iface->readOnly ) {
891 aval = alertpanel( _("Delete address(es)"),
892 _("This address data is readonly and cannot be deleted."),
893 _("Close"), NULL, NULL );
897 /* Test whether Ok to proceed */
899 if( pobj->type == ADDR_DATASOURCE ) {
900 ads = ADAPTER_DSOURCE(pobj);
901 if( ads->subType == ADDR_BOOK ) procFlag = TRUE;
903 else if( pobj->type == ADDR_ITEM_FOLDER ) {
906 else if( pobj->type == ADDR_ITEM_GROUP ) {
909 if( ! procFlag ) return;
910 abf = ds->rawDataSource;
911 if( abf == NULL ) return;
913 /* Confirm deletion */
914 aval = alertpanel( _("Delete address(es)"),
915 _("Really delete the address(es)?"),
916 _("Yes"), _("No"), NULL );
917 if( aval != G_ALERTDEFAULT ) return;
919 /* Process deletions */
920 if( pobj->type == ADDR_DATASOURCE || pobj->type == ADDR_ITEM_FOLDER ) {
921 /* Items inside folders */
922 list = addrselect_get_list( _addressSelect_ );
926 node = g_list_next( node );
927 aio = ( AddrItemObject * ) item->addressItem;
928 if( aio->type == ADDR_ITEM_GROUP ) {
929 ItemGroup *item = ( ItemGroup * ) aio;
930 GtkCTreeNode *nd = NULL;
932 nd = addressbook_find_group_node( addrbook.opened, item );
933 item = addrbook_remove_group( abf, item );
935 addritem_free_item_group( item );
937 /* Remove group from parent node */
938 gtk_ctree_remove_node( ctree, nd );
940 else if( aio->type == ADDR_ITEM_PERSON ) {
941 ItemPerson *item = ( ItemPerson * ) aio;
942 item = addrbook_remove_person( abf, item );
944 addritem_free_item_person( item );
947 else if( aio->type == ADDR_ITEM_EMAIL ) {
948 ItemEMail *item = ( ItemEMail * ) aio;
949 ItemPerson *person = ( ItemPerson * ) ADDRITEM_PARENT(item);
950 item = addrbook_person_remove_email( abf, person, item );
952 addritem_free_item_email( item );
957 addressbook_list_select_clear();
958 gtk_ctree_select( ctree, addrbook.opened);
961 else if( pobj->type == ADDR_ITEM_GROUP ) {
962 /* Items inside groups */
963 list = addrselect_get_list( _addressSelect_ );
967 node = g_list_next( node );
968 aio = ( AddrItemObject * ) item->addressItem;
969 if( aio->type == ADDR_ITEM_EMAIL ) {
970 ItemEMail *item = ( ItemEMail * ) aio;
971 ItemPerson *person = ( ItemPerson * ) ADDRITEM_PARENT(item);
972 item = addrbook_person_remove_email( abf, person, item );
974 addritem_free_item_email( item );
979 addressbook_list_select_clear();
980 gtk_ctree_select( ctree, addrbook.opened);
984 gtk_ctree_node_set_row_data( clist, nodeList, NULL );
985 gtk_ctree_remove_node( clist, nodeList );
989 static void addressbook_reg_clicked(GtkButton *button, gpointer data)
991 addressbook_new_address_cb( NULL, 0, NULL );
994 gchar *addressbook_format_address( AddrItemObject * aio ) {
997 gchar *address = NULL;
999 if( aio->type == ADDR_ITEM_EMAIL ) {
1000 ItemPerson *person = NULL;
1001 ItemEMail *email = ( ItemEMail * ) aio;
1003 person = ( ItemPerson * ) ADDRITEM_PARENT(email);
1004 if( email->address ) {
1005 if( ADDRITEM_NAME(email) ) {
1006 name = ADDRITEM_NAME(email);
1007 if( *name == '\0' ) {
1008 name = ADDRITEM_NAME(person);
1011 else if( ADDRITEM_NAME(person) ) {
1012 name = ADDRITEM_NAME(person);
1015 buf = g_strdup( email->address );
1017 address = email->address;
1020 else if( aio->type == ADDR_ITEM_PERSON ) {
1021 ItemPerson *person = ( ItemPerson * ) aio;
1022 GList *node = person->listEMail;
1024 name = ADDRITEM_NAME(person);
1026 ItemEMail *email = ( ItemEMail * ) node->data;
1027 address = email->address;
1032 if( strchr_with_skip_quote( name, '"', ',' ) )
1033 buf = g_strdup_printf( "\"%s\" <%s>", name, address );
1035 buf = g_strdup_printf( "%s <%s>", name, address );
1038 buf = g_strdup( address );
1045 static void addressbook_to_clicked(GtkButton *button, gpointer data)
1049 AddrSelectItem *item;
1050 AddrItemObject *aio;
1053 compose = addrbook.target_compose;
1054 if( ! compose ) return;
1056 list = addrselect_get_list( _addressSelect_ );
1060 node = g_list_next( node );
1061 aio = item->addressItem;
1062 if( aio->type == ADDR_ITEM_PERSON ||
1063 aio->type == ADDR_ITEM_EMAIL ) {
1064 addr = addressbook_format_address( aio );
1065 compose_entry_append(
1066 compose, addr, (ComposeEntryType) data );
1069 else if( aio->type == ADDR_ITEM_GROUP ) {
1070 ItemGroup *group = ( ItemGroup * ) aio;
1071 GList *nodeMail = group->listEMail;
1073 ItemEMail *email = nodeMail->data;
1075 addr = addressbook_format_address(
1076 ( AddrItemObject * ) email );
1077 compose_entry_append(
1078 compose, addr, (ComposeEntryType) data );
1080 nodeMail = g_list_next( nodeMail );
1084 g_list_free( list );
1087 static void addressbook_menubar_set_sensitive( gboolean sensitive ) {
1088 menu_set_sensitive( addrbook.menu_factory, "/File/Edit", sensitive );
1089 menu_set_sensitive( addrbook.menu_factory, "/File/Delete", sensitive );
1091 menu_set_sensitive( addrbook.menu_factory, "/Edit/Cut", sensitive );
1092 menu_set_sensitive( addrbook.menu_factory, "/Edit/Copy", sensitive );
1093 menu_set_sensitive( addrbook.menu_factory, "/Edit/Paste", sensitive );
1094 menu_set_sensitive( addrbook.menu_factory, "/Edit/Paste Address", sensitive );
1096 menu_set_sensitive( addrbook.menu_factory, "/Address/New Address", sensitive );
1097 menu_set_sensitive( addrbook.menu_factory, "/Address/New Group", sensitive );
1098 menu_set_sensitive( addrbook.menu_factory, "/Address/New Folder", sensitive );
1099 gtk_widget_set_sensitive( addrbook.reg_btn, sensitive );
1100 gtk_widget_set_sensitive( addrbook.del_btn, sensitive );
1103 static void addressbook_menuitem_set_sensitive( AddressObject *obj, GtkCTreeNode *node ) {
1104 gboolean canEdit = FALSE;
1105 gboolean canAdd = FALSE;
1106 gboolean canEditTr = TRUE;
1107 gboolean editAddress = FALSE;
1108 AddressTypeControlItem *atci = NULL;
1109 AddressDataSource *ds = NULL;
1110 AddressInterface *iface = NULL;
1112 if( obj == NULL ) return;
1113 if( obj->type == ADDR_INTERFACE ) {
1114 AdapterInterface *adapter = ADAPTER_INTERFACE(obj);
1115 iface = adapter->interface;
1117 if( iface->haveLibrary ) {
1118 /* Enable appropriate File / New command */
1119 atci = adapter->atci;
1120 menu_set_sensitive( addrbook.menu_factory, atci->menuCommand, TRUE );
1125 else if( obj->type == ADDR_DATASOURCE ) {
1126 AdapterDSource *ads = ADAPTER_DSOURCE(obj);
1127 ds = ads->dataSource;
1128 iface = ds->interface;
1129 if( ! iface->readOnly ) {
1130 canAdd = canEdit = editAddress = TRUE;
1132 if( ! iface->haveLibrary ) {
1133 canAdd = canEdit = editAddress = FALSE;
1136 else if( obj->type == ADDR_ITEM_FOLDER ) {
1137 ds = addressbook_find_datasource( addrbook.treeSelected );
1139 iface = ds->interface;
1140 if( iface->readOnly ) {
1144 canAdd = editAddress = TRUE;
1148 else if( obj->type == ADDR_ITEM_GROUP ) {
1149 ds = addressbook_find_datasource( addrbook.treeSelected );
1151 iface = ds->interface;
1152 if( ! iface->readOnly ) {
1158 if( addrbook.listSelected == NULL ) canEdit = FALSE;
1161 menu_set_sensitive( addrbook.menu_factory, "/Address/New Address", editAddress );
1162 menu_set_sensitive( addrbook.menu_factory, "/Address/New Group", canAdd );
1163 menu_set_sensitive( addrbook.menu_factory, "/Address/New Folder", canAdd );
1164 gtk_widget_set_sensitive( addrbook.reg_btn, editAddress );
1167 menu_set_sensitive( addrbook.menu_factory, "/Address/Edit", canEdit );
1168 menu_set_sensitive( addrbook.menu_factory, "/Address/Delete", canEdit );
1169 gtk_widget_set_sensitive( addrbook.del_btn, canEdit );
1171 menu_set_sensitive( addrbook.menu_factory, "/File/Edit", canEditTr );
1172 menu_set_sensitive( addrbook.menu_factory, "/File/Delete", canEditTr );
1175 static void addressbook_tree_selected(GtkCTree *ctree, GtkCTreeNode *node,
1176 gint column, gpointer data)
1178 AddressObject *obj = NULL;
1179 AdapterDSource *ads = NULL;
1180 AddressDataSource *ds = NULL;
1181 ItemFolder *rootFolder = NULL;
1183 addrbook.treeSelected = node;
1184 addrbook.listSelected = NULL;
1185 addressbook_status_show( "" );
1186 if( addrbook.entry != NULL ) gtk_entry_set_text(GTK_ENTRY(addrbook.entry), "");
1188 if( addrbook.clist ) gtk_clist_clear( GTK_CLIST(addrbook.clist) );
1189 if( node ) obj = gtk_ctree_node_get_row_data( ctree, node );
1190 if( obj == NULL ) return;
1192 addrbook.opened = node;
1194 if( obj->type == ADDR_DATASOURCE ) {
1195 /* Read from file */
1196 static gboolean tVal = TRUE;
1198 ads = ADAPTER_DSOURCE(obj);
1199 if( ads == NULL ) return;
1200 ds = ads->dataSource;
1201 if( ds == NULL ) return;
1203 if( addrindex_ds_get_modify_flag( ds ) ) {
1204 addrindex_ds_read_data( ds );
1207 if( ! addrindex_ds_get_read_flag( ds ) ) {
1208 addrindex_ds_read_data( ds );
1210 addressbook_ds_show_message( ds );
1212 if( ! addrindex_ds_get_access_flag( ds ) ) {
1213 /* Remove existing folders and groups */
1214 gtk_clist_freeze( GTK_CLIST(ctree) );
1215 addressbook_tree_remove_children( ctree, node );
1216 gtk_clist_thaw( GTK_CLIST(ctree) );
1218 /* Load folders into the tree */
1219 rootFolder = addrindex_ds_get_root_folder( ds );
1220 if( ds->type == ADDR_IF_JPILOT ) {
1221 addressbook_node_add_folder( node, ds, rootFolder, ADDR_CATEGORY );
1224 addressbook_node_add_folder( node, ds, rootFolder, ADDR_ITEM_FOLDER );
1226 addrindex_ds_set_access_flag( ds, &tVal );
1227 gtk_ctree_expand( ctree, node );
1231 /* Update address list */
1232 addressbook_set_clist( obj );
1234 /* Setup main menu selections */
1235 addressbook_menubar_set_sensitive( FALSE );
1236 addressbook_menuitem_set_sensitive( obj, node );
1238 addressbook_list_select_clear();
1243 * Setup address list popup menu.
1244 * Enter: pobj Parent address object in address tree.
1245 * obj Address object in address list.
1247 static void addressbook_list_menu_setup( void ) {
1248 GtkCTree *clist = NULL;
1249 AddressObject *pobj = NULL;
1250 AddressObject *obj = NULL;
1251 AdapterDSource *ads = NULL;
1252 AddressInterface *iface = NULL;
1253 AddressDataSource *ds = NULL;
1254 gboolean canEdit = FALSE;
1255 gboolean canDelete = FALSE;
1256 gboolean canCut = FALSE;
1257 gboolean canCopy = FALSE;
1258 gboolean canPaste = FALSE;
1260 pobj = gtk_ctree_node_get_row_data( GTK_CTREE(addrbook.ctree), addrbook.treeSelected );
1261 if( pobj == NULL ) return;
1263 clist = GTK_CTREE(addrbook.clist);
1264 obj = gtk_ctree_node_get_row_data( clist, addrbook.listSelected );
1265 if( obj == NULL ) canEdit = FALSE;
1267 menu_set_insensitive_all( GTK_MENU_SHELL(addrbook.list_popup) );
1269 if( pobj->type == ADDR_DATASOURCE ) {
1270 ads = ADAPTER_DSOURCE(pobj);
1271 ds = ads->dataSource;
1272 iface = ds->interface;
1273 if( ! iface->readOnly ) {
1274 menu_set_sensitive( addrbook.list_factory, "/New Address", TRUE );
1275 menu_set_sensitive( addrbook.list_factory, "/New Folder", TRUE );
1276 menu_set_sensitive( addrbook.list_factory, "/New Group", TRUE );
1277 gtk_widget_set_sensitive( addrbook.reg_btn, TRUE );
1278 if( ! addrclip_is_empty( _clipBoard_ ) ) canPaste = TRUE;
1279 if( ! addrselect_test_empty( _addressSelect_ ) ) canCut = TRUE;
1280 if( obj ) canEdit = TRUE;
1283 else if( pobj->type != ADDR_INTERFACE ) {
1284 ds = addressbook_find_datasource( addrbook.treeSelected );
1285 iface = ds->interface;
1286 if( ! iface->readOnly ) {
1287 if( pobj->type == ADDR_ITEM_FOLDER || pobj->type == ADDR_ITEM_GROUP ) {
1288 menu_set_sensitive( addrbook.list_factory, "/New Address", TRUE );
1289 gtk_widget_set_sensitive( addrbook.reg_btn, TRUE );
1290 if( obj ) canEdit = TRUE;
1292 if( pobj->type == ADDR_ITEM_FOLDER ) {
1293 menu_set_sensitive( addrbook.list_factory, "/New Folder", TRUE );
1294 menu_set_sensitive( addrbook.list_factory, "/New Group", TRUE );
1295 if( obj ) canEdit = TRUE;
1297 if( ! addrclip_is_empty( _clipBoard_ ) ) canPaste = TRUE;
1298 if( ! addrselect_test_empty( _addressSelect_ ) ) canCut = TRUE;
1301 if( ! addrselect_test_empty( _addressSelect_ ) ) canCopy = TRUE;
1303 canDelete = canEdit;
1304 canDelete = canEdit;
1306 /* Disable edit if more than one row selected */
1307 if( GTK_CLIST(clist)->selection && GTK_CLIST(clist)->selection->next ) canEdit = FALSE;
1309 menu_set_sensitive( addrbook.list_factory, "/Edit", canEdit );
1310 menu_set_sensitive( addrbook.list_factory, "/Delete", canDelete );
1312 menu_set_sensitive( addrbook.list_factory, "/Cut", canCut );
1313 menu_set_sensitive( addrbook.list_factory, "/Copy", canCopy );
1314 menu_set_sensitive( addrbook.list_factory, "/Paste", canPaste );
1315 menu_set_sensitive( addrbook.list_factory, "/Paste Address", canPaste );
1317 menu_set_sensitive( addrbook.menu_factory, "/Edit/Cut", canCut );
1318 menu_set_sensitive( addrbook.menu_factory, "/Edit/Copy", canCopy );
1319 menu_set_sensitive( addrbook.menu_factory, "/Edit/Paste", canPaste );
1320 menu_set_sensitive( addrbook.menu_factory, "/Edit/Paste Address", canPaste );
1322 menu_set_sensitive( addrbook.tree_factory, "/Cut", canCut );
1323 menu_set_sensitive( addrbook.tree_factory, "/Copy", canCopy );
1324 menu_set_sensitive( addrbook.tree_factory, "/Paste", canPaste );
1326 menu_set_sensitive( addrbook.menu_factory, "/Address/Edit", canEdit );
1327 menu_set_sensitive( addrbook.menu_factory, "/Address/Delete", canDelete );
1329 gtk_widget_set_sensitive( addrbook.del_btn, canDelete );
1332 static void addressbook_list_selected(GtkCList *clist, gint row, gint column,
1333 GdkEvent *event, gpointer data)
1335 if (event && event->type == GDK_2BUTTON_PRESS) {
1336 /* Handle double click */
1337 if (prefs_common.add_address_by_click &&
1338 addrbook.target_compose)
1339 addressbook_to_clicked(NULL, NULL);
1341 addressbook_edit_address_cb(NULL, 0, NULL);
1346 * Add list of items into tree node below specified tree node.
1347 * Enter: treeNode Tree node.
1349 * listItems List of items.
1351 static void addressbook_treenode_add_list(
1352 GtkCTreeNode *treeNode, AddressDataSource *ds, GList *listItems )
1358 AddrItemObject *aio;
1362 if( ADDRESS_OBJECT_TYPE(aio) == ITEMTYPE_GROUP ) {
1365 group = ( ItemGroup * ) aio;
1366 nn = addressbook_node_add_group( treeNode, ds, group );
1368 else if( ADDRESS_OBJECT_TYPE(aio) == ITEMTYPE_FOLDER ) {
1371 folder = ( ItemFolder * ) aio;
1372 nn = addressbook_node_add_folder(
1373 treeNode, ds, folder, ADDR_ITEM_FOLDER );
1375 node = g_list_next( node );
1380 * Cut from address list widget.
1382 static void addressbook_clip_cut_cb( void ) {
1383 _clipBoard_->cutFlag = TRUE;
1384 addrclip_clear( _clipBoard_ );
1385 addrclip_add( _clipBoard_, _addressSelect_ );
1386 /* addrclip_list_show( _clipBoard_, stdout ); */
1390 * Copy from address list widget.
1392 static void addressbook_clip_copy_cb( void ) {
1393 _clipBoard_->cutFlag = FALSE;
1394 addrclip_clear( _clipBoard_ );
1395 addrclip_add( _clipBoard_, _addressSelect_ );
1396 /* addrclip_list_show( _clipBoard_, stdout ); */
1400 * Paste clipboard into address list widget.
1402 static void addressbook_clip_paste_cb( void ) {
1403 GtkCTree *ctree = GTK_CTREE( addrbook.ctree );
1404 AddressObject *pobj = NULL;
1405 AddressDataSource *ds = NULL;
1406 AddressBookFile *abf = NULL;
1407 ItemFolder *folder = NULL;
1408 GList *folderGroup = NULL;
1410 ds = addressbook_find_datasource( GTK_CTREE_NODE(addrbook.treeSelected) );
1411 if( ds == NULL ) return;
1412 if( addrindex_ds_get_readonly( ds ) ) {
1413 addressbook_ds_status_message(
1414 ds, _( "Cannot paste. Target address book is readonly." ) );
1418 pobj = gtk_ctree_node_get_row_data( ctree, addrbook.treeSelected );
1420 if( pobj->type == ADDR_ITEM_FOLDER ) {
1421 folder = ADAPTER_FOLDER(pobj)->itemFolder;
1423 else if( pobj->type == ADDR_ITEM_GROUP ) {
1424 addressbook_ds_status_message(
1425 ds, _( "Cannot paste into an address group." ) );
1430 /* Get an address book */
1431 abf = addressbook_get_book_file();
1432 if( abf == NULL ) return;
1434 if( _clipBoard_->cutFlag ) {
1436 folderGroup = addrclip_paste_cut( _clipBoard_, abf, folder );
1438 /* Remove all groups and folders in clipboard from tree node */
1439 addressbook_treenode_remove_item();
1441 /* Remove all "cut" items */
1442 addrclip_delete_item( _clipBoard_ );
1444 /* Clear clipboard - cut items??? */
1445 addrclip_clear( _clipBoard_ );
1449 folderGroup = addrclip_paste_copy( _clipBoard_, abf, folder );
1452 /* addrclip_list_show( _clipBoard_, stdout ); */
1454 /* Update tree by inserting node for each folder or group */
1455 addressbook_treenode_add_list(
1456 addrbook.treeSelected, ds, folderGroup );
1457 gtk_ctree_expand( ctree, addrbook.treeSelected );
1458 g_list_free( folderGroup );
1462 /* Display items pasted */
1463 gtk_ctree_select( ctree, addrbook.opened );
1468 * Paste clipboard email addresses only into address list widget.
1470 static void addressbook_clip_paste_address_cb( void ) {
1471 GtkCTree *clist = GTK_CTREE(addrbook.clist);
1473 AddressObject *pobj = NULL;
1474 AddressDataSource *ds = NULL;
1475 AddressBookFile *abf = NULL;
1476 ItemFolder *folder = NULL;
1477 AddrItemObject *aio;
1480 if( addrbook.listSelected == NULL ) return;
1482 ctree = GTK_CTREE( addrbook.ctree );
1483 ds = addressbook_find_datasource( GTK_CTREE_NODE(addrbook.treeSelected) );
1484 if( ds == NULL ) return;
1485 if( addrindex_ds_get_readonly( ds ) ) {
1486 addressbook_ds_status_message(
1487 ds, _( "Cannot paste. Target address book is readonly." ) );
1491 pobj = gtk_ctree_node_get_row_data( ctree, addrbook.treeSelected );
1493 if( pobj->type == ADDR_ITEM_FOLDER ) {
1494 folder = ADAPTER_FOLDER(pobj)->itemFolder;
1498 abf = addressbook_get_book_file();
1499 if( abf == NULL ) return;
1502 aio = gtk_ctree_node_get_row_data( clist, addrbook.listSelected );
1503 if( aio->type == ADDR_ITEM_PERSON ) {
1506 person = ( ItemPerson * ) aio;
1507 if( _clipBoard_->cutFlag ) {
1509 cnt = addrclip_paste_person_cut( _clipBoard_, abf, person );
1511 /* Remove all "cut" items */
1512 addrclip_delete_address( _clipBoard_ );
1514 /* Clear clipboard */
1515 addrclip_clear( _clipBoard_ );
1519 cnt = addrclip_paste_person_copy( _clipBoard_, abf, person );
1522 addritem_person_set_opened( person, TRUE );
1526 /* Display items pasted */
1528 gtk_ctree_select( ctree, addrbook.opened );
1533 * Add current treenode object to clipboard. Note that widget only allows
1534 * one entry from the tree list to be selected.
1536 static void addressbook_treenode_to_clipboard( void ) {
1537 AddressObject *obj = NULL;
1538 AddressDataSource *ds = NULL;
1539 AddrSelectItem *item;
1540 GtkCTree *ctree = GTK_CTREE( addrbook.ctree );
1543 node = addrbook.treeSelected;
1544 if( node == NULL ) return;
1545 obj = gtk_ctree_node_get_row_data( ctree, node );
1546 if( obj == NULL ) return;
1548 ds = addressbook_find_datasource( node );
1549 if( ds == NULL ) return;
1552 if( obj->type == ADDR_ITEM_FOLDER ) {
1553 AdapterFolder *adapter = ADAPTER_FOLDER(obj);
1554 ItemFolder *folder = adapter->itemFolder;
1556 item = addrselect_create_node( obj );
1557 item->uid = g_strdup( ADDRITEM_ID(folder) );
1559 else if( obj->type == ADDR_ITEM_GROUP ) {
1560 AdapterGroup *adapter = ADAPTER_GROUP(obj);
1561 ItemGroup *group = adapter->itemGroup;
1563 item = addrselect_create_node( obj );
1564 item->uid = g_strdup( ADDRITEM_ID(group) );
1566 else if( obj->type == ADDR_DATASOURCE ) {
1568 item = addrselect_create_node( obj );
1573 /* Clear existing list and add item into list */
1576 addressbook_list_select_clear();
1577 cacheID = addrindex_get_cache_id( _addressIndex_, ds );
1578 addrselect_list_add( _addressSelect_, item, cacheID );
1584 * Cut from tree widget.
1586 static void addressbook_treenode_cut_cb( void ) {
1587 _clipBoard_->cutFlag = TRUE;
1588 addressbook_treenode_to_clipboard();
1589 addrclip_clear( _clipBoard_ );
1590 addrclip_add( _clipBoard_, _addressSelect_ );
1591 /* addrclip_list_show( _clipBoard_, stdout ); */
1595 * Copy from tree widget.
1597 static void addressbook_treenode_copy_cb( void ) {
1598 _clipBoard_->cutFlag = FALSE;
1599 addressbook_treenode_to_clipboard();
1600 addrclip_clear( _clipBoard_ );
1601 addrclip_add( _clipBoard_, _addressSelect_ );
1602 /* addrclip_list_show( _clipBoard_, stdout ); */
1606 * Paste clipboard into address tree widget.
1608 static void addressbook_treenode_paste_cb( void ) {
1609 addressbook_clip_paste_cb();
1612 static void addressbook_list_select_clear( void ) {
1613 addrselect_list_clear( _addressSelect_ );
1616 static void addressbook_list_select_add( AddrItemObject *aio, AddressDataSource *ds ) {
1619 if( ds == NULL ) return;
1620 cacheID = addrindex_get_cache_id( _addressIndex_, ds );
1621 addrselect_list_add_obj( _addressSelect_, aio, cacheID );
1625 static void addressbook_list_select_remove( AddrItemObject *aio ) {
1626 addrselect_list_remove( _addressSelect_, aio );
1629 static void addressbook_list_row_selected( GtkCTree *clist,
1634 GtkEntry *entry = GTK_ENTRY(addrbook.entry);
1635 AddrItemObject *aio = NULL;
1636 AddressObject *pobj = NULL;
1637 AdapterDSource *ads = NULL;
1638 AddressDataSource *ds = NULL;
1640 gtk_entry_set_text( entry, "" );
1641 addrbook.listSelected = node;
1643 pobj = gtk_ctree_node_get_row_data( GTK_CTREE(addrbook.ctree), addrbook.treeSelected );
1644 if( pobj == NULL ) return;
1646 if( pobj->type == ADDR_DATASOURCE ) {
1647 ads = ADAPTER_DSOURCE(pobj);
1648 ds = ads->dataSource;
1650 else if( pobj->type != ADDR_INTERFACE ) {
1651 ds = addressbook_find_datasource( addrbook.treeSelected );
1654 aio = gtk_ctree_node_get_row_data( clist, node );
1656 /* printf( "list select: %d : '%s'\n", aio->type, aio->name ); */
1657 addressbook_list_select_add( aio, ds );
1660 addressbook_list_menu_setup();
1663 static void addressbook_list_row_unselected( GtkCTree *ctree,
1668 AddrItemObject *aio;
1670 aio = gtk_ctree_node_get_row_data( ctree, node );
1672 /* printf( "list unselect: %d : '%s'\n", aio->type, aio->name ); */
1673 addressbook_list_select_remove( aio );
1677 static void addressbook_entry_gotfocus( GtkWidget *widget ) {
1678 gtk_editable_select_region( GTK_EDITABLE(addrbook.entry), 0, -1 );
1681 static void addressbook_list_button_pressed(GtkWidget *widget,
1682 GdkEventButton *event,
1685 if( ! event ) return;
1687 addressbook_list_menu_setup();
1689 if( event->button == 3 ) {
1690 gtk_menu_popup( GTK_MENU(addrbook.list_popup), NULL, NULL, NULL, NULL,
1691 event->button, event->time );
1695 static void addressbook_list_button_released(GtkWidget *widget,
1696 GdkEventButton *event,
1701 static void addressbook_tree_button_pressed(GtkWidget *ctree,
1702 GdkEventButton *event,
1705 GtkCList *clist = GTK_CLIST(ctree);
1707 AddressObject *obj = NULL;
1708 AdapterDSource *ads = NULL;
1709 AddressInterface *iface = NULL;
1710 AddressDataSource *ds = NULL;
1711 gboolean canEdit = FALSE;
1712 gboolean canCut = FALSE;
1713 gboolean canCopy = FALSE;
1714 gboolean canPaste = FALSE;
1715 gboolean canTreeCut = FALSE;
1716 gboolean canTreeCopy = FALSE;
1717 gboolean canTreePaste = FALSE;
1719 if( ! event ) return;
1720 addressbook_menubar_set_sensitive( FALSE );
1722 if( gtk_clist_get_selection_info( clist, event->x, event->y, &row, &column ) ) {
1723 gtk_clist_select_row( clist, row, column );
1724 gtkut_clist_set_focus_row(clist, row);
1725 obj = gtk_clist_get_row_data( clist, row );
1728 menu_set_insensitive_all(GTK_MENU_SHELL(addrbook.tree_popup));
1730 if( obj == NULL ) return;
1732 if( ! addrclip_is_empty( _clipBoard_ ) ) {
1733 canTreePaste = TRUE;
1736 if (obj->type == ADDR_DATASOURCE) {
1737 ads = ADAPTER_DSOURCE(obj);
1738 ds = ads->dataSource;
1739 iface = ds->interface;
1741 if( iface->readOnly ) {
1742 canTreePaste = FALSE;
1745 menu_set_sensitive( addrbook.tree_factory, "/New Address", TRUE );
1746 menu_set_sensitive( addrbook.tree_factory, "/New Folder", TRUE );
1747 menu_set_sensitive( addrbook.tree_factory, "/New Group", TRUE );
1748 gtk_widget_set_sensitive( addrbook.reg_btn, TRUE );
1752 else if (obj->type == ADDR_ITEM_FOLDER) {
1753 ds = addressbook_find_datasource( addrbook.treeSelected );
1754 iface = ds->interface;
1755 if( iface->readOnly ) {
1756 canTreePaste = FALSE;
1761 menu_set_sensitive( addrbook.tree_factory, "/New Address", TRUE );
1762 menu_set_sensitive( addrbook.tree_factory, "/New Folder", TRUE );
1763 menu_set_sensitive( addrbook.tree_factory, "/New Group", TRUE );
1764 gtk_widget_set_sensitive( addrbook.reg_btn, TRUE );
1768 else if (obj->type == ADDR_ITEM_GROUP) {
1769 ds = addressbook_find_datasource( addrbook.treeSelected );
1770 iface = ds->interface;
1771 if( ! iface->readOnly ) {
1773 menu_set_sensitive( addrbook.tree_factory, "/New Address", TRUE );
1774 gtk_widget_set_sensitive( addrbook.reg_btn, TRUE );
1777 else if (obj->type == ADDR_INTERFACE) {
1778 canTreePaste = FALSE;
1782 if( ! addrselect_test_empty( _addressSelect_ ) ) canCut = TRUE;
1784 if( ! addrselect_test_empty( _addressSelect_ ) ) canCopy = TRUE;
1785 if( ! addrclip_is_empty( _clipBoard_ ) ) canPaste = TRUE;
1788 menu_set_sensitive( addrbook.tree_factory, "/Edit", canEdit );
1789 menu_set_sensitive( addrbook.tree_factory, "/Delete", canEdit );
1790 menu_set_sensitive( addrbook.tree_factory, "/Cut", canTreeCut );
1791 menu_set_sensitive( addrbook.tree_factory, "/Copy", canTreeCopy );
1792 menu_set_sensitive( addrbook.tree_factory, "/Paste", canTreePaste );
1794 menu_set_sensitive( addrbook.menu_factory, "/File/Edit", canEdit );
1795 menu_set_sensitive( addrbook.menu_factory, "/File/Delete", canEdit );
1796 menu_set_sensitive( addrbook.menu_factory, "/Edit/Cut", canCut );
1797 menu_set_sensitive( addrbook.menu_factory, "/Edit/Copy", canCopy );
1798 menu_set_sensitive( addrbook.menu_factory, "/Edit/Paste", canPaste );
1799 menu_set_sensitive( addrbook.menu_factory, "/Edit/Paste Address", canPaste );
1801 if( event->button == 3 ) {
1802 gtk_menu_popup(GTK_MENU(addrbook.tree_popup), NULL, NULL, NULL, NULL,
1803 event->button, event->time);
1808 static void addressbook_tree_button_released(GtkWidget *ctree,
1809 GdkEventButton *event,
1812 gtk_ctree_select(GTK_CTREE(addrbook.ctree), addrbook.opened);
1813 gtkut_ctree_set_focus_row(GTK_CTREE(addrbook.ctree), addrbook.opened);
1816 static void addressbook_popup_close(GtkMenuShell *menu_shell, gpointer data)
1818 if (!addrbook.opened) return;
1820 gtk_ctree_select(GTK_CTREE(addrbook.ctree), addrbook.opened);
1821 gtkut_ctree_set_focus_row(GTK_CTREE(addrbook.ctree),
1825 static void addressbook_new_folder_cb(gpointer data, guint action,
1828 GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
1829 AddressObject *obj = NULL;
1830 AddressDataSource *ds = NULL;
1831 AddressBookFile *abf = NULL;
1832 ItemFolder *parentFolder = NULL;
1833 ItemFolder *folder = NULL;
1835 if( ! addrbook.treeSelected ) return;
1836 obj = gtk_ctree_node_get_row_data( ctree, addrbook.treeSelected );
1837 if( obj == NULL ) return;
1838 ds = addressbook_find_datasource( addrbook.treeSelected );
1839 if( ds == NULL ) return;
1841 if( obj->type == ADDR_DATASOURCE ) {
1842 if( ADAPTER_DSOURCE(obj)->subType != ADDR_BOOK ) return;
1844 else if( obj->type == ADDR_ITEM_FOLDER ) {
1845 parentFolder = ADAPTER_FOLDER(obj)->itemFolder;
1851 abf = ds->rawDataSource;
1852 if( abf == NULL ) return;
1853 folder = addressbook_edit_folder( abf, parentFolder, NULL );
1856 nn = addressbook_node_add_folder( addrbook.treeSelected, ds, folder, ADDR_ITEM_FOLDER );
1857 gtk_ctree_expand( ctree, addrbook.treeSelected );
1858 if( addrbook.treeSelected == addrbook.opened ) addressbook_set_clist(obj);
1863 static void addressbook_new_group_cb(gpointer data, guint action,
1866 GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
1867 AddressObject *obj = NULL;
1868 AddressDataSource *ds = NULL;
1869 AddressBookFile *abf = NULL;
1870 ItemFolder *parentFolder = NULL;
1871 ItemGroup *group = NULL;
1873 if( ! addrbook.treeSelected ) return;
1874 obj = gtk_ctree_node_get_row_data(ctree, addrbook.treeSelected);
1875 if( obj == NULL ) return;
1876 ds = addressbook_find_datasource( addrbook.treeSelected );
1877 if( ds == NULL ) return;
1879 if( obj->type == ADDR_DATASOURCE ) {
1880 if( ADAPTER_DSOURCE(obj)->subType != ADDR_BOOK ) return;
1882 else if( obj->type == ADDR_ITEM_FOLDER ) {
1883 parentFolder = ADAPTER_FOLDER(obj)->itemFolder;
1889 abf = ds->rawDataSource;
1890 if( abf == NULL ) return;
1891 group = addressbook_edit_group( abf, parentFolder, NULL );
1894 nn = addressbook_node_add_group( addrbook.treeSelected, ds, group );
1895 gtk_ctree_expand( ctree, addrbook.treeSelected );
1896 if( addrbook.treeSelected == addrbook.opened ) addressbook_set_clist(obj);
1901 static void addressbook_change_node_name(GtkCTreeNode *node, const gchar *name)
1903 GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
1906 GdkPixmap *pix_cl, *pix_op;
1907 GdkBitmap *mask_cl, *mask_op;
1908 gboolean is_leaf, expanded;
1910 gtk_ctree_get_node_info(ctree, node, text, &spacing,
1911 &pix_cl, &mask_cl, &pix_op, &mask_op,
1912 &is_leaf, &expanded);
1913 gtk_ctree_set_node_info(ctree, node, name, spacing,
1914 pix_cl, mask_cl, pix_op, mask_op,
1920 * Enter: obj Address object to edit.
1921 * node Node in tree.
1922 * Return: New name of data source.
1924 static gchar *addressbook_edit_datasource( AddressObject *obj, GtkCTreeNode *node ) {
1925 gchar *newName = NULL;
1926 AddressDataSource *ds = NULL;
1927 AddressInterface *iface = NULL;
1928 AdapterDSource *ads = NULL;
1930 ds = addressbook_find_datasource( node );
1931 if( ds == NULL ) return NULL;
1932 iface = ds->interface;
1933 if( ! iface->haveLibrary ) return NULL;
1935 /* Read data from data source */
1936 if( ! addrindex_ds_get_read_flag( ds ) ) {
1937 addrindex_ds_read_data( ds );
1941 ads = ADAPTER_DSOURCE(obj);
1942 if( ads->subType == ADDR_BOOK ) {
1943 if( addressbook_edit_book( _addressIndex_, ads ) == NULL ) return NULL;
1945 else if( ads->subType == ADDR_VCARD ) {
1946 if( addressbook_edit_vcard( _addressIndex_, ads ) == NULL ) return NULL;
1949 else if( ads->subType == ADDR_JPILOT ) {
1950 if( addressbook_edit_jpilot( _addressIndex_, ads ) == NULL ) return NULL;
1954 else if( ads->subType == ADDR_LDAP ) {
1955 if( addressbook_edit_ldap( _addressIndex_, ads ) == NULL ) return NULL;
1961 newName = obj->name;
1966 * Edit an object that is in the address tree area.
1968 static void addressbook_treenode_edit_cb(gpointer data, guint action,
1971 GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
1973 AddressDataSource *ds = NULL;
1974 AddressBookFile *abf = NULL;
1975 GtkCTreeNode *node = NULL, *parentNode = NULL;
1978 if( ! addrbook.treeSelected ) return;
1979 node = addrbook.treeSelected;
1980 if( GTK_CTREE_ROW(node)->level == 1 ) return;
1981 obj = gtk_ctree_node_get_row_data( ctree, node );
1982 if( obj == NULL ) return;
1983 parentNode = GTK_CTREE_ROW(node)->parent;
1985 ds = addressbook_find_datasource( node );
1986 if( ds == NULL ) return;
1988 if( obj->type == ADDR_DATASOURCE ) {
1989 name = addressbook_edit_datasource( obj, node );
1990 if( name == NULL ) return;
1993 abf = ds->rawDataSource;
1994 if( abf == NULL ) return;
1995 if( obj->type == ADDR_ITEM_FOLDER ) {
1996 AdapterFolder *adapter = ADAPTER_FOLDER(obj);
1997 ItemFolder *item = adapter->itemFolder;
1998 ItemFolder *parentFolder = NULL;
1999 parentFolder = ( ItemFolder * ) ADDRITEM_PARENT(item);
2000 if( addressbook_edit_folder( abf, parentFolder, item ) == NULL ) return;
2001 name = ADDRITEM_NAME(item);
2003 else if( obj->type == ADDR_ITEM_GROUP ) {
2004 AdapterGroup *adapter = ADAPTER_GROUP(obj);
2005 ItemGroup *item = adapter->itemGroup;
2006 ItemFolder *parentFolder = NULL;
2007 parentFolder = ( ItemFolder * ) ADDRITEM_PARENT(item);
2008 if( addressbook_edit_group( abf, parentFolder, item ) == NULL ) return;
2009 name = ADDRITEM_NAME(item);
2012 if( name && parentNode ) {
2013 /* Update node in tree view */
2014 addressbook_change_node_name( node, name );
2015 gtk_ctree_sort_node(ctree, parentNode);
2016 gtk_ctree_expand( ctree, node );
2017 gtk_ctree_select( ctree, node );
2022 * Delete an item from the tree widget.
2024 static void addressbook_treenode_delete_cb(gpointer data, guint action,
2027 GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
2028 GtkCTreeNode *node = NULL;
2032 AddressBookFile *abf = NULL;
2033 AdapterDSource *ads = NULL;
2034 AddressInterface *iface = NULL;
2035 AddressDataSource *ds = NULL;
2036 gboolean remFlag = FALSE;
2038 if( ! addrbook.treeSelected ) return;
2039 node = addrbook.treeSelected;
2040 if( GTK_CTREE_ROW(node)->level == 1 ) return;
2042 obj = gtk_ctree_node_get_row_data( ctree, node );
2043 g_return_if_fail(obj != NULL);
2045 if( obj->type == ADDR_DATASOURCE ) {
2046 ads = ADAPTER_DSOURCE(obj);
2047 if( ads == NULL ) return;
2048 ds = ads->dataSource;
2049 if( ds == NULL ) return;
2052 /* Must be folder or something else */
2053 ds = addressbook_find_datasource( node );
2054 if( ds == NULL ) return;
2056 /* Only allow deletion from non-readOnly data sources */
2057 iface = ds->interface;
2058 if( iface->readOnly ) return;
2061 /* Confirm deletion */
2062 if( obj->type == ADDR_ITEM_FOLDER ) {
2063 message = g_strdup_printf( _(
2064 "Do you want to delete the folder AND all addresses in `%s' ? \n" \
2065 "If deleting the folder only, addresses will be moved into parent folder." ),
2067 aval = alertpanel( _("Delete"), message,
2068 _("Folder only"), _("Folder and Addresses"), _("Cancel") );
2070 if( aval == G_ALERTOTHER ) return;
2073 message = g_strdup_printf(_("Really delete `%s' ?"), obj->name);
2074 aval = alertpanel(_("Delete"), message, _("Yes"), _("No"), NULL);
2076 if (aval != G_ALERTDEFAULT) return;
2079 /* Proceed with deletion */
2080 if( obj->type == ADDR_DATASOURCE ) {
2081 /* Remove data source. */
2082 if( addrindex_index_remove_datasource( _addressIndex_, ds ) ) {
2083 addrindex_free_datasource( ds );
2088 abf = addressbook_get_book_file();
2089 if( abf == NULL ) return;
2092 if( obj->type == ADDR_ITEM_FOLDER ) {
2093 AdapterFolder *adapter = ADAPTER_FOLDER(obj);
2094 ItemFolder *item = adapter->itemFolder;
2095 if( aval == G_ALERTDEFAULT ) {
2096 /* Remove folder only */
2097 item = addrbook_remove_folder( abf, item );
2099 addritem_free_item_folder( item );
2100 addressbook_move_nodes_up( ctree, node );
2104 else if( aval == G_ALERTALTERNATE ) {
2105 /* Remove folder and addresses */
2106 item = addrbook_remove_folder_delete( abf, item );
2108 addritem_free_item_folder( item );
2113 else if( obj->type == ADDR_ITEM_GROUP ) {
2114 AdapterGroup *adapter = ADAPTER_GROUP(obj);
2115 ItemGroup *item = adapter->itemGroup;
2117 item = addrbook_remove_group( abf, item );
2119 addritem_free_item_group( item );
2126 gtk_ctree_remove_node(ctree, node );
2130 static void addressbook_new_address_cb( gpointer data, guint action, GtkWidget *widget ) {
2131 AddressObject *pobj = NULL;
2132 AddressDataSource *ds = NULL;
2133 AddressBookFile *abf = NULL;
2135 pobj = gtk_ctree_node_get_row_data(GTK_CTREE(addrbook.ctree), addrbook.treeSelected);
2136 if( pobj == NULL ) return;
2137 ds = addressbook_find_datasource( GTK_CTREE_NODE(addrbook.treeSelected) );
2138 if( ds == NULL ) return;
2140 abf = ds->rawDataSource;
2141 if( abf == NULL ) return;
2143 if( pobj->type == ADDR_DATASOURCE ) {
2144 if( ADAPTER_DSOURCE(pobj)->subType == ADDR_BOOK ) {
2146 ItemPerson *person = addressbook_edit_person( abf, NULL, NULL, FALSE );
2148 if( addrbook.treeSelected == addrbook.opened ) {
2149 gtk_ctree_select( GTK_CTREE(addrbook.ctree), addrbook.opened );
2154 else if( pobj->type == ADDR_ITEM_FOLDER ) {
2156 ItemFolder *folder = ADAPTER_FOLDER(pobj)->itemFolder;
2157 ItemPerson *person = addressbook_edit_person( abf, folder, NULL, FALSE );
2159 if (addrbook.treeSelected == addrbook.opened) {
2160 gtk_ctree_select( GTK_CTREE(addrbook.ctree), addrbook.opened );
2164 else if( pobj->type == ADDR_ITEM_GROUP ) {
2165 /* New address in group */
2166 ItemGroup *group = ADAPTER_GROUP(pobj)->itemGroup;
2167 if( addressbook_edit_group( abf, NULL, group ) == NULL ) return;
2168 if (addrbook.treeSelected == addrbook.opened) {
2169 /* Change node name in tree. */
2170 addressbook_change_node_name( addrbook.treeSelected, ADDRITEM_NAME(group) );
2171 gtk_ctree_select( GTK_CTREE(addrbook.ctree), addrbook.opened );
2177 * Search for specified child group node in address index tree.
2178 * Enter: parent Parent node.
2179 * group Group to find.
2181 static GtkCTreeNode *addressbook_find_group_node( GtkCTreeNode *parent, ItemGroup *group ) {
2182 GtkCTreeNode *node = NULL;
2183 GtkCTreeRow *currRow;
2185 currRow = GTK_CTREE_ROW( parent );
2187 node = currRow->children;
2191 obj = gtk_ctree_node_get_row_data( GTK_CTREE(addrbook.ctree), node );
2192 if( obj->type == ADDR_ITEM_GROUP ) {
2193 ItemGroup *g = ADAPTER_GROUP(obj)->itemGroup;
2194 if( g == group ) return node;
2196 currRow = GTK_CTREE_ROW(node);
2197 node = currRow->sibling;
2204 * Search for specified child folder node in address index tree.
2205 * Enter: parent Parent node.
2206 * folder Folder to find.
2208 static GtkCTreeNode *addressbook_find_folder_node( GtkCTreeNode *parent, ItemFolder *folder ) {
2209 GtkCTreeNode *node = NULL;
2210 GtkCTreeRow *currRow;
2212 currRow = GTK_CTREE_ROW( parent );
2214 node = currRow->children;
2218 obj = gtk_ctree_node_get_row_data( GTK_CTREE(addrbook.ctree), node );
2219 if( obj->type == ADDR_ITEM_FOLDER ) {
2220 ItemFolder *f = ADAPTER_FOLDER(obj)->itemFolder;
2221 if( f == folder ) return node;
2223 currRow = GTK_CTREE_ROW(node);
2224 node = currRow->sibling;
2230 static AddressBookFile *addressbook_get_book_file() {
2231 AddressBookFile *abf = NULL;
2232 AddressDataSource *ds = NULL;
2234 ds = addressbook_find_datasource( addrbook.treeSelected );
2235 if( ds == NULL ) return NULL;
2236 if( ds->type == ADDR_IF_BOOK ) abf = ds->rawDataSource;
2240 static void addressbook_tree_remove_children( GtkCTree *ctree, GtkCTreeNode *parent ) {
2244 /* Remove existing folders and groups */
2245 row = GTK_CTREE_ROW( parent );
2247 while( (node = row->children) ) {
2248 gtk_ctree_remove_node( ctree, node );
2253 static void addressbook_move_nodes_up( GtkCTree *ctree, GtkCTreeNode *node ) {
2254 GtkCTreeNode *parent, *child;
2255 GtkCTreeRow *currRow;
2256 currRow = GTK_CTREE_ROW( node );
2258 parent = currRow->parent;
2259 while( (child = currRow->children) ) {
2260 gtk_ctree_move( ctree, child, parent, node );
2262 gtk_ctree_sort_node( ctree, parent );
2266 static void addressbook_edit_address_cb( gpointer data, guint action, GtkWidget *widget ) {
2267 GtkCTree *clist = GTK_CTREE(addrbook.clist);
2269 AddressObject *obj = NULL, *pobj = NULL;
2270 AddressDataSource *ds = NULL;
2271 GtkCTreeNode *node = NULL, *parentNode = NULL;
2273 AddressBookFile *abf = NULL;
2275 if( addrbook.listSelected == NULL ) return;
2276 obj = gtk_ctree_node_get_row_data( clist, addrbook.listSelected );
2277 g_return_if_fail(obj != NULL);
2279 ctree = GTK_CTREE( addrbook.ctree );
2280 pobj = gtk_ctree_node_get_row_data( ctree, addrbook.treeSelected );
2281 node = gtk_ctree_find_by_row_data( ctree, addrbook.treeSelected, obj );
2283 ds = addressbook_find_datasource( GTK_CTREE_NODE(addrbook.treeSelected) );
2284 if( ds == NULL ) return;
2286 abf = addressbook_get_book_file();
2287 if( abf == NULL ) return;
2288 if( obj->type == ADDR_ITEM_EMAIL ) {
2289 ItemEMail *email = ( ItemEMail * ) obj;
2290 if( email == NULL ) return;
2291 if( pobj && pobj->type == ADDR_ITEM_GROUP ) {
2292 /* Edit parent group */
2293 AdapterGroup *adapter = ADAPTER_GROUP(pobj);
2294 ItemGroup *itemGrp = adapter->itemGroup;
2295 if( addressbook_edit_group( abf, NULL, itemGrp ) == NULL ) return;
2296 name = ADDRITEM_NAME(itemGrp);
2297 node = addrbook.treeSelected;
2298 parentNode = GTK_CTREE_ROW(node)->parent;
2301 /* Edit person - email page */
2303 person = ( ItemPerson * ) ADDRITEM_PARENT(email);
2304 if( addressbook_edit_person( abf, NULL, person, TRUE ) == NULL ) return;
2305 gtk_ctree_select( ctree, addrbook.opened );
2306 invalidate_address_completion();
2310 else if( obj->type == ADDR_ITEM_PERSON ) {
2311 /* Edit person - basic page */
2312 ItemPerson *person = ( ItemPerson * ) obj;
2313 if( addressbook_edit_person( abf, NULL, person, FALSE ) == NULL ) return;
2314 gtk_ctree_select( ctree, addrbook.opened);
2315 invalidate_address_completion();
2318 else if( obj->type == ADDR_ITEM_GROUP ) {
2319 ItemGroup *itemGrp = ( ItemGroup * ) obj;
2320 if( addressbook_edit_group( abf, NULL, itemGrp ) == NULL ) return;
2321 parentNode = addrbook.treeSelected;
2322 node = addressbook_find_group_node( parentNode, itemGrp );
2323 name = ADDRITEM_NAME(itemGrp);
2329 /* Update tree node with node name */
2330 if( node == NULL ) return;
2331 addressbook_change_node_name( node, name );
2332 gtk_ctree_sort_node( ctree, parentNode );
2333 gtk_ctree_select( ctree, addrbook.opened );
2336 static void addressbook_delete_address_cb(gpointer data, guint action,
2339 addressbook_del_clicked(NULL, NULL);
2342 static void close_cb(gpointer data, guint action, GtkWidget *widget)
2344 addressbook_close();
2347 static void addressbook_file_save_cb( gpointer data, guint action, GtkWidget *widget ) {
2348 addressbook_export_to_file();
2351 static void addressbook_person_expand_node( GtkCTree *ctree, GList *node, gpointer *data ) {
2353 ItemPerson *person = gtk_ctree_node_get_row_data( ctree, GTK_CTREE_NODE(node) );
2354 if( person ) addritem_person_set_opened( person, TRUE );
2358 static void addressbook_person_collapse_node( GtkCTree *ctree, GList *node, gpointer *data ) {
2360 ItemPerson *person = gtk_ctree_node_get_row_data( ctree, GTK_CTREE_NODE(node) );
2361 if( person ) addritem_person_set_opened( person, FALSE );
2365 static gchar *addressbook_format_item_clist( ItemPerson *person, ItemEMail *email ) {
2367 gchar *eMailAlias = ADDRITEM_NAME(email);
2368 if( eMailAlias && *eMailAlias != '\0' ) {
2370 str = g_strdup_printf( "%s - %s", ADDRITEM_NAME(person), eMailAlias );
2373 str = g_strdup( eMailAlias );
2379 static void addressbook_load_group( GtkCTree *clist, ItemGroup *itemGroup ) {
2380 GList *items = itemGroup->listEMail;
2381 AddressTypeControlItem *atci = addrbookctl_lookup( ADDR_ITEM_EMAIL );
2382 for( ; items != NULL; items = g_list_next( items ) ) {
2383 GtkCTreeNode *nodeEMail = NULL;
2384 gchar *text[N_COLS];
2385 ItemEMail *email = items->data;
2389 if( ! email ) continue;
2391 person = ( ItemPerson * ) ADDRITEM_PARENT(email);
2392 str = addressbook_format_item_clist( person, email );
2394 text[COL_NAME] = str;
2397 text[COL_NAME] = ADDRITEM_NAME(person);
2399 text[COL_ADDRESS] = email->address;
2400 text[COL_REMARKS] = email->remarks;
2401 nodeEMail = gtk_ctree_insert_node(
2403 text, FOLDER_SPACING,
2404 atci->iconXpm, atci->maskXpm,
2405 atci->iconXpmOpen, atci->maskXpmOpen,
2407 gtk_ctree_node_set_row_data( clist, nodeEMail, email );
2413 static void addressbook_folder_load_person( GtkCTree *clist, ItemFolder *itemFolder ) {
2415 AddressTypeControlItem *atci = addrbookctl_lookup( ADDR_ITEM_PERSON );
2416 AddressTypeControlItem *atciMail = addrbookctl_lookup( ADDR_ITEM_EMAIL );
2418 if( atci == NULL ) return;
2419 if( atciMail == NULL ) return;
2421 /* Load email addresses */
2422 items = addritem_folder_get_person_list( itemFolder );
2423 for( ; items != NULL; items = g_list_next( items ) ) {
2424 GtkCTreeNode *nodePerson = NULL;
2425 GtkCTreeNode *nodeEMail = NULL;
2426 gchar *text[N_COLS];
2427 gboolean flgFirst = TRUE, haveAddr = FALSE;
2431 person = ( ItemPerson * ) items->data;
2432 if( person == NULL ) continue;
2434 text[COL_NAME] = NULL;
2435 node = person->listEMail;
2437 ItemEMail *email = node->data;
2438 gchar *eMailAddr = NULL;
2439 node = g_list_next( node );
2441 text[COL_ADDRESS] = email->address;
2442 text[COL_REMARKS] = email->remarks;
2443 eMailAddr = ADDRITEM_NAME(email);
2444 if( eMailAddr && *eMailAddr == '\0' ) eMailAddr = NULL;
2446 /* First email belongs with person */
2447 gchar *str = addressbook_format_item_clist( person, email );
2449 text[COL_NAME] = str;
2452 text[COL_NAME] = ADDRITEM_NAME(person);
2454 nodePerson = gtk_ctree_insert_node(
2456 text, FOLDER_SPACING,
2457 atci->iconXpm, atci->maskXpm,
2458 atci->iconXpmOpen, atci->maskXpmOpen,
2459 FALSE, person->isOpened );
2462 gtk_ctree_node_set_row_data(clist, nodePerson, person );
2465 /* Subsequent email is a child node of person */
2466 text[COL_NAME] = ADDRITEM_NAME(email);
2467 nodeEMail = gtk_ctree_insert_node(
2468 clist, nodePerson, NULL,
2469 text, FOLDER_SPACING,
2470 atciMail->iconXpm, atciMail->maskXpm,
2471 atciMail->iconXpmOpen, atciMail->maskXpmOpen,
2473 gtk_ctree_node_set_row_data(clist, nodeEMail, email );
2479 /* Have name without EMail */
2480 text[COL_NAME] = ADDRITEM_NAME(person);
2481 text[COL_ADDRESS] = NULL;
2482 text[COL_REMARKS] = NULL;
2483 nodePerson = gtk_ctree_insert_node(
2485 text, FOLDER_SPACING,
2486 atci->iconXpm, atci->maskXpm,
2487 atci->iconXpmOpen, atci->maskXpmOpen,
2488 FALSE, person->isOpened );
2489 gtk_ctree_node_set_row_data(clist, nodePerson, person );
2491 gtk_ctree_sort_node(GTK_CTREE(clist), NULL);
2493 /* Free up the list */
2494 mgu_clear_list( items );
2495 g_list_free( items );
2498 static void addressbook_folder_load_group( GtkCTree *clist, ItemFolder *itemFolder ) {
2500 AddressTypeControlItem *atci = addrbookctl_lookup( ADDR_ITEM_GROUP );
2502 /* Load any groups */
2503 if( ! atci ) return;
2504 items = addritem_folder_get_group_list( itemFolder );
2505 for( ; items != NULL; items = g_list_next( items ) ) {
2506 GtkCTreeNode *nodeGroup = NULL;
2507 gchar *text[N_COLS];
2508 ItemGroup *group = items->data;
2509 if( group == NULL ) continue;
2510 text[COL_NAME] = ADDRITEM_NAME(group);
2511 text[COL_ADDRESS] = NULL;
2512 text[COL_REMARKS] = NULL;
2513 nodeGroup = gtk_ctree_insert_node(clist, NULL, NULL,
2514 text, FOLDER_SPACING,
2515 atci->iconXpm, atci->maskXpm,
2516 atci->iconXpmOpen, atci->maskXpmOpen,
2518 gtk_ctree_node_set_row_data(clist, nodeGroup, group );
2519 gtk_ctree_sort_node(clist, NULL);
2521 /* Free up the list */
2522 mgu_clear_list( items );
2523 g_list_free( items );
2527 * Load data sources into list.
2529 static void addressbook_node_load_datasource( GtkCTree *clist, AddressObject *obj ) {
2530 AdapterInterface *adapter;
2531 AddressInterface *iface;
2532 AddressTypeControlItem *atci = NULL;
2533 GtkCTreeNode *newNode, *node;
2535 GtkCell *cell = NULL;
2536 gchar *text[N_COLS];
2538 adapter = ADAPTER_INTERFACE(obj);
2539 if( adapter == NULL ) return;
2540 iface = adapter->interface;
2541 atci = adapter->atci;
2542 if( atci == NULL ) return;
2544 /* Create nodes in list copying values for data sources in tree */
2545 row = GTK_CTREE_ROW( adapter->treeNode );
2547 node = row->children;
2551 data = gtk_ctree_node_get_row_data( clist, node );
2552 row = GTK_CTREE_ROW( node );
2553 cell = ( ( GtkCListRow * )row )->cell;
2554 text[COL_NAME] = cell->u.text;
2555 text[COL_ADDRESS] = NULL;
2556 text[COL_REMARKS] = NULL;
2557 newNode = gtk_ctree_insert_node( clist, NULL, NULL,
2558 text, FOLDER_SPACING,
2559 atci->iconXpm, atci->maskXpm,
2560 atci->iconXpmOpen, atci->maskXpmOpen,
2563 gtk_ctree_node_set_row_data( clist, newNode, data );
2564 gtk_ctree_node_set_row_data_full( clist, newNode, NULL, NULL );
2566 node = row->sibling;
2569 gtk_ctree_sort_node( clist, NULL );
2573 * Search ctree widget callback function.
2574 * Enter: pA Pointer to node.
2575 * pB Pointer to data item being sought.
2576 * Return: Zero (0) if group found.
2578 static int addressbook_treenode_find_group_cb( gconstpointer pA, gconstpointer pB ) {
2581 aoA = ( AddressObject * ) pA;
2582 if( aoA->type == ADDR_ITEM_GROUP ) {
2583 ItemGroup *group, *grp;
2585 grp = ADAPTER_GROUP(aoA)->itemGroup;
2586 group = ( ItemGroup * ) pB;
2587 if( grp == group ) return 0; /* Found group */
2593 * Search ctree widget callback function.
2594 * Enter: pA Pointer to node.
2595 * pB Pointer to data item being sought.
2596 * Return: Zero (0) if folder found.
2598 static int addressbook_treenode_find_folder_cb( gconstpointer pA, gconstpointer pB ) {
2601 aoA = ( AddressObject * ) pA;
2602 if( aoA->type == ADDR_ITEM_FOLDER ) {
2603 ItemFolder *folder, *fld;
2605 fld = ADAPTER_FOLDER(aoA)->itemFolder;
2606 folder = ( ItemFolder * ) pB;
2607 if( fld == folder ) return 0; /* Found folder */
2613 * Remove folder and group nodes from tree widget for items contained ("cut")
2616 static void addressbook_treenode_remove_item( void ) {
2618 AddrSelectItem *cutItem;
2619 AddressCache *cache;
2620 AddrItemObject *aio;
2621 GtkCTree *ctree = GTK_CTREE( addrbook.ctree );
2624 node = _clipBoard_->objectList;
2626 cutItem = node->data;
2627 node = g_list_next( node );
2628 cache = addrindex_get_cache(
2629 _clipBoard_->addressIndex, cutItem->cacheID );
2630 if( cache == NULL ) continue;
2631 aio = addrcache_get_object( cache, cutItem->uid );
2634 if( ADDRITEM_TYPE(aio) == ITEMTYPE_FOLDER ) {
2637 folder = ( ItemFolder * ) aio;
2638 tn = gtk_ctree_find_by_row_data_custom(
2639 ctree, NULL, folder,
2640 addressbook_treenode_find_folder_cb );
2642 else if( ADDRITEM_TYPE(aio) == ITEMTYPE_GROUP ) {
2645 group = ( ItemGroup * ) aio;
2646 tn = gtk_ctree_find_by_row_data_custom(
2648 addressbook_treenode_find_group_cb );
2652 /* Free up adapter and remove node. */
2653 gtk_ctree_remove_node( ctree, tn );
2660 * Find parent datasource for specified tree node.
2661 * Enter: node Node to test.
2662 * Return: Data source, or NULL if not found.
2664 static AddressDataSource *addressbook_find_datasource( GtkCTreeNode *node ) {
2665 AddressDataSource *ds = NULL;
2668 g_return_val_if_fail(addrbook.ctree != NULL, NULL);
2671 if( GTK_CTREE_ROW(node)->level < 2 ) return NULL;
2672 ao = gtk_ctree_node_get_row_data( GTK_CTREE(addrbook.ctree), node );
2674 /* printf( "ao->type = %d\n", ao->type ); */
2675 if( ao->type == ADDR_DATASOURCE ) {
2676 AdapterDSource *ads = ADAPTER_DSOURCE(ao);
2677 /* printf( "found it\n" ); */
2678 ds = ads->dataSource;
2682 node = GTK_CTREE_ROW(node)->parent;
2688 * Load address list widget with children of specified object.
2689 * Enter: obj Parent object to be loaded.
2691 static void addressbook_set_clist( AddressObject *obj ) {
2692 GtkCTree *ctreelist = GTK_CTREE(addrbook.clist);
2693 GtkCList *clist = GTK_CLIST(addrbook.clist);
2694 AddressDataSource *ds = NULL;
2695 AdapterDSource *ads = NULL;
2698 gtk_clist_clear(clist);
2702 if( obj->type == ADDR_INTERFACE ) {
2703 /* printf( "set_clist: loading datasource...\n" ); */
2704 /* addressbook_node_load_datasource( GTK_CTREE(clist), obj ); */
2708 gtk_clist_freeze(clist);
2709 gtk_clist_clear(clist);
2711 if( obj->type == ADDR_DATASOURCE ) {
2712 ads = ADAPTER_DSOURCE(obj);
2713 ds = ADAPTER_DSOURCE(obj)->dataSource;
2715 /* Load root folder */
2716 ItemFolder *rootFolder = NULL;
2717 rootFolder = addrindex_ds_get_root_folder( ds );
2718 addressbook_folder_load_person( ctreelist, addrindex_ds_get_root_folder( ds ) );
2719 addressbook_folder_load_group( ctreelist, addrindex_ds_get_root_folder( ds ) );
2723 if( obj->type == ADDR_ITEM_GROUP ) {
2725 ItemGroup *itemGroup = ADAPTER_GROUP(obj)->itemGroup;
2726 addressbook_load_group( ctreelist, itemGroup );
2728 else if( obj->type == ADDR_ITEM_FOLDER ) {
2730 ItemFolder *itemFolder = ADAPTER_FOLDER(obj)->itemFolder;
2731 addressbook_folder_load_person( ctreelist, itemFolder );
2732 addressbook_folder_load_group( ctreelist, itemFolder );
2735 /* gtk_clist_sort(clist); */
2736 gtk_clist_thaw(clist);
2740 * Call back function to free adaptor. Call back is setup by function
2741 * gtk_ctree_node_set_row_data_full() when node is populated. This function is
2742 * called when the address book tree widget node is removed by calling
2743 * function gtk_ctree_remove_node().
2744 * Enter: data Tree node's row data.
2746 static void addressbook_free_treenode( gpointer data ) {
2749 ao = ( AddressObject * ) data;
2750 if( ao == NULL ) return;
2751 if( ao->type == ADDR_INTERFACE ) {
2752 AdapterInterface *ai = ADAPTER_INTERFACE(ao);
2753 addrbookctl_free_interface( ai );
2755 else if( ao->type == ADDR_DATASOURCE ) {
2756 AdapterDSource *ads = ADAPTER_DSOURCE(ao);
2757 addrbookctl_free_datasource( ads );
2759 else if( ao->type == ADDR_ITEM_FOLDER ) {
2760 AdapterFolder *af = ADAPTER_FOLDER(ao);
2761 addrbookctl_free_folder( af );
2763 else if( ao->type == ADDR_ITEM_GROUP ) {
2764 AdapterGroup *ag = ADAPTER_GROUP(ao);
2765 addrbookctl_free_group( ag );
2770 * Create new adaptor for specified data source.
2772 AdapterDSource *addressbook_create_ds_adapter( AddressDataSource *ds,
2773 AddressObjectType otype, gchar *name )
2775 AdapterDSource *adapter = g_new0( AdapterDSource, 1 );
2776 ADDRESS_OBJECT(adapter)->type = ADDR_DATASOURCE;
2777 ADDRESS_OBJECT_NAME(adapter) = g_strdup( name );
2778 adapter->dataSource = ds;
2779 adapter->subType = otype;
2783 void addressbook_ads_set_name( AdapterDSource *adapter, gchar *value ) {
2784 ADDRESS_OBJECT_NAME(adapter) = mgu_replace_string( ADDRESS_OBJECT_NAME(adapter), value );
2788 * Load tree from address index with the initial data.
2790 static void addressbook_load_tree( void ) {
2791 GtkCTree *ctree = GTK_CTREE( addrbook.ctree );
2792 GList *nodeIf, *nodeDS;
2793 AdapterInterface *adapter;
2794 AddressInterface *iface;
2795 AddressTypeControlItem *atci;
2796 AddressDataSource *ds;
2797 AdapterDSource *ads;
2798 GtkCTreeNode *node, *newNode;
2801 nodeIf = _addressInterfaceList_;
2803 adapter = nodeIf->data;
2804 node = adapter->treeNode;
2805 iface = adapter->interface;
2806 atci = adapter->atci;
2808 if( iface->useInterface ) {
2809 /* Load data sources below interface node */
2810 nodeDS = iface->listSource;
2814 name = addrindex_ds_get_name( ds );
2815 ads = addressbook_create_ds_adapter( ds, atci->objectType, name );
2816 newNode = addressbook_add_object( node, ADDRESS_OBJECT(ads) );
2817 nodeDS = g_list_next( nodeDS );
2819 gtk_ctree_expand( ctree, node );
2822 nodeIf = g_list_next( nodeIf );
2827 * Convert the old address book to new format.
2829 static gboolean addressbook_convert( AddressIndex *addrIndex ) {
2830 gboolean retVal = FALSE;
2831 gboolean errFlag = TRUE;
2834 /* Read old address book, performing conversion */
2835 debug_print( "Reading and converting old address book...\n" );
2836 addrindex_set_file_name( addrIndex, ADDRESSBOOK_OLD_FILE );
2837 addrindex_read_data( addrIndex );
2838 if( addrIndex->retVal == MGU_NO_FILE ) {
2839 /* We do not have a file - new user */
2840 debug_print( "New user... create new books...\n" );
2841 addrindex_create_new_books( addrIndex );
2842 if( addrIndex->retVal == MGU_SUCCESS ) {
2843 /* Save index file */
2844 addrindex_set_file_name( addrIndex, ADDRESSBOOK_INDEX_FILE );
2845 addrindex_save_data( addrIndex );
2846 if( addrIndex->retVal == MGU_SUCCESS ) {
2851 msg = _( "New user, could not save index file." );
2855 msg = _( "New user, could not save address book files." );
2859 /* We have an old file */
2860 if( addrIndex->wasConverted ) {
2861 /* Converted successfully - save address index */
2862 addrindex_set_file_name( addrIndex, ADDRESSBOOK_INDEX_FILE );
2863 addrindex_save_data( addrIndex );
2864 if( addrIndex->retVal == MGU_SUCCESS ) {
2865 msg = _( "Old address book converted successfully." );
2870 msg = _("Old address book converted,\n"
2871 "could not save new address index file" );
2875 /* File conversion failed - just create new books */
2876 debug_print( "File conversion failed... just create new books...\n" );
2877 addrindex_create_new_books( addrIndex );
2878 if( addrIndex->retVal == MGU_SUCCESS ) {
2880 addrindex_set_file_name( addrIndex, ADDRESSBOOK_INDEX_FILE );
2881 addrindex_save_data( addrIndex );
2882 if( addrIndex->retVal == MGU_SUCCESS ) {
2883 msg = _("Could not convert address book,\n"
2884 "but created empty new address book files." );
2889 msg = _("Could not convert address book,\n"
2890 "could not create new address book files." );
2894 msg = _("Could not convert address book\n"
2895 "and could not create new address book files." );
2900 debug_print( "Error\n%s\n", msg );
2901 alertpanel( _( "Addressbook conversion error" ), msg, _( "Close" ), NULL, NULL );
2904 debug_print( "Warning\n%s\n", msg );
2905 alertpanel( _( "Addressbook conversion" ), msg, _( "Close" ), NULL, NULL );
2911 void addressbook_read_file( void ) {
2912 AddressIndex *addrIndex = NULL;
2914 debug_print( "Reading address index...\n" );
2915 if( _addressIndex_ ) {
2916 debug_print( "address book already read!!!\n" );
2920 addrIndex = addrindex_create_index();
2922 /* Use new address book index. */
2923 addrindex_set_file_path( addrIndex, get_rc_dir() );
2924 addrindex_set_file_name( addrIndex, ADDRESSBOOK_INDEX_FILE );
2925 addrindex_read_data( addrIndex );
2926 if( addrIndex->retVal == MGU_NO_FILE ) {
2927 /* Conversion required */
2928 debug_print( "Converting...\n" );
2929 if( addressbook_convert( addrIndex ) ) {
2930 _addressIndex_ = addrIndex;
2933 else if( addrIndex->retVal == MGU_SUCCESS ) {
2934 _addressIndex_ = addrIndex;
2937 /* Error reading address book */
2938 debug_print( "Could not read address index.\n" );
2939 addrindex_print_index( addrIndex, stdout );
2940 alertpanel( _( "Addressbook Error" ),
2941 _( "Could not read address index" ),
2942 _( "Close" ), NULL, NULL );
2944 debug_print( "done.\n" );
2948 * Add object into the address index tree widget.
2949 * Enter: node Parent node.
2950 * obj Object to add.
2951 * Return: Node that was added, or NULL if object not added.
2953 static GtkCTreeNode *addressbook_add_object(GtkCTreeNode *node,
2956 GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
2957 GtkCTreeNode *added;
2958 AddressObject *pobj;
2959 AddressObjectType otype;
2960 AddressTypeControlItem *atci = NULL;
2962 g_return_val_if_fail(node != NULL, NULL);
2963 g_return_val_if_fail(obj != NULL, NULL);
2965 pobj = gtk_ctree_node_get_row_data(ctree, node);
2966 g_return_val_if_fail(pobj != NULL, NULL);
2968 /* Determine object type to be displayed */
2969 if( obj->type == ADDR_DATASOURCE ) {
2970 otype = ADAPTER_DSOURCE(obj)->subType;
2976 /* Handle any special conditions. */
2978 atci = addrbookctl_lookup( otype );
2980 if( atci->showInTree ) {
2981 /* Add object to tree */
2984 added = gtk_ctree_insert_node( ctree, node, NULL, name, FOLDER_SPACING,
2985 atci->iconXpm, atci->maskXpm, atci->iconXpmOpen, atci->maskXpmOpen,
2986 atci->treeLeaf, atci->treeExpand );
2987 gtk_ctree_node_set_row_data_full( ctree, added, obj,
2988 addressbook_free_treenode );
2992 gtk_ctree_sort_node(ctree, node);
2998 * Add group into the address index tree.
2999 * Enter: node Parent node.
3001 * itemGroup Group to add.
3002 * Return: Inserted node.
3004 static GtkCTreeNode *addressbook_node_add_group( GtkCTreeNode *node, AddressDataSource *ds, ItemGroup *itemGroup ) {
3005 GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
3006 GtkCTreeNode *newNode;
3007 AdapterGroup *adapter;
3008 AddressTypeControlItem *atci = NULL;
3011 if( ds == NULL ) return NULL;
3012 if( node == NULL || itemGroup == NULL ) return NULL;
3014 name = &itemGroup->obj.name;
3016 atci = addrbookctl_lookup( ADDR_ITEM_GROUP );
3018 adapter = g_new0( AdapterGroup, 1 );
3019 ADDRESS_OBJECT_TYPE(adapter) = ADDR_ITEM_GROUP;
3020 ADDRESS_OBJECT_NAME(adapter) = g_strdup( ADDRITEM_NAME(itemGroup) );
3021 adapter->itemGroup = itemGroup;
3023 newNode = gtk_ctree_insert_node( ctree, node, NULL, name, FOLDER_SPACING,
3024 atci->iconXpm, atci->maskXpm, atci->iconXpm, atci->maskXpm,
3025 atci->treeLeaf, atci->treeExpand );
3026 gtk_ctree_node_set_row_data_full( ctree, newNode, adapter,
3027 addressbook_free_treenode );
3028 gtk_ctree_sort_node( ctree, node );
3033 * Add folder into the address index tree.
3034 * Enter: node Parent node.
3036 * itemFolder Folder to add.
3037 * otype Object type to display.
3038 * Return: Inserted node.
3040 static GtkCTreeNode *addressbook_node_add_folder(
3041 GtkCTreeNode *node, AddressDataSource *ds, ItemFolder *itemFolder, AddressObjectType otype )
3043 GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
3044 GtkCTreeNode *newNode = NULL;
3045 AdapterFolder *adapter;
3046 AddressTypeControlItem *atci = NULL;
3047 GList *listItems = NULL;
3049 ItemFolder *rootFolder;
3051 if( ds == NULL ) return NULL;
3052 if( node == NULL || itemFolder == NULL ) return NULL;
3054 /* Determine object type */
3055 atci = addrbookctl_lookup( otype );
3056 if( atci == NULL ) return NULL;
3058 rootFolder = addrindex_ds_get_root_folder( ds );
3059 if( itemFolder == rootFolder ) {
3063 name = &itemFolder->obj.name;
3065 adapter = g_new0( AdapterFolder, 1 );
3066 ADDRESS_OBJECT_TYPE(adapter) = ADDR_ITEM_FOLDER;
3067 ADDRESS_OBJECT_NAME(adapter) = g_strdup( ADDRITEM_NAME(itemFolder) );
3068 adapter->itemFolder = itemFolder;
3070 newNode = gtk_ctree_insert_node( ctree, node, NULL, name, FOLDER_SPACING,
3071 atci->iconXpm, atci->maskXpm, atci->iconXpm, atci->maskXpm,
3072 atci->treeLeaf, atci->treeExpand );
3073 gtk_ctree_node_set_row_data_full( ctree, newNode, adapter,
3074 addressbook_free_treenode );
3077 listItems = itemFolder->listFolder;
3078 while( listItems ) {
3079 ItemFolder *item = listItems->data;
3080 addressbook_node_add_folder( newNode, ds, item, otype );
3081 listItems = g_list_next( listItems );
3083 listItems = itemFolder->listGroup;
3084 while( listItems ) {
3085 ItemGroup *item = listItems->data;
3086 addressbook_node_add_group( newNode, ds, item );
3087 listItems = g_list_next( listItems );
3089 gtk_ctree_sort_node( ctree, node );
3093 static void addressbook_delete_object(AddressObject *obj) {
3094 AdapterDSource *ads = NULL;
3095 AddressDataSource *ds = NULL;
3098 /* Remove data source. */
3099 /* printf( "Delete obj type : %d\n", obj->type ); */
3101 ads = ADAPTER_DSOURCE(obj);
3102 if( ads == NULL ) return;
3103 ds = ads->dataSource;
3104 if( ds == NULL ) return;
3106 /* Remove data source */
3107 if( addrindex_index_remove_datasource( _addressIndex_, ds ) ) {
3108 addrindex_free_datasource( ds );
3110 /* Free up Adapter object */
3114 void addressbook_export_to_file( void ) {
3115 if( _addressIndex_ ) {
3116 /* Save all new address book data */
3117 debug_print( "Saving address books...\n" );
3118 addrindex_save_all_books( _addressIndex_ );
3120 debug_print( "Exporting addressbook to file...\n" );
3121 addrindex_save_data( _addressIndex_ );
3122 if( _addressIndex_->retVal != MGU_SUCCESS ) {
3123 addrindex_print_index( _addressIndex_, stdout );
3126 /* Notify address completion of new data */
3127 invalidate_address_completion();
3131 static void key_pressed(GtkWidget *widget, GdkEventKey *event, gpointer data)
3133 if (event && event->keyval == GDK_Escape)
3134 addressbook_close();
3138 * Comparison using cell contents (text in first column). Used for sort
3139 * address index widget.
3141 static gint addressbook_treenode_compare_func(
3142 GtkCList *clist, gconstpointer ptr1, gconstpointer ptr2 )
3144 GtkCell *cell1 = ((GtkCListRow *)ptr1)->cell;
3145 GtkCell *cell2 = ((GtkCListRow *)ptr2)->cell;
3146 gchar *name1 = NULL, *name2 = NULL;
3147 if( cell1 ) name1 = cell1->u.text;
3148 if( cell2 ) name2 = cell2->u.text;
3149 if( ! name1 ) return ( name2 != NULL );
3150 if( ! name2 ) return -1;
3151 return strcasecmp( name1, name2 );
3155 * Comparison using object names and types.
3157 static gint addressbook_list_compare_func(
3158 GtkCList *clist, gconstpointer ptr1, gconstpointer ptr2 )
3160 AddrItemObject *aio1 = ((GtkCListRow *)ptr1)->data;
3161 AddrItemObject *aio2 = ((GtkCListRow *)ptr2)->data;
3162 gchar *name1 = NULL, *name2 = NULL;
3164 /* Order by cell contents */
3165 name1 = ADDRITEM_NAME( aio1 );
3166 name2 = ADDRITEM_NAME( aio2 );
3168 if( aio1->type == aio2->type ) {
3170 if( ! name1 ) return ( name2 != NULL );
3171 if( ! name2 ) return -1;
3172 return strcasecmp( name1, name2 );
3175 /* Order groups before person */
3176 if( aio1->type == ITEMTYPE_GROUP ) {
3179 else if( aio2->type == ITEMTYPE_GROUP ) {
3186 static void addressbook_new_book_cb( gpointer data, guint action, GtkWidget *widget ) {
3187 AdapterDSource *ads;
3188 AdapterInterface *adapter;
3189 GtkCTreeNode *newNode;
3191 adapter = addrbookctl_find_interface( ADDR_IF_BOOK );
3192 if( adapter == NULL ) return;
3193 ads = addressbook_edit_book( _addressIndex_, NULL );
3195 newNode = addressbook_add_object( adapter->treeNode, ADDRESS_OBJECT(ads) );
3197 gtk_ctree_select( GTK_CTREE(addrbook.ctree), newNode );
3198 addrbook.treeSelected = newNode;
3203 static void addressbook_new_vcard_cb( gpointer data, guint action, GtkWidget *widget ) {
3204 AdapterDSource *ads;
3205 AdapterInterface *adapter;
3206 GtkCTreeNode *newNode;
3208 adapter = addrbookctl_find_interface( ADDR_IF_VCARD );
3209 if( adapter == NULL ) return;
3210 ads = addressbook_edit_vcard( _addressIndex_, NULL );
3212 newNode = addressbook_add_object( adapter->treeNode, ADDRESS_OBJECT(ads) );
3214 gtk_ctree_select( GTK_CTREE(addrbook.ctree), newNode );
3215 addrbook.treeSelected = newNode;
3221 static void addressbook_new_jpilot_cb( gpointer data, guint action, GtkWidget *widget ) {
3222 AdapterDSource *ads;
3223 AdapterInterface *adapter;
3224 AddressInterface *iface;
3225 GtkCTreeNode *newNode;
3227 adapter = addrbookctl_find_interface( ADDR_IF_JPILOT );
3228 if( adapter == NULL ) return;
3229 iface = adapter->interface;
3230 if( ! iface->haveLibrary ) return;
3231 ads = addressbook_edit_jpilot( _addressIndex_, NULL );
3233 newNode = addressbook_add_object( adapter->treeNode, ADDRESS_OBJECT(ads) );
3235 gtk_ctree_select( GTK_CTREE(addrbook.ctree), newNode );
3236 addrbook.treeSelected = newNode;
3243 static void addressbook_new_ldap_cb( gpointer data, guint action, GtkWidget *widget ) {
3244 AdapterDSource *ads;
3245 AdapterInterface *adapter;
3246 AddressInterface *iface;
3247 GtkCTreeNode *newNode;
3249 adapter = addrbookctl_find_interface( ADDR_IF_LDAP );
3250 if( adapter == NULL ) return;
3251 iface = adapter->interface;
3252 if( ! iface->haveLibrary ) return;
3253 ads = addressbook_edit_ldap( _addressIndex_, NULL );
3255 newNode = addressbook_add_object( adapter->treeNode, ADDRESS_OBJECT(ads) );
3257 gtk_ctree_select( GTK_CTREE(addrbook.ctree), newNode );
3258 addrbook.treeSelected = newNode;
3263 static void addressbook_ldap_show_message( SyldapServer *svr ) {
3265 *addressbook_msgbuf = '\0';
3267 name = syldap_get_name( svr );
3268 if( svr->busyFlag ) {
3269 sprintf( addressbook_msgbuf, "%s: %s", name, ADDRESSBOOK_LDAP_BUSYMSG );
3272 if( svr->retVal == MGU_SUCCESS ) {
3273 sprintf( addressbook_msgbuf, "%s", name );
3276 sprintf( addressbook_msgbuf, "%s: %s", name, mgu_error2string( svr->retVal ) );
3280 addressbook_status_show( addressbook_msgbuf );
3283 static void ldapsearch_callback( SyldapServer *sls ) {
3284 GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
3286 AdapterDSource *ads = NULL;
3287 AddressDataSource *ds = NULL;
3288 AddressInterface *iface = NULL;
3290 if( sls == NULL ) return;
3291 if( ! addrbook.treeSelected ) return;
3292 if( GTK_CTREE_ROW( addrbook.treeSelected )->level == 1 ) return;
3294 obj = gtk_ctree_node_get_row_data( ctree, addrbook.treeSelected );
3295 if( obj == NULL ) return;
3296 if( obj->type == ADDR_DATASOURCE ) {
3297 ads = ADAPTER_DSOURCE(obj);
3298 if( ads->subType == ADDR_LDAP ) {
3299 SyldapServer *server;
3301 ds = ads->dataSource;
3302 if( ds == NULL ) return;
3303 iface = ds->interface;
3304 if( ! iface->haveLibrary ) return;
3305 server = ds->rawDataSource;
3306 if( server == sls ) {
3307 /* Read from cache */
3308 gtk_widget_show_all(addrbook.window);
3309 addressbook_set_clist( obj );
3310 addressbook_ldap_show_message( sls );
3311 gtk_widget_show_all(addrbook.window);
3312 gtk_entry_set_text( GTK_ENTRY(addrbook.entry), "" );
3320 * Lookup button handler.
3322 static void addressbook_lup_clicked( GtkButton *button, gpointer data ) {
3323 GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
3326 AdapterDSource *ads = NULL;
3327 AddressDataSource *ds = NULL;
3328 AddressInterface *iface = NULL;
3332 sLookup = gtk_editable_get_chars( GTK_EDITABLE(addrbook.entry), 0, -1 );
3333 g_strchomp( sLookup );
3335 if( ! addrbook.treeSelected ) return;
3336 if( GTK_CTREE_ROW( addrbook.treeSelected )->level == 1 ) return;
3338 obj = gtk_ctree_node_get_row_data( ctree, addrbook.treeSelected );
3339 if( obj == NULL ) return;
3342 if( obj->type == ADDR_DATASOURCE ) {
3343 ads = ADAPTER_DSOURCE(obj);
3344 if( ads->subType == ADDR_LDAP ) {
3345 SyldapServer *server;
3347 ds = ads->dataSource;
3348 if( ds == NULL ) return;
3349 iface = ds->interface;
3350 if( ! iface->haveLibrary ) return;
3351 server = ds->rawDataSource;
3353 syldap_cancel_read( server );
3354 if( *sLookup == '\0' || strlen( sLookup ) < 1 ) return;
3355 syldap_set_search_value( server, sLookup );
3356 syldap_set_callback( server, ldapsearch_callback );
3357 syldap_read_data_th( server );
3358 addressbook_ldap_show_message( server );
3366 /* **********************************************************************
3367 * Build lookup tables.
3368 * ***********************************************************************
3372 * Remap object types.
3373 * Enter: abType AddressObjectType (used in tree node).
3374 * Return: ItemObjectType (used in address cache data).
3376 ItemObjectType addressbook_type2item( AddressObjectType abType ) {
3377 ItemObjectType ioType;
3379 ioType = ITEMTYPE_NONE;
3381 case ADDR_ITEM_PERSON: ioType = ITEMTYPE_PERSON; break;
3382 case ADDR_ITEM_EMAIL: ioType = ITEMTYPE_EMAIL; break;
3383 case ADDR_ITEM_FOLDER: ioType = ITEMTYPE_FOLDER; break;
3384 case ADDR_ITEM_GROUP: ioType = ITEMTYPE_GROUP; break;
3385 case ADDR_DATASOURCE: ioType = ITEMTYPE_DATASOURCE; break;
3391 * Build table that controls the rendering of object types.
3393 void addrbookctl_build_map( GtkWidget *window ) {
3394 AddressTypeControlItem *atci;
3397 stock_pixmap_gdk(window, STOCK_PIXMAP_DIR_CLOSE, &folderxpm, &folderxpmmask);
3398 stock_pixmap_gdk(window, STOCK_PIXMAP_DIR_OPEN, &folderopenxpm, &folderopenxpmmask);
3399 stock_pixmap_gdk(window, STOCK_PIXMAP_GROUP, &groupxpm, &groupxpmmask);
3400 stock_pixmap_gdk(window, STOCK_PIXMAP_VCARD, &vcardxpm, &vcardxpmmask);
3401 stock_pixmap_gdk(window, STOCK_PIXMAP_BOOK, &bookxpm, &bookxpmmask);
3402 stock_pixmap_gdk(window, STOCK_PIXMAP_ADDRESS, &addressxpm, &addressxpmmask);
3403 stock_pixmap_gdk(window, STOCK_PIXMAP_JPILOT, &jpilotxpm, &jpilotxpmmask);
3404 stock_pixmap_gdk(window, STOCK_PIXMAP_CATEGORY, &categoryxpm, &categoryxpmmask);
3405 stock_pixmap_gdk(window, STOCK_PIXMAP_LDAP, &ldapxpm, &ldapxpmmask);
3407 _addressBookTypeHash_ = g_hash_table_new( g_int_hash, g_int_equal );
3408 _addressBookTypeList_ = NULL;
3411 atci = g_new0( AddressTypeControlItem, 1 );
3412 atci->objectType = ADDR_INTERFACE;
3413 atci->interfaceType = ADDR_IF_NONE;
3414 atci->showInTree = TRUE;
3415 atci->treeExpand = TRUE;
3416 atci->treeLeaf = FALSE;
3417 atci->displayName = _( "Interface" );
3418 atci->iconXpm = folderxpm;
3419 atci->maskXpm = folderxpmmask;
3420 atci->iconXpmOpen = folderopenxpm;
3421 atci->maskXpmOpen = folderopenxpmmask;
3422 atci->menuCommand = NULL;
3423 g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3424 _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3427 atci = g_new0( AddressTypeControlItem, 1 );
3428 atci->objectType = ADDR_BOOK;
3429 atci->interfaceType = ADDR_IF_BOOK;
3430 atci->showInTree = TRUE;
3431 atci->treeExpand = TRUE;
3432 atci->treeLeaf = FALSE;
3433 atci->displayName = _( "Address Book" );
3434 atci->iconXpm = bookxpm;
3435 atci->maskXpm = bookxpmmask;
3436 atci->iconXpmOpen = bookxpm;
3437 atci->maskXpmOpen = bookxpmmask;
3438 atci->menuCommand = "/File/New Book";
3439 g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3440 _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3443 atci = g_new0( AddressTypeControlItem, 1 );
3444 atci->objectType = ADDR_ITEM_PERSON;
3445 atci->interfaceType = ADDR_IF_NONE;
3446 atci->showInTree = FALSE;
3447 atci->treeExpand = FALSE;
3448 atci->treeLeaf = FALSE;
3449 atci->displayName = _( "Person" );
3450 atci->iconXpm = NULL;
3451 atci->maskXpm = NULL;
3452 atci->iconXpmOpen = NULL;
3453 atci->maskXpmOpen = NULL;
3454 atci->menuCommand = NULL;
3455 g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3456 _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3459 atci = g_new0( AddressTypeControlItem, 1 );
3460 atci->objectType = ADDR_ITEM_EMAIL;
3461 atci->interfaceType = ADDR_IF_NONE;
3462 atci->showInTree = FALSE;
3463 atci->treeExpand = FALSE;
3464 atci->treeLeaf = TRUE;
3465 atci->displayName = _( "EMail Address" );
3466 atci->iconXpm = addressxpm;
3467 atci->maskXpm = addressxpmmask;
3468 atci->iconXpmOpen = addressxpm;
3469 atci->maskXpmOpen = addressxpmmask;
3470 atci->menuCommand = NULL;
3471 g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3472 _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3475 atci = g_new0( AddressTypeControlItem, 1 );
3476 atci->objectType = ADDR_ITEM_GROUP;
3477 atci->interfaceType = ADDR_IF_BOOK;
3478 atci->showInTree = TRUE;
3479 atci->treeExpand = FALSE;
3480 atci->treeLeaf = FALSE;
3481 atci->displayName = _( "Group" );
3482 atci->iconXpm = groupxpm;
3483 atci->maskXpm = groupxpmmask;
3484 atci->iconXpmOpen = groupxpm;
3485 atci->maskXpmOpen = groupxpmmask;
3486 atci->menuCommand = NULL;
3487 g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3488 _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3491 atci = g_new0( AddressTypeControlItem, 1 );
3492 atci->objectType = ADDR_ITEM_FOLDER;
3493 atci->interfaceType = ADDR_IF_BOOK;
3494 atci->showInTree = TRUE;
3495 atci->treeExpand = FALSE;
3496 atci->treeLeaf = FALSE;
3497 atci->displayName = _( "Folder" );
3498 atci->iconXpm = folderxpm;
3499 atci->maskXpm = folderxpmmask;
3500 atci->iconXpmOpen = folderopenxpm;
3501 atci->maskXpmOpen = folderopenxpmmask;
3502 atci->menuCommand = NULL;
3503 g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3504 _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3507 atci = g_new0( AddressTypeControlItem, 1 );
3508 atci->objectType = ADDR_VCARD;
3509 atci->interfaceType = ADDR_IF_VCARD;
3510 atci->showInTree = TRUE;
3511 atci->treeExpand = TRUE;
3512 atci->treeLeaf = TRUE;
3513 atci->displayName = _( "vCard" );
3514 atci->iconXpm = vcardxpm;
3515 atci->maskXpm = vcardxpmmask;
3516 atci->iconXpmOpen = vcardxpm;
3517 atci->maskXpmOpen = vcardxpmmask;
3518 atci->menuCommand = "/File/New vCard";
3519 g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3520 _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3523 atci = g_new0( AddressTypeControlItem, 1 );
3524 atci->objectType = ADDR_JPILOT;
3525 atci->interfaceType = ADDR_IF_JPILOT;
3526 atci->showInTree = TRUE;
3527 atci->treeExpand = TRUE;
3528 atci->treeLeaf = FALSE;
3529 atci->displayName = _( "JPilot" );
3530 atci->iconXpm = jpilotxpm;
3531 atci->maskXpm = jpilotxpmmask;
3532 atci->iconXpmOpen = jpilotxpm;
3533 atci->maskXpmOpen = jpilotxpmmask;
3534 atci->menuCommand = "/File/New JPilot";
3535 g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3536 _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3539 atci = g_new0( AddressTypeControlItem, 1 );
3540 atci->objectType = ADDR_CATEGORY;
3541 atci->interfaceType = ADDR_IF_JPILOT;
3542 atci->showInTree = TRUE;
3543 atci->treeExpand = TRUE;
3544 atci->treeLeaf = TRUE;
3545 atci->displayName = _( "JPilot" );
3546 atci->iconXpm = categoryxpm;
3547 atci->maskXpm = categoryxpmmask;
3548 atci->iconXpmOpen = categoryxpm;
3549 atci->maskXpmOpen = categoryxpmmask;
3550 atci->menuCommand = NULL;
3551 g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3552 _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3555 atci = g_new0( AddressTypeControlItem, 1 );
3556 atci->objectType = ADDR_LDAP;
3557 atci->interfaceType = ADDR_IF_LDAP;
3558 atci->showInTree = TRUE;
3559 atci->treeExpand = TRUE;
3560 atci->treeLeaf = TRUE;
3561 atci->displayName = _( "LDAP Server" );
3562 atci->iconXpm = ldapxpm;
3563 atci->maskXpm = ldapxpmmask;
3564 atci->iconXpmOpen = ldapxpm;
3565 atci->maskXpmOpen = ldapxpmmask;
3566 atci->menuCommand = "/File/New Server";
3567 g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3568 _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3573 * Search for specified object type.
3575 AddressTypeControlItem *addrbookctl_lookup( gint ot ) {
3577 return ( AddressTypeControlItem * ) g_hash_table_lookup( _addressBookTypeHash_, &objType );
3581 * Search for specified interface type.
3583 AddressTypeControlItem *addrbookctl_lookup_iface( AddressIfType ifType ) {
3584 GList *node = _addressBookTypeList_;
3586 AddressTypeControlItem *atci = node->data;
3587 if( atci->interfaceType == ifType ) return atci;
3588 node = g_list_next( node );
3593 static void addrbookctl_free_address( AddressObject *obj ) {
3594 g_free( obj->name );
3595 obj->type = ADDR_NONE;
3599 static void addrbookctl_free_interface( AdapterInterface *adapter ) {
3600 addrbookctl_free_address( ADDRESS_OBJECT(adapter) );
3601 adapter->interface = NULL;
3602 adapter->interfaceType = ADDR_IF_NONE;
3603 adapter->atci = NULL;
3604 adapter->enabled = FALSE;
3605 adapter->haveLibrary = FALSE;
3606 adapter->treeNode = NULL;
3610 static void addrbookctl_free_datasource( AdapterDSource *adapter ) {
3611 addrbookctl_free_address( ADDRESS_OBJECT(adapter) );
3612 adapter->dataSource = NULL;
3613 adapter->subType = ADDR_NONE;
3617 static void addrbookctl_free_folder( AdapterFolder *adapter ) {
3618 addrbookctl_free_address( ADDRESS_OBJECT(adapter) );
3619 adapter->itemFolder = NULL;
3623 static void addrbookctl_free_group( AdapterGroup *adapter ) {
3624 addrbookctl_free_address( ADDRESS_OBJECT(adapter) );
3625 adapter->itemGroup = NULL;
3630 * Build GUI interface list.
3632 void addrbookctl_build_iflist() {
3633 AddressTypeControlItem *atci;
3634 AdapterInterface *adapter;
3637 if( _addressIndex_ == NULL ) {
3638 _addressIndex_ = addrindex_create_index();
3639 if( _clipBoard_ == NULL ) {
3640 _clipBoard_ = addrclip_create();
3642 addrclip_set_index( _clipBoard_, _addressIndex_ );
3644 _addressInterfaceList_ = NULL;
3645 list = addrindex_get_interface_list( _addressIndex_ );
3647 AddressInterface *interface = list->data;
3648 atci = addrbookctl_lookup_iface( interface->type );
3650 adapter = g_new0( AdapterInterface, 1 );
3651 adapter->interfaceType = interface->type;
3652 adapter->atci = atci;
3653 adapter->interface = interface;
3654 adapter->treeNode = NULL;
3655 adapter->enabled = TRUE;
3656 adapter->haveLibrary = interface->haveLibrary;
3657 ADDRESS_OBJECT(adapter)->type = ADDR_INTERFACE;
3658 ADDRESS_OBJECT_NAME(adapter) = g_strdup( atci->displayName );
3659 _addressInterfaceList_ = g_list_append( _addressInterfaceList_, adapter );
3661 list = g_list_next( list );
3665 void addrbookctl_free_selection( GList *list ) {
3668 AdapterInterface *adapter = node->data;
3670 node = g_list_next( node );
3672 g_list_free( list );
3676 * Find GUI interface type specified interface type.
3677 * Return: Interface item, or NULL if not found.
3679 AdapterInterface *addrbookctl_find_interface( AddressIfType ifType ) {
3680 GList *node = _addressInterfaceList_;
3682 AdapterInterface *adapter = node->data;
3683 if( adapter->interfaceType == ifType ) return adapter;
3684 node = g_list_next( node );
3690 * Build interface list selection.
3692 void addrbookctl_build_ifselect() {
3693 GList *newList = NULL;
3698 gchar *endptr = NULL;
3700 AdapterInterface *adapter;
3703 selectStr = g_strdup( ADDRESSBOOK_IFACE_SELECTION );
3706 splitStr = g_strsplit( selectStr, ",", -1 );
3707 for( i = 0; i < ADDRESSBOOK_MAX_IFACE; i++ ) {
3709 /* printf( "%d : %s\n", i, splitStr[i] ); */
3710 ifType = strtol( splitStr[i], &endptr, 10 );
3713 if( strcmp( endptr, "/n" ) == 0 ) {
3717 /* printf( "\t%d : %s\n", ifType, enabled ? "yes" : "no" ); */
3718 adapter = addrbookctl_find_interface( ifType );
3720 newList = g_list_append( newList, adapter );
3727 /* printf( "i=%d\n", i ); */
3728 g_strfreev( splitStr );
3729 g_free( selectStr );
3731 /* Replace existing list */
3732 mgu_clear_list( _addressIFaceSelection_ );
3733 g_list_free( _addressIFaceSelection_ );
3734 _addressIFaceSelection_ = newList;
3739 /* **********************************************************************
3740 * Add sender to address book.
3741 * ***********************************************************************
3745 * This function is used by the Add sender to address book function.
3747 gboolean addressbook_add_contact( const gchar *name, const gchar *address, const gchar *remarks ) {
3748 debug_print( "addressbook_add_contact: name/address: %s - %s\n", name, address );
3749 if( addressadd_selection( _addressIndex_, name, address, remarks ) ) {
3750 debug_print( "addressbook_add_contact - added\n" );
3751 addressbook_refresh();
3756 /* **********************************************************************
3757 * Address completion support.
3758 * ***********************************************************************
3762 * This function is used by the address completion function to load
3764 * Enter: callBackFunc Function to be called when an address is
3766 * Return: TRUE if data loaded, FALSE if address index not loaded.
3768 gboolean addressbook_load_completion( gint (*callBackFunc) ( const gchar *, const gchar * ) ) {
3769 /* AddressInterface *interface; */
3770 AddressDataSource *ds;
3771 GList *nodeIf, *nodeDS;
3772 GList *listP, *nodeP;
3774 gchar *sName, *sAddress, *sAlias, *sFriendly;
3776 debug_print( "addressbook_load_completion\n" );
3778 if( _addressIndex_ == NULL ) return FALSE;
3780 nodeIf = addrindex_get_interface_list( _addressIndex_ );
3782 AddressInterface *interface = nodeIf->data;
3783 nodeDS = interface->listSource;
3787 /* Read address book */
3788 if( ! addrindex_ds_get_read_flag( ds ) ) {
3789 addrindex_ds_read_data( ds );
3792 /* Get all persons */
3793 listP = addrindex_ds_get_all_persons( ds );
3796 ItemPerson *person = nodeP->data;
3797 nodeM = person->listEMail;
3799 /* Figure out name to use */
3800 sName = person->nickName;
3801 if( sName == NULL || *sName == '\0' ) {
3802 sName = ADDRITEM_NAME(person);
3805 /* Process each E-Mail address */
3807 ItemEMail *email = nodeM->data;
3810 sAddress = email->address;
3811 if( sAddress || *sAddress != '\0' ) {
3812 sAlias = ADDRITEM_NAME(email);
3813 if( sAlias && *sAlias != '\0' ) {
3816 ( callBackFunc ) ( sFriendly, sAddress );
3819 nodeM = g_list_next( nodeM );
3821 nodeP = g_list_next( nodeP );
3823 /* Free up the list */
3824 g_list_free( listP );
3826 nodeDS = g_list_next( nodeDS );
3828 nodeIf = g_list_next( nodeIf );
3830 debug_print( "addressbook_load_completion... done\n" );
3835 /* **********************************************************************
3837 * ***********************************************************************
3843 static void addressbook_import_ldif_cb() {
3844 AddressDataSource *ds = NULL;
3845 AdapterDSource *ads = NULL;
3846 AddressBookFile *abf = NULL;
3847 AdapterInterface *adapter;
3848 GtkCTreeNode *newNode;
3850 adapter = addrbookctl_find_interface( ADDR_IF_BOOK );
3852 if( adapter->treeNode ) {
3853 abf = addressbook_imp_ldif( _addressIndex_ );
3855 ds = addrindex_index_add_datasource( _addressIndex_, ADDR_IF_BOOK, abf );
3856 ads = addressbook_create_ds_adapter( ds, ADDR_BOOK, NULL );
3857 addressbook_ads_set_name( ads, addrbook_get_name( abf ) );
3858 newNode = addressbook_add_object( adapter->treeNode, ADDRESS_OBJECT(ads) );
3860 gtk_ctree_select( GTK_CTREE(addrbook.ctree), newNode );
3861 addrbook.treeSelected = newNode;
3864 /* Notify address completion */
3865 invalidate_address_completion();
3875 static void addressbook_import_mutt_cb() {
3876 AddressDataSource *ds = NULL;
3877 AdapterDSource *ads = NULL;
3878 AddressBookFile *abf = NULL;
3879 AdapterInterface *adapter;
3880 GtkCTreeNode *newNode;
3882 adapter = addrbookctl_find_interface( ADDR_IF_BOOK );
3884 if( adapter->treeNode ) {
3885 abf = addressbook_imp_mutt( _addressIndex_ );
3887 ds = addrindex_index_add_datasource( _addressIndex_, ADDR_IF_BOOK, abf );
3888 ads = addressbook_create_ds_adapter( ds, ADDR_BOOK, NULL );
3889 addressbook_ads_set_name( ads, addrbook_get_name( abf ) );
3890 newNode = addressbook_add_object( adapter->treeNode, ADDRESS_OBJECT(ads) );
3892 gtk_ctree_select( GTK_CTREE(addrbook.ctree), newNode );
3893 addrbook.treeSelected = newNode;
3896 /* Notify address completion */
3897 invalidate_address_completion();