src/plugins/spamassassin/spamassassin_gtk.c

   1 /*
   2  * Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2007 the Claws Mail Team
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  17  *
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #endif
  23
  24 #include "defs.h"
  25
  26 #include <glib.h>
  27 #include <glib/gi18n.h>
  28 #include <gtk/gtk.h>
  29 #include <gtk/gtkutils.h>
  30
  31 #include "common/claws.h"
  32 #include "common/version.h"
  33 #include "plugin.h"
  34 #include "common/utils.h"
  35 #include "prefs.h"
  36 #include "folder.h"
  37 #include "prefs_gtk.h"
  38 #include "foldersel.h"
  39 #include "spamassassin.h"
  40 #include "statusbar.h"
  41 #include "menu.h"
  42
  43 struct SpamAssassinPage
  44 {
  45         PrefsPage page;
  46
  47         GtkWidget *enable_sa_checkbtn;
  48         GtkWidget *transport_optmenu;
  49         GtkWidget *transport_label;
  50         GtkWidget *username;
  51         GtkWidget *hostname;
  52         GtkWidget *colon;
  53         GtkWidget *port;
  54         GtkWidget *socket;
  55         GtkWidget *process_emails;
  56         GtkWidget *receive_spam;
  57         GtkWidget *save_folder;
  58         GtkWidget *save_folder_select;
  59         GtkWidget *max_size;
  60         GtkWidget *timeout;
  61         GtkWidget *mark_as_read;
  62
  63         SpamAssassinTransport   trans;
  64 };
  65
  66 struct Transport
  67 {
  68         gchar                   *name;
  69         SpamAssassinTransport    transport;
  70         guint                    page;
  71         guint                    pageflags;
  72 };
  73
  74 enum {
  75         PAGE_DISABLED = 0,
  76         PAGE_NETWORK  = 1,
  77         PAGE_UNIX     = 2,
  78 };
  79
  80 enum {
  81         NETWORK_HOSTNAME = 1,
  82 };
  83
  84 struct Transport transports[] = {
  85         /*{ N_("Disabled"),     SPAMASSASSIN_DISABLED,                  PAGE_DISABLED, 0 },*/
  86         { N_("Localhost"),      SPAMASSASSIN_TRANSPORT_LOCALHOST,       PAGE_NETWORK, 0 },
  87         { N_("TCP"),            SPAMASSASSIN_TRANSPORT_TCP,             PAGE_NETWORK, NETWORK_HOSTNAME },
  88         { N_("Unix Socket"),    SPAMASSASSIN_TRANSPORT_UNIX,            PAGE_UNIX,    0 },
  89 };
  90
  91 static void foldersel_cb(GtkWidget *widget, gpointer data)
  92 {
  93         struct SpamAssassinPage *page = (struct SpamAssassinPage *) data;
  94         FolderItem *item;
  95         gchar *item_id;
  96         gint newpos = 0;
  97
  98         item = foldersel_folder_sel(NULL, FOLDER_SEL_MOVE, NULL);
  99         if (item && (item_id = folder_item_get_identifier(item)) != NULL) {
 100                 gtk_editable_delete_text(GTK_EDITABLE(page->save_folder), 0, -1);
 101                 gtk_editable_insert_text(GTK_EDITABLE(page->save_folder), item_id, strlen(item_id), &newpos);
 102                 g_free(item_id);
 103         }
 104 }
 105
 106 static void show_transport(struct SpamAssassinPage *page, struct Transport *transport)
 107 {
 108         page->trans = transport->transport;
 109
 110         switch (transport->page) {
 111                 /*
 112         case PAGE_DISABLED:
 113                 gtk_widget_show(page->hostname);
 114                 gtk_widget_show(page->colon);
 115                 gtk_widget_show(page->port);
 116                 gtk_widget_hide(page->socket);
 117                 gtk_widget_set_sensitive(page->username, FALSE);
 118                 gtk_widget_set_sensitive(page->hostname, FALSE);
 119                 gtk_widget_set_sensitive(page->colon, FALSE);
 120                 gtk_widget_set_sensitive(page->port, FALSE);
 121                 gtk_widget_set_sensitive(page->max_size, FALSE);
 122                 gtk_widget_set_sensitive(page->timeout, FALSE);
 123                 gtk_widget_set_sensitive(page->process_emails, FALSE);
 124                 gtk_widget_set_sensitive(page->receive_spam, FALSE);
 125                 gtk_widget_set_sensitive(page->save_folder, FALSE);
 126                 gtk_widget_set_sensitive(page->save_folder_select, FALSE);
 127                 break;
 128                 */
 129         case PAGE_UNIX:
 130                 gtk_widget_hide(page->hostname);
 131                 gtk_widget_hide(page->colon);
 132                 gtk_widget_hide(page->port);
 133                 gtk_widget_show(page->socket);
 134                 gtk_widget_set_sensitive(page->username, TRUE);
 135                 gtk_widget_set_sensitive(page->socket, TRUE);
 136                 gtk_widget_set_sensitive(page->max_size, TRUE);
 137                 gtk_widget_set_sensitive(page->timeout, TRUE);
 138                 gtk_widget_set_sensitive(page->process_emails, TRUE);
 139                 gtk_widget_set_sensitive(page->receive_spam, TRUE);
 140                 gtk_widget_set_sensitive(page->save_folder, TRUE);
 141                 gtk_widget_set_sensitive(page->save_folder_select, TRUE);
 142                 break;
 143         case PAGE_NETWORK:
 144                 gtk_widget_show(page->hostname);
 145                 gtk_widget_show(page->colon);
 146                 gtk_widget_show(page->port);
 147                 gtk_widget_hide(page->socket);
 148                 gtk_widget_set_sensitive(page->username, TRUE);
 149                 gtk_widget_set_sensitive(page->max_size, TRUE);
 150                 gtk_widget_set_sensitive(page->timeout, TRUE);
 151                 gtk_widget_set_sensitive(page->process_emails, TRUE);
 152                 gtk_widget_set_sensitive(page->receive_spam, TRUE);
 153                 gtk_widget_set_sensitive(page->save_folder, TRUE);
 154                 gtk_widget_set_sensitive(page->save_folder_select, TRUE);
 155                 if (transport->pageflags & NETWORK_HOSTNAME) {
 156                         gtk_widget_set_sensitive(page->hostname, TRUE);
 157                         gtk_widget_set_sensitive(page->colon, TRUE);
 158                         gtk_widget_set_sensitive(page->port, TRUE);
 159                 } else {
 160                         gtk_widget_set_sensitive(page->hostname, FALSE);
 161                         gtk_widget_set_sensitive(page->colon, FALSE);
 162                         gtk_widget_set_sensitive(page->port, TRUE);
 163                 }
 164                 break;
 165         default:
 166                 break;
 167         }
 168 }
 169
 170 static void transport_sel_cb(GtkMenuItem *menuitem, gpointer data)
 171 {
 172         struct SpamAssassinPage *page = (struct SpamAssassinPage *) data;
 173         struct Transport *transport;
 174
 175         transport = (struct Transport *) g_object_get_data(G_OBJECT(menuitem), MENU_VAL_ID);
 176         show_transport(page, transport);
 177 }
 178
 179 static void spamassassin_create_widget_func(PrefsPage * _page,
 180                                             GtkWindow * window,
 181                                             gpointer data)
 182 {
 183         struct SpamAssassinPage *page = (struct SpamAssassinPage *) _page;
 184         SpamAssassinConfig *config;
 185         guint i, active;
 186
 187         GtkWidget *vbox1, *vbox2;
 188         GtkWidget *frame_transport, *table_transport, *vbox_transport;
 189         GtkWidget *hbox_spamd, *hbox_max_size, *hbox_timeout;
 190         GtkWidget *hbox_process_emails, *hbox_save_spam;
 191         GtkWidget *hbox_mark_as_read;
 192
 193         GtkWidget *enable_sa_checkbtn;
 194
 195         GtkWidget *transport_label;
 196         GtkWidget *transport_optmenu;
 197         GtkWidget *transport_menu;
 198
 199         GtkWidget *user_label;
 200         GtkWidget *user_entry;
 201
 202         GtkWidget *spamd_label;
 203         GtkWidget *spamd_hostname_entry;
 204         GtkWidget *spamd_colon_label;
 205         GtkObject *spamd_port_spinbtn_adj;
 206         GtkWidget *spamd_port_spinbtn;
 207         GtkWidget *spamd_socket_entry;
 208
 209         GtkWidget *max_size_label;
 210         GtkObject *max_size_spinbtn_adj;
 211         GtkWidget *max_size_spinbtn;
 212         GtkWidget *max_size_kb_label;
 213
 214         GtkWidget *timeout_label;
 215         GtkObject *timeout_spinbtn_adj;
 216         GtkWidget *timeout_spinbtn;
 217         GtkWidget *timeout_seconds_label;
 218
 219         GtkWidget *process_emails_checkbtn;
 220
 221         GtkWidget *save_spam_checkbtn;
 222         GtkWidget *save_spam_folder_entry;
 223         GtkWidget *save_spam_folder_select;
 224
 225         GtkWidget *mark_as_read_checkbtn;
 226
 227         GtkTooltips *tooltips;
 228
 229         tooltips = gtk_tooltips_new();
 230
 231         vbox1 = gtk_vbox_new (FALSE, VSPACING);
 232         gtk_widget_show (vbox1);
 233         gtk_container_set_border_width (GTK_CONTAINER (vbox1), VBOX_BORDER);
 234
 235         vbox2 = gtk_vbox_new (FALSE, 4);
 236         gtk_widget_show (vbox2);
 237         gtk_box_pack_start (GTK_BOX (vbox1), vbox2, FALSE, FALSE, 0);
 238
 239         enable_sa_checkbtn = gtk_check_button_new_with_label(_("Enable SpamAssassin plugin"));
 240         gtk_widget_show(enable_sa_checkbtn);
 241         gtk_box_pack_start(GTK_BOX(vbox2), enable_sa_checkbtn, TRUE, TRUE, 0);
 242
 243         vbox_transport = gtkut_get_options_frame(vbox2, &frame_transport, _("Transport"));
 244
 245         table_transport = gtk_table_new (3, 3, FALSE);
 246         gtk_widget_show (table_transport);
 247         gtk_box_pack_start(GTK_BOX(vbox_transport), table_transport, TRUE, TRUE, 0);
 248         gtk_table_set_row_spacings (GTK_TABLE (table_transport), 4);
 249         gtk_table_set_col_spacings (GTK_TABLE (table_transport), 8);
 250
 251         transport_label = gtk_label_new(_("Type of transport"));
 252         gtk_widget_show(transport_label);
 253         gtk_table_attach (GTK_TABLE (table_transport), transport_label, 0, 1, 0, 1,
 254                         (GtkAttachOptions) (GTK_FILL),
 255                         (GtkAttachOptions) (0), 0, 0);
 256         gtk_label_set_justify(GTK_LABEL(transport_label), GTK_JUSTIFY_RIGHT);
 257         gtk_misc_set_alignment(GTK_MISC(transport_label), 1, 0.5);
 258
 259         transport_optmenu = gtk_option_menu_new();
 260         gtk_widget_show(transport_optmenu);
 261
 262         gtk_table_attach (GTK_TABLE (table_transport), transport_optmenu, 1, 2, 0, 1,
 263                         (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
 264                         (GtkAttachOptions) (0), 0, 0);
 265         transport_menu = gtk_menu_new();
 266
 267         user_label = gtk_label_new(_("User"));
 268         gtk_widget_show(user_label);
 269         gtk_table_attach (GTK_TABLE (table_transport), user_label, 0, 1, 1, 2,
 270                         (GtkAttachOptions) (GTK_FILL),
 271                         (GtkAttachOptions) (0), 0, 0);
 272         gtk_label_set_justify(GTK_LABEL(user_label), GTK_JUSTIFY_RIGHT);
 273         gtk_misc_set_alignment(GTK_MISC(user_label), 1, 0.5);
 274
 275         user_entry = gtk_entry_new();
 276         gtk_widget_show(user_entry);
 277         gtk_table_attach (GTK_TABLE (table_transport), user_entry, 1, 2, 1, 2,
 278                         (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
 279                         (GtkAttachOptions) (0), 0, 0);
 280         gtk_tooltips_set_tip(tooltips, user_entry, _("User to use with spamd server"),
 281                         NULL);
 282
 283         spamd_label = gtk_label_new(_("spamd"));
 284         gtk_widget_show(spamd_label);
 285         gtk_table_attach (GTK_TABLE (table_transport), spamd_label, 0, 1, 2, 3,
 286                         (GtkAttachOptions) (GTK_FILL),
 287                         (GtkAttachOptions) (0), 0, 0);
 288         gtk_label_set_justify(GTK_LABEL(spamd_label), GTK_JUSTIFY_RIGHT);
 289         gtk_misc_set_alignment(GTK_MISC(spamd_label), 1, 0.5);
 290
 291         hbox_spamd = gtk_hbox_new(FALSE, 8);
 292         gtk_widget_show(hbox_spamd);
 293         gtk_table_attach (GTK_TABLE (table_transport), hbox_spamd, 1, 2, 2, 3,
 294                         (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
 295                         (GtkAttachOptions) (0), 0, 0);
 296
 297         spamd_hostname_entry = gtk_entry_new();
 298         gtk_widget_show(spamd_hostname_entry);
 299         gtk_box_pack_start(GTK_BOX(hbox_spamd), spamd_hostname_entry, TRUE, TRUE, 0);
 300         gtk_tooltips_set_tip(tooltips, spamd_hostname_entry,
 301                         _("Hostname or IP address of spamd server"), NULL);
 302
 303         spamd_colon_label = gtk_label_new(":");
 304         gtk_widget_show(spamd_colon_label);
 305         gtk_box_pack_start(GTK_BOX(hbox_spamd), spamd_colon_label, FALSE, FALSE, 0);
 306
 307         spamd_port_spinbtn_adj = gtk_adjustment_new(783, 1, 65535, 1, 10, 10);
 308         spamd_port_spinbtn = gtk_spin_button_new(GTK_ADJUSTMENT(spamd_port_spinbtn_adj), 1, 0);
 309         gtk_widget_show(spamd_port_spinbtn);
 310         gtk_box_pack_start(GTK_BOX(hbox_spamd), spamd_port_spinbtn, FALSE, FALSE, 0);
 311         gtk_tooltips_set_tip(tooltips, spamd_port_spinbtn,
 312                         _("Port of spamd server"), NULL);
 313         gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spamd_port_spinbtn), TRUE);
 314
 315         spamd_socket_entry = gtk_entry_new();
 316         gtk_widget_show(spamd_socket_entry);
 317         gtk_box_pack_start(GTK_BOX(hbox_spamd), spamd_socket_entry, TRUE, TRUE, 0);
 318         gtk_tooltips_set_tip(tooltips, spamd_socket_entry, _("Path of Unix socket"),
 319                         NULL);
 320
 321         hbox_max_size = gtk_hbox_new(FALSE, 8);
 322         gtk_widget_show(hbox_max_size);
 323         gtk_box_pack_start (GTK_BOX (vbox2), hbox_max_size, TRUE, TRUE, 0);
 324
 325         max_size_label = gtk_label_new(_("Maximum size"));
 326         gtk_widget_show(max_size_label);
 327         gtk_box_pack_start(GTK_BOX(hbox_max_size), max_size_label, FALSE, FALSE, 0);
 328
 329         max_size_spinbtn_adj = gtk_adjustment_new(250, 0, 10000, 10, 10, 10);
 330         max_size_spinbtn = gtk_spin_button_new(GTK_ADJUSTMENT(max_size_spinbtn_adj), 1, 0);
 331         gtk_widget_show(max_size_spinbtn);
 332         gtk_box_pack_start(GTK_BOX(hbox_max_size), max_size_spinbtn, FALSE, FALSE, 0);
 333         gtk_tooltips_set_tip(tooltips, max_size_spinbtn,
 334                         _("Messages larger than this will not be checked"), NULL);
 335         gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(max_size_spinbtn), TRUE);
 336
 337         max_size_kb_label = gtk_label_new(_("kB"));
 338         gtk_widget_show(max_size_kb_label);
 339         gtk_box_pack_start(GTK_BOX(hbox_max_size), max_size_kb_label, FALSE, FALSE, 0);
 340
 341         hbox_timeout = gtk_hbox_new(FALSE, 8);
 342         gtk_widget_show(hbox_timeout);
 343         gtk_box_pack_start (GTK_BOX (vbox2), hbox_timeout, TRUE, TRUE, 0);
 344
 345         timeout_label = gtk_label_new(_("Timeout"));
 346         gtk_widget_show(timeout_label);
 347         gtk_box_pack_start(GTK_BOX(hbox_timeout), timeout_label, FALSE, FALSE, 0);
 348
 349         timeout_spinbtn_adj = gtk_adjustment_new(60, 0, 10000, 10, 10, 10);
 350         timeout_spinbtn = gtk_spin_button_new(GTK_ADJUSTMENT(timeout_spinbtn_adj), 1, 0);
 351         gtk_widget_show(timeout_spinbtn);
 352         gtk_box_pack_start(GTK_BOX(hbox_timeout), timeout_spinbtn, FALSE, FALSE, 0);
 353         gtk_tooltips_set_tip(tooltips, timeout_spinbtn,
 354                         _("Maximum time allowed for checking. If the check takes longer "
 355                                 "it will be aborted."),
 356                         NULL);
 357         gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(timeout_spinbtn), TRUE);
 358
 359         timeout_seconds_label = gtk_label_new(_("seconds"));
 360         gtk_widget_show(timeout_seconds_label);
 361         gtk_box_pack_start(GTK_BOX(hbox_timeout), timeout_seconds_label, FALSE, FALSE, 0);
 362
 363         hbox_process_emails = gtk_hbox_new(FALSE, 8);
 364         gtk_widget_show(hbox_process_emails);
 365         gtk_box_pack_start (GTK_BOX (vbox2), hbox_process_emails, TRUE, TRUE, 0);
 366
 367         process_emails_checkbtn = gtk_check_button_new_with_label(
 368                         _("Process messages on receiving"));
 369         gtk_widget_show(process_emails_checkbtn);
 370         gtk_box_pack_start(GTK_BOX(hbox_process_emails), process_emails_checkbtn, TRUE, TRUE, 0);
 371
 372         hbox_save_spam = gtk_hbox_new(FALSE, 8);
 373         gtk_widget_show(hbox_save_spam);
 374         gtk_box_pack_start (GTK_BOX (vbox2), hbox_save_spam, TRUE, TRUE, 0);
 375
 376         save_spam_checkbtn = gtk_check_button_new_with_label(_("Save spam in"));
 377         gtk_widget_show(save_spam_checkbtn);
 378         gtk_box_pack_start(GTK_BOX(hbox_save_spam), save_spam_checkbtn, FALSE, FALSE, 0);
 379
 380         save_spam_folder_entry = gtk_entry_new();
 381         gtk_widget_show (save_spam_folder_entry);
 382         gtk_box_pack_start (GTK_BOX (hbox_save_spam), save_spam_folder_entry, TRUE, TRUE, 0);
 383         gtk_tooltips_set_tip(tooltips, save_spam_folder_entry,
 384                         _("Folder for storing identified spam. Leave empty to use the trash folder."),
 385                         NULL);
 386
 387         save_spam_folder_select = gtkut_get_browse_directory_btn(_("_Browse"));
 388         gtk_widget_show (save_spam_folder_select);
 389         gtk_box_pack_start (GTK_BOX (hbox_save_spam), save_spam_folder_select, FALSE, FALSE, 0);
 390         gtk_tooltips_set_tip(tooltips, save_spam_folder_select,
 391                         _("Click this button to select a folder for storing spam"),
 392                         NULL);
 393
 394         hbox_mark_as_read = gtk_hbox_new(FALSE, 8);
 395         gtk_widget_show(hbox_mark_as_read);
 396         gtk_box_pack_start (GTK_BOX (vbox2), hbox_mark_as_read, TRUE, TRUE, 0);
 397
 398         mark_as_read_checkbtn = gtk_check_button_new_with_label(
 399                         _("Mark spam as read"));
 400         gtk_widget_show(mark_as_read_checkbtn);
 401         gtk_box_pack_start(GTK_BOX(hbox_mark_as_read), mark_as_read_checkbtn, TRUE, TRUE, 0);
 402
 403         SET_TOGGLE_SENSITIVITY(enable_sa_checkbtn, frame_transport);
 404         SET_TOGGLE_SENSITIVITY(enable_sa_checkbtn, hbox_max_size);
 405         SET_TOGGLE_SENSITIVITY(enable_sa_checkbtn, hbox_timeout);
 406         SET_TOGGLE_SENSITIVITY(enable_sa_checkbtn, hbox_save_spam);
 407         SET_TOGGLE_SENSITIVITY(save_spam_checkbtn, save_spam_folder_entry);
 408         SET_TOGGLE_SENSITIVITY(save_spam_checkbtn, save_spam_folder_select);
 409         SET_TOGGLE_SENSITIVITY(enable_sa_checkbtn, hbox_process_emails);
 410         SET_TOGGLE_SENSITIVITY(save_spam_checkbtn, mark_as_read_checkbtn);
 411
 412         config = spamassassin_get_config();
 413
 414         g_signal_connect(G_OBJECT(save_spam_folder_select), "clicked",
 415                         G_CALLBACK(foldersel_cb), page);
 416
 417         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enable_sa_checkbtn), config->enable);
 418         if (config->username != NULL)
 419                 gtk_entry_set_text(GTK_ENTRY(user_entry), config->username);
 420         if (config->hostname != NULL)
 421                 gtk_entry_set_text(GTK_ENTRY(spamd_hostname_entry), config->hostname);
 422         if (config->socket != NULL)
 423                 gtk_entry_set_text(GTK_ENTRY(spamd_socket_entry), config->socket);
 424         gtk_spin_button_set_value(GTK_SPIN_BUTTON(spamd_port_spinbtn), (float) config->port);
 425         gtk_spin_button_set_value(GTK_SPIN_BUTTON(max_size_spinbtn), (float) config->max_size);
 426         gtk_spin_button_set_value(GTK_SPIN_BUTTON(timeout_spinbtn), (float) config->timeout);
 427         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(process_emails_checkbtn), config->process_emails);
 428         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(save_spam_checkbtn), config->receive_spam);
 429         if (config->save_folder != NULL)
 430                 gtk_entry_set_text(GTK_ENTRY(save_spam_folder_entry), config->save_folder);
 431         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mark_as_read_checkbtn), config->mark_as_read);
 432
 433         page->enable_sa_checkbtn = enable_sa_checkbtn;
 434         page->transport_label = transport_label;
 435         page->transport_optmenu = transport_optmenu;
 436         page->username = user_entry;
 437         page->hostname = spamd_hostname_entry;
 438         page->colon = spamd_colon_label;
 439         page->port = spamd_port_spinbtn;
 440         page->socket = spamd_socket_entry;
 441         page->max_size = max_size_spinbtn;
 442         page->timeout = timeout_spinbtn;
 443         page->process_emails = process_emails_checkbtn;
 444         page->receive_spam = save_spam_checkbtn;
 445         page->save_folder = save_spam_folder_entry;
 446         page->save_folder_select = save_spam_folder_select;
 447         page->mark_as_read = mark_as_read_checkbtn;
 448
 449         active = 0;
 450         for (i = 0; i < (sizeof(transports) / sizeof(struct Transport)); i++) {
 451                 GtkWidget *menuitem;
 452
 453                 menuitem = gtk_menu_item_new_with_label(gettext(transports[i].name));
 454                 g_object_set_data(G_OBJECT(menuitem), MENU_VAL_ID, &transports[i]);
 455                 g_signal_connect(G_OBJECT(menuitem), "activate",
 456                                 G_CALLBACK(transport_sel_cb), page);
 457                 gtk_widget_show(menuitem);
 458                 gtk_menu_append(GTK_MENU(transport_menu), menuitem);
 459
 460                 if (config->transport == transports[i].transport) {
 461                         show_transport(page, &transports[i]);
 462                         active = i;
 463                 } else if (config->transport == SPAMASSASSIN_DISABLED
 464                         && transports[i].transport == SPAMASSASSIN_TRANSPORT_LOCALHOST) {
 465                         show_transport(page, &transports[i]);
 466                         active = i;
 467                         /* and disable via new way */
 468                         config->enable = FALSE;
 469                         gtk_toggle_button_set_active(
 470                                 GTK_TOGGLE_BUTTON(enable_sa_checkbtn),
 471                                 config->enable);
 472                 }
 473         }
 474         gtk_option_menu_set_menu(GTK_OPTION_MENU(transport_optmenu), transport_menu);
 475         gtk_option_menu_set_history(GTK_OPTION_MENU(transport_optmenu), active);
 476
 477         page->page.widget = vbox1;
 478 }
 479
 480 static void spamassassin_destroy_widget_func(PrefsPage *_page)
 481 {
 482         debug_print("Destroying SpamAssassin widget\n");
 483 }
 484
 485 static void spamassassin_save_func(PrefsPage *_page)
 486 {
 487         struct SpamAssassinPage *page = (struct SpamAssassinPage *) _page;
 488         SpamAssassinConfig *config;
 489
 490         debug_print("Saving SpamAssassin Page\n");
 491
 492         config = spamassassin_get_config();
 493
 494         /* enable */
 495         config->enable = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->enable_sa_checkbtn));
 496         config->transport = page->trans;
 497
 498         /* username */
 499         g_free(config->username);
 500         config->username = gtk_editable_get_chars(GTK_EDITABLE(page->username), 0, -1);
 501         spamassassin_check_username();
 502
 503         /* hostname */
 504         g_free(config->hostname);
 505         config->hostname = gtk_editable_get_chars(GTK_EDITABLE(page->hostname), 0, -1);
 506
 507         /* port */
 508         config->port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(page->port));
 509
 510         /* hostname */
 511         g_free(config->socket);
 512         config->socket = gtk_editable_get_chars(GTK_EDITABLE(page->socket), 0, -1);
 513
 514         /* process_emails */
 515         config->process_emails = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->process_emails));
 516
 517         /* receive_spam */
 518         config->receive_spam = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->receive_spam));
 519
 520         /* save_folder */
 521         g_free(config->save_folder);
 522         config->save_folder = gtk_editable_get_chars(GTK_EDITABLE(page->save_folder), 0, -1);
 523
 524         /* max_size */
 525         config->max_size = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(page->max_size));
 526
 527         /* timeout */
 528         config->timeout = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(page->timeout));
 529
 530         /* mark_as_read */
 531         config->mark_as_read = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->mark_as_read));
 532
 533         if (config->process_emails) {
 534                 spamassassin_register_hook();
 535         } else {
 536                 spamassassin_unregister_hook();
 537         }
 538
 539         if (!config->enable) {
 540                 procmsg_unregister_spam_learner(spamassassin_learn);
 541                 procmsg_spam_set_folder(NULL, NULL);
 542         } else {
 543                 if (config->transport == SPAMASSASSIN_TRANSPORT_TCP)
 544                         debug_print("enabling learner with a remote spamassassin server requires spamc/spamd 3.1.x\n");
 545                 procmsg_register_spam_learner(spamassassin_learn);
 546                 procmsg_spam_set_folder(config->save_folder, spamassassin_get_spam_folder);
 547         }
 548
 549         spamassassin_save_config();
 550 }
 551
 552 static void gtk_message_callback(gchar *message)
 553 {
 554         statusbar_print_all(message);
 555 }
 556
 557 static struct SpamAssassinPage spamassassin_page;
 558
 559 gint spamassassin_gtk_init(void)
 560 {
 561         static gchar *path[3];
 562
 563         path[0] = _("Plugins");
 564         path[1] = _("SpamAssassin");
 565         path[2] = NULL;
 566
 567         spamassassin_page.page.path = path;
 568         spamassassin_page.page.create_widget = spamassassin_create_widget_func;
 569         spamassassin_page.page.destroy_widget = spamassassin_destroy_widget_func;
 570         spamassassin_page.page.save_page = spamassassin_save_func;
 571         spamassassin_page.page.weight = 35.0;
 572
 573         prefs_gtk_register_page((PrefsPage *) &spamassassin_page);
 574         spamassassin_set_message_callback(gtk_message_callback);
 575
 576         debug_print("SpamAssassin GTK plugin loaded\n");
 577         return 0;
 578 }
 579
 580 void spamassassin_gtk_done(void)
 581 {
 582         prefs_gtk_unregister_page((PrefsPage *) &spamassassin_page);
 583 }