mail/em-subscribe-editor.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
   2  * em-subscribe-editor.c *
   3  *
   4  * Authors: Michael Zucchi <notzed@ximian.com>
   5  *
   6  * Copyright 2003 Ximian, Inc. (www.ximian.com)
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of version 2 of the GNU General Public
  10  * License as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public
  18  * License along with this program; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  *
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include <string.h>
  29
  30 #include <pthread.h>
  31
  32 #include "mail-tools.h"
  33 #include "mail-ops.h"
  34 #include "mail-mt.h"
  35 /*#include "mail-folder-cache.h"*/
  36 #include "camel/camel-exception.h"
  37 #include "camel/camel-store.h"
  38 #include "camel/camel-session.h"
  39 #include "e-util/e-account-list.h"
  40
  41 #include "em-subscribe-editor.h"
  42
  43 #include "mail-config.h"
  44
  45 #include <glade/glade.h>
  46 #include <libgnome/gnome-i18n.h>
  47
  48 #include <gtk/gtkdialog.h>
  49 #include <gtk/gtkscrolledwindow.h>
  50 #include <gtk/gtkbox.h>
  51 #include <gtk/gtklabel.h>
  52 #include <gtk/gtktreeview.h>
  53 #include <gtk/gtktreestore.h>
  54 #include <gtk/gtktreeselection.h>
  55 #include <gtk/gtkcellrenderertoggle.h>
  56 #include <gtk/gtkcellrenderertext.h>
  57 #include <gtk/gtkoptionmenu.h>
  58 #include <gtk/gtkprogressbar.h>
  59 #include <gtk/gtkmenuitem.h>
  60
  61 #define d(x)
  62
  63 typedef struct _EMSubscribeEditor EMSubscribeEditor;
  64 struct _EMSubscribeEditor {
  65         EDList stores;
  66
  67         int busy;
  68         guint busy_id;
  69
  70         struct _EMSubscribe *current; /* the current one, if any */
  71
  72         GtkDialog *dialog;
  73         GtkWidget *vbox;        /* where new stores are added */
  74         GtkWidget *optionmenu;
  75         GtkWidget *none_selected; /* 'please select a xxx' message */
  76         GtkWidget *none_selected_item;
  77         GtkWidget *subscribe_button;
  78         GtkWidget *unsubscribe_button;
  79         GtkWidget *progress;
  80 };
  81
  82 typedef struct _EMSubscribe EMSubscribe;
  83 struct _EMSubscribe {
  84         struct _EMSubscribe *next;
  85         struct _EMSubscribe *prev;
  86
  87         int ref_count;
  88         int cancel;
  89         int seq;                /* upped every time we refresh */
  90
  91         struct _EMSubscribeEditor *editor; /* parent object*/
  92
  93         char *store_uri;
  94         int store_id;           /* looking up a store */
  95
  96         CamelStore *store;
  97         GHashTable *folders;
  98
  99         GtkWidget *widget;      /* widget to show for this store */
 100         GtkTreeView *tree;      /* tree, if we have it */
 101
 102         /* list of all returns from get_folder_info, accessed by other structures */
 103         GSList *info_list;
 104
 105         /* pending LISTs, EMSubscribeNode's */
 106         int pending_id;
 107         EDList pending;
 108
 109         /* queue of pending UN/SUBSCRIBEs, EMsg's */
 110         int subscribe_id;
 111         EDList subscribe;
 112
 113         /* working variables at runtime */
 114         int selected_count;
 115         int selected_subscribed_count;
 116         gboolean subscribed_state:1; /* for setting the selection*/
 117 };
 118
 119 typedef struct _EMSubscribeNode EMSubscribeNode;
 120 struct _EMSubscribeNode {
 121         struct _EMSubscribeNode *next;
 122         struct _EMSubscribeNode *prev;
 123
 124         CamelFolderInfo *info;
 125         GtkTreePath *path;
 126 };
 127
 128 static void sub_editor_busy(EMSubscribeEditor *se, int dir);
 129 static int sub_queue_fill_level(EMSubscribe *sub, EMSubscribeNode *node);
 130 static void sub_selection_changed(GtkTreeSelection *selection, EMSubscribe *sub);
 131
 132 static void
 133 sub_node_free(char *key, EMSubscribeNode *node, EMSubscribe *sub)
 134 {
 135         d(printf("sub node free '%s'\n", node->info?node->info->full_name:"<unknown>"));
 136         if (node->path)
 137                 gtk_tree_path_free(node->path);
 138         g_free(node);
 139 }
 140
 141 static void
 142 sub_ref(EMSubscribe *sub)
 143 {
 144         sub->ref_count++;
 145 }
 146
 147 static void
 148 sub_unref(EMSubscribe *sub)
 149 {
 150         GSList *l;
 151
 152         sub->ref_count--;
 153         if (sub->ref_count == 0) {
 154                 d(printf("subscribe object finalised\n"));
 155                 /* we dont have to delete the "subscribe" task list, as it must be empty,
 156                    otherwise we wouldn't be unreffed (intentional circular reference) */
 157                 if (sub->folders) {
 158                         g_hash_table_foreach(sub->folders, (GHFunc)sub_node_free, sub);
 159                         g_hash_table_destroy(sub->folders);
 160                 }
 161                 l = sub->info_list;
 162                 while (l) {
 163                         GSList *n = l->next;
 164
 165                         camel_store_free_folder_info(sub->store, (CamelFolderInfo *)l->data);
 166                         g_slist_free_1(l);
 167                         l = n;
 168                 }
 169                 if (sub->store)
 170                         camel_object_unref(sub->store);
 171                 g_free(sub->store_uri);
 172                 g_free(sub);
 173         }
 174 }
 175
 176 /* ** Subscribe folder operation **************************************** */
 177
 178 struct _zsubscribe_msg {
 179         struct _mail_msg msg;
 180
 181         EMSubscribe *sub;
 182         EMSubscribeNode *node;
 183         int subscribe;
 184         char *path;
 185 };
 186
 187 static void
 188 sub_folder_subscribe (struct _mail_msg *mm)
 189 {
 190         struct _zsubscribe_msg *m = (struct _zsubscribe_msg *) mm;
 191
 192         if (m->subscribe)
 193                 camel_store_subscribe_folder (m->sub->store, m->node->info->full_name, &mm->ex);
 194         else
 195                 camel_store_unsubscribe_folder (m->sub->store, m->node->info->full_name, &mm->ex);
 196 }
 197
 198 static void
 199 sub_folder_subscribed (struct _mail_msg *mm)
 200 {
 201         struct _zsubscribe_msg *m = (struct _zsubscribe_msg *)mm, *next;
 202         GtkTreeIter iter;
 203         GtkTreeModel *model;
 204         EMSubscribeNode *node;
 205         gboolean subscribed, issub;
 206
 207         m->sub->subscribe_id = -1;
 208         if (m->sub->cancel)
 209                 return;
 210
 211         if (!camel_exception_is_set(&mm->ex)) {
 212                 if (m->subscribe)
 213                         m->node->info->flags |= CAMEL_FOLDER_SUBSCRIBED;
 214                 else
 215                         m->node->info->flags &= ~CAMEL_FOLDER_SUBSCRIBED;
 216         }
 217
 218         /* make sure the tree view matches the correct state */
 219         model = gtk_tree_view_get_model(m->sub->tree);
 220         if (gtk_tree_model_get_iter_from_string(model, &iter, m->path)) {
 221                 issub = (m->node->info->flags & CAMEL_FOLDER_SUBSCRIBED) != 0;
 222                 gtk_tree_model_get(model, &iter, 0, &subscribed, 2, &node, -1);
 223                 if (node == m->node)
 224                         gtk_tree_store_set((GtkTreeStore *)model, &iter, 0, issub, -1);
 225                 else
 226                         d(printf("node mismatch, or subscribe state changed failed\n"));
 227         }
 228
 229         /* queue any further ones, or if out, update the ui */
 230         next = (struct _zsubscribe_msg *)e_dlist_remhead(&m->sub->subscribe);
 231         if (next) {
 232                 next->sub->subscribe_id = next->msg.seq;
 233                 e_thread_put(mail_thread_new, (EMsg *)next);
 234         } else {
 235                 /* should it go off the model instead? */
 236                 sub_selection_changed(gtk_tree_view_get_selection(m->sub->tree), m->sub);
 237         }
 238 }
 239
 240 static void
 241 sub_folder_free (struct _mail_msg *mm)
 242 {
 243         struct _zsubscribe_msg *m = (struct _zsubscribe_msg *) mm;
 244
 245         g_free(m->path);
 246         sub_unref(m->sub);
 247 }
 248
 249 static struct _mail_msg_op sub_subscribe_folder_op = {
 250         NULL, /*subscribe_folder_desc,*/
 251         sub_folder_subscribe,
 252         sub_folder_subscribed,
 253         sub_folder_free,
 254 };
 255
 256 /* spath is tree path in string form */
 257 static int
 258 sub_subscribe_folder (EMSubscribe *sub, EMSubscribeNode *node, int state, const char *spath)
 259 {
 260         struct _zsubscribe_msg *m;
 261         int id;
 262
 263         m = mail_msg_new (&sub_subscribe_folder_op, NULL, sizeof(*m));
 264         m->sub = sub;
 265         sub_ref(sub);
 266         m->node = node;
 267         m->subscribe = state;
 268         m->path = g_strdup(spath);
 269
 270         id = m->msg.seq;
 271         if (sub->subscribe_id == -1) {
 272                 sub->subscribe_id = id;
 273                 d(printf("running subscribe folder '%s'\n", spath));
 274                 e_thread_put (mail_thread_new, (EMsg *)m);
 275         } else {
 276                 d(printf("queueing subscribe folder '%s'\n", spath));
 277                 e_dlist_addtail(&sub->subscribe, (EDListNode *)m);
 278         }
 279
 280         return id;
 281 }
 282
 283 /* ********************************************************************** */
 284 static void
 285 sub_fill_level(EMSubscribe *sub, CamelFolderInfo *info,  GtkTreeIter *parent, int pending)
 286 {
 287         CamelFolderInfo *fi;
 288         GtkTreeStore *treestore;
 289         GtkTreeIter iter;
 290         EMSubscribeNode *node;
 291
 292         treestore = (GtkTreeStore *)gtk_tree_view_get_model(sub->tree);
 293
 294         /* first, fill a level up */
 295         fi = info;
 296         while (fi) {
 297                 if ((node = g_hash_table_lookup(sub->folders, fi->full_name)) == NULL) {
 298                         gboolean state;
 299
 300                         gtk_tree_store_append(treestore, &iter, parent);
 301                         node = g_malloc0(sizeof(*node));
 302                         node->info = fi;
 303                         state = (fi->flags & CAMEL_FOLDER_SUBSCRIBED) != 0;
 304                         gtk_tree_store_set(treestore, &iter, 0, state, 1, fi->name, 2, node, -1);
 305                         if ((fi->flags & CAMEL_FOLDER_NOINFERIORS) == 0)
 306                                 node->path = gtk_tree_model_get_path((GtkTreeModel *)treestore, &iter);
 307                         g_hash_table_insert(sub->folders, fi->full_name, node);
 308                 } else if (node->path) {
 309                         gtk_tree_model_get_iter(gtk_tree_view_get_model(sub->tree), &iter, node->path);
 310                 }
 311
 312                 if ((fi->flags & CAMEL_FOLDER_NOINFERIORS) == 0
 313                     && node->path) {
 314                         /* save time, if we have any children alread, dont re-scan */
 315                         if (fi->child) {
 316                                 d(printf("scanning child '%s'\n", fi->child->full_name));
 317                                 sub_fill_level(sub, fi->child, &iter, FALSE);
 318                         } else {
 319                                 if (pending)
 320                                         e_dlist_addtail(&sub->pending, (EDListNode *)node);
 321                         }
 322                 }
 323                 fi = fi->next;
 324         }
 325 }
 326
 327 /* async query of folderinfo */
 328
 329 struct _emse_folderinfo_msg {
 330         struct _mail_msg msg;
 331
 332         int seq;
 333
 334         EMSubscribe *sub;
 335         EMSubscribeNode *node;
 336         CamelFolderInfo *info;
 337 };
 338
 339 static void
 340 sub_folderinfo_get (struct _mail_msg *mm)
 341 {
 342         struct _emse_folderinfo_msg *m = (struct _emse_folderinfo_msg *) mm;
 343
 344         if (m->seq == m->sub->seq) {
 345                 camel_operation_register(mm->cancel);
 346                 m->info = camel_store_get_folder_info(m->sub->store, m->node?m->node->info->full_name:"", CAMEL_STORE_FOLDER_INFO_FAST | CAMEL_STORE_FOLDER_INFO_NO_VIRTUAL, &mm->ex);
 347                 camel_operation_unregister(mm->cancel);
 348         }
 349 }
 350
 351 static void
 352 sub_folderinfo_got(struct _mail_msg *mm)
 353 {
 354         struct _emse_folderinfo_msg *m = (struct _emse_folderinfo_msg *) mm;
 355         EMSubscribeNode *node;
 356
 357         m->sub->pending_id = -1;
 358         if (m->sub->cancel || m->seq != m->sub->seq)
 359                 return;
 360
 361         if (camel_exception_is_set (&mm->ex)) {
 362                 g_warning ("Error getting folder info from store: %s",
 363                            camel_exception_get_description (&mm->ex));
 364         }
 365
 366         if (m->info) {
 367                 if (m->node) {
 368                         GtkTreeIter iter;
 369
 370                         gtk_tree_model_get_iter(gtk_tree_view_get_model(m->sub->tree), &iter, m->node->path);
 371                         sub_fill_level(m->sub, m->info, &iter, FALSE);
 372                 } else {
 373                         sub_fill_level(m->sub, m->info, NULL, TRUE);
 374                 }
 375         }
 376
 377         /* check for more to do */
 378         node = (EMSubscribeNode *)e_dlist_remhead(&m->sub->pending);
 379         if (node)
 380                 sub_queue_fill_level(m->sub, node);
 381 }
 382
 383 static void
 384 sub_folderinfo_free(struct _mail_msg *mm)
 385 {
 386         struct _emse_folderinfo_msg *m = (struct _emse_folderinfo_msg *) mm;
 387
 388         if (m->info)
 389                 m->sub->info_list = g_slist_prepend(m->sub->info_list, m->info);
 390
 391         if (!m->sub->cancel)
 392                 sub_editor_busy(m->sub->editor, -1);
 393
 394         sub_unref(m->sub);
 395 }
 396
 397 static struct _mail_msg_op sub_folderinfo_op = {
 398         NULL, /*sub_folderinfo_desc,  we do our own progress reporting/cancellation */
 399         sub_folderinfo_get,
 400         sub_folderinfo_got,
 401         sub_folderinfo_free,
 402 };
 403
 404 static int
 405 sub_queue_fill_level(EMSubscribe *sub, EMSubscribeNode *node)
 406 {
 407         struct _emse_folderinfo_msg *m;
 408         int id;
 409
 410         d(printf("Starting get folderinfo of '%s'\n", node?node->info->full_name:"<root>"));
 411
 412         m = mail_msg_new (&sub_folderinfo_op, NULL, sizeof(*m));
 413         sub_ref(sub);
 414         m->sub = sub;
 415         m->node = node;
 416         m->seq = sub->seq;
 417
 418         sub->pending_id = m->msg.seq;
 419
 420         sub_editor_busy(sub->editor, 1);
 421
 422         id = m->msg.seq;
 423
 424         e_thread_put (mail_thread_new, (EMsg *)m);
 425         return id;
 426 }
 427
 428 /* ********************************************************************** */
 429
 430 /* (un) subscribes the current selection */
 431 static void sub_do_subscribe(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, void *data)
 432 {
 433         EMSubscribe *sub = data;
 434         EMSubscribeNode *node;
 435         gboolean subscribed;
 436
 437         gtk_tree_model_get(model, iter, 0, &subscribed, 2, &node, -1);
 438         if (sub->subscribed_state ^ subscribed) {
 439                 char *spath;
 440
 441                 spath = gtk_tree_path_to_string(path);
 442                 gtk_tree_store_set((GtkTreeStore *)model, iter, 0, subscribed, -1);
 443                 sub_subscribe_folder(sub, node, sub->subscribed_state, spath);
 444                 g_free(spath);
 445         }
 446 }
 447
 448 static void
 449 sub_subscribe(EMSubscribe *sub, gboolean subscribed)
 450 {
 451         GtkTreeSelection *selection;
 452
 453         if (sub->tree == NULL)
 454                 return;
 455
 456         sub->subscribed_state = subscribed;
 457         selection = gtk_tree_view_get_selection (sub->tree);
 458         gtk_tree_selection_selected_foreach(selection, sub_do_subscribe, sub);
 459 }
 460
 461 static void
 462 sub_subscribe_toggled(GtkCellRendererToggle *render, const char *spath, EMSubscribe *sub)
 463 {
 464         GtkTreeIter iter;
 465         GtkTreeModel *model = gtk_tree_view_get_model(sub->tree);
 466         EMSubscribeNode *node;
 467         gboolean subscribed;
 468
 469         d(printf("subscribe toggled?\n"));
 470
 471         if (gtk_tree_model_get_iter_from_string(model, &iter, spath)) {
 472                 gtk_tree_model_get(model, &iter, 0, &subscribed, 2, &node, -1);
 473                 subscribed = !subscribed;
 474                 d(printf("new state is %s\n", subscribed?"subscribed":"not subscribed"));
 475                 gtk_tree_store_set((GtkTreeStore *)model, &iter, 0, subscribed, -1);
 476                 sub_subscribe_folder(sub, node, subscribed, spath);
 477         }
 478 }
 479
 480 static void sub_do_changed(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, void *data)
 481 {
 482         EMSubscribe *sub = data;
 483         EMSubscribeNode *node;
 484         gboolean subscribed;
 485
 486         gtk_tree_model_get(model, iter, 0, &subscribed, 2, &node, -1);
 487
 488         if (subscribed)
 489                 sub->selected_subscribed_count++;
 490         sub->selected_count++;
 491 }
 492
 493 static void
 494 sub_selection_changed(GtkTreeSelection *selection, EMSubscribe *sub)
 495 {
 496         int dosub = TRUE, dounsub = TRUE;
 497
 498         sub->selected_count = 0;
 499         sub->selected_subscribed_count = 0;
 500         gtk_tree_selection_selected_foreach(selection, sub_do_changed, sub);
 501
 502         if (sub->selected_count == 0) {
 503                 dosub = FALSE;
 504                 dounsub = FALSE;
 505         } else if (sub->selected_subscribed_count == sub->selected_count)
 506                 dosub = FALSE;
 507         else if (sub->selected_subscribed_count == 0)
 508                 dounsub = FALSE;
 509
 510         gtk_widget_set_sensitive(sub->editor->subscribe_button, dosub);
 511         gtk_widget_set_sensitive(sub->editor->unsubscribe_button, dounsub);
 512 }
 513
 514 /* double-clicking causes a node item to be evaluated directly */
 515 static void sub_row_activated(GtkTreeView *tree, GtkTreePath *path, GtkTreeViewColumn *col, EMSubscribe *sub) {
 516         EMSubscribeNode *node;
 517         GtkTreeIter iter;
 518         GtkTreeModel *model = gtk_tree_view_get_model(tree);
 519
 520         if (gtk_tree_model_get_iter(model, &iter, path) != TRUE) return;
 521
 522         gtk_tree_model_get(model, &iter, 2, &node, -1);
 523
 524         /* check whether the item is already processed */
 525         if (node->path == NULL)
 526                 return;
 527
 528         /* remove it from wherever in the list it is, and place it in front instead */
 529         e_dlist_remove((EDListNode *)node);
 530         e_dlist_addhead(&sub->pending, (EDListNode *)node);
 531
 532         if (sub->pending_id == -1
 533             && (node = (EMSubscribeNode *)e_dlist_remtail(&sub->pending)))
 534                 sub_queue_fill_level(sub, node);
 535 }
 536
 537 static void
 538 sub_row_expanded(GtkTreeView *tree, GtkTreeIter *iter, GtkTreePath *path, EMSubscribe *sub)
 539 {
 540         EMSubscribeNode *node;
 541         GtkTreeIter child;
 542         GtkTreeModel *model = (GtkTreeModel *)gtk_tree_view_get_model(tree);
 543         EDList list;
 544
 545         gtk_tree_model_get(model, iter, 2, &node, -1);
 546         if (node->path == NULL) {
 547                 d(printf("path '%s' already processed\n", node->info->full_name));
 548                 return;
 549         }
 550         gtk_tree_path_free(node->path);
 551         node->path = NULL;
 552
 553         e_dlist_init(&list);
 554
 555         /* add all children nodes to pending, and fire off a pending */
 556         /* we add them to the head of the pending list, to make it more interactive */
 557         gtk_tree_model_iter_children(model, &child, iter);
 558         do {
 559                 gtk_tree_model_get(model, &child, 2, &node, -1);
 560                 if (node->path)
 561                         e_dlist_addtail(&list, (EDListNode *)node);
 562         } while (gtk_tree_model_iter_next(model, &child));
 563
 564         while ( (node = (EMSubscribeNode *)e_dlist_remtail(&list)) )
 565                 e_dlist_addhead(&sub->pending, (EDListNode *)node);
 566
 567         if (sub->pending_id == -1
 568             && (node = (EMSubscribeNode *)e_dlist_remtail(&sub->pending)))
 569                 sub_queue_fill_level(sub, node);
 570 }
 571
 572 static void
 573 sub_destroy(GtkWidget *w, EMSubscribe *sub)
 574 {
 575         struct _zsubscribe_msg *m;
 576
 577         d(printf("subscribe closed\n"));
 578         sub->cancel = TRUE;
 579
 580         if (sub->pending_id != -1)
 581                 mail_msg_cancel(sub->pending_id);
 582
 583         if (sub->subscribe_id != -1)
 584                 mail_msg_cancel(sub->subscribe_id);
 585
 586         while ( (m = (struct _zsubscribe_msg *)e_dlist_remhead(&sub->subscribe)) )
 587                 mail_msg_free(m);
 588
 589         sub_unref(sub);
 590 }
 591
 592 static EMSubscribe *
 593 subscribe_new(EMSubscribeEditor *se, const char *uri)
 594 {
 595         EMSubscribe *sub;
 596
 597         sub = g_malloc0(sizeof(*sub));
 598         sub->store_uri = g_strdup(uri);
 599         sub->editor = se;
 600         sub->ref_count = 1;
 601         sub->pending_id = -1;
 602         e_dlist_init(&sub->pending);
 603         sub->subscribe_id = -1;
 604         e_dlist_init(&sub->subscribe);
 605         sub->store_id = -1;
 606
 607         return sub;
 608 }
 609
 610 static void
 611 subscribe_set_store(EMSubscribe *sub, CamelStore *store)
 612 {
 613         if (store == NULL || !camel_store_supports_subscriptions(store)) {
 614                 GtkWidget *w = gtk_label_new(_("This store does not support subscriptions, or they are not enabled."));
 615
 616                 gtk_label_set_line_wrap((GtkLabel *)w, TRUE);
 617                 sub->widget = gtk_viewport_new(NULL, NULL);
 618                 gtk_viewport_set_shadow_type((GtkViewport *)sub->widget, GTK_SHADOW_IN);
 619                 gtk_container_add((GtkContainer *)sub->widget, w);
 620                 gtk_widget_show(w);
 621                 gtk_widget_show(sub->widget);
 622         } else {
 623                 GtkTreeSelection *selection;
 624                 GtkCellRenderer *renderer;
 625                 GtkTreeStore *model;
 626
 627                 sub->store = store;
 628                 camel_object_ref(store);
 629                 sub->folders = g_hash_table_new(g_str_hash, g_str_equal);
 630
 631                 model = gtk_tree_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER);
 632                 sub->tree = (GtkTreeView *) gtk_tree_view_new_with_model ((GtkTreeModel *) model);
 633                 gtk_widget_show ((GtkWidget *)sub->tree);
 634
 635                 sub->widget = gtk_scrolled_window_new (NULL, NULL);
 636                 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sub->widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 637                 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sub->widget), GTK_SHADOW_IN);
 638                 gtk_container_add((GtkContainer *)sub->widget, (GtkWidget *)sub->tree);
 639                 gtk_widget_show(sub->widget);
 640
 641                 renderer = gtk_cell_renderer_toggle_new ();
 642                 g_object_set(renderer, "activatable", TRUE, NULL);
 643                 gtk_tree_view_insert_column_with_attributes (sub->tree, -1, _("Subscribed"), renderer, "active", 0, NULL);
 644                 g_signal_connect(renderer, "toggled", G_CALLBACK(sub_subscribe_toggled), sub);
 645
 646                 renderer = gtk_cell_renderer_text_new ();
 647                 gtk_tree_view_insert_column_with_attributes (sub->tree, -1, _("Folder"), renderer, "text", 1, NULL);
 648                 gtk_tree_view_set_expander_column(sub->tree, gtk_tree_view_get_column(sub->tree, 1));
 649
 650                 selection = gtk_tree_view_get_selection (sub->tree);
 651                 gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
 652                 gtk_tree_view_set_headers_visible (sub->tree, FALSE);
 653
 654                 g_signal_connect(sub->tree, "row-expanded", G_CALLBACK(sub_row_expanded), sub);
 655                 g_signal_connect(sub->tree, "row-activated", G_CALLBACK(sub_row_activated), sub);
 656                 g_signal_connect(sub->tree, "destroy", G_CALLBACK(sub_destroy), sub);
 657
 658                 sub_selection_changed(selection, sub);
 659                 g_signal_connect(selection, "changed", G_CALLBACK(sub_selection_changed), sub);
 660
 661                 sub_queue_fill_level(sub, NULL);
 662         }
 663
 664         gtk_box_pack_start((GtkBox *)sub->editor->vbox, sub->widget, TRUE, TRUE, 0);
 665 }
 666
 667 static void
 668 sub_editor_destroy(GtkWidget *w, EMSubscribeEditor *se)
 669 {
 670         /* need to clean out pending store opens */
 671         d(printf("editor destroyed, freeing editor\n"));
 672         if (se->busy_id)
 673                 g_source_remove(se->busy_id);
 674
 675         g_free(se);
 676 }
 677
 678 static void
 679 sub_editor_close(GtkWidget *w, EMSubscribeEditor *se)
 680 {
 681         gtk_widget_destroy((GtkWidget *)se->dialog);
 682 }
 683
 684 static void
 685 sub_editor_refresh(GtkWidget *w, EMSubscribeEditor *se)
 686 {
 687         EMSubscribe *sub = se->current;
 688         GSList *l;
 689
 690         d(printf("sub editor refresh?\n"));
 691         if (sub == NULL || sub->store == NULL)
 692                 return;
 693
 694         sub->seq++;
 695
 696         /* drop any currently pending */
 697         if (sub->pending_id != -1)
 698                 mail_msg_cancel(sub->pending_id);
 699
 700         gtk_tree_store_clear((GtkTreeStore *)gtk_tree_view_get_model(sub->tree));
 701
 702         e_dlist_init(&sub->pending);
 703         if (sub->folders) {
 704                 g_hash_table_foreach(sub->folders, (GHFunc)sub_node_free, sub);
 705                 g_hash_table_destroy(sub->folders);
 706         }
 707         sub->folders = g_hash_table_new(g_str_hash, g_str_equal);
 708
 709         l = sub->info_list;
 710         sub->info_list = NULL;
 711         while (l) {
 712                 GSList *n = l->next;
 713
 714                 camel_store_free_folder_info(sub->store, (CamelFolderInfo *)l->data);
 715                 g_slist_free_1(l);
 716                 l = n;
 717         }
 718
 719         sub_queue_fill_level(sub, NULL);
 720 }
 721
 722 static void
 723 sub_editor_subscribe(GtkWidget *w, EMSubscribeEditor *se)
 724 {
 725         d(printf("subscribe clicked, current = %p\n", se->current));
 726
 727         if (se->current)
 728                 sub_subscribe(se->current, TRUE);
 729 }
 730
 731 static void
 732 sub_editor_unsubscribe(GtkWidget *w, EMSubscribeEditor *se)
 733 {
 734         d(printf("unsubscribe clicked\n"));
 735
 736         if (se->current)
 737                 sub_subscribe(se->current, FALSE);
 738 }
 739
 740 static void
 741 sub_editor_got_store(char *uri, CamelStore *store, void *data)
 742 {
 743         struct _EMSubscribe *sub = data;
 744
 745         if (!sub->cancel)
 746                 subscribe_set_store(sub, store);
 747         sub_unref(sub);
 748 }
 749
 750 static void
 751 sub_editor_menu_changed(GtkWidget *w, EMSubscribeEditor *se)
 752 {
 753         int i, n;
 754         struct _EMSubscribe *sub;
 755
 756         d(printf("menu changed\n"));
 757
 758         i = 1;
 759         n = gtk_option_menu_get_history((GtkOptionMenu *)se->optionmenu);
 760         if (n == 0)
 761                 gtk_widget_show(se->none_selected);
 762         else {
 763                 gtk_widget_hide(se->none_selected);
 764                 gtk_widget_hide(se->none_selected_item);
 765         }
 766
 767         se->current = NULL;
 768         sub = (struct _EMSubscribe *)se->stores.head;
 769         while (sub->next) {
 770                 if (i == n) {
 771                         se->current = sub;
 772                         if (sub->widget) {
 773                                 gtk_widget_show(sub->widget);
 774                         } else if (sub->store_id == -1) {
 775                                 sub_ref(sub);
 776                                 sub->store_id = mail_get_store(sub->store_uri, NULL, sub_editor_got_store, sub);
 777                         }
 778                 } else {
 779                         if (sub->widget)
 780                                 gtk_widget_hide(sub->widget);
 781                 }
 782                 i++;
 783                 sub = sub->next;
 784         }
 785 }
 786
 787 static gboolean sub_editor_timeout(EMSubscribeEditor *se)
 788 {
 789         gtk_progress_bar_pulse((GtkProgressBar *)se->progress);
 790
 791         return TRUE;
 792 }
 793
 794 static void sub_editor_busy(EMSubscribeEditor *se, int dir)
 795 {
 796         int was;
 797
 798         was = se->busy != 0;
 799         se->busy += dir;
 800         if (was && !se->busy) {
 801                 g_source_remove(se->busy_id);
 802                 se->busy_id = 0;
 803                 gtk_widget_hide(se->progress);
 804         } else if (!was && se->busy) {
 805                 se->busy_id = g_timeout_add(1000/5, (GSourceFunc)sub_editor_timeout, se);
 806                 gtk_widget_show(se->progress);
 807         }
 808 }
 809
 810
 811 #define DEFAULT_WIDTH  600
 812 #define DEFAULT_HEIGHT 400
 813
 814 static GtkAllocation window_size = { 0, 0, 0, 0 };
 815
 816 static void
 817 window_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
 818 {
 819         GConfClient *gconf;
 820
 821         /* save to in-memory variable for current session access */
 822         window_size = *allocation;
 823
 824         /* save the setting across sessions */
 825         gconf = gconf_client_get_default ();
 826         gconf_client_set_int (gconf, "/apps/evolution/mail/subscribe_window/width", window_size.width, NULL);
 827         gconf_client_set_int (gconf, "/apps/evolution/mail/subscribe_window/height", window_size.height, NULL);
 828         g_object_unref (gconf);
 829 }
 830
 831 GtkDialog *em_subscribe_editor_new(void)
 832 {
 833         EMSubscribeEditor *se;
 834         EAccountList *accounts;
 835         EIterator *iter;
 836         GladeXML *xml;
 837         GtkWidget *menu, *w;
 838
 839         se = g_malloc0(sizeof(*se));
 840         e_dlist_init(&se->stores);
 841
 842         xml = glade_xml_new (EVOLUTION_GLADEDIR "/mail-dialogs.glade", "subscribe_dialog", NULL);
 843         if (xml == NULL) {
 844                 /* ?? */
 845                 return NULL;
 846         }
 847         se->dialog = (GtkDialog *)glade_xml_get_widget (xml, "subscribe_dialog");
 848         g_signal_connect(se->dialog, "destroy", G_CALLBACK(sub_editor_destroy), se);
 849
 850         gtk_widget_ensure_style ((GtkWidget *)se->dialog);
 851         gtk_container_set_border_width ((GtkContainer *) ((GtkDialog *)se->dialog)->action_area, 12);
 852         gtk_container_set_border_width ((GtkContainer *) ((GtkDialog *)se->dialog)->vbox, 0);
 853
 854         se->vbox = glade_xml_get_widget(xml, "tree_box");
 855
 856         se->subscribe_button = glade_xml_get_widget (xml, "subscribe_button");
 857         g_signal_connect(se->subscribe_button, "clicked", G_CALLBACK(sub_editor_subscribe), se);
 858         se->unsubscribe_button = glade_xml_get_widget (xml, "unsubscribe_button");
 859         g_signal_connect(se->unsubscribe_button, "clicked", G_CALLBACK(sub_editor_unsubscribe), se);
 860
 861         /* FIXME: This is just to get the shadow, is there a better way? */
 862         w = gtk_label_new(_("Please select a server."));
 863         se->none_selected = gtk_viewport_new(NULL, NULL);
 864         gtk_viewport_set_shadow_type((GtkViewport *)se->none_selected, GTK_SHADOW_IN);
 865         gtk_container_add((GtkContainer *)se->none_selected, w);
 866         gtk_widget_show(w);
 867
 868         gtk_box_pack_start((GtkBox *)se->vbox, se->none_selected, TRUE, TRUE, 0);
 869         gtk_widget_show(se->none_selected);
 870
 871         se->progress = glade_xml_get_widget(xml, "progress_bar");
 872         gtk_widget_hide(se->progress);
 873
 874         w = glade_xml_get_widget(xml, "close_button");
 875         g_signal_connect(w, "clicked", G_CALLBACK(sub_editor_close), se);
 876
 877         w = glade_xml_get_widget(xml, "refresh_button");
 878         g_signal_connect(w, "clicked", G_CALLBACK(sub_editor_refresh), se);
 879
 880         /* setup stores menu */
 881         se->optionmenu = glade_xml_get_widget(xml, "store_menu");
 882         menu = gtk_menu_new();
 883         se->none_selected_item = w = gtk_menu_item_new_with_label(_("No server has been selected"));
 884         gtk_widget_show(w);
 885         gtk_menu_shell_append ((GtkMenuShell *)menu, w);
 886
 887         accounts = mail_config_get_accounts ();
 888         for (iter = e_list_get_iterator ((EList *) accounts);
 889              e_iterator_is_valid (iter);
 890              e_iterator_next (iter)) {
 891                 EAccount *account = (EAccount *) e_iterator_get (iter);
 892
 893                 /* setup url table, and store table? */
 894                 if (account->enabled && account->source->url) {
 895                         d(printf("adding account '%s'\n", account->name));
 896                         w = gtk_menu_item_new_with_label(account->name);
 897                         gtk_menu_shell_append ((GtkMenuShell *)menu, w);
 898                         gtk_widget_show(w);
 899                         e_dlist_addtail(&se->stores, (EDListNode *)subscribe_new(se, account->source->url));
 900                 } else {
 901                         d(printf("not adding account '%s'\n", account->name));
 902                 }
 903         }
 904         g_object_unref(iter);
 905
 906         gtk_option_menu_set_menu((GtkOptionMenu *)se->optionmenu, menu);
 907         g_signal_connect(se->optionmenu, "changed", G_CALLBACK(sub_editor_menu_changed), se);
 908
 909         if (window_size.width == 0) {
 910                 /* initialize @window_size with the previous session's size */
 911                 GConfClient *gconf;
 912                 GError *err = NULL;
 913
 914                 gconf = gconf_client_get_default ();
 915
 916                 window_size.width = gconf_client_get_int (gconf, "/apps/evolution/mail/subscribe_window/width", &err);
 917                 if (err != NULL) {
 918                         window_size.width = DEFAULT_WIDTH;
 919                         g_clear_error (&err);
 920                 }
 921
 922                 window_size.height = gconf_client_get_int (gconf, "/apps/evolution/mail/subscribe_window/height", &err);
 923                 if (err != NULL) {
 924                         window_size.height = DEFAULT_HEIGHT;
 925                         g_clear_error (&err);
 926                 }
 927
 928                 g_object_unref (gconf);
 929         }
 930
 931         gtk_window_set_default_size ((GtkWindow *) se->dialog, window_size.width, window_size.height);
 932         g_signal_connect (se->dialog, "size-allocate", G_CALLBACK (window_size_allocate), NULL);
 933
 934         return se->dialog;
 935 }