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];
532 debug_print("Creating addressbook window...\n");
534 titles[COL_NAME] = _("Name");
535 titles[COL_ADDRESS] = _("E-Mail address");
536 titles[COL_REMARKS] = _("Remarks");
538 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
539 gtk_window_set_title(GTK_WINDOW(window), _("Address book"));
540 gtk_widget_set_usize(window, ADDRESSBOOK_WIDTH, ADDRESSBOOK_HEIGHT);
541 gtk_window_set_policy(GTK_WINDOW(window), TRUE, TRUE, TRUE);
542 gtk_window_set_wmclass(GTK_WINDOW(window), "addressbook", "Sylpheed");
543 gtk_widget_realize(window);
545 gtk_signal_connect(GTK_OBJECT(window), "delete_event",
546 GTK_SIGNAL_FUNC(addressbook_close), NULL);
547 gtk_signal_connect(GTK_OBJECT(window), "key_press_event",
548 GTK_SIGNAL_FUNC(key_pressed), NULL);
549 MANAGE_WINDOW_SIGNALS_CONNECT(window);
551 vbox = gtk_vbox_new(FALSE, 0);
552 gtk_container_add(GTK_CONTAINER(window), vbox);
554 n_entries = sizeof(addressbook_entries) /
555 sizeof(addressbook_entries[0]);
556 menubar = menubar_create(window, addressbook_entries, n_entries,
557 "<AddressBook>", NULL);
558 gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, TRUE, 0);
559 menu_factory = gtk_item_factory_from_widget(menubar);
561 vbox2 = gtk_vbox_new(FALSE, 4);
562 gtk_container_set_border_width(GTK_CONTAINER(vbox2), BORDER_WIDTH);
563 gtk_box_pack_start(GTK_BOX(vbox), vbox2, TRUE, TRUE, 0);
565 ctree_swin = gtk_scrolled_window_new(NULL, NULL);
566 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ctree_swin),
567 GTK_POLICY_AUTOMATIC,
569 gtk_widget_set_usize(ctree_swin, COL_FOLDER_WIDTH + 40, -1);
572 ctree = gtk_ctree_new(1, 0);
573 gtk_container_add(GTK_CONTAINER(ctree_swin), ctree);
574 gtk_clist_set_selection_mode(GTK_CLIST(ctree), GTK_SELECTION_BROWSE);
575 gtk_clist_set_column_width(GTK_CLIST(ctree), 0, COL_FOLDER_WIDTH);
576 gtk_ctree_set_line_style(GTK_CTREE(ctree), GTK_CTREE_LINES_DOTTED);
577 gtk_ctree_set_expander_style(GTK_CTREE(ctree),
578 GTK_CTREE_EXPANDER_SQUARE);
579 gtk_ctree_set_indent(GTK_CTREE(ctree), CTREE_INDENT);
580 gtk_clist_set_compare_func(GTK_CLIST(ctree),
581 addressbook_treenode_compare_func);
583 gtk_signal_connect(GTK_OBJECT(ctree), "tree_select_row",
584 GTK_SIGNAL_FUNC(addressbook_tree_selected), NULL);
585 gtk_signal_connect(GTK_OBJECT(ctree), "button_press_event",
586 GTK_SIGNAL_FUNC(addressbook_tree_button_pressed),
588 gtk_signal_connect(GTK_OBJECT(ctree), "button_release_event",
589 GTK_SIGNAL_FUNC(addressbook_tree_button_released),
592 clist_vbox = gtk_vbox_new(FALSE, 4);
594 clist_swin = gtk_scrolled_window_new(NULL, NULL);
595 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(clist_swin),
596 GTK_POLICY_AUTOMATIC,
598 gtk_box_pack_start(GTK_BOX(clist_vbox), clist_swin, TRUE, TRUE, 0);
601 clist = gtk_ctree_new_with_titles(N_COLS, 0, titles);
602 gtk_container_add(GTK_CONTAINER(clist_swin), clist);
603 gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_EXTENDED);
604 gtk_ctree_set_line_style(GTK_CTREE(clist), GTK_CTREE_LINES_NONE);
605 gtk_ctree_set_expander_style(GTK_CTREE(clist), GTK_CTREE_EXPANDER_SQUARE);
606 gtk_ctree_set_indent(GTK_CTREE(clist), CTREE_INDENT);
607 gtk_clist_set_column_width(GTK_CLIST(clist), COL_NAME,
609 gtk_clist_set_column_width(GTK_CLIST(clist), COL_ADDRESS,
611 gtk_clist_set_compare_func(GTK_CLIST(clist),
612 addressbook_list_compare_func);
614 for (i = 0; i < N_COLS; i++)
615 GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(clist)->column[i].button,
618 gtk_signal_connect(GTK_OBJECT(clist), "tree_select_row",
619 GTK_SIGNAL_FUNC(addressbook_list_row_selected), NULL);
620 gtk_signal_connect(GTK_OBJECT(clist), "tree_unselect_row",
621 GTK_SIGNAL_FUNC(addressbook_list_row_unselected), NULL);
622 gtk_signal_connect(GTK_OBJECT(clist), "button_press_event",
623 GTK_SIGNAL_FUNC(addressbook_list_button_pressed),
625 gtk_signal_connect(GTK_OBJECT(clist), "button_release_event",
626 GTK_SIGNAL_FUNC(addressbook_list_button_released),
628 gtk_signal_connect(GTK_OBJECT(clist), "select_row",
629 GTK_SIGNAL_FUNC(addressbook_list_selected), NULL);
630 gtk_signal_connect(GTK_OBJECT(clist), "tree_expand",
631 GTK_SIGNAL_FUNC(addressbook_person_expand_node), NULL );
632 gtk_signal_connect(GTK_OBJECT(clist), "tree_collapse",
633 GTK_SIGNAL_FUNC(addressbook_person_collapse_node), NULL );
635 hbox = gtk_hbox_new(FALSE, 4);
636 gtk_box_pack_start(GTK_BOX(clist_vbox), hbox, FALSE, FALSE, 0);
638 label = gtk_label_new(_("Name:"));
639 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
641 entry = gtk_entry_new();
642 gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0);
644 address_completion_register_entry(GTK_ENTRY(entry));
645 gtk_signal_connect(GTK_OBJECT(entry), "focus_in_event",
646 GTK_SIGNAL_FUNC(addressbook_entry_gotfocus), NULL);
649 gtk_signal_connect(GTK_OBJECT(entry), "changed",
650 GTK_SIGNAL_FUNC(addressbook_entry_changed), NULL);
653 paned = gtk_hpaned_new();
654 gtk_box_pack_start(GTK_BOX(vbox2), paned, TRUE, TRUE, 0);
655 gtk_paned_add1(GTK_PANED(paned), ctree_swin);
656 gtk_paned_add2(GTK_PANED(paned), clist_vbox);
659 hsbox = gtk_hbox_new(FALSE, 0);
660 gtk_box_pack_end(GTK_BOX(vbox), hsbox, FALSE, FALSE, BORDER_WIDTH);
661 statusbar = gtk_statusbar_new();
662 gtk_box_pack_start(GTK_BOX(hsbox), statusbar, TRUE, TRUE, BORDER_WIDTH);
665 hbbox = gtk_hbutton_box_new();
666 gtk_button_box_set_layout(GTK_BUTTON_BOX(hbbox), GTK_BUTTONBOX_END);
667 gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbbox), 2);
668 gtk_box_pack_end(GTK_BOX(vbox), hbbox, FALSE, FALSE, 0);
670 del_btn = gtk_button_new_with_label(_("Delete"));
671 GTK_WIDGET_SET_FLAGS(del_btn, GTK_CAN_DEFAULT);
672 gtk_box_pack_start(GTK_BOX(hbbox), del_btn, TRUE, TRUE, 0);
673 reg_btn = gtk_button_new_with_label(_("Add"));
674 GTK_WIDGET_SET_FLAGS(reg_btn, GTK_CAN_DEFAULT);
675 gtk_box_pack_start(GTK_BOX(hbbox), reg_btn, TRUE, TRUE, 0);
676 lup_btn = gtk_button_new_with_label(_("Lookup"));
677 GTK_WIDGET_SET_FLAGS(lup_btn, GTK_CAN_DEFAULT);
678 gtk_box_pack_start(GTK_BOX(hbbox), lup_btn, TRUE, TRUE, 0);
680 gtk_signal_connect(GTK_OBJECT(del_btn), "clicked",
681 GTK_SIGNAL_FUNC(addressbook_del_clicked), NULL);
682 gtk_signal_connect(GTK_OBJECT(reg_btn), "clicked",
683 GTK_SIGNAL_FUNC(addressbook_reg_clicked), NULL);
684 gtk_signal_connect(GTK_OBJECT(lup_btn), "clicked",
685 GTK_SIGNAL_FUNC(addressbook_lup_clicked), NULL);
687 to_btn = gtk_button_new_with_label
688 (prefs_common.trans_hdr ? _("To:") : "To:");
689 GTK_WIDGET_SET_FLAGS(to_btn, GTK_CAN_DEFAULT);
690 gtk_box_pack_start(GTK_BOX(hbbox), to_btn, TRUE, TRUE, 0);
691 cc_btn = gtk_button_new_with_label
692 (prefs_common.trans_hdr ? _("Cc:") : "Cc:");
693 GTK_WIDGET_SET_FLAGS(cc_btn, GTK_CAN_DEFAULT);
694 gtk_box_pack_start(GTK_BOX(hbbox), cc_btn, TRUE, TRUE, 0);
695 bcc_btn = gtk_button_new_with_label
696 (prefs_common.trans_hdr ? _("Bcc:") : "Bcc:");
697 GTK_WIDGET_SET_FLAGS(bcc_btn, GTK_CAN_DEFAULT);
698 gtk_box_pack_start(GTK_BOX(hbbox), bcc_btn, TRUE, TRUE, 0);
700 gtk_signal_connect(GTK_OBJECT(to_btn), "clicked",
701 GTK_SIGNAL_FUNC(addressbook_to_clicked),
702 GINT_TO_POINTER(COMPOSE_TO));
703 gtk_signal_connect(GTK_OBJECT(cc_btn), "clicked",
704 GTK_SIGNAL_FUNC(addressbook_to_clicked),
705 GINT_TO_POINTER(COMPOSE_CC));
706 gtk_signal_connect(GTK_OBJECT(bcc_btn), "clicked",
707 GTK_SIGNAL_FUNC(addressbook_to_clicked),
708 GINT_TO_POINTER(COMPOSE_BCC));
710 /* Build icons for interface */
711 stock_pixmap_gdk( window, STOCK_PIXMAP_INTERFACE,
712 &interfacexpm, &interfacexpmmask );
714 /* Build control tables */
715 addrbookctl_build_map(window);
716 addrbookctl_build_iflist();
717 addrbookctl_build_ifselect();
719 /* Add each interface into the tree as a root level folder */
720 nodeIf = _addressInterfaceList_;
722 AdapterInterface *adapter = nodeIf->data;
723 AddressInterface *iface = adapter->interface;
724 nodeIf = g_list_next(nodeIf);
726 if(iface->useInterface) {
727 AddressTypeControlItem *atci = adapter->atci;
728 text = atci->displayName;
730 gtk_ctree_insert_node( GTK_CTREE(ctree),
731 NULL, NULL, &text, FOLDER_SPACING,
732 interfacexpm, interfacexpmmask,
733 interfacexpm, interfacexpmmask,
735 menu_set_sensitive( menu_factory, atci->menuCommand, adapter->haveLibrary );
736 gtk_ctree_node_set_row_data_full(
737 GTK_CTREE(ctree), adapter->treeNode, adapter,
738 addressbook_free_treenode );
743 n_entries = sizeof(addressbook_tree_popup_entries) /
744 sizeof(addressbook_tree_popup_entries[0]);
745 tree_popup = menu_create_items(addressbook_tree_popup_entries,
747 "<AddressBookTree>", &tree_factory,
749 gtk_signal_connect(GTK_OBJECT(tree_popup), "selection_done",
750 GTK_SIGNAL_FUNC(addressbook_popup_close), NULL);
751 n_entries = sizeof(addressbook_list_popup_entries) /
752 sizeof(addressbook_list_popup_entries[0]);
753 list_popup = menu_create_items(addressbook_list_popup_entries,
755 "<AddressBookList>", &list_factory,
758 addrbook.window = window;
759 addrbook.menubar = menubar;
760 addrbook.ctree = ctree;
761 addrbook.clist = clist;
762 addrbook.entry = entry;
763 addrbook.statusbar = statusbar;
764 addrbook.status_cid = gtk_statusbar_get_context_id(
765 GTK_STATUSBAR(statusbar), "Addressbook Window" );
767 addrbook.del_btn = del_btn;
768 addrbook.reg_btn = reg_btn;
769 addrbook.lup_btn = lup_btn;
770 addrbook.to_btn = to_btn;
771 addrbook.cc_btn = cc_btn;
772 addrbook.bcc_btn = bcc_btn;
774 addrbook.tree_popup = tree_popup;
775 addrbook.list_popup = list_popup;
776 addrbook.tree_factory = tree_factory;
777 addrbook.list_factory = list_factory;
778 addrbook.menu_factory = menu_factory;
780 addrbook.listSelected = NULL;
781 address_completion_start(window);
782 gtk_widget_show_all(window);
786 static gint addressbook_close(void)
788 gtk_widget_hide(addrbook.window);
789 addressbook_export_to_file();
793 static void addressbook_status_show( gchar *msg ) {
794 if( addrbook.statusbar != NULL ) {
796 GTK_STATUSBAR(addrbook.statusbar),
797 addrbook.status_cid );
800 GTK_STATUSBAR(addrbook.statusbar),
801 addrbook.status_cid, msg );
806 static void addressbook_ds_status_message( AddressDataSource *ds, gchar *msg ) {
807 *addressbook_msgbuf = '\0';
811 name = addrindex_ds_get_name( ds );
812 sprintf( addressbook_msgbuf, "%s: %s", name, msg );
815 sprintf( addressbook_msgbuf, "%s", msg );
817 addressbook_status_show( addressbook_msgbuf );
820 static void addressbook_ds_show_message( AddressDataSource *ds ) {
823 *addressbook_msgbuf = '\0';
825 name = addrindex_ds_get_name( ds );
826 retVal = addrindex_ds_get_status_code( ds );
827 if( retVal == MGU_SUCCESS ) {
828 sprintf( addressbook_msgbuf, "%s", name );
831 sprintf( addressbook_msgbuf, "%s: %s", name,
832 mgu_error2string( retVal ) );
835 addressbook_status_show( addressbook_msgbuf );
838 static void addressbook_button_set_sensitive(void)
840 gboolean to_sens = FALSE;
841 gboolean cc_sens = FALSE;
842 gboolean bcc_sens = FALSE;
844 if (!addrbook.window) return;
846 if (addrbook.target_compose) {
850 if (addrbook.target_compose->use_bcc)
855 gtk_widget_set_sensitive(addrbook.to_btn, to_sens);
856 gtk_widget_set_sensitive(addrbook.cc_btn, cc_sens);
857 gtk_widget_set_sensitive(addrbook.bcc_btn, bcc_sens);
861 * Delete one or more objects from address list.
863 static void addressbook_del_clicked(GtkButton *button, gpointer data)
865 GtkCTree *clist = GTK_CTREE(addrbook.clist);
866 GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
868 AdapterDSource *ads = NULL;
869 GtkCTreeNode *nodeList;
872 AddressBookFile *abf = NULL;
873 AddressDataSource *ds = NULL;
874 AddressInterface *iface;
876 AddrSelectItem *item;
879 pobj = gtk_ctree_node_get_row_data(ctree, addrbook.opened );
880 g_return_if_fail(pobj != NULL);
882 /* Test whether anything selected for deletion */
883 nodeList = addrbook.listSelected;
884 aio = gtk_ctree_node_get_row_data( clist, nodeList );
885 if( aio == NULL) return;
886 ds = addressbook_find_datasource( addrbook.treeSelected );
887 if( ds == NULL ) return;
889 /* Test for read only */
890 iface = ds->interface;
891 if( iface->readOnly ) {
892 aval = alertpanel( _("Delete address(es)"),
893 _("This address data is readonly and cannot be deleted."),
894 _("Close"), NULL, NULL );
898 /* Test whether Ok to proceed */
900 if( pobj->type == ADDR_DATASOURCE ) {
901 ads = ADAPTER_DSOURCE(pobj);
902 if( ads->subType == ADDR_BOOK ) procFlag = TRUE;
904 else if( pobj->type == ADDR_ITEM_FOLDER ) {
907 else if( pobj->type == ADDR_ITEM_GROUP ) {
910 if( ! procFlag ) return;
911 abf = ds->rawDataSource;
912 if( abf == NULL ) return;
914 /* Confirm deletion */
915 aval = alertpanel( _("Delete address(es)"),
916 _("Really delete the address(es)?"),
917 _("Yes"), _("No"), NULL );
918 if( aval != G_ALERTDEFAULT ) return;
920 /* Process deletions */
921 if( pobj->type == ADDR_DATASOURCE || pobj->type == ADDR_ITEM_FOLDER ) {
922 /* Items inside folders */
923 list = addrselect_get_list( _addressSelect_ );
927 node = g_list_next( node );
928 aio = ( AddrItemObject * ) item->addressItem;
929 if( aio->type == ADDR_ITEM_GROUP ) {
930 ItemGroup *item = ( ItemGroup * ) aio;
931 GtkCTreeNode *nd = NULL;
933 nd = addressbook_find_group_node( addrbook.opened, item );
934 item = addrbook_remove_group( abf, item );
936 addritem_free_item_group( item );
938 /* Remove group from parent node */
939 gtk_ctree_remove_node( ctree, nd );
941 else if( aio->type == ADDR_ITEM_PERSON ) {
942 ItemPerson *item = ( ItemPerson * ) aio;
943 item = addrbook_remove_person( abf, item );
945 addritem_free_item_person( item );
948 else if( aio->type == ADDR_ITEM_EMAIL ) {
949 ItemEMail *item = ( ItemEMail * ) aio;
950 ItemPerson *person = ( ItemPerson * ) ADDRITEM_PARENT(item);
951 item = addrbook_person_remove_email( abf, person, item );
953 addritem_free_item_email( item );
958 addressbook_list_select_clear();
959 gtk_ctree_select( ctree, addrbook.opened);
962 else if( pobj->type == ADDR_ITEM_GROUP ) {
963 /* Items inside groups */
964 list = addrselect_get_list( _addressSelect_ );
968 node = g_list_next( node );
969 aio = ( AddrItemObject * ) item->addressItem;
970 if( aio->type == ADDR_ITEM_EMAIL ) {
971 ItemEMail *item = ( ItemEMail * ) aio;
972 ItemPerson *person = ( ItemPerson * ) ADDRITEM_PARENT(item);
973 item = addrbook_person_remove_email( abf, person, item );
975 addritem_free_item_email( item );
980 addressbook_list_select_clear();
981 gtk_ctree_select( ctree, addrbook.opened);
985 gtk_ctree_node_set_row_data( clist, nodeList, NULL );
986 gtk_ctree_remove_node( clist, nodeList );
990 static void addressbook_reg_clicked(GtkButton *button, gpointer data)
992 addressbook_new_address_cb( NULL, 0, NULL );
995 gchar *addressbook_format_address( AddrItemObject * aio ) {
998 gchar *address = NULL;
1000 if( aio->type == ADDR_ITEM_EMAIL ) {
1001 ItemPerson *person = NULL;
1002 ItemEMail *email = ( ItemEMail * ) aio;
1004 person = ( ItemPerson * ) ADDRITEM_PARENT(email);
1005 if( email->address ) {
1006 if( ADDRITEM_NAME(email) ) {
1007 name = ADDRITEM_NAME(email);
1008 if( *name == '\0' ) {
1009 name = ADDRITEM_NAME(person);
1012 else if( ADDRITEM_NAME(person) ) {
1013 name = ADDRITEM_NAME(person);
1016 buf = g_strdup( email->address );
1018 address = email->address;
1021 else if( aio->type == ADDR_ITEM_PERSON ) {
1022 ItemPerson *person = ( ItemPerson * ) aio;
1023 GList *node = person->listEMail;
1025 name = ADDRITEM_NAME(person);
1027 ItemEMail *email = ( ItemEMail * ) node->data;
1028 address = email->address;
1032 if( name && name[0] != '\0' ) {
1033 if( strchr_with_skip_quote( name, '"', ',' ) )
1034 buf = g_strdup_printf( "\"%s\" <%s>", name, address );
1036 buf = g_strdup_printf( "%s <%s>", name, address );
1039 buf = g_strdup( address );
1046 static void addressbook_to_clicked(GtkButton *button, gpointer data)
1050 AddrSelectItem *item;
1051 AddrItemObject *aio;
1054 compose = addrbook.target_compose;
1055 if( ! compose ) return;
1057 list = addrselect_get_list( _addressSelect_ );
1061 node = g_list_next( node );
1062 aio = item->addressItem;
1063 if( aio->type == ADDR_ITEM_PERSON ||
1064 aio->type == ADDR_ITEM_EMAIL ) {
1065 addr = addressbook_format_address( aio );
1066 compose_entry_append(
1067 compose, addr, (ComposeEntryType) data );
1070 else if( aio->type == ADDR_ITEM_GROUP ) {
1071 ItemGroup *group = ( ItemGroup * ) aio;
1072 GList *nodeMail = group->listEMail;
1074 ItemEMail *email = nodeMail->data;
1076 addr = addressbook_format_address(
1077 ( AddrItemObject * ) email );
1078 compose_entry_append(
1079 compose, addr, (ComposeEntryType) data );
1081 nodeMail = g_list_next( nodeMail );
1085 g_list_free( list );
1088 static void addressbook_menubar_set_sensitive( gboolean sensitive ) {
1089 menu_set_sensitive( addrbook.menu_factory, "/File/Edit", sensitive );
1090 menu_set_sensitive( addrbook.menu_factory, "/File/Delete", sensitive );
1092 menu_set_sensitive( addrbook.menu_factory, "/Edit/Cut", sensitive );
1093 menu_set_sensitive( addrbook.menu_factory, "/Edit/Copy", sensitive );
1094 menu_set_sensitive( addrbook.menu_factory, "/Edit/Paste", sensitive );
1095 menu_set_sensitive( addrbook.menu_factory, "/Edit/Paste Address", sensitive );
1097 menu_set_sensitive( addrbook.menu_factory, "/Address/New Address", sensitive );
1098 menu_set_sensitive( addrbook.menu_factory, "/Address/New Group", sensitive );
1099 menu_set_sensitive( addrbook.menu_factory, "/Address/New Folder", sensitive );
1100 gtk_widget_set_sensitive( addrbook.reg_btn, sensitive );
1101 gtk_widget_set_sensitive( addrbook.del_btn, sensitive );
1104 static void addressbook_menuitem_set_sensitive( AddressObject *obj, GtkCTreeNode *node ) {
1105 gboolean canEdit = FALSE;
1106 gboolean canAdd = FALSE;
1107 gboolean canEditTr = TRUE;
1108 gboolean editAddress = FALSE;
1109 AddressTypeControlItem *atci = NULL;
1110 AddressDataSource *ds = NULL;
1111 AddressInterface *iface = NULL;
1113 if( obj == NULL ) return;
1114 if( obj->type == ADDR_INTERFACE ) {
1115 AdapterInterface *adapter = ADAPTER_INTERFACE(obj);
1116 iface = adapter->interface;
1118 if( iface->haveLibrary ) {
1119 /* Enable appropriate File / New command */
1120 atci = adapter->atci;
1121 menu_set_sensitive( addrbook.menu_factory, atci->menuCommand, TRUE );
1126 else if( obj->type == ADDR_DATASOURCE ) {
1127 AdapterDSource *ads = ADAPTER_DSOURCE(obj);
1128 ds = ads->dataSource;
1129 iface = ds->interface;
1130 if( ! iface->readOnly ) {
1131 canAdd = canEdit = editAddress = TRUE;
1133 if( ! iface->haveLibrary ) {
1134 canAdd = canEdit = editAddress = FALSE;
1137 else if( obj->type == ADDR_ITEM_FOLDER ) {
1138 ds = addressbook_find_datasource( addrbook.treeSelected );
1140 iface = ds->interface;
1141 if( iface->readOnly ) {
1145 canAdd = editAddress = TRUE;
1149 else if( obj->type == ADDR_ITEM_GROUP ) {
1150 ds = addressbook_find_datasource( addrbook.treeSelected );
1152 iface = ds->interface;
1153 if( ! iface->readOnly ) {
1159 if( addrbook.listSelected == NULL ) canEdit = FALSE;
1162 menu_set_sensitive( addrbook.menu_factory, "/Address/New Address", editAddress );
1163 menu_set_sensitive( addrbook.menu_factory, "/Address/New Group", canAdd );
1164 menu_set_sensitive( addrbook.menu_factory, "/Address/New Folder", canAdd );
1165 gtk_widget_set_sensitive( addrbook.reg_btn, editAddress );
1168 menu_set_sensitive( addrbook.menu_factory, "/Address/Edit", canEdit );
1169 menu_set_sensitive( addrbook.menu_factory, "/Address/Delete", canEdit );
1170 gtk_widget_set_sensitive( addrbook.del_btn, canEdit );
1172 menu_set_sensitive( addrbook.menu_factory, "/File/Edit", canEditTr );
1173 menu_set_sensitive( addrbook.menu_factory, "/File/Delete", canEditTr );
1176 static void addressbook_tree_selected(GtkCTree *ctree, GtkCTreeNode *node,
1177 gint column, gpointer data)
1179 AddressObject *obj = NULL;
1180 AdapterDSource *ads = NULL;
1181 AddressDataSource *ds = NULL;
1182 ItemFolder *rootFolder = NULL;
1184 addrbook.treeSelected = node;
1185 addrbook.listSelected = NULL;
1186 addressbook_status_show( "" );
1187 if( addrbook.entry != NULL ) gtk_entry_set_text(GTK_ENTRY(addrbook.entry), "");
1189 if( addrbook.clist ) gtk_clist_clear( GTK_CLIST(addrbook.clist) );
1190 if( node ) obj = gtk_ctree_node_get_row_data( ctree, node );
1191 if( obj == NULL ) return;
1193 addrbook.opened = node;
1195 if( obj->type == ADDR_DATASOURCE ) {
1196 /* Read from file */
1197 static gboolean tVal = TRUE;
1199 ads = ADAPTER_DSOURCE(obj);
1200 if( ads == NULL ) return;
1201 ds = ads->dataSource;
1202 if( ds == NULL ) return;
1204 if( addrindex_ds_get_modify_flag( ds ) ) {
1205 addrindex_ds_read_data( ds );
1208 if( ! addrindex_ds_get_read_flag( ds ) ) {
1209 addrindex_ds_read_data( ds );
1211 addressbook_ds_show_message( ds );
1213 if( ! addrindex_ds_get_access_flag( ds ) ) {
1214 /* Remove existing folders and groups */
1215 gtk_clist_freeze( GTK_CLIST(ctree) );
1216 addressbook_tree_remove_children( ctree, node );
1217 gtk_clist_thaw( GTK_CLIST(ctree) );
1219 /* Load folders into the tree */
1220 rootFolder = addrindex_ds_get_root_folder( ds );
1221 if( ds->type == ADDR_IF_JPILOT ) {
1222 addressbook_node_add_folder( node, ds, rootFolder, ADDR_CATEGORY );
1225 addressbook_node_add_folder( node, ds, rootFolder, ADDR_ITEM_FOLDER );
1227 addrindex_ds_set_access_flag( ds, &tVal );
1228 gtk_ctree_expand( ctree, node );
1232 /* Update address list */
1233 addressbook_set_clist( obj );
1235 /* Setup main menu selections */
1236 addressbook_menubar_set_sensitive( FALSE );
1237 addressbook_menuitem_set_sensitive( obj, node );
1239 addressbook_list_select_clear();
1244 * Setup address list popup menu.
1245 * Enter: pobj Parent address object in address tree.
1246 * obj Address object in address list.
1248 static void addressbook_list_menu_setup( void ) {
1249 GtkCTree *clist = NULL;
1250 AddressObject *pobj = NULL;
1251 AddressObject *obj = NULL;
1252 AdapterDSource *ads = NULL;
1253 AddressInterface *iface = NULL;
1254 AddressDataSource *ds = NULL;
1255 gboolean canEdit = FALSE;
1256 gboolean canDelete = FALSE;
1257 gboolean canCut = FALSE;
1258 gboolean canCopy = FALSE;
1259 gboolean canPaste = FALSE;
1261 pobj = gtk_ctree_node_get_row_data( GTK_CTREE(addrbook.ctree), addrbook.treeSelected );
1262 if( pobj == NULL ) return;
1264 clist = GTK_CTREE(addrbook.clist);
1265 obj = gtk_ctree_node_get_row_data( clist, addrbook.listSelected );
1266 if( obj == NULL ) canEdit = FALSE;
1268 menu_set_insensitive_all( GTK_MENU_SHELL(addrbook.list_popup) );
1270 if( pobj->type == ADDR_DATASOURCE ) {
1271 ads = ADAPTER_DSOURCE(pobj);
1272 ds = ads->dataSource;
1273 iface = ds->interface;
1274 if( ! iface->readOnly ) {
1275 menu_set_sensitive( addrbook.list_factory, "/New Address", TRUE );
1276 menu_set_sensitive( addrbook.list_factory, "/New Folder", TRUE );
1277 menu_set_sensitive( addrbook.list_factory, "/New Group", TRUE );
1278 gtk_widget_set_sensitive( addrbook.reg_btn, TRUE );
1279 if( ! addrclip_is_empty( _clipBoard_ ) ) canPaste = TRUE;
1280 if( ! addrselect_test_empty( _addressSelect_ ) ) canCut = TRUE;
1281 if( obj ) canEdit = TRUE;
1284 else if( pobj->type != ADDR_INTERFACE ) {
1285 ds = addressbook_find_datasource( addrbook.treeSelected );
1286 iface = ds->interface;
1287 if( ! iface->readOnly ) {
1288 if( pobj->type == ADDR_ITEM_FOLDER || pobj->type == ADDR_ITEM_GROUP ) {
1289 menu_set_sensitive( addrbook.list_factory, "/New Address", TRUE );
1290 gtk_widget_set_sensitive( addrbook.reg_btn, TRUE );
1291 if( obj ) canEdit = TRUE;
1293 if( pobj->type == ADDR_ITEM_FOLDER ) {
1294 menu_set_sensitive( addrbook.list_factory, "/New Folder", TRUE );
1295 menu_set_sensitive( addrbook.list_factory, "/New Group", TRUE );
1296 if( obj ) canEdit = TRUE;
1298 if( ! addrclip_is_empty( _clipBoard_ ) ) canPaste = TRUE;
1299 if( ! addrselect_test_empty( _addressSelect_ ) ) canCut = TRUE;
1302 if( ! addrselect_test_empty( _addressSelect_ ) ) canCopy = TRUE;
1304 canDelete = canEdit;
1305 canDelete = canEdit;
1307 /* Disable edit if more than one row selected */
1308 if( GTK_CLIST(clist)->selection && GTK_CLIST(clist)->selection->next ) canEdit = FALSE;
1310 menu_set_sensitive( addrbook.list_factory, "/Edit", canEdit );
1311 menu_set_sensitive( addrbook.list_factory, "/Delete", canDelete );
1313 menu_set_sensitive( addrbook.list_factory, "/Cut", canCut );
1314 menu_set_sensitive( addrbook.list_factory, "/Copy", canCopy );
1315 menu_set_sensitive( addrbook.list_factory, "/Paste", canPaste );
1316 menu_set_sensitive( addrbook.list_factory, "/Paste Address", canPaste );
1318 menu_set_sensitive( addrbook.menu_factory, "/Edit/Cut", canCut );
1319 menu_set_sensitive( addrbook.menu_factory, "/Edit/Copy", canCopy );
1320 menu_set_sensitive( addrbook.menu_factory, "/Edit/Paste", canPaste );
1321 menu_set_sensitive( addrbook.menu_factory, "/Edit/Paste Address", canPaste );
1323 menu_set_sensitive( addrbook.tree_factory, "/Cut", canCut );
1324 menu_set_sensitive( addrbook.tree_factory, "/Copy", canCopy );
1325 menu_set_sensitive( addrbook.tree_factory, "/Paste", canPaste );
1327 menu_set_sensitive( addrbook.menu_factory, "/Address/Edit", canEdit );
1328 menu_set_sensitive( addrbook.menu_factory, "/Address/Delete", canDelete );
1330 gtk_widget_set_sensitive( addrbook.del_btn, canDelete );
1333 static void addressbook_list_selected(GtkCList *clist, gint row, gint column,
1334 GdkEvent *event, gpointer data)
1336 if (event && event->type == GDK_2BUTTON_PRESS) {
1337 /* Handle double click */
1338 if (prefs_common.add_address_by_click &&
1339 addrbook.target_compose)
1340 addressbook_to_clicked(NULL, NULL);
1342 addressbook_edit_address_cb(NULL, 0, NULL);
1347 * Add list of items into tree node below specified tree node.
1348 * Enter: treeNode Tree node.
1350 * listItems List of items.
1352 static void addressbook_treenode_add_list(
1353 GtkCTreeNode *treeNode, AddressDataSource *ds, GList *listItems )
1359 AddrItemObject *aio;
1363 if( ADDRESS_OBJECT_TYPE(aio) == ITEMTYPE_GROUP ) {
1366 group = ( ItemGroup * ) aio;
1367 nn = addressbook_node_add_group( treeNode, ds, group );
1369 else if( ADDRESS_OBJECT_TYPE(aio) == ITEMTYPE_FOLDER ) {
1372 folder = ( ItemFolder * ) aio;
1373 nn = addressbook_node_add_folder(
1374 treeNode, ds, folder, ADDR_ITEM_FOLDER );
1376 node = g_list_next( node );
1381 * Cut from address list widget.
1383 static void addressbook_clip_cut_cb( void ) {
1384 _clipBoard_->cutFlag = TRUE;
1385 addrclip_clear( _clipBoard_ );
1386 addrclip_add( _clipBoard_, _addressSelect_ );
1387 /* addrclip_list_show( _clipBoard_, stdout ); */
1391 * Copy from address list widget.
1393 static void addressbook_clip_copy_cb( void ) {
1394 _clipBoard_->cutFlag = FALSE;
1395 addrclip_clear( _clipBoard_ );
1396 addrclip_add( _clipBoard_, _addressSelect_ );
1397 /* addrclip_list_show( _clipBoard_, stdout ); */
1401 * Paste clipboard into address list widget.
1403 static void addressbook_clip_paste_cb( void ) {
1404 GtkCTree *ctree = GTK_CTREE( addrbook.ctree );
1405 AddressObject *pobj = NULL;
1406 AddressDataSource *ds = NULL;
1407 AddressBookFile *abf = NULL;
1408 ItemFolder *folder = NULL;
1409 GList *folderGroup = NULL;
1411 ds = addressbook_find_datasource( GTK_CTREE_NODE(addrbook.treeSelected) );
1412 if( ds == NULL ) return;
1413 if( addrindex_ds_get_readonly( ds ) ) {
1414 addressbook_ds_status_message(
1415 ds, _( "Cannot paste. Target address book is readonly." ) );
1419 pobj = gtk_ctree_node_get_row_data( ctree, addrbook.treeSelected );
1421 if( pobj->type == ADDR_ITEM_FOLDER ) {
1422 folder = ADAPTER_FOLDER(pobj)->itemFolder;
1424 else if( pobj->type == ADDR_ITEM_GROUP ) {
1425 addressbook_ds_status_message(
1426 ds, _( "Cannot paste into an address group." ) );
1431 /* Get an address book */
1432 abf = addressbook_get_book_file();
1433 if( abf == NULL ) return;
1435 if( _clipBoard_->cutFlag ) {
1437 folderGroup = addrclip_paste_cut( _clipBoard_, abf, folder );
1439 /* Remove all groups and folders in clipboard from tree node */
1440 addressbook_treenode_remove_item();
1442 /* Remove all "cut" items */
1443 addrclip_delete_item( _clipBoard_ );
1445 /* Clear clipboard - cut items??? */
1446 addrclip_clear( _clipBoard_ );
1450 folderGroup = addrclip_paste_copy( _clipBoard_, abf, folder );
1453 /* addrclip_list_show( _clipBoard_, stdout ); */
1455 /* Update tree by inserting node for each folder or group */
1456 addressbook_treenode_add_list(
1457 addrbook.treeSelected, ds, folderGroup );
1458 gtk_ctree_expand( ctree, addrbook.treeSelected );
1459 g_list_free( folderGroup );
1463 /* Display items pasted */
1464 gtk_ctree_select( ctree, addrbook.opened );
1469 * Paste clipboard email addresses only into address list widget.
1471 static void addressbook_clip_paste_address_cb( void ) {
1472 GtkCTree *clist = GTK_CTREE(addrbook.clist);
1474 AddressObject *pobj = NULL;
1475 AddressDataSource *ds = NULL;
1476 AddressBookFile *abf = NULL;
1477 ItemFolder *folder = NULL;
1478 AddrItemObject *aio;
1481 if( addrbook.listSelected == NULL ) return;
1483 ctree = GTK_CTREE( addrbook.ctree );
1484 ds = addressbook_find_datasource( GTK_CTREE_NODE(addrbook.treeSelected) );
1485 if( ds == NULL ) return;
1486 if( addrindex_ds_get_readonly( ds ) ) {
1487 addressbook_ds_status_message(
1488 ds, _( "Cannot paste. Target address book is readonly." ) );
1492 pobj = gtk_ctree_node_get_row_data( ctree, addrbook.treeSelected );
1494 if( pobj->type == ADDR_ITEM_FOLDER ) {
1495 folder = ADAPTER_FOLDER(pobj)->itemFolder;
1499 abf = addressbook_get_book_file();
1500 if( abf == NULL ) return;
1503 aio = gtk_ctree_node_get_row_data( clist, addrbook.listSelected );
1504 if( aio->type == ADDR_ITEM_PERSON ) {
1507 person = ( ItemPerson * ) aio;
1508 if( _clipBoard_->cutFlag ) {
1510 cnt = addrclip_paste_person_cut( _clipBoard_, abf, person );
1512 /* Remove all "cut" items */
1513 addrclip_delete_address( _clipBoard_ );
1515 /* Clear clipboard */
1516 addrclip_clear( _clipBoard_ );
1520 cnt = addrclip_paste_person_copy( _clipBoard_, abf, person );
1523 addritem_person_set_opened( person, TRUE );
1527 /* Display items pasted */
1529 gtk_ctree_select( ctree, addrbook.opened );
1534 * Add current treenode object to clipboard. Note that widget only allows
1535 * one entry from the tree list to be selected.
1537 static void addressbook_treenode_to_clipboard( void ) {
1538 AddressObject *obj = NULL;
1539 AddressDataSource *ds = NULL;
1540 AddrSelectItem *item;
1541 GtkCTree *ctree = GTK_CTREE( addrbook.ctree );
1544 node = addrbook.treeSelected;
1545 if( node == NULL ) return;
1546 obj = gtk_ctree_node_get_row_data( ctree, node );
1547 if( obj == NULL ) return;
1549 ds = addressbook_find_datasource( node );
1550 if( ds == NULL ) return;
1553 if( obj->type == ADDR_ITEM_FOLDER ) {
1554 AdapterFolder *adapter = ADAPTER_FOLDER(obj);
1555 ItemFolder *folder = adapter->itemFolder;
1557 item = addrselect_create_node( obj );
1558 item->uid = g_strdup( ADDRITEM_ID(folder) );
1560 else if( obj->type == ADDR_ITEM_GROUP ) {
1561 AdapterGroup *adapter = ADAPTER_GROUP(obj);
1562 ItemGroup *group = adapter->itemGroup;
1564 item = addrselect_create_node( obj );
1565 item->uid = g_strdup( ADDRITEM_ID(group) );
1567 else if( obj->type == ADDR_DATASOURCE ) {
1569 item = addrselect_create_node( obj );
1574 /* Clear existing list and add item into list */
1577 addressbook_list_select_clear();
1578 cacheID = addrindex_get_cache_id( _addressIndex_, ds );
1579 addrselect_list_add( _addressSelect_, item, cacheID );
1585 * Cut from tree widget.
1587 static void addressbook_treenode_cut_cb( void ) {
1588 _clipBoard_->cutFlag = TRUE;
1589 addressbook_treenode_to_clipboard();
1590 addrclip_clear( _clipBoard_ );
1591 addrclip_add( _clipBoard_, _addressSelect_ );
1592 /* addrclip_list_show( _clipBoard_, stdout ); */
1596 * Copy from tree widget.
1598 static void addressbook_treenode_copy_cb( void ) {
1599 _clipBoard_->cutFlag = FALSE;
1600 addressbook_treenode_to_clipboard();
1601 addrclip_clear( _clipBoard_ );
1602 addrclip_add( _clipBoard_, _addressSelect_ );
1603 /* addrclip_list_show( _clipBoard_, stdout ); */
1607 * Paste clipboard into address tree widget.
1609 static void addressbook_treenode_paste_cb( void ) {
1610 addressbook_clip_paste_cb();
1613 static void addressbook_list_select_clear( void ) {
1614 addrselect_list_clear( _addressSelect_ );
1617 static void addressbook_list_select_add( AddrItemObject *aio, AddressDataSource *ds ) {
1620 if( ds == NULL ) return;
1621 cacheID = addrindex_get_cache_id( _addressIndex_, ds );
1622 addrselect_list_add_obj( _addressSelect_, aio, cacheID );
1626 static void addressbook_list_select_remove( AddrItemObject *aio ) {
1627 addrselect_list_remove( _addressSelect_, aio );
1630 static void addressbook_list_row_selected( GtkCTree *clist,
1635 GtkEntry *entry = GTK_ENTRY(addrbook.entry);
1636 AddrItemObject *aio = NULL;
1637 AddressObject *pobj = NULL;
1638 AdapterDSource *ads = NULL;
1639 AddressDataSource *ds = NULL;
1641 gtk_entry_set_text( entry, "" );
1642 addrbook.listSelected = node;
1644 pobj = gtk_ctree_node_get_row_data( GTK_CTREE(addrbook.ctree), addrbook.treeSelected );
1645 if( pobj == NULL ) return;
1647 if( pobj->type == ADDR_DATASOURCE ) {
1648 ads = ADAPTER_DSOURCE(pobj);
1649 ds = ads->dataSource;
1651 else if( pobj->type != ADDR_INTERFACE ) {
1652 ds = addressbook_find_datasource( addrbook.treeSelected );
1655 aio = gtk_ctree_node_get_row_data( clist, node );
1657 /* printf( "list select: %d : '%s'\n", aio->type, aio->name ); */
1658 addressbook_list_select_add( aio, ds );
1661 addressbook_list_menu_setup();
1664 static void addressbook_list_row_unselected( GtkCTree *ctree,
1669 AddrItemObject *aio;
1671 aio = gtk_ctree_node_get_row_data( ctree, node );
1673 /* printf( "list unselect: %d : '%s'\n", aio->type, aio->name ); */
1674 addressbook_list_select_remove( aio );
1678 static void addressbook_entry_gotfocus( GtkWidget *widget ) {
1679 gtk_editable_select_region( GTK_EDITABLE(addrbook.entry), 0, -1 );
1682 static void addressbook_list_button_pressed(GtkWidget *widget,
1683 GdkEventButton *event,
1686 if( ! event ) return;
1688 addressbook_list_menu_setup();
1690 if( event->button == 3 ) {
1691 gtk_menu_popup( GTK_MENU(addrbook.list_popup), NULL, NULL, NULL, NULL,
1692 event->button, event->time );
1696 static void addressbook_list_button_released(GtkWidget *widget,
1697 GdkEventButton *event,
1702 static void addressbook_tree_button_pressed(GtkWidget *ctree,
1703 GdkEventButton *event,
1706 GtkCList *clist = GTK_CLIST(ctree);
1708 AddressObject *obj = NULL;
1709 AdapterDSource *ads = NULL;
1710 AddressInterface *iface = NULL;
1711 AddressDataSource *ds = NULL;
1712 gboolean canEdit = FALSE;
1713 gboolean canCut = FALSE;
1714 gboolean canCopy = FALSE;
1715 gboolean canPaste = FALSE;
1716 gboolean canTreeCut = FALSE;
1717 gboolean canTreeCopy = FALSE;
1718 gboolean canTreePaste = FALSE;
1720 if( ! event ) return;
1721 addressbook_menubar_set_sensitive( FALSE );
1723 if( gtk_clist_get_selection_info( clist, event->x, event->y, &row, &column ) ) {
1724 gtk_clist_select_row( clist, row, column );
1725 gtkut_clist_set_focus_row(clist, row);
1726 obj = gtk_clist_get_row_data( clist, row );
1729 menu_set_insensitive_all(GTK_MENU_SHELL(addrbook.tree_popup));
1731 if( obj == NULL ) return;
1733 if( ! addrclip_is_empty( _clipBoard_ ) ) {
1734 canTreePaste = TRUE;
1737 if (obj->type == ADDR_DATASOURCE) {
1738 ads = ADAPTER_DSOURCE(obj);
1739 ds = ads->dataSource;
1740 iface = ds->interface;
1742 if( iface->readOnly ) {
1743 canTreePaste = FALSE;
1746 menu_set_sensitive( addrbook.tree_factory, "/New Address", TRUE );
1747 menu_set_sensitive( addrbook.tree_factory, "/New Folder", TRUE );
1748 menu_set_sensitive( addrbook.tree_factory, "/New Group", TRUE );
1749 gtk_widget_set_sensitive( addrbook.reg_btn, TRUE );
1753 else if (obj->type == ADDR_ITEM_FOLDER) {
1754 ds = addressbook_find_datasource( addrbook.treeSelected );
1755 iface = ds->interface;
1756 if( iface->readOnly ) {
1757 canTreePaste = FALSE;
1762 menu_set_sensitive( addrbook.tree_factory, "/New Address", TRUE );
1763 menu_set_sensitive( addrbook.tree_factory, "/New Folder", TRUE );
1764 menu_set_sensitive( addrbook.tree_factory, "/New Group", TRUE );
1765 gtk_widget_set_sensitive( addrbook.reg_btn, TRUE );
1769 else if (obj->type == ADDR_ITEM_GROUP) {
1770 ds = addressbook_find_datasource( addrbook.treeSelected );
1771 iface = ds->interface;
1772 if( ! iface->readOnly ) {
1774 menu_set_sensitive( addrbook.tree_factory, "/New Address", TRUE );
1775 gtk_widget_set_sensitive( addrbook.reg_btn, TRUE );
1778 else if (obj->type == ADDR_INTERFACE) {
1779 canTreePaste = FALSE;
1783 if( ! addrselect_test_empty( _addressSelect_ ) ) canCut = TRUE;
1785 if( ! addrselect_test_empty( _addressSelect_ ) ) canCopy = TRUE;
1786 if( ! addrclip_is_empty( _clipBoard_ ) ) canPaste = TRUE;
1789 menu_set_sensitive( addrbook.tree_factory, "/Edit", canEdit );
1790 menu_set_sensitive( addrbook.tree_factory, "/Delete", canEdit );
1791 menu_set_sensitive( addrbook.tree_factory, "/Cut", canTreeCut );
1792 menu_set_sensitive( addrbook.tree_factory, "/Copy", canTreeCopy );
1793 menu_set_sensitive( addrbook.tree_factory, "/Paste", canTreePaste );
1795 menu_set_sensitive( addrbook.menu_factory, "/File/Edit", canEdit );
1796 menu_set_sensitive( addrbook.menu_factory, "/File/Delete", canEdit );
1797 menu_set_sensitive( addrbook.menu_factory, "/Edit/Cut", canCut );
1798 menu_set_sensitive( addrbook.menu_factory, "/Edit/Copy", canCopy );
1799 menu_set_sensitive( addrbook.menu_factory, "/Edit/Paste", canPaste );
1800 menu_set_sensitive( addrbook.menu_factory, "/Edit/Paste Address", canPaste );
1802 if( event->button == 3 ) {
1803 gtk_menu_popup(GTK_MENU(addrbook.tree_popup), NULL, NULL, NULL, NULL,
1804 event->button, event->time);
1809 static void addressbook_tree_button_released(GtkWidget *ctree,
1810 GdkEventButton *event,
1813 gtk_ctree_select(GTK_CTREE(addrbook.ctree), addrbook.opened);
1814 gtkut_ctree_set_focus_row(GTK_CTREE(addrbook.ctree), addrbook.opened);
1817 static void addressbook_popup_close(GtkMenuShell *menu_shell, gpointer data)
1819 if (!addrbook.opened) return;
1821 gtk_ctree_select(GTK_CTREE(addrbook.ctree), addrbook.opened);
1822 gtkut_ctree_set_focus_row(GTK_CTREE(addrbook.ctree),
1826 static void addressbook_new_folder_cb(gpointer data, guint action,
1829 GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
1830 AddressObject *obj = NULL;
1831 AddressDataSource *ds = NULL;
1832 AddressBookFile *abf = NULL;
1833 ItemFolder *parentFolder = NULL;
1834 ItemFolder *folder = NULL;
1836 if( ! addrbook.treeSelected ) return;
1837 obj = gtk_ctree_node_get_row_data( ctree, addrbook.treeSelected );
1838 if( obj == NULL ) return;
1839 ds = addressbook_find_datasource( addrbook.treeSelected );
1840 if( ds == NULL ) return;
1842 if( obj->type == ADDR_DATASOURCE ) {
1843 if( ADAPTER_DSOURCE(obj)->subType != ADDR_BOOK ) return;
1845 else if( obj->type == ADDR_ITEM_FOLDER ) {
1846 parentFolder = ADAPTER_FOLDER(obj)->itemFolder;
1852 abf = ds->rawDataSource;
1853 if( abf == NULL ) return;
1854 folder = addressbook_edit_folder( abf, parentFolder, NULL );
1857 nn = addressbook_node_add_folder( addrbook.treeSelected, ds, folder, ADDR_ITEM_FOLDER );
1858 gtk_ctree_expand( ctree, addrbook.treeSelected );
1859 if( addrbook.treeSelected == addrbook.opened ) addressbook_set_clist(obj);
1864 static void addressbook_new_group_cb(gpointer data, guint action,
1867 GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
1868 AddressObject *obj = NULL;
1869 AddressDataSource *ds = NULL;
1870 AddressBookFile *abf = NULL;
1871 ItemFolder *parentFolder = NULL;
1872 ItemGroup *group = NULL;
1874 if( ! addrbook.treeSelected ) return;
1875 obj = gtk_ctree_node_get_row_data(ctree, addrbook.treeSelected);
1876 if( obj == NULL ) return;
1877 ds = addressbook_find_datasource( addrbook.treeSelected );
1878 if( ds == NULL ) return;
1880 if( obj->type == ADDR_DATASOURCE ) {
1881 if( ADAPTER_DSOURCE(obj)->subType != ADDR_BOOK ) return;
1883 else if( obj->type == ADDR_ITEM_FOLDER ) {
1884 parentFolder = ADAPTER_FOLDER(obj)->itemFolder;
1890 abf = ds->rawDataSource;
1891 if( abf == NULL ) return;
1892 group = addressbook_edit_group( abf, parentFolder, NULL );
1895 nn = addressbook_node_add_group( addrbook.treeSelected, ds, group );
1896 gtk_ctree_expand( ctree, addrbook.treeSelected );
1897 if( addrbook.treeSelected == addrbook.opened ) addressbook_set_clist(obj);
1902 static void addressbook_change_node_name(GtkCTreeNode *node, const gchar *name)
1904 GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
1907 GdkPixmap *pix_cl, *pix_op;
1908 GdkBitmap *mask_cl, *mask_op;
1909 gboolean is_leaf, expanded;
1911 gtk_ctree_get_node_info(ctree, node, text, &spacing,
1912 &pix_cl, &mask_cl, &pix_op, &mask_op,
1913 &is_leaf, &expanded);
1914 gtk_ctree_set_node_info(ctree, node, name, spacing,
1915 pix_cl, mask_cl, pix_op, mask_op,
1921 * Enter: obj Address object to edit.
1922 * node Node in tree.
1923 * Return: New name of data source.
1925 static gchar *addressbook_edit_datasource( AddressObject *obj, GtkCTreeNode *node ) {
1926 gchar *newName = NULL;
1927 AddressDataSource *ds = NULL;
1928 AddressInterface *iface = NULL;
1929 AdapterDSource *ads = NULL;
1931 ds = addressbook_find_datasource( node );
1932 if( ds == NULL ) return NULL;
1933 iface = ds->interface;
1934 if( ! iface->haveLibrary ) return NULL;
1936 /* Read data from data source */
1937 if( ! addrindex_ds_get_read_flag( ds ) ) {
1938 addrindex_ds_read_data( ds );
1942 ads = ADAPTER_DSOURCE(obj);
1943 if( ads->subType == ADDR_BOOK ) {
1944 if( addressbook_edit_book( _addressIndex_, ads ) == NULL ) return NULL;
1946 else if( ads->subType == ADDR_VCARD ) {
1947 if( addressbook_edit_vcard( _addressIndex_, ads ) == NULL ) return NULL;
1950 else if( ads->subType == ADDR_JPILOT ) {
1951 if( addressbook_edit_jpilot( _addressIndex_, ads ) == NULL ) return NULL;
1955 else if( ads->subType == ADDR_LDAP ) {
1956 if( addressbook_edit_ldap( _addressIndex_, ads ) == NULL ) return NULL;
1962 newName = obj->name;
1967 * Edit an object that is in the address tree area.
1969 static void addressbook_treenode_edit_cb(gpointer data, guint action,
1972 GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
1974 AddressDataSource *ds = NULL;
1975 AddressBookFile *abf = NULL;
1976 GtkCTreeNode *node = NULL, *parentNode = NULL;
1979 if( ! addrbook.treeSelected ) return;
1980 node = addrbook.treeSelected;
1981 if( GTK_CTREE_ROW(node)->level == 1 ) return;
1982 obj = gtk_ctree_node_get_row_data( ctree, node );
1983 if( obj == NULL ) return;
1984 parentNode = GTK_CTREE_ROW(node)->parent;
1986 ds = addressbook_find_datasource( node );
1987 if( ds == NULL ) return;
1989 if( obj->type == ADDR_DATASOURCE ) {
1990 name = addressbook_edit_datasource( obj, node );
1991 if( name == NULL ) return;
1994 abf = ds->rawDataSource;
1995 if( abf == NULL ) return;
1996 if( obj->type == ADDR_ITEM_FOLDER ) {
1997 AdapterFolder *adapter = ADAPTER_FOLDER(obj);
1998 ItemFolder *item = adapter->itemFolder;
1999 ItemFolder *parentFolder = NULL;
2000 parentFolder = ( ItemFolder * ) ADDRITEM_PARENT(item);
2001 if( addressbook_edit_folder( abf, parentFolder, item ) == NULL ) return;
2002 name = ADDRITEM_NAME(item);
2004 else if( obj->type == ADDR_ITEM_GROUP ) {
2005 AdapterGroup *adapter = ADAPTER_GROUP(obj);
2006 ItemGroup *item = adapter->itemGroup;
2007 ItemFolder *parentFolder = NULL;
2008 parentFolder = ( ItemFolder * ) ADDRITEM_PARENT(item);
2009 if( addressbook_edit_group( abf, parentFolder, item ) == NULL ) return;
2010 name = ADDRITEM_NAME(item);
2013 if( name && parentNode ) {
2014 /* Update node in tree view */
2015 addressbook_change_node_name( node, name );
2016 gtk_ctree_sort_node(ctree, parentNode);
2017 gtk_ctree_expand( ctree, node );
2018 gtk_ctree_select( ctree, node );
2023 * Delete an item from the tree widget.
2025 static void addressbook_treenode_delete_cb(gpointer data, guint action,
2028 GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
2029 GtkCTreeNode *node = NULL;
2033 AddressBookFile *abf = NULL;
2034 AdapterDSource *ads = NULL;
2035 AddressInterface *iface = NULL;
2036 AddressDataSource *ds = NULL;
2037 gboolean remFlag = FALSE;
2039 if( ! addrbook.treeSelected ) return;
2040 node = addrbook.treeSelected;
2041 if( GTK_CTREE_ROW(node)->level == 1 ) return;
2043 obj = gtk_ctree_node_get_row_data( ctree, node );
2044 g_return_if_fail(obj != NULL);
2046 if( obj->type == ADDR_DATASOURCE ) {
2047 ads = ADAPTER_DSOURCE(obj);
2048 if( ads == NULL ) return;
2049 ds = ads->dataSource;
2050 if( ds == NULL ) return;
2053 /* Must be folder or something else */
2054 ds = addressbook_find_datasource( node );
2055 if( ds == NULL ) return;
2057 /* Only allow deletion from non-readOnly data sources */
2058 iface = ds->interface;
2059 if( iface->readOnly ) return;
2062 /* Confirm deletion */
2063 if( obj->type == ADDR_ITEM_FOLDER ) {
2064 message = g_strdup_printf( _(
2065 "Do you want to delete the folder AND all addresses in `%s' ? \n" \
2066 "If deleting the folder only, addresses will be moved into parent folder." ),
2068 aval = alertpanel( _("Delete"), message,
2069 _("Folder only"), _("Folder and Addresses"), _("Cancel") );
2071 if( aval == G_ALERTOTHER ) return;
2074 message = g_strdup_printf(_("Really delete `%s' ?"), obj->name);
2075 aval = alertpanel(_("Delete"), message, _("Yes"), _("No"), NULL);
2077 if (aval != G_ALERTDEFAULT) return;
2080 /* Proceed with deletion */
2081 if( obj->type == ADDR_DATASOURCE ) {
2082 /* Remove data source. */
2083 if( addrindex_index_remove_datasource( _addressIndex_, ds ) ) {
2084 addrindex_free_datasource( ds );
2089 abf = addressbook_get_book_file();
2090 if( abf == NULL ) return;
2093 if( obj->type == ADDR_ITEM_FOLDER ) {
2094 AdapterFolder *adapter = ADAPTER_FOLDER(obj);
2095 ItemFolder *item = adapter->itemFolder;
2096 if( aval == G_ALERTDEFAULT ) {
2097 /* Remove folder only */
2098 item = addrbook_remove_folder( abf, item );
2100 addritem_free_item_folder( item );
2101 addressbook_move_nodes_up( ctree, node );
2105 else if( aval == G_ALERTALTERNATE ) {
2106 /* Remove folder and addresses */
2107 item = addrbook_remove_folder_delete( abf, item );
2109 addritem_free_item_folder( item );
2114 else if( obj->type == ADDR_ITEM_GROUP ) {
2115 AdapterGroup *adapter = ADAPTER_GROUP(obj);
2116 ItemGroup *item = adapter->itemGroup;
2118 item = addrbook_remove_group( abf, item );
2120 addritem_free_item_group( item );
2127 gtk_ctree_remove_node(ctree, node );
2131 static void addressbook_new_address_cb( gpointer data, guint action, GtkWidget *widget ) {
2132 AddressObject *pobj = NULL;
2133 AddressDataSource *ds = NULL;
2134 AddressBookFile *abf = NULL;
2136 pobj = gtk_ctree_node_get_row_data(GTK_CTREE(addrbook.ctree), addrbook.treeSelected);
2137 if( pobj == NULL ) return;
2138 ds = addressbook_find_datasource( GTK_CTREE_NODE(addrbook.treeSelected) );
2139 if( ds == NULL ) return;
2141 abf = ds->rawDataSource;
2142 if( abf == NULL ) return;
2144 if( pobj->type == ADDR_DATASOURCE ) {
2145 if( ADAPTER_DSOURCE(pobj)->subType == ADDR_BOOK ) {
2147 ItemPerson *person = addressbook_edit_person( abf, NULL, NULL, FALSE );
2149 if( addrbook.treeSelected == addrbook.opened ) {
2150 gtk_ctree_select( GTK_CTREE(addrbook.ctree), addrbook.opened );
2155 else if( pobj->type == ADDR_ITEM_FOLDER ) {
2157 ItemFolder *folder = ADAPTER_FOLDER(pobj)->itemFolder;
2158 ItemPerson *person = addressbook_edit_person( abf, folder, NULL, FALSE );
2160 if (addrbook.treeSelected == addrbook.opened) {
2161 gtk_ctree_select( GTK_CTREE(addrbook.ctree), addrbook.opened );
2165 else if( pobj->type == ADDR_ITEM_GROUP ) {
2166 /* New address in group */
2167 ItemGroup *group = ADAPTER_GROUP(pobj)->itemGroup;
2168 if( addressbook_edit_group( abf, NULL, group ) == NULL ) return;
2169 if (addrbook.treeSelected == addrbook.opened) {
2170 /* Change node name in tree. */
2171 addressbook_change_node_name( addrbook.treeSelected, ADDRITEM_NAME(group) );
2172 gtk_ctree_select( GTK_CTREE(addrbook.ctree), addrbook.opened );
2178 * Search for specified child group node in address index tree.
2179 * Enter: parent Parent node.
2180 * group Group to find.
2182 static GtkCTreeNode *addressbook_find_group_node( GtkCTreeNode *parent, ItemGroup *group ) {
2183 GtkCTreeNode *node = NULL;
2184 GtkCTreeRow *currRow;
2186 currRow = GTK_CTREE_ROW( parent );
2188 node = currRow->children;
2192 obj = gtk_ctree_node_get_row_data( GTK_CTREE(addrbook.ctree), node );
2193 if( obj->type == ADDR_ITEM_GROUP ) {
2194 ItemGroup *g = ADAPTER_GROUP(obj)->itemGroup;
2195 if( g == group ) return node;
2197 currRow = GTK_CTREE_ROW(node);
2198 node = currRow->sibling;
2205 * Search for specified child folder node in address index tree.
2206 * Enter: parent Parent node.
2207 * folder Folder to find.
2209 static GtkCTreeNode *addressbook_find_folder_node( GtkCTreeNode *parent, ItemFolder *folder ) {
2210 GtkCTreeNode *node = NULL;
2211 GtkCTreeRow *currRow;
2213 currRow = GTK_CTREE_ROW( parent );
2215 node = currRow->children;
2219 obj = gtk_ctree_node_get_row_data( GTK_CTREE(addrbook.ctree), node );
2220 if( obj->type == ADDR_ITEM_FOLDER ) {
2221 ItemFolder *f = ADAPTER_FOLDER(obj)->itemFolder;
2222 if( f == folder ) return node;
2224 currRow = GTK_CTREE_ROW(node);
2225 node = currRow->sibling;
2231 static AddressBookFile *addressbook_get_book_file() {
2232 AddressBookFile *abf = NULL;
2233 AddressDataSource *ds = NULL;
2235 ds = addressbook_find_datasource( addrbook.treeSelected );
2236 if( ds == NULL ) return NULL;
2237 if( ds->type == ADDR_IF_BOOK ) abf = ds->rawDataSource;
2241 static void addressbook_tree_remove_children( GtkCTree *ctree, GtkCTreeNode *parent ) {
2245 /* Remove existing folders and groups */
2246 row = GTK_CTREE_ROW( parent );
2248 while( (node = row->children) ) {
2249 gtk_ctree_remove_node( ctree, node );
2254 static void addressbook_move_nodes_up( GtkCTree *ctree, GtkCTreeNode *node ) {
2255 GtkCTreeNode *parent, *child;
2256 GtkCTreeRow *currRow;
2257 currRow = GTK_CTREE_ROW( node );
2259 parent = currRow->parent;
2260 while( (child = currRow->children) ) {
2261 gtk_ctree_move( ctree, child, parent, node );
2263 gtk_ctree_sort_node( ctree, parent );
2267 static void addressbook_edit_address_cb( gpointer data, guint action, GtkWidget *widget ) {
2268 GtkCTree *clist = GTK_CTREE(addrbook.clist);
2270 AddressObject *obj = NULL, *pobj = NULL;
2271 AddressDataSource *ds = NULL;
2272 GtkCTreeNode *node = NULL, *parentNode = NULL;
2274 AddressBookFile *abf = NULL;
2276 if( addrbook.listSelected == NULL ) return;
2277 obj = gtk_ctree_node_get_row_data( clist, addrbook.listSelected );
2278 g_return_if_fail(obj != NULL);
2280 ctree = GTK_CTREE( addrbook.ctree );
2281 pobj = gtk_ctree_node_get_row_data( ctree, addrbook.treeSelected );
2282 node = gtk_ctree_find_by_row_data( ctree, addrbook.treeSelected, obj );
2284 ds = addressbook_find_datasource( GTK_CTREE_NODE(addrbook.treeSelected) );
2285 if( ds == NULL ) return;
2287 abf = addressbook_get_book_file();
2288 if( abf == NULL ) return;
2289 if( obj->type == ADDR_ITEM_EMAIL ) {
2290 ItemEMail *email = ( ItemEMail * ) obj;
2291 if( email == NULL ) return;
2292 if( pobj && pobj->type == ADDR_ITEM_GROUP ) {
2293 /* Edit parent group */
2294 AdapterGroup *adapter = ADAPTER_GROUP(pobj);
2295 ItemGroup *itemGrp = adapter->itemGroup;
2296 if( addressbook_edit_group( abf, NULL, itemGrp ) == NULL ) return;
2297 name = ADDRITEM_NAME(itemGrp);
2298 node = addrbook.treeSelected;
2299 parentNode = GTK_CTREE_ROW(node)->parent;
2302 /* Edit person - email page */
2304 person = ( ItemPerson * ) ADDRITEM_PARENT(email);
2305 if( addressbook_edit_person( abf, NULL, person, TRUE ) == NULL ) return;
2306 gtk_ctree_select( ctree, addrbook.opened );
2307 invalidate_address_completion();
2311 else if( obj->type == ADDR_ITEM_PERSON ) {
2312 /* Edit person - basic page */
2313 ItemPerson *person = ( ItemPerson * ) obj;
2314 if( addressbook_edit_person( abf, NULL, person, FALSE ) == NULL ) return;
2315 gtk_ctree_select( ctree, addrbook.opened);
2316 invalidate_address_completion();
2319 else if( obj->type == ADDR_ITEM_GROUP ) {
2320 ItemGroup *itemGrp = ( ItemGroup * ) obj;
2321 if( addressbook_edit_group( abf, NULL, itemGrp ) == NULL ) return;
2322 parentNode = addrbook.treeSelected;
2323 node = addressbook_find_group_node( parentNode, itemGrp );
2324 name = ADDRITEM_NAME(itemGrp);
2330 /* Update tree node with node name */
2331 if( node == NULL ) return;
2332 addressbook_change_node_name( node, name );
2333 gtk_ctree_sort_node( ctree, parentNode );
2334 gtk_ctree_select( ctree, addrbook.opened );
2337 static void addressbook_delete_address_cb(gpointer data, guint action,
2340 addressbook_del_clicked(NULL, NULL);
2343 static void close_cb(gpointer data, guint action, GtkWidget *widget)
2345 addressbook_close();
2348 static void addressbook_file_save_cb( gpointer data, guint action, GtkWidget *widget ) {
2349 addressbook_export_to_file();
2352 static void addressbook_person_expand_node( GtkCTree *ctree, GList *node, gpointer *data ) {
2354 ItemPerson *person = gtk_ctree_node_get_row_data( ctree, GTK_CTREE_NODE(node) );
2355 if( person ) addritem_person_set_opened( person, TRUE );
2359 static void addressbook_person_collapse_node( GtkCTree *ctree, GList *node, gpointer *data ) {
2361 ItemPerson *person = gtk_ctree_node_get_row_data( ctree, GTK_CTREE_NODE(node) );
2362 if( person ) addritem_person_set_opened( person, FALSE );
2366 static gchar *addressbook_format_item_clist( ItemPerson *person, ItemEMail *email ) {
2368 gchar *eMailAlias = ADDRITEM_NAME(email);
2369 if( eMailAlias && *eMailAlias != '\0' ) {
2371 str = g_strdup_printf( "%s - %s", ADDRITEM_NAME(person), eMailAlias );
2374 str = g_strdup( eMailAlias );
2380 static void addressbook_load_group( GtkCTree *clist, ItemGroup *itemGroup ) {
2381 GList *items = itemGroup->listEMail;
2382 AddressTypeControlItem *atci = addrbookctl_lookup( ADDR_ITEM_EMAIL );
2383 for( ; items != NULL; items = g_list_next( items ) ) {
2384 GtkCTreeNode *nodeEMail = NULL;
2385 gchar *text[N_COLS];
2386 ItemEMail *email = items->data;
2390 if( ! email ) continue;
2392 person = ( ItemPerson * ) ADDRITEM_PARENT(email);
2393 str = addressbook_format_item_clist( person, email );
2395 text[COL_NAME] = str;
2398 text[COL_NAME] = ADDRITEM_NAME(person);
2400 text[COL_ADDRESS] = email->address;
2401 text[COL_REMARKS] = email->remarks;
2402 nodeEMail = gtk_ctree_insert_node(
2404 text, FOLDER_SPACING,
2405 atci->iconXpm, atci->maskXpm,
2406 atci->iconXpmOpen, atci->maskXpmOpen,
2408 gtk_ctree_node_set_row_data( clist, nodeEMail, email );
2414 static void addressbook_folder_load_person( GtkCTree *clist, ItemFolder *itemFolder ) {
2416 AddressTypeControlItem *atci = addrbookctl_lookup( ADDR_ITEM_PERSON );
2417 AddressTypeControlItem *atciMail = addrbookctl_lookup( ADDR_ITEM_EMAIL );
2419 if( atci == NULL ) return;
2420 if( atciMail == NULL ) return;
2422 /* Load email addresses */
2423 items = addritem_folder_get_person_list( itemFolder );
2424 for( ; items != NULL; items = g_list_next( items ) ) {
2425 GtkCTreeNode *nodePerson = NULL;
2426 GtkCTreeNode *nodeEMail = NULL;
2427 gchar *text[N_COLS];
2428 gboolean flgFirst = TRUE, haveAddr = FALSE;
2432 person = ( ItemPerson * ) items->data;
2433 if( person == NULL ) continue;
2435 text[COL_NAME] = NULL;
2436 node = person->listEMail;
2438 ItemEMail *email = node->data;
2439 gchar *eMailAddr = NULL;
2440 node = g_list_next( node );
2442 text[COL_ADDRESS] = email->address;
2443 text[COL_REMARKS] = email->remarks;
2444 eMailAddr = ADDRITEM_NAME(email);
2445 if( eMailAddr && *eMailAddr == '\0' ) eMailAddr = NULL;
2447 /* First email belongs with person */
2448 gchar *str = addressbook_format_item_clist( person, email );
2450 text[COL_NAME] = str;
2453 text[COL_NAME] = ADDRITEM_NAME(person);
2455 nodePerson = gtk_ctree_insert_node(
2457 text, FOLDER_SPACING,
2458 atci->iconXpm, atci->maskXpm,
2459 atci->iconXpmOpen, atci->maskXpmOpen,
2460 FALSE, person->isOpened );
2463 gtk_ctree_node_set_row_data(clist, nodePerson, person );
2466 /* Subsequent email is a child node of person */
2467 text[COL_NAME] = ADDRITEM_NAME(email);
2468 nodeEMail = gtk_ctree_insert_node(
2469 clist, nodePerson, NULL,
2470 text, FOLDER_SPACING,
2471 atciMail->iconXpm, atciMail->maskXpm,
2472 atciMail->iconXpmOpen, atciMail->maskXpmOpen,
2474 gtk_ctree_node_set_row_data(clist, nodeEMail, email );
2480 /* Have name without EMail */
2481 text[COL_NAME] = ADDRITEM_NAME(person);
2482 text[COL_ADDRESS] = NULL;
2483 text[COL_REMARKS] = NULL;
2484 nodePerson = gtk_ctree_insert_node(
2486 text, FOLDER_SPACING,
2487 atci->iconXpm, atci->maskXpm,
2488 atci->iconXpmOpen, atci->maskXpmOpen,
2489 FALSE, person->isOpened );
2490 gtk_ctree_node_set_row_data(clist, nodePerson, person );
2492 gtk_ctree_sort_node(GTK_CTREE(clist), NULL);
2494 /* Free up the list */
2495 mgu_clear_list( items );
2496 g_list_free( items );
2499 static void addressbook_folder_load_group( GtkCTree *clist, ItemFolder *itemFolder ) {
2501 AddressTypeControlItem *atci = addrbookctl_lookup( ADDR_ITEM_GROUP );
2503 /* Load any groups */
2504 if( ! atci ) return;
2505 items = addritem_folder_get_group_list( itemFolder );
2506 for( ; items != NULL; items = g_list_next( items ) ) {
2507 GtkCTreeNode *nodeGroup = NULL;
2508 gchar *text[N_COLS];
2509 ItemGroup *group = items->data;
2510 if( group == NULL ) continue;
2511 text[COL_NAME] = ADDRITEM_NAME(group);
2512 text[COL_ADDRESS] = NULL;
2513 text[COL_REMARKS] = NULL;
2514 nodeGroup = gtk_ctree_insert_node(clist, NULL, NULL,
2515 text, FOLDER_SPACING,
2516 atci->iconXpm, atci->maskXpm,
2517 atci->iconXpmOpen, atci->maskXpmOpen,
2519 gtk_ctree_node_set_row_data(clist, nodeGroup, group );
2520 gtk_ctree_sort_node(clist, NULL);
2522 /* Free up the list */
2523 mgu_clear_list( items );
2524 g_list_free( items );
2528 * Load data sources into list.
2530 static void addressbook_node_load_datasource( GtkCTree *clist, AddressObject *obj ) {
2531 AdapterInterface *adapter;
2532 AddressInterface *iface;
2533 AddressTypeControlItem *atci = NULL;
2534 GtkCTreeNode *newNode, *node;
2536 GtkCell *cell = NULL;
2537 gchar *text[N_COLS];
2539 adapter = ADAPTER_INTERFACE(obj);
2540 if( adapter == NULL ) return;
2541 iface = adapter->interface;
2542 atci = adapter->atci;
2543 if( atci == NULL ) return;
2545 /* Create nodes in list copying values for data sources in tree */
2546 row = GTK_CTREE_ROW( adapter->treeNode );
2548 node = row->children;
2552 data = gtk_ctree_node_get_row_data( clist, node );
2553 row = GTK_CTREE_ROW( node );
2554 cell = ( ( GtkCListRow * )row )->cell;
2555 text[COL_NAME] = cell->u.text;
2556 text[COL_ADDRESS] = NULL;
2557 text[COL_REMARKS] = NULL;
2558 newNode = gtk_ctree_insert_node( clist, NULL, NULL,
2559 text, FOLDER_SPACING,
2560 atci->iconXpm, atci->maskXpm,
2561 atci->iconXpmOpen, atci->maskXpmOpen,
2564 gtk_ctree_node_set_row_data( clist, newNode, data );
2565 gtk_ctree_node_set_row_data_full( clist, newNode, NULL, NULL );
2567 node = row->sibling;
2570 gtk_ctree_sort_node( clist, NULL );
2574 * Search ctree widget callback function.
2575 * Enter: pA Pointer to node.
2576 * pB Pointer to data item being sought.
2577 * Return: Zero (0) if group found.
2579 static int addressbook_treenode_find_group_cb( gconstpointer pA, gconstpointer pB ) {
2582 aoA = ( AddressObject * ) pA;
2583 if( aoA->type == ADDR_ITEM_GROUP ) {
2584 ItemGroup *group, *grp;
2586 grp = ADAPTER_GROUP(aoA)->itemGroup;
2587 group = ( ItemGroup * ) pB;
2588 if( grp == group ) return 0; /* Found group */
2594 * Search ctree widget callback function.
2595 * Enter: pA Pointer to node.
2596 * pB Pointer to data item being sought.
2597 * Return: Zero (0) if folder found.
2599 static int addressbook_treenode_find_folder_cb( gconstpointer pA, gconstpointer pB ) {
2602 aoA = ( AddressObject * ) pA;
2603 if( aoA->type == ADDR_ITEM_FOLDER ) {
2604 ItemFolder *folder, *fld;
2606 fld = ADAPTER_FOLDER(aoA)->itemFolder;
2607 folder = ( ItemFolder * ) pB;
2608 if( fld == folder ) return 0; /* Found folder */
2614 * Remove folder and group nodes from tree widget for items contained ("cut")
2617 static void addressbook_treenode_remove_item( void ) {
2619 AddrSelectItem *cutItem;
2620 AddressCache *cache;
2621 AddrItemObject *aio;
2622 GtkCTree *ctree = GTK_CTREE( addrbook.ctree );
2625 node = _clipBoard_->objectList;
2627 cutItem = node->data;
2628 node = g_list_next( node );
2629 cache = addrindex_get_cache(
2630 _clipBoard_->addressIndex, cutItem->cacheID );
2631 if( cache == NULL ) continue;
2632 aio = addrcache_get_object( cache, cutItem->uid );
2635 if( ADDRITEM_TYPE(aio) == ITEMTYPE_FOLDER ) {
2638 folder = ( ItemFolder * ) aio;
2639 tn = gtk_ctree_find_by_row_data_custom(
2640 ctree, NULL, folder,
2641 addressbook_treenode_find_folder_cb );
2643 else if( ADDRITEM_TYPE(aio) == ITEMTYPE_GROUP ) {
2646 group = ( ItemGroup * ) aio;
2647 tn = gtk_ctree_find_by_row_data_custom(
2649 addressbook_treenode_find_group_cb );
2653 /* Free up adapter and remove node. */
2654 gtk_ctree_remove_node( ctree, tn );
2661 * Find parent datasource for specified tree node.
2662 * Enter: node Node to test.
2663 * Return: Data source, or NULL if not found.
2665 static AddressDataSource *addressbook_find_datasource( GtkCTreeNode *node ) {
2666 AddressDataSource *ds = NULL;
2669 g_return_val_if_fail(addrbook.ctree != NULL, NULL);
2672 if( GTK_CTREE_ROW(node)->level < 2 ) return NULL;
2673 ao = gtk_ctree_node_get_row_data( GTK_CTREE(addrbook.ctree), node );
2675 /* printf( "ao->type = %d\n", ao->type ); */
2676 if( ao->type == ADDR_DATASOURCE ) {
2677 AdapterDSource *ads = ADAPTER_DSOURCE(ao);
2678 /* printf( "found it\n" ); */
2679 ds = ads->dataSource;
2683 node = GTK_CTREE_ROW(node)->parent;
2689 * Load address list widget with children of specified object.
2690 * Enter: obj Parent object to be loaded.
2692 static void addressbook_set_clist( AddressObject *obj ) {
2693 GtkCTree *ctreelist = GTK_CTREE(addrbook.clist);
2694 GtkCList *clist = GTK_CLIST(addrbook.clist);
2695 AddressDataSource *ds = NULL;
2696 AdapterDSource *ads = NULL;
2699 gtk_clist_clear(clist);
2703 if( obj->type == ADDR_INTERFACE ) {
2704 /* printf( "set_clist: loading datasource...\n" ); */
2705 /* addressbook_node_load_datasource( GTK_CTREE(clist), obj ); */
2709 gtk_clist_freeze(clist);
2710 gtk_clist_clear(clist);
2712 if( obj->type == ADDR_DATASOURCE ) {
2713 ads = ADAPTER_DSOURCE(obj);
2714 ds = ADAPTER_DSOURCE(obj)->dataSource;
2716 /* Load root folder */
2717 ItemFolder *rootFolder = NULL;
2718 rootFolder = addrindex_ds_get_root_folder( ds );
2719 addressbook_folder_load_person( ctreelist, addrindex_ds_get_root_folder( ds ) );
2720 addressbook_folder_load_group( ctreelist, addrindex_ds_get_root_folder( ds ) );
2724 if( obj->type == ADDR_ITEM_GROUP ) {
2726 ItemGroup *itemGroup = ADAPTER_GROUP(obj)->itemGroup;
2727 addressbook_load_group( ctreelist, itemGroup );
2729 else if( obj->type == ADDR_ITEM_FOLDER ) {
2731 ItemFolder *itemFolder = ADAPTER_FOLDER(obj)->itemFolder;
2732 addressbook_folder_load_person( ctreelist, itemFolder );
2733 addressbook_folder_load_group( ctreelist, itemFolder );
2736 /* gtk_clist_sort(clist); */
2737 gtk_clist_thaw(clist);
2741 * Call back function to free adaptor. Call back is setup by function
2742 * gtk_ctree_node_set_row_data_full() when node is populated. This function is
2743 * called when the address book tree widget node is removed by calling
2744 * function gtk_ctree_remove_node().
2745 * Enter: data Tree node's row data.
2747 static void addressbook_free_treenode( gpointer data ) {
2750 ao = ( AddressObject * ) data;
2751 if( ao == NULL ) return;
2752 if( ao->type == ADDR_INTERFACE ) {
2753 AdapterInterface *ai = ADAPTER_INTERFACE(ao);
2754 addrbookctl_free_interface( ai );
2756 else if( ao->type == ADDR_DATASOURCE ) {
2757 AdapterDSource *ads = ADAPTER_DSOURCE(ao);
2758 addrbookctl_free_datasource( ads );
2760 else if( ao->type == ADDR_ITEM_FOLDER ) {
2761 AdapterFolder *af = ADAPTER_FOLDER(ao);
2762 addrbookctl_free_folder( af );
2764 else if( ao->type == ADDR_ITEM_GROUP ) {
2765 AdapterGroup *ag = ADAPTER_GROUP(ao);
2766 addrbookctl_free_group( ag );
2771 * Create new adaptor for specified data source.
2773 AdapterDSource *addressbook_create_ds_adapter( AddressDataSource *ds,
2774 AddressObjectType otype, gchar *name )
2776 AdapterDSource *adapter = g_new0( AdapterDSource, 1 );
2777 ADDRESS_OBJECT(adapter)->type = ADDR_DATASOURCE;
2778 ADDRESS_OBJECT_NAME(adapter) = g_strdup( name );
2779 adapter->dataSource = ds;
2780 adapter->subType = otype;
2784 void addressbook_ads_set_name( AdapterDSource *adapter, gchar *value ) {
2785 ADDRESS_OBJECT_NAME(adapter) = mgu_replace_string( ADDRESS_OBJECT_NAME(adapter), value );
2789 * Load tree from address index with the initial data.
2791 static void addressbook_load_tree( void ) {
2792 GtkCTree *ctree = GTK_CTREE( addrbook.ctree );
2793 GList *nodeIf, *nodeDS;
2794 AdapterInterface *adapter;
2795 AddressInterface *iface;
2796 AddressTypeControlItem *atci;
2797 AddressDataSource *ds;
2798 AdapterDSource *ads;
2799 GtkCTreeNode *node, *newNode;
2802 nodeIf = _addressInterfaceList_;
2804 adapter = nodeIf->data;
2805 node = adapter->treeNode;
2806 iface = adapter->interface;
2807 atci = adapter->atci;
2809 if( iface->useInterface ) {
2810 /* Load data sources below interface node */
2811 nodeDS = iface->listSource;
2815 name = addrindex_ds_get_name( ds );
2816 ads = addressbook_create_ds_adapter( ds, atci->objectType, name );
2817 newNode = addressbook_add_object( node, ADDRESS_OBJECT(ads) );
2818 nodeDS = g_list_next( nodeDS );
2820 gtk_ctree_expand( ctree, node );
2823 nodeIf = g_list_next( nodeIf );
2828 * Convert the old address book to new format.
2830 static gboolean addressbook_convert( AddressIndex *addrIndex ) {
2831 gboolean retVal = FALSE;
2832 gboolean errFlag = TRUE;
2835 /* Read old address book, performing conversion */
2836 debug_print( "Reading and converting old address book...\n" );
2837 addrindex_set_file_name( addrIndex, ADDRESSBOOK_OLD_FILE );
2838 addrindex_read_data( addrIndex );
2839 if( addrIndex->retVal == MGU_NO_FILE ) {
2840 /* We do not have a file - new user */
2841 debug_print( "New user... create new books...\n" );
2842 addrindex_create_new_books( addrIndex );
2843 if( addrIndex->retVal == MGU_SUCCESS ) {
2844 /* Save index file */
2845 addrindex_set_file_name( addrIndex, ADDRESSBOOK_INDEX_FILE );
2846 addrindex_save_data( addrIndex );
2847 if( addrIndex->retVal == MGU_SUCCESS ) {
2852 msg = _( "New user, could not save index file." );
2856 msg = _( "New user, could not save address book files." );
2860 /* We have an old file */
2861 if( addrIndex->wasConverted ) {
2862 /* Converted successfully - save address index */
2863 addrindex_set_file_name( addrIndex, ADDRESSBOOK_INDEX_FILE );
2864 addrindex_save_data( addrIndex );
2865 if( addrIndex->retVal == MGU_SUCCESS ) {
2866 msg = _( "Old address book converted successfully." );
2871 msg = _("Old address book converted,\n"
2872 "could not save new address index file" );
2876 /* File conversion failed - just create new books */
2877 debug_print( "File conversion failed... just create new books...\n" );
2878 addrindex_create_new_books( addrIndex );
2879 if( addrIndex->retVal == MGU_SUCCESS ) {
2881 addrindex_set_file_name( addrIndex, ADDRESSBOOK_INDEX_FILE );
2882 addrindex_save_data( addrIndex );
2883 if( addrIndex->retVal == MGU_SUCCESS ) {
2884 msg = _("Could not convert address book,\n"
2885 "but created empty new address book files." );
2890 msg = _("Could not convert address book,\n"
2891 "could not create new address book files." );
2895 msg = _("Could not convert address book\n"
2896 "and could not create new address book files." );
2901 debug_print( "Error\n%s\n", msg );
2902 alertpanel( _( "Addressbook conversion error" ), msg, _( "Close" ), NULL, NULL );
2905 debug_print( "Warning\n%s\n", msg );
2906 alertpanel( _( "Addressbook conversion" ), msg, _( "Close" ), NULL, NULL );
2912 void addressbook_read_file( void ) {
2913 AddressIndex *addrIndex = NULL;
2915 debug_print( "Reading address index...\n" );
2916 if( _addressIndex_ ) {
2917 debug_print( "address book already read!!!\n" );
2921 addrIndex = addrindex_create_index();
2923 /* Use new address book index. */
2924 addrindex_set_file_path( addrIndex, get_rc_dir() );
2925 addrindex_set_file_name( addrIndex, ADDRESSBOOK_INDEX_FILE );
2926 addrindex_read_data( addrIndex );
2927 if( addrIndex->retVal == MGU_NO_FILE ) {
2928 /* Conversion required */
2929 debug_print( "Converting...\n" );
2930 if( addressbook_convert( addrIndex ) ) {
2931 _addressIndex_ = addrIndex;
2934 else if( addrIndex->retVal == MGU_SUCCESS ) {
2935 _addressIndex_ = addrIndex;
2938 /* Error reading address book */
2939 debug_print( "Could not read address index.\n" );
2940 addrindex_print_index( addrIndex, stdout );
2941 alertpanel( _( "Addressbook Error" ),
2942 _( "Could not read address index" ),
2943 _( "Close" ), NULL, NULL );
2945 debug_print( "done.\n" );
2949 * Add object into the address index tree widget.
2950 * Enter: node Parent node.
2951 * obj Object to add.
2952 * Return: Node that was added, or NULL if object not added.
2954 static GtkCTreeNode *addressbook_add_object(GtkCTreeNode *node,
2957 GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
2958 GtkCTreeNode *added;
2959 AddressObject *pobj;
2960 AddressObjectType otype;
2961 AddressTypeControlItem *atci = NULL;
2963 g_return_val_if_fail(node != NULL, NULL);
2964 g_return_val_if_fail(obj != NULL, NULL);
2966 pobj = gtk_ctree_node_get_row_data(ctree, node);
2967 g_return_val_if_fail(pobj != NULL, NULL);
2969 /* Determine object type to be displayed */
2970 if( obj->type == ADDR_DATASOURCE ) {
2971 otype = ADAPTER_DSOURCE(obj)->subType;
2977 /* Handle any special conditions. */
2979 atci = addrbookctl_lookup( otype );
2981 if( atci->showInTree ) {
2982 /* Add object to tree */
2985 added = gtk_ctree_insert_node( ctree, node, NULL, name, FOLDER_SPACING,
2986 atci->iconXpm, atci->maskXpm, atci->iconXpmOpen, atci->maskXpmOpen,
2987 atci->treeLeaf, atci->treeExpand );
2988 gtk_ctree_node_set_row_data_full( ctree, added, obj,
2989 addressbook_free_treenode );
2993 gtk_ctree_sort_node(ctree, node);
2999 * Add group into the address index tree.
3000 * Enter: node Parent node.
3002 * itemGroup Group to add.
3003 * Return: Inserted node.
3005 static GtkCTreeNode *addressbook_node_add_group( GtkCTreeNode *node, AddressDataSource *ds, ItemGroup *itemGroup ) {
3006 GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
3007 GtkCTreeNode *newNode;
3008 AdapterGroup *adapter;
3009 AddressTypeControlItem *atci = NULL;
3012 if( ds == NULL ) return NULL;
3013 if( node == NULL || itemGroup == NULL ) return NULL;
3015 name = &itemGroup->obj.name;
3017 atci = addrbookctl_lookup( ADDR_ITEM_GROUP );
3019 adapter = g_new0( AdapterGroup, 1 );
3020 ADDRESS_OBJECT_TYPE(adapter) = ADDR_ITEM_GROUP;
3021 ADDRESS_OBJECT_NAME(adapter) = g_strdup( ADDRITEM_NAME(itemGroup) );
3022 adapter->itemGroup = itemGroup;
3024 newNode = gtk_ctree_insert_node( ctree, node, NULL, name, FOLDER_SPACING,
3025 atci->iconXpm, atci->maskXpm, atci->iconXpm, atci->maskXpm,
3026 atci->treeLeaf, atci->treeExpand );
3027 gtk_ctree_node_set_row_data_full( ctree, newNode, adapter,
3028 addressbook_free_treenode );
3029 gtk_ctree_sort_node( ctree, node );
3034 * Add folder into the address index tree.
3035 * Enter: node Parent node.
3037 * itemFolder Folder to add.
3038 * otype Object type to display.
3039 * Return: Inserted node.
3041 static GtkCTreeNode *addressbook_node_add_folder(
3042 GtkCTreeNode *node, AddressDataSource *ds, ItemFolder *itemFolder, AddressObjectType otype )
3044 GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
3045 GtkCTreeNode *newNode = NULL;
3046 AdapterFolder *adapter;
3047 AddressTypeControlItem *atci = NULL;
3048 GList *listItems = NULL;
3050 ItemFolder *rootFolder;
3052 if( ds == NULL ) return NULL;
3053 if( node == NULL || itemFolder == NULL ) return NULL;
3055 /* Determine object type */
3056 atci = addrbookctl_lookup( otype );
3057 if( atci == NULL ) return NULL;
3059 rootFolder = addrindex_ds_get_root_folder( ds );
3060 if( itemFolder == rootFolder ) {
3064 name = &itemFolder->obj.name;
3066 adapter = g_new0( AdapterFolder, 1 );
3067 ADDRESS_OBJECT_TYPE(adapter) = ADDR_ITEM_FOLDER;
3068 ADDRESS_OBJECT_NAME(adapter) = g_strdup( ADDRITEM_NAME(itemFolder) );
3069 adapter->itemFolder = itemFolder;
3071 newNode = gtk_ctree_insert_node( ctree, node, NULL, name, FOLDER_SPACING,
3072 atci->iconXpm, atci->maskXpm, atci->iconXpm, atci->maskXpm,
3073 atci->treeLeaf, atci->treeExpand );
3074 gtk_ctree_node_set_row_data_full( ctree, newNode, adapter,
3075 addressbook_free_treenode );
3078 listItems = itemFolder->listFolder;
3079 while( listItems ) {
3080 ItemFolder *item = listItems->data;
3081 addressbook_node_add_folder( newNode, ds, item, otype );
3082 listItems = g_list_next( listItems );
3084 listItems = itemFolder->listGroup;
3085 while( listItems ) {
3086 ItemGroup *item = listItems->data;
3087 addressbook_node_add_group( newNode, ds, item );
3088 listItems = g_list_next( listItems );
3090 gtk_ctree_sort_node( ctree, node );
3094 static void addressbook_delete_object(AddressObject *obj) {
3095 AdapterDSource *ads = NULL;
3096 AddressDataSource *ds = NULL;
3099 /* Remove data source. */
3100 /* printf( "Delete obj type : %d\n", obj->type ); */
3102 ads = ADAPTER_DSOURCE(obj);
3103 if( ads == NULL ) return;
3104 ds = ads->dataSource;
3105 if( ds == NULL ) return;
3107 /* Remove data source */
3108 if( addrindex_index_remove_datasource( _addressIndex_, ds ) ) {
3109 addrindex_free_datasource( ds );
3111 /* Free up Adapter object */
3115 void addressbook_export_to_file( void ) {
3116 if( _addressIndex_ ) {
3117 /* Save all new address book data */
3118 debug_print( "Saving address books...\n" );
3119 addrindex_save_all_books( _addressIndex_ );
3121 debug_print( "Exporting addressbook to file...\n" );
3122 addrindex_save_data( _addressIndex_ );
3123 if( _addressIndex_->retVal != MGU_SUCCESS ) {
3124 addrindex_print_index( _addressIndex_, stdout );
3127 /* Notify address completion of new data */
3128 invalidate_address_completion();
3132 static void key_pressed(GtkWidget *widget, GdkEventKey *event, gpointer data)
3134 if (event && event->keyval == GDK_Escape)
3135 addressbook_close();
3139 * Comparison using cell contents (text in first column). Used for sort
3140 * address index widget.
3142 static gint addressbook_treenode_compare_func(
3143 GtkCList *clist, gconstpointer ptr1, gconstpointer ptr2 )
3145 GtkCell *cell1 = ((GtkCListRow *)ptr1)->cell;
3146 GtkCell *cell2 = ((GtkCListRow *)ptr2)->cell;
3147 gchar *name1 = NULL, *name2 = NULL;
3148 if( cell1 ) name1 = cell1->u.text;
3149 if( cell2 ) name2 = cell2->u.text;
3150 if( ! name1 ) return ( name2 != NULL );
3151 if( ! name2 ) return -1;
3152 return strcasecmp( name1, name2 );
3156 * Comparison using object names and types.
3158 static gint addressbook_list_compare_func(
3159 GtkCList *clist, gconstpointer ptr1, gconstpointer ptr2 )
3161 AddrItemObject *aio1 = ((GtkCListRow *)ptr1)->data;
3162 AddrItemObject *aio2 = ((GtkCListRow *)ptr2)->data;
3163 gchar *name1 = NULL, *name2 = NULL;
3165 /* Order by cell contents */
3166 name1 = ADDRITEM_NAME( aio1 );
3167 name2 = ADDRITEM_NAME( aio2 );
3169 if( aio1->type == aio2->type ) {
3171 if( ! name1 ) return ( name2 != NULL );
3172 if( ! name2 ) return -1;
3173 return strcasecmp( name1, name2 );
3176 /* Order groups before person */
3177 if( aio1->type == ITEMTYPE_GROUP ) {
3180 else if( aio2->type == ITEMTYPE_GROUP ) {
3187 static void addressbook_new_book_cb( gpointer data, guint action, GtkWidget *widget ) {
3188 AdapterDSource *ads;
3189 AdapterInterface *adapter;
3190 GtkCTreeNode *newNode;
3192 adapter = addrbookctl_find_interface( ADDR_IF_BOOK );
3193 if( adapter == NULL ) return;
3194 ads = addressbook_edit_book( _addressIndex_, NULL );
3196 newNode = addressbook_add_object( adapter->treeNode, ADDRESS_OBJECT(ads) );
3198 gtk_ctree_select( GTK_CTREE(addrbook.ctree), newNode );
3199 addrbook.treeSelected = newNode;
3204 static void addressbook_new_vcard_cb( gpointer data, guint action, GtkWidget *widget ) {
3205 AdapterDSource *ads;
3206 AdapterInterface *adapter;
3207 GtkCTreeNode *newNode;
3209 adapter = addrbookctl_find_interface( ADDR_IF_VCARD );
3210 if( adapter == NULL ) return;
3211 ads = addressbook_edit_vcard( _addressIndex_, NULL );
3213 newNode = addressbook_add_object( adapter->treeNode, ADDRESS_OBJECT(ads) );
3215 gtk_ctree_select( GTK_CTREE(addrbook.ctree), newNode );
3216 addrbook.treeSelected = newNode;
3222 static void addressbook_new_jpilot_cb( gpointer data, guint action, GtkWidget *widget ) {
3223 AdapterDSource *ads;
3224 AdapterInterface *adapter;
3225 AddressInterface *iface;
3226 GtkCTreeNode *newNode;
3228 adapter = addrbookctl_find_interface( ADDR_IF_JPILOT );
3229 if( adapter == NULL ) return;
3230 iface = adapter->interface;
3231 if( ! iface->haveLibrary ) return;
3232 ads = addressbook_edit_jpilot( _addressIndex_, NULL );
3234 newNode = addressbook_add_object( adapter->treeNode, ADDRESS_OBJECT(ads) );
3236 gtk_ctree_select( GTK_CTREE(addrbook.ctree), newNode );
3237 addrbook.treeSelected = newNode;
3244 static void addressbook_new_ldap_cb( gpointer data, guint action, GtkWidget *widget ) {
3245 AdapterDSource *ads;
3246 AdapterInterface *adapter;
3247 AddressInterface *iface;
3248 GtkCTreeNode *newNode;
3250 adapter = addrbookctl_find_interface( ADDR_IF_LDAP );
3251 if( adapter == NULL ) return;
3252 iface = adapter->interface;
3253 if( ! iface->haveLibrary ) return;
3254 ads = addressbook_edit_ldap( _addressIndex_, NULL );
3256 newNode = addressbook_add_object( adapter->treeNode, ADDRESS_OBJECT(ads) );
3258 gtk_ctree_select( GTK_CTREE(addrbook.ctree), newNode );
3259 addrbook.treeSelected = newNode;
3264 static void addressbook_ldap_show_message( SyldapServer *svr ) {
3266 *addressbook_msgbuf = '\0';
3268 name = syldap_get_name( svr );
3269 if( svr->busyFlag ) {
3270 sprintf( addressbook_msgbuf, "%s: %s", name, ADDRESSBOOK_LDAP_BUSYMSG );
3273 if( svr->retVal == MGU_SUCCESS ) {
3274 sprintf( addressbook_msgbuf, "%s", name );
3277 sprintf( addressbook_msgbuf, "%s: %s", name, mgu_error2string( svr->retVal ) );
3281 addressbook_status_show( addressbook_msgbuf );
3284 static void ldapsearch_callback( SyldapServer *sls ) {
3285 GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
3287 AdapterDSource *ads = NULL;
3288 AddressDataSource *ds = NULL;
3289 AddressInterface *iface = NULL;
3291 if( sls == NULL ) return;
3292 if( ! addrbook.treeSelected ) return;
3293 if( GTK_CTREE_ROW( addrbook.treeSelected )->level == 1 ) return;
3295 obj = gtk_ctree_node_get_row_data( ctree, addrbook.treeSelected );
3296 if( obj == NULL ) return;
3297 if( obj->type == ADDR_DATASOURCE ) {
3298 ads = ADAPTER_DSOURCE(obj);
3299 if( ads->subType == ADDR_LDAP ) {
3300 SyldapServer *server;
3302 ds = ads->dataSource;
3303 if( ds == NULL ) return;
3304 iface = ds->interface;
3305 if( ! iface->haveLibrary ) return;
3306 server = ds->rawDataSource;
3307 if( server == sls ) {
3308 /* Read from cache */
3309 gtk_widget_show_all(addrbook.window);
3310 addressbook_set_clist( obj );
3311 addressbook_ldap_show_message( sls );
3312 gtk_widget_show_all(addrbook.window);
3313 gtk_entry_set_text( GTK_ENTRY(addrbook.entry), "" );
3321 * Lookup button handler.
3323 static void addressbook_lup_clicked( GtkButton *button, gpointer data ) {
3324 GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
3327 AdapterDSource *ads = NULL;
3328 AddressDataSource *ds = NULL;
3329 AddressInterface *iface = NULL;
3333 sLookup = gtk_editable_get_chars( GTK_EDITABLE(addrbook.entry), 0, -1 );
3334 g_strchomp( sLookup );
3336 if( ! addrbook.treeSelected ) return;
3337 if( GTK_CTREE_ROW( addrbook.treeSelected )->level == 1 ) return;
3339 obj = gtk_ctree_node_get_row_data( ctree, addrbook.treeSelected );
3340 if( obj == NULL ) return;
3343 if( obj->type == ADDR_DATASOURCE ) {
3344 ads = ADAPTER_DSOURCE(obj);
3345 if( ads->subType == ADDR_LDAP ) {
3346 SyldapServer *server;
3348 ds = ads->dataSource;
3349 if( ds == NULL ) return;
3350 iface = ds->interface;
3351 if( ! iface->haveLibrary ) return;
3352 server = ds->rawDataSource;
3354 syldap_cancel_read( server );
3355 if( *sLookup == '\0' || strlen( sLookup ) < 1 ) return;
3356 syldap_set_search_value( server, sLookup );
3357 syldap_set_callback( server, ldapsearch_callback );
3358 syldap_read_data_th( server );
3359 addressbook_ldap_show_message( server );
3367 /* **********************************************************************
3368 * Build lookup tables.
3369 * ***********************************************************************
3373 * Remap object types.
3374 * Enter: abType AddressObjectType (used in tree node).
3375 * Return: ItemObjectType (used in address cache data).
3377 ItemObjectType addressbook_type2item( AddressObjectType abType ) {
3378 ItemObjectType ioType;
3380 ioType = ITEMTYPE_NONE;
3382 case ADDR_ITEM_PERSON: ioType = ITEMTYPE_PERSON; break;
3383 case ADDR_ITEM_EMAIL: ioType = ITEMTYPE_EMAIL; break;
3384 case ADDR_ITEM_FOLDER: ioType = ITEMTYPE_FOLDER; break;
3385 case ADDR_ITEM_GROUP: ioType = ITEMTYPE_GROUP; break;
3386 case ADDR_DATASOURCE: ioType = ITEMTYPE_DATASOURCE; break;
3392 * Build table that controls the rendering of object types.
3394 void addrbookctl_build_map( GtkWidget *window ) {
3395 AddressTypeControlItem *atci;
3398 stock_pixmap_gdk(window, STOCK_PIXMAP_DIR_CLOSE, &folderxpm, &folderxpmmask);
3399 stock_pixmap_gdk(window, STOCK_PIXMAP_DIR_OPEN, &folderopenxpm, &folderopenxpmmask);
3400 stock_pixmap_gdk(window, STOCK_PIXMAP_GROUP, &groupxpm, &groupxpmmask);
3401 stock_pixmap_gdk(window, STOCK_PIXMAP_VCARD, &vcardxpm, &vcardxpmmask);
3402 stock_pixmap_gdk(window, STOCK_PIXMAP_BOOK, &bookxpm, &bookxpmmask);
3403 stock_pixmap_gdk(window, STOCK_PIXMAP_ADDRESS, &addressxpm, &addressxpmmask);
3404 stock_pixmap_gdk(window, STOCK_PIXMAP_JPILOT, &jpilotxpm, &jpilotxpmmask);
3405 stock_pixmap_gdk(window, STOCK_PIXMAP_CATEGORY, &categoryxpm, &categoryxpmmask);
3406 stock_pixmap_gdk(window, STOCK_PIXMAP_LDAP, &ldapxpm, &ldapxpmmask);
3408 _addressBookTypeHash_ = g_hash_table_new( g_int_hash, g_int_equal );
3409 _addressBookTypeList_ = NULL;
3412 atci = g_new0( AddressTypeControlItem, 1 );
3413 atci->objectType = ADDR_INTERFACE;
3414 atci->interfaceType = ADDR_IF_NONE;
3415 atci->showInTree = TRUE;
3416 atci->treeExpand = TRUE;
3417 atci->treeLeaf = FALSE;
3418 atci->displayName = _( "Interface" );
3419 atci->iconXpm = folderxpm;
3420 atci->maskXpm = folderxpmmask;
3421 atci->iconXpmOpen = folderopenxpm;
3422 atci->maskXpmOpen = folderopenxpmmask;
3423 atci->menuCommand = NULL;
3424 g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3425 _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3428 atci = g_new0( AddressTypeControlItem, 1 );
3429 atci->objectType = ADDR_BOOK;
3430 atci->interfaceType = ADDR_IF_BOOK;
3431 atci->showInTree = TRUE;
3432 atci->treeExpand = TRUE;
3433 atci->treeLeaf = FALSE;
3434 atci->displayName = _( "Address Book" );
3435 atci->iconXpm = bookxpm;
3436 atci->maskXpm = bookxpmmask;
3437 atci->iconXpmOpen = bookxpm;
3438 atci->maskXpmOpen = bookxpmmask;
3439 atci->menuCommand = "/File/New Book";
3440 g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3441 _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3444 atci = g_new0( AddressTypeControlItem, 1 );
3445 atci->objectType = ADDR_ITEM_PERSON;
3446 atci->interfaceType = ADDR_IF_NONE;
3447 atci->showInTree = FALSE;
3448 atci->treeExpand = FALSE;
3449 atci->treeLeaf = FALSE;
3450 atci->displayName = _( "Person" );
3451 atci->iconXpm = NULL;
3452 atci->maskXpm = NULL;
3453 atci->iconXpmOpen = NULL;
3454 atci->maskXpmOpen = NULL;
3455 atci->menuCommand = NULL;
3456 g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3457 _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3460 atci = g_new0( AddressTypeControlItem, 1 );
3461 atci->objectType = ADDR_ITEM_EMAIL;
3462 atci->interfaceType = ADDR_IF_NONE;
3463 atci->showInTree = FALSE;
3464 atci->treeExpand = FALSE;
3465 atci->treeLeaf = TRUE;
3466 atci->displayName = _( "EMail Address" );
3467 atci->iconXpm = addressxpm;
3468 atci->maskXpm = addressxpmmask;
3469 atci->iconXpmOpen = addressxpm;
3470 atci->maskXpmOpen = addressxpmmask;
3471 atci->menuCommand = NULL;
3472 g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3473 _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3476 atci = g_new0( AddressTypeControlItem, 1 );
3477 atci->objectType = ADDR_ITEM_GROUP;
3478 atci->interfaceType = ADDR_IF_BOOK;
3479 atci->showInTree = TRUE;
3480 atci->treeExpand = FALSE;
3481 atci->treeLeaf = FALSE;
3482 atci->displayName = _( "Group" );
3483 atci->iconXpm = groupxpm;
3484 atci->maskXpm = groupxpmmask;
3485 atci->iconXpmOpen = groupxpm;
3486 atci->maskXpmOpen = groupxpmmask;
3487 atci->menuCommand = NULL;
3488 g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3489 _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3492 atci = g_new0( AddressTypeControlItem, 1 );
3493 atci->objectType = ADDR_ITEM_FOLDER;
3494 atci->interfaceType = ADDR_IF_BOOK;
3495 atci->showInTree = TRUE;
3496 atci->treeExpand = FALSE;
3497 atci->treeLeaf = FALSE;
3498 atci->displayName = _( "Folder" );
3499 atci->iconXpm = folderxpm;
3500 atci->maskXpm = folderxpmmask;
3501 atci->iconXpmOpen = folderopenxpm;
3502 atci->maskXpmOpen = folderopenxpmmask;
3503 atci->menuCommand = NULL;
3504 g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3505 _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3508 atci = g_new0( AddressTypeControlItem, 1 );
3509 atci->objectType = ADDR_VCARD;
3510 atci->interfaceType = ADDR_IF_VCARD;
3511 atci->showInTree = TRUE;
3512 atci->treeExpand = TRUE;
3513 atci->treeLeaf = TRUE;
3514 atci->displayName = _( "vCard" );
3515 atci->iconXpm = vcardxpm;
3516 atci->maskXpm = vcardxpmmask;
3517 atci->iconXpmOpen = vcardxpm;
3518 atci->maskXpmOpen = vcardxpmmask;
3519 atci->menuCommand = "/File/New vCard";
3520 g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3521 _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3524 atci = g_new0( AddressTypeControlItem, 1 );
3525 atci->objectType = ADDR_JPILOT;
3526 atci->interfaceType = ADDR_IF_JPILOT;
3527 atci->showInTree = TRUE;
3528 atci->treeExpand = TRUE;
3529 atci->treeLeaf = FALSE;
3530 atci->displayName = _( "JPilot" );
3531 atci->iconXpm = jpilotxpm;
3532 atci->maskXpm = jpilotxpmmask;
3533 atci->iconXpmOpen = jpilotxpm;
3534 atci->maskXpmOpen = jpilotxpmmask;
3535 atci->menuCommand = "/File/New JPilot";
3536 g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3537 _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3540 atci = g_new0( AddressTypeControlItem, 1 );
3541 atci->objectType = ADDR_CATEGORY;
3542 atci->interfaceType = ADDR_IF_JPILOT;
3543 atci->showInTree = TRUE;
3544 atci->treeExpand = TRUE;
3545 atci->treeLeaf = TRUE;
3546 atci->displayName = _( "JPilot" );
3547 atci->iconXpm = categoryxpm;
3548 atci->maskXpm = categoryxpmmask;
3549 atci->iconXpmOpen = categoryxpm;
3550 atci->maskXpmOpen = categoryxpmmask;
3551 atci->menuCommand = NULL;
3552 g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3553 _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3556 atci = g_new0( AddressTypeControlItem, 1 );
3557 atci->objectType = ADDR_LDAP;
3558 atci->interfaceType = ADDR_IF_LDAP;
3559 atci->showInTree = TRUE;
3560 atci->treeExpand = TRUE;
3561 atci->treeLeaf = TRUE;
3562 atci->displayName = _( "LDAP Server" );
3563 atci->iconXpm = ldapxpm;
3564 atci->maskXpm = ldapxpmmask;
3565 atci->iconXpmOpen = ldapxpm;
3566 atci->maskXpmOpen = ldapxpmmask;
3567 atci->menuCommand = "/File/New Server";
3568 g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3569 _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3574 * Search for specified object type.
3576 AddressTypeControlItem *addrbookctl_lookup( gint ot ) {
3578 return ( AddressTypeControlItem * ) g_hash_table_lookup( _addressBookTypeHash_, &objType );
3582 * Search for specified interface type.
3584 AddressTypeControlItem *addrbookctl_lookup_iface( AddressIfType ifType ) {
3585 GList *node = _addressBookTypeList_;
3587 AddressTypeControlItem *atci = node->data;
3588 if( atci->interfaceType == ifType ) return atci;
3589 node = g_list_next( node );
3594 static void addrbookctl_free_address( AddressObject *obj ) {
3595 g_free( obj->name );
3596 obj->type = ADDR_NONE;
3600 static void addrbookctl_free_interface( AdapterInterface *adapter ) {
3601 addrbookctl_free_address( ADDRESS_OBJECT(adapter) );
3602 adapter->interface = NULL;
3603 adapter->interfaceType = ADDR_IF_NONE;
3604 adapter->atci = NULL;
3605 adapter->enabled = FALSE;
3606 adapter->haveLibrary = FALSE;
3607 adapter->treeNode = NULL;
3611 static void addrbookctl_free_datasource( AdapterDSource *adapter ) {
3612 addrbookctl_free_address( ADDRESS_OBJECT(adapter) );
3613 adapter->dataSource = NULL;
3614 adapter->subType = ADDR_NONE;
3618 static void addrbookctl_free_folder( AdapterFolder *adapter ) {
3619 addrbookctl_free_address( ADDRESS_OBJECT(adapter) );
3620 adapter->itemFolder = NULL;
3624 static void addrbookctl_free_group( AdapterGroup *adapter ) {
3625 addrbookctl_free_address( ADDRESS_OBJECT(adapter) );
3626 adapter->itemGroup = NULL;
3631 * Build GUI interface list.
3633 void addrbookctl_build_iflist() {
3634 AddressTypeControlItem *atci;
3635 AdapterInterface *adapter;
3638 if( _addressIndex_ == NULL ) {
3639 _addressIndex_ = addrindex_create_index();
3640 if( _clipBoard_ == NULL ) {
3641 _clipBoard_ = addrclip_create();
3643 addrclip_set_index( _clipBoard_, _addressIndex_ );
3645 _addressInterfaceList_ = NULL;
3646 list = addrindex_get_interface_list( _addressIndex_ );
3648 AddressInterface *interface = list->data;
3649 atci = addrbookctl_lookup_iface( interface->type );
3651 adapter = g_new0( AdapterInterface, 1 );
3652 adapter->interfaceType = interface->type;
3653 adapter->atci = atci;
3654 adapter->interface = interface;
3655 adapter->treeNode = NULL;
3656 adapter->enabled = TRUE;
3657 adapter->haveLibrary = interface->haveLibrary;
3658 ADDRESS_OBJECT(adapter)->type = ADDR_INTERFACE;
3659 ADDRESS_OBJECT_NAME(adapter) = g_strdup( atci->displayName );
3660 _addressInterfaceList_ = g_list_append( _addressInterfaceList_, adapter );
3662 list = g_list_next( list );
3666 void addrbookctl_free_selection( GList *list ) {
3669 AdapterInterface *adapter = node->data;
3671 node = g_list_next( node );
3673 g_list_free( list );
3677 * Find GUI interface type specified interface type.
3678 * Return: Interface item, or NULL if not found.
3680 AdapterInterface *addrbookctl_find_interface( AddressIfType ifType ) {
3681 GList *node = _addressInterfaceList_;
3683 AdapterInterface *adapter = node->data;
3684 if( adapter->interfaceType == ifType ) return adapter;
3685 node = g_list_next( node );
3691 * Build interface list selection.
3693 void addrbookctl_build_ifselect() {
3694 GList *newList = NULL;
3699 gchar *endptr = NULL;
3701 AdapterInterface *adapter;
3704 selectStr = g_strdup( ADDRESSBOOK_IFACE_SELECTION );
3707 splitStr = g_strsplit( selectStr, ",", -1 );
3708 for( i = 0; i < ADDRESSBOOK_MAX_IFACE; i++ ) {
3710 /* printf( "%d : %s\n", i, splitStr[i] ); */
3711 ifType = strtol( splitStr[i], &endptr, 10 );
3714 if( strcmp( endptr, "/n" ) == 0 ) {
3718 /* printf( "\t%d : %s\n", ifType, enabled ? "yes" : "no" ); */
3719 adapter = addrbookctl_find_interface( ifType );
3721 newList = g_list_append( newList, adapter );
3728 /* printf( "i=%d\n", i ); */
3729 g_strfreev( splitStr );
3730 g_free( selectStr );
3732 /* Replace existing list */
3733 mgu_clear_list( _addressIFaceSelection_ );
3734 g_list_free( _addressIFaceSelection_ );
3735 _addressIFaceSelection_ = newList;
3740 /* **********************************************************************
3741 * Add sender to address book.
3742 * ***********************************************************************
3746 * This function is used by the Add sender to address book function.
3748 gboolean addressbook_add_contact( const gchar *name, const gchar *address, const gchar *remarks ) {
3749 debug_print( "addressbook_add_contact: name/address: %s - %s\n", name, address );
3750 if( addressadd_selection( _addressIndex_, name, address, remarks ) ) {
3751 debug_print( "addressbook_add_contact - added\n" );
3752 addressbook_refresh();
3757 /* **********************************************************************
3758 * Address completion support.
3759 * ***********************************************************************
3763 * This function is used by the address completion function to load
3765 * Enter: callBackFunc Function to be called when an address is
3767 * Return: TRUE if data loaded, FALSE if address index not loaded.
3769 gboolean addressbook_load_completion( gint (*callBackFunc) ( const gchar *, const gchar * ) ) {
3770 /* AddressInterface *interface; */
3771 AddressDataSource *ds;
3772 GList *nodeIf, *nodeDS;
3773 GList *listP, *nodeP;
3775 gchar *sName, *sAddress, *sAlias, *sFriendly;
3777 debug_print( "addressbook_load_completion\n" );
3779 if( _addressIndex_ == NULL ) return FALSE;
3781 nodeIf = addrindex_get_interface_list( _addressIndex_ );
3783 AddressInterface *interface = nodeIf->data;
3784 nodeDS = interface->listSource;
3788 /* Read address book */
3789 if( ! addrindex_ds_get_read_flag( ds ) ) {
3790 addrindex_ds_read_data( ds );
3793 /* Get all persons */
3794 listP = addrindex_ds_get_all_persons( ds );
3797 ItemPerson *person = nodeP->data;
3798 nodeM = person->listEMail;
3800 /* Figure out name to use */
3801 sName = person->nickName;
3802 if( sName == NULL || *sName == '\0' ) {
3803 sName = ADDRITEM_NAME(person);
3806 /* Process each E-Mail address */
3808 ItemEMail *email = nodeM->data;
3811 sAddress = email->address;
3812 if( sAddress || *sAddress != '\0' ) {
3813 sAlias = ADDRITEM_NAME(email);
3814 if( sAlias && *sAlias != '\0' ) {
3817 ( callBackFunc ) ( sFriendly, sAddress );
3820 nodeM = g_list_next( nodeM );
3822 nodeP = g_list_next( nodeP );
3824 /* Free up the list */
3825 g_list_free( listP );
3827 nodeDS = g_list_next( nodeDS );
3829 nodeIf = g_list_next( nodeIf );
3831 debug_print( "addressbook_load_completion... done\n" );
3836 /* **********************************************************************
3838 * ***********************************************************************
3844 static void addressbook_import_ldif_cb() {
3845 AddressDataSource *ds = NULL;
3846 AdapterDSource *ads = NULL;
3847 AddressBookFile *abf = NULL;
3848 AdapterInterface *adapter;
3849 GtkCTreeNode *newNode;
3851 adapter = addrbookctl_find_interface( ADDR_IF_BOOK );
3853 if( adapter->treeNode ) {
3854 abf = addressbook_imp_ldif( _addressIndex_ );
3856 ds = addrindex_index_add_datasource( _addressIndex_, ADDR_IF_BOOK, abf );
3857 ads = addressbook_create_ds_adapter( ds, ADDR_BOOK, NULL );
3858 addressbook_ads_set_name( ads, addrbook_get_name( abf ) );
3859 newNode = addressbook_add_object( adapter->treeNode, ADDRESS_OBJECT(ads) );
3861 gtk_ctree_select( GTK_CTREE(addrbook.ctree), newNode );
3862 addrbook.treeSelected = newNode;
3865 /* Notify address completion */
3866 invalidate_address_completion();
3876 static void addressbook_import_mutt_cb() {
3877 AddressDataSource *ds = NULL;
3878 AdapterDSource *ads = NULL;
3879 AddressBookFile *abf = NULL;
3880 AdapterInterface *adapter;
3881 GtkCTreeNode *newNode;
3883 adapter = addrbookctl_find_interface( ADDR_IF_BOOK );
3885 if( adapter->treeNode ) {
3886 abf = addressbook_imp_mutt( _addressIndex_ );
3888 ds = addrindex_index_add_datasource( _addressIndex_, ADDR_IF_BOOK, abf );
3889 ads = addressbook_create_ds_adapter( ds, ADDR_BOOK, NULL );
3890 addressbook_ads_set_name( ads, addrbook_get_name( abf ) );
3891 newNode = addressbook_add_object( adapter->treeNode, ADDRESS_OBJECT(ads) );
3893 gtk_ctree_select( GTK_CTREE(addrbook.ctree), newNode );
3894 addrbook.treeSelected = newNode;
3897 /* Notify address completion */
3898 invalidate_address_completion();