src/prefs_logging.c

   1 /*
   2  * Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2007 Tristan Chabredier <wwp@claws-mail.org> and
   4  * the Claws Mail team
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #  include "config.h"
  23 #endif
  24
  25 #include "defs.h"
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29
  30 #include <glib.h>
  31 #include <glib/gi18n.h>
  32 #include <gtk/gtk.h>
  33
  34 #include "prefs_common.h"
  35 #include "prefs_gtk.h"
  36
  37 #include "gtk/gtkutils.h"
  38 #include "gtk/prefswindow.h"
  39 #include "gtk/menu.h"
  40
  41 #include "manage_window.h"
  42
  43 #include "log.h"
  44
  45 typedef struct _LoggingPage
  46 {
  47         PrefsPage page;
  48
  49         GtkWidget *window;
  50
  51         GtkWidget *checkbtn_clip_network_log;
  52         GtkWidget *spinbtn_network_log_length;
  53         GtkWidget *checkbtn_clip_filtering_log;
  54         GtkWidget *spinbtn_filtering_log_length;
  55         GtkWidget *checkbtn_filtering_log;
  56         GtkWidget *checkbtn_filtering_log_inc;
  57         GtkWidget *checkbtn_filtering_log_manual;
  58         GtkWidget *checkbtn_filtering_log_folder_proc;
  59         GtkWidget *checkbtn_filtering_log_pre_proc;
  60         GtkWidget *checkbtn_filtering_log_post_proc;
  61         GtkWidget *optmenu_filtering_log_level;
  62 } LoggingPage;
  63
  64 static void prefs_logging_create_widget(PrefsPage *_page, GtkWindow *window,
  65                                   gpointer data)
  66 {
  67         LoggingPage *prefs_logging = (LoggingPage *) _page;
  68
  69         GtkWidget *vbox1;
  70
  71         GtkWidget *frame_logging;
  72         GtkWidget *vbox_network_log;
  73         GtkWidget *hbox_clip_network_log;
  74         GtkWidget *checkbtn_clip_network_log;
  75         GtkWidget *spinbtn_network_log_length;
  76         GtkObject *spinbtn_network_log_length_adj;
  77         GtkTooltips *network_log_length_tooltip;
  78         GtkWidget *label;
  79         GtkWidget *vbox1_filtering_log;
  80         GtkWidget *hbox_clip_filtering_log;
  81         GtkWidget *checkbtn_clip_filtering_log;
  82         GtkWidget *spinbtn_filtering_log_length;
  83         GtkObject *spinbtn_filtering_log_length_adj;
  84         GtkTooltips *filtering_log_length_tooltip;
  85         GtkWidget *hbox_filtering_log;
  86         GtkWidget *checkbtn_filtering_log;
  87         GtkWidget *frame_filtering_log;
  88         GtkWidget *vbox2_filtering_log;
  89         GtkWidget *hbox_filtering_log_inc;
  90         GtkWidget *checkbtn_filtering_log_inc;
  91         GtkWidget *hbox_filtering_log_manual;
  92         GtkWidget *checkbtn_filtering_log_manual;
  93         GtkWidget *hbox_filtering_log_folder_proc;
  94         GtkWidget *checkbtn_filtering_log_folder_proc;
  95         GtkWidget *hbox_filtering_log_pre_proc;
  96         GtkWidget *checkbtn_filtering_log_pre_proc;
  97         GtkWidget *hbox_filtering_log_post_proc;
  98         GtkWidget *checkbtn_filtering_log_post_proc;
  99         GtkTooltips *filtering_log_tooltip;
 100         GtkWidget *hbox_filtering_log_level;
 101         GtkWidget *label_filtering_log_level;
 102         GtkWidget *optmenu_filtering_log_level;
 103         GtkWidget *menu;
 104         GtkWidget *menuitem;
 105         GtkTooltips *filtering_log_level_tooltip;
 106
 107         vbox1 = gtk_vbox_new (FALSE, VSPACING);
 108         gtk_widget_show (vbox1);
 109         gtk_container_set_border_width (GTK_CONTAINER (vbox1), VBOX_BORDER);
 110
 111         /* Protocol log */
 112         vbox_network_log = gtkut_get_options_frame(vbox1, &frame_logging, _("Network log"));
 113
 114         hbox_clip_network_log = gtk_hbox_new (FALSE, 8);
 115         gtk_container_add (GTK_CONTAINER (vbox_network_log), hbox_clip_network_log);
 116         gtk_widget_show (hbox_clip_network_log);
 117
 118         PACK_CHECK_BUTTON (hbox_clip_network_log, checkbtn_clip_network_log,
 119                            _("Restrict the log window to"));
 120
 121         network_log_length_tooltip = gtk_tooltips_new();
 122
 123         spinbtn_network_log_length_adj = gtk_adjustment_new (500, 0, G_MAXINT, 1, 10, 10);
 124         spinbtn_network_log_length = gtk_spin_button_new
 125                 (GTK_ADJUSTMENT (spinbtn_network_log_length_adj), 1, 0);
 126         gtk_widget_show (spinbtn_network_log_length);
 127         gtk_box_pack_start (GTK_BOX (hbox_clip_network_log), spinbtn_network_log_length,
 128                             FALSE, FALSE, 0);
 129         gtk_widget_set_size_request (GTK_WIDGET (spinbtn_network_log_length), 64, -1);
 130         gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbtn_network_log_length), TRUE);
 131
 132         gtk_tooltips_set_tip(GTK_TOOLTIPS(network_log_length_tooltip), spinbtn_network_log_length,
 133                              _("0 to stop logging in the log window"),
 134                              NULL);
 135
 136         label = gtk_label_new(_("lines"));
 137         gtk_widget_show (label);
 138         gtk_box_pack_start(GTK_BOX(hbox_clip_network_log), label, FALSE, FALSE, 0);
 139
 140         SET_TOGGLE_SENSITIVITY(checkbtn_clip_network_log, spinbtn_network_log_length);
 141         SET_TOGGLE_SENSITIVITY(checkbtn_clip_network_log, label);
 142
 143         /* Filtering/processing debug log */
 144         vbox1_filtering_log = gtkut_get_options_frame(vbox1,
 145                                 &frame_logging, _("Filtering/processing log"));
 146
 147         PACK_CHECK_BUTTON (vbox1_filtering_log, checkbtn_filtering_log,
 148                            _("Enable logging of filtering/processing rules"));
 149         hbox_filtering_log = gtk_hbox_new (FALSE, 8);
 150         gtk_container_add (GTK_CONTAINER (vbox1_filtering_log), hbox_filtering_log);
 151         gtk_widget_show (hbox_filtering_log);
 152
 153         filtering_log_tooltip = gtk_tooltips_new();
 154         gtk_tooltips_set_tip(GTK_TOOLTIPS(filtering_log_tooltip),
 155                              checkbtn_filtering_log,
 156                              _("If checked, turns on logging of filtering and processing rules.\n"
 157                                 "The log is accessible from 'Tools/Filtering log'.\n"
 158                                 "Caution: enabling this option will slow down the filtering/processing, "
 159                                 "this might be critical when applying many rules upon thousands of "
 160                                 "messages."),
 161                                 NULL);
 162
 163         vbox2_filtering_log = gtkut_get_options_frame(vbox1_filtering_log, &frame_filtering_log,
 164                                                         _("Log filtering/processing when..."));
 165
 166         PACK_CHECK_BUTTON (vbox2_filtering_log, checkbtn_filtering_log_inc,
 167                            _("filtering at incorporation"));
 168         hbox_filtering_log_inc = gtk_hbox_new (FALSE, 8);
 169         gtk_container_add (GTK_CONTAINER (vbox2_filtering_log), hbox_filtering_log_inc);
 170         gtk_widget_show (hbox_filtering_log_inc);
 171
 172         PACK_CHECK_BUTTON (vbox2_filtering_log, checkbtn_filtering_log_manual,
 173                            _("manually filtering"));
 174         hbox_filtering_log_manual = gtk_hbox_new (FALSE, 8);
 175         gtk_container_add (GTK_CONTAINER (vbox2_filtering_log), hbox_filtering_log_manual);
 176         gtk_widget_show (hbox_filtering_log_manual);
 177
 178         PACK_CHECK_BUTTON (vbox2_filtering_log, checkbtn_filtering_log_folder_proc,
 179                            _("processing folders"));
 180         hbox_filtering_log_folder_proc = gtk_hbox_new (FALSE, 8);
 181         gtk_container_add (GTK_CONTAINER (vbox2_filtering_log), hbox_filtering_log_folder_proc);
 182         gtk_widget_show (hbox_filtering_log_folder_proc);
 183
 184         PACK_CHECK_BUTTON (vbox2_filtering_log, checkbtn_filtering_log_pre_proc,
 185                            _("pre-processing folders"));
 186         hbox_filtering_log_pre_proc = gtk_hbox_new (FALSE, 8);
 187         gtk_container_add (GTK_CONTAINER (vbox2_filtering_log), hbox_filtering_log_pre_proc);
 188         gtk_widget_show (hbox_filtering_log_pre_proc);
 189
 190         PACK_CHECK_BUTTON (vbox2_filtering_log, checkbtn_filtering_log_post_proc,
 191                            _("post-processing folders"));
 192         hbox_filtering_log_post_proc = gtk_hbox_new (FALSE, 8);
 193         gtk_container_add (GTK_CONTAINER (vbox2_filtering_log), hbox_filtering_log_post_proc);
 194         gtk_widget_show (hbox_filtering_log_post_proc);
 195
 196         SET_TOGGLE_SENSITIVITY(checkbtn_filtering_log, frame_filtering_log);
 197
 198         hbox_filtering_log_level = gtk_hbox_new (FALSE, 8);
 199         gtk_widget_show (hbox_filtering_log_level);
 200         gtk_box_pack_start(GTK_BOX (vbox1_filtering_log), hbox_filtering_log_level, FALSE, FALSE, 0);
 201
 202         label_filtering_log_level = gtk_label_new (_("Log level"));
 203         gtk_widget_show (label_filtering_log_level);
 204         gtk_box_pack_start(GTK_BOX(hbox_filtering_log_level), label_filtering_log_level, FALSE, FALSE, 0);
 205
 206         optmenu_filtering_log_level = gtk_option_menu_new ();
 207         gtk_widget_show (optmenu_filtering_log_level);
 208
 209         menu = gtk_menu_new ();
 210         MENUITEM_ADD (menu, menuitem, _("Low"), 0);
 211         MENUITEM_ADD (menu, menuitem, _("Medium"), 1);
 212         MENUITEM_ADD (menu, menuitem, _("High"), 2);
 213
 214         gtk_option_menu_set_menu (GTK_OPTION_MENU (optmenu_filtering_log_level), menu);
 215         gtk_box_pack_start(GTK_BOX(hbox_filtering_log_level), optmenu_filtering_log_level, FALSE, FALSE, 0);
 216
 217         filtering_log_level_tooltip = gtk_tooltips_new();
 218         gtk_tooltips_set_tip(GTK_TOOLTIPS(filtering_log_level_tooltip),
 219                              optmenu_filtering_log_level,
 220                              _("Select the level of detail of the logging.\n"
 221                                 "Choose Low to see when rules are applied, which "
 222                                 "conditions match or don't match and what actions are "
 223                                 "performed.\n"
 224                                 "Choose Medium to see more details about the message "
 225                                 "that is being processed, and why rules are skipped.\n"
 226                                 "Choose High to explicitly show the reason why all "
 227                                 "rules are processed or skipped, and why all conditions "
 228                                 "are matched or not matched.\n"
 229                                 "Caution: the higher the level, the greater the "
 230                                 "impact on performance."),
 231                              NULL);
 232
 233         hbox_clip_filtering_log = gtk_hbox_new (FALSE, 8);
 234         gtk_container_add (GTK_CONTAINER (vbox1_filtering_log), hbox_clip_filtering_log);
 235         gtk_widget_show (hbox_clip_filtering_log);
 236         PACK_CHECK_BUTTON (hbox_clip_filtering_log, checkbtn_clip_filtering_log,
 237                            _("Restrict the log window to"));
 238
 239         filtering_log_length_tooltip = gtk_tooltips_new();
 240
 241         spinbtn_filtering_log_length_adj = gtk_adjustment_new (500, 0, G_MAXINT, 1, 10, 10);
 242         spinbtn_filtering_log_length = gtk_spin_button_new
 243                 (GTK_ADJUSTMENT (spinbtn_filtering_log_length_adj), 1, 0);
 244         gtk_widget_show (spinbtn_filtering_log_length);
 245         gtk_box_pack_start (GTK_BOX (hbox_clip_filtering_log), spinbtn_filtering_log_length,
 246                             FALSE, FALSE, 0);
 247         gtk_widget_set_size_request (GTK_WIDGET (spinbtn_filtering_log_length), 64, -1);
 248         gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbtn_filtering_log_length), TRUE);
 249
 250         gtk_tooltips_set_tip(GTK_TOOLTIPS(filtering_log_length_tooltip), spinbtn_filtering_log_length,
 251                              _("0 to stop logging in the log window"),
 252                              NULL);
 253
 254         label = gtk_label_new(_("lines"));
 255         gtk_widget_show (label);
 256         gtk_box_pack_start(GTK_BOX(hbox_clip_filtering_log), label, FALSE, FALSE, 0);
 257
 258         SET_TOGGLE_SENSITIVITY(checkbtn_clip_filtering_log, spinbtn_filtering_log_length);
 259         SET_TOGGLE_SENSITIVITY(checkbtn_clip_filtering_log, label);
 260         SET_TOGGLE_SENSITIVITY(checkbtn_filtering_log, hbox_clip_filtering_log);
 261         SET_TOGGLE_SENSITIVITY(checkbtn_filtering_log, optmenu_filtering_log_level);
 262         SET_TOGGLE_SENSITIVITY(checkbtn_filtering_log, checkbtn_clip_filtering_log);
 263         SET_TOGGLE_SENSITIVITY(checkbtn_filtering_log, label_filtering_log_level);
 264
 265         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbtn_clip_network_log),
 266                 prefs_common.cliplog);
 267         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbtn_clip_filtering_log),
 268                 prefs_common.filtering_debug_cliplog);
 269         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbtn_filtering_log),
 270                 prefs_common.enable_filtering_debug);
 271         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbtn_filtering_log_inc),
 272                 prefs_common.enable_filtering_debug_inc);
 273         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbtn_filtering_log_manual),
 274                 prefs_common.enable_filtering_debug_manual);
 275         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbtn_filtering_log_folder_proc),
 276                 prefs_common.enable_filtering_debug_folder_proc);
 277         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbtn_filtering_log_pre_proc),
 278                 prefs_common.enable_filtering_debug_pre_proc);
 279         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbtn_filtering_log_post_proc),
 280                 prefs_common.enable_filtering_debug_post_proc);
 281
 282         gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinbtn_network_log_length),
 283                 prefs_common.loglength);
 284         gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinbtn_filtering_log_length),
 285                 prefs_common.filtering_debug_loglength);
 286
 287         gtk_option_menu_set_history(GTK_OPTION_MENU(optmenu_filtering_log_level),
 288                         prefs_common.filtering_debug_level);
 289
 290         prefs_logging->checkbtn_clip_network_log = checkbtn_clip_network_log;
 291         prefs_logging->spinbtn_network_log_length = spinbtn_network_log_length;
 292         prefs_logging->checkbtn_clip_filtering_log = checkbtn_clip_filtering_log;
 293         prefs_logging->spinbtn_filtering_log_length = spinbtn_filtering_log_length;
 294         prefs_logging->checkbtn_filtering_log = checkbtn_filtering_log;
 295         prefs_logging->checkbtn_filtering_log_inc = checkbtn_filtering_log_inc;
 296         prefs_logging->checkbtn_filtering_log_manual = checkbtn_filtering_log_manual;
 297         prefs_logging->checkbtn_filtering_log_folder_proc = checkbtn_filtering_log_folder_proc;
 298         prefs_logging->checkbtn_filtering_log_pre_proc = checkbtn_filtering_log_pre_proc;
 299         prefs_logging->checkbtn_filtering_log_post_proc = checkbtn_filtering_log_post_proc;
 300         prefs_logging->optmenu_filtering_log_level = optmenu_filtering_log_level;
 301
 302         prefs_logging->page.widget = vbox1;
 303 }
 304
 305 static void prefs_logging_save(PrefsPage *_page)
 306 {
 307         LoggingPage *page = (LoggingPage *) _page;
 308         MainWindow *mainwindow;
 309         gboolean filtering_debug_enabled;
 310         GtkWidget *menu;
 311         GtkWidget *menuitem;
 312
 313         menu = gtk_option_menu_get_menu(GTK_OPTION_MENU(page->optmenu_filtering_log_level));
 314         menuitem = gtk_menu_get_active(GTK_MENU(menu));
 315         prefs_common.filtering_debug_level = GPOINTER_TO_INT
 316                         (g_object_get_data(G_OBJECT(menuitem), MENU_VAL_ID));
 317
 318         prefs_common.cliplog = gtk_toggle_button_get_active(
 319                 GTK_TOGGLE_BUTTON(page->checkbtn_clip_network_log));
 320         prefs_common.loglength = gtk_spin_button_get_value_as_int(
 321                 GTK_SPIN_BUTTON(page->spinbtn_network_log_length));
 322         prefs_common.filtering_debug_cliplog = gtk_toggle_button_get_active(
 323                 GTK_TOGGLE_BUTTON(page->checkbtn_clip_filtering_log));
 324         prefs_common.filtering_debug_loglength = gtk_spin_button_get_value_as_int(
 325                 GTK_SPIN_BUTTON(page->spinbtn_filtering_log_length));
 326         filtering_debug_enabled = prefs_common.enable_filtering_debug;
 327         prefs_common.enable_filtering_debug = gtk_toggle_button_get_active(
 328                 GTK_TOGGLE_BUTTON(page->checkbtn_filtering_log));
 329         if (filtering_debug_enabled != prefs_common.enable_filtering_debug) {
 330                 if (prefs_common.enable_filtering_debug)
 331                         log_message(LOG_DEBUG_FILTERING, _("filtering log enabled\n"));
 332                 else
 333                         log_message(LOG_DEBUG_FILTERING, _("filtering log disabled\n"));
 334         }
 335         prefs_common.enable_filtering_debug_inc = gtk_toggle_button_get_active(
 336                 GTK_TOGGLE_BUTTON(page->checkbtn_filtering_log_inc));
 337         prefs_common.enable_filtering_debug_manual = gtk_toggle_button_get_active(
 338                 GTK_TOGGLE_BUTTON(page->checkbtn_filtering_log_manual));
 339         prefs_common.enable_filtering_debug_folder_proc = gtk_toggle_button_get_active(
 340                 GTK_TOGGLE_BUTTON(page->checkbtn_filtering_log_folder_proc));
 341         prefs_common.enable_filtering_debug_pre_proc = gtk_toggle_button_get_active(
 342                 GTK_TOGGLE_BUTTON(page->checkbtn_filtering_log_pre_proc));
 343         prefs_common.enable_filtering_debug_post_proc = gtk_toggle_button_get_active(
 344                 GTK_TOGGLE_BUTTON(page->checkbtn_filtering_log_post_proc));
 345
 346         mainwindow = mainwindow_get_mainwindow();
 347         log_window_set_clipping(mainwindow->logwin, prefs_common.cliplog,
 348                                 prefs_common.loglength);
 349         log_window_set_clipping(mainwindow->filtering_debugwin, prefs_common.filtering_debug_cliplog,
 350                                 prefs_common.filtering_debug_loglength);
 351 }
 352
 353 static void prefs_logging_destroy_widget(PrefsPage *_page)
 354 {
 355 }
 356
 357 LoggingPage *prefs_logging;
 358
 359 void prefs_logging_init(void)
 360 {
 361         LoggingPage *page;
 362         static gchar *path[3];
 363
 364         path[0] = _("Other");
 365         path[1] = _("Logging");
 366         path[2] = NULL;
 367
 368         page = g_new0(LoggingPage, 1);
 369         page->page.path = path;
 370         page->page.create_widget = prefs_logging_create_widget;
 371         page->page.destroy_widget = prefs_logging_destroy_widget;
 372         page->page.save_page = prefs_logging_save;
 373         page->page.weight = 5.0;
 374         prefs_gtk_register_page((PrefsPage *) page);
 375         prefs_logging = page;
 376 }
 377
 378 void prefs_logging_done(void)
 379 {
 380         prefs_gtk_unregister_page((PrefsPage *) prefs_logging);
 381         g_free(prefs_logging);
 382 }